Devgiants\Storage\Ftp

Complexity

Total Complexity

29

Size/Duplication

Total Lines	197
Duplicated Lines	0 %

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	makeDir()	0	8	4
A	isSsl()	0	2	1
A	getServer()	0	2	1
A	isPassive()	0	2	1
A	delete()	0	8	4
A	getConnectionResource()	0	2	1
A	handleRetention()	0	13	3
A	__construct()	0	7	1
A	close()	0	2	1
A	getTransferMode()	0	2	1
A	getType()	0	2	1
B	connect()	0	25	6
A	get()	0	2	1
A	getUsername()	0	2	1
A	getItemsList()	0	2	1
A	put()	0	2	1

<?php
/**
 * Created by PhpStorm.
 * User: nicolas
 * Date: 09/02/17
 * Time: 23:06
 */

namespace Devgiants\Storage;


use Devgiants\Configuration\ApplicationConfiguration;
use Devgiants\Configuration\ConfigurationManager;
use Devgiants\Model\Storage;
use Devgiants\Model\StorageInterface;
use Symfony\Component\Config\Definition\Exception\Exception;

The type Symfony\Component\Config\Definition\Exception\Exception was not found. Maybe you did not declare it correctly or list all dependencies?

class Ftp extends Storage {
	/**
	 * @var resource the FTP connection resource
	 */
	protected $connectionResource;
	/**
	 * @var string $server
	 */
	protected $server;
	/**
	 * @var string $username
	 */
	protected $username;
	/**
	 * @var string $password
	 */
	protected $password;
	/**
	 * @var bool $passive
	 */

	protected $passive;
	/**
	 * @var bool $ssl
	 */
	protected $ssl;
	/**
	 * @var int $transferMode
	 */
	protected $transferMode;

	/**
	 * FtpManager constructor.
	 *
	 * @param array $options
	 */
	public function __construct( $options ) {
		$this->server       = $options[ ApplicationConfiguration::SERVER ];
		$this->username     = $options[ ApplicationConfiguration::USER ];
		$this->password     = $options[ ApplicationConfiguration::PASSWORD ];
		$this->passive      = $options[ ApplicationConfiguration::PASSIVE ];
		$this->ssl          = $options[ ApplicationConfiguration::SSL ];
		$this->transferMode = $options[ ApplicationConfiguration::TRANSFER ];
	}

	/**
	 * @return resource
	 */
	public function getConnectionResource() {
		return $this->connectionResource;
	}

	/**
	 * @return string
	 */
	public function getServer() {
		return $this->server;
	}

	/**
	 * @return string
	 */
	public function getUsername() {
		return $this->username;
	}

	/**
	 * @return boolean
	 */
	public function isPassive() {
		return $this->passive;
	}

	/**
	 * @return boolean
	 */
	public function isSsl() {
		return $this->ssl;
	}

	/**
	 * @return int
	 */
	public function getTransferMode() {
		return $this->transferMode;
	}

	/**
	 * Establish FTP connection
	 * @throws Exception
	 */
	public function connect() {

		// Handle SSL connection
		if ( $this->ssl === true ) {
			$this->connectionResource = ftp_ssl_connect( $this->server );
		} else {
			$this->connectionResource = ftp_connect( $this->server );
		}

		if ( ! $this->connectionResource ) {
			throw new Exception( "Impossible to establish connection on FTP server {$this->server} with username {$this->username} (SSL = {$this->ssl})" );
		}

		// Try to login
		$loginResult = ftp_login( $this->connectionResource, $this->username, $this->password );

		// If login successful
		if ( $loginResult ) {
			// Set passive mode according to configuration
			if ( $this->passive === true ) {
				ftp_pasv( $this->connectionResource, true );
			}
		}
		if ( ! $loginResult ) {
			throw new Exception( "Impossible to authenticate on FTP server {$this->server} with username {$this->username} (SSL = {$this->ssl})" );
		}
	}

	/**
	 * @inheritdoc
	 */
	public function put( $localPath, $remotePath, array $params = null ) {
		return ftp_put( $this->connectionResource, $remotePath, $localPath, $this->transferMode );
	}

	/**
	 * @inheritdoc
	 */
	public function getItemsList( $remotePath, array $params = null ) {
		return ftp_nlist( $this->connectionResource, $remotePath );
	}

	/**
	 * @inheritdoc
	 */
	public function get( $remotePath, $localPath, array $params = null ) {
		return ftp_get( $this->connectionResource, $localPath, $remotePath, FTP_BINARY );
	}

	/**
	 * @inheritdoc
	 * // TODO handle recursive
	 */
	public function delete( $path, $recursive = true ) {
		if ( @ftp_delete( $this->connectionResource, $path ) === false ) {
			if ( $children = @ftp_nlist( $this->connectionResource, $path ) ) {
				foreach ( $children as $p ) {
					$this->delete( $p, $recursive );
				}
			}
			@ftp_rmdir( $this->connectionResource, $path );

It seems like you do not handle an error condition for ftp_rmdir(). This can introduce security issues, and is generally not recommended.

		}
	}

	/**
	 * @inheritdoc
	 * // TODO handle recursive
	 */
	public function makeDir( $path, $recursive = true ) {
		$parts = explode( '/', $path );

		foreach ( $parts as $part ) {
			if ( ! empty( $part ) && ! @ftp_chdir( $this->connectionResource, $path ) ) {
				// TODO find how to correctly specify folder to not trigger warning
				@ftp_mkdir( $this->connectionResource, $part );

It seems like you do not handle an error condition for ftp_mkdir(). This can introduce security issues, and is generally not recommended.

				ftp_chdir( $this->connectionResource, $part );
			}
		}
	}

	/**
	 * @inheritdoc
	 */
	public function handleRetention( int $retention, array $params = null ) {
		// TODO find best way for configurable architecture
		// Goes back to timestamps folders list
		ftp_chdir( $this->connectionResource, '../' );
		$timestampDirs = ftp_nlist( $this->connectionResource, "." );
		if ( count( $timestampDirs ) > $retention ) {

			sort( $timestampDirs );
			$folderNumberToRemove = count( $timestampDirs ) - $retention;

			// Prune older directories
			for ( $i = 0; $i < $folderNumberToRemove; $i ++ ) {
				$this->delete( $timestampDirs[ $i ] );
			}
		}
	}

	public function close() {
		ftp_close( $this->connectionResource );
	}

	public static function getType() {
		return 'FTP';
	}
}