RedisSource::__construct() - Code Metrics - Oefenweb/cakephp-redis - Measure and Improve Code Quality continuously with Scrutinizer

RedisSource::__construct() A
last analyzed 2019-01-23 12:27 UTC

↳ Parent: RedisSource
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	10
rs	10
<?php
App::uses('DataSource', 'Model/Datasource');

/**
 * Redis Source class
 *
 */
class RedisSource extends DataSource {
filter:
    dependency_paths: ["lib/*"]

/**
 * Datasource description.
 *
 * @var string
 */
	public $description = 'Redis Data Source';

/**
 * Base configuration.
 *
 * @var array
 */
	protected $_baseConfig = [
		'host' => '127.0.0.1',
		'port' => 6379,
		'password' => '',
		'database' => 0,
		'timeout' => 0,
		'persistent' => false,
		'unix_socket' => '',
		'prefix' => '',
	];

/**
 * Configuration.
 *
 * @var array
 */
	public $config = [];

/**
 * A reference to the physical connection of this DataSource.
 *
 * @var Redis
 */
	protected $_connection = null;

/**
 * Whether or not we are connected to the DataSource.
 *
 * @var bool
 */
	public $connected = false;

/**
 * Whether or not source data like available tables and schema descriptions should be cached.
 *
 * @var bool
 */
	public $cacheSources = false;

/**
 * Constructor.
 *
 * @param array $config Array of configuration information for the Datasource
 * @return bool True if connecting to the DataSource succeeds, else false
 * @throws RedisSourceException
 */
	public function __construct($config = []) {
		parent::__construct($config);

		if (!$this->enabled()) {
			throw new RedisSourceException(__d('redis', 'Extension is not loaded.'));
			throw new RedisSourceException(/** @scrutinizer ignore-call */ __d('redis', 'Extension is not loaded.'));
		}

		$this->_connection = new Redis();

		return $this->connect();
	}

/**
 * Destructor.
 *
 *  Closes the connection to the host (if needed).
 *
 * @return void
 * @todo Write test
 */
	public function __destruct() {
		if (!$this->config['persistent']) {
			$this->close();
		}
	}

/**
 * Passes (non-existing) method calls to `Redis`.
 *
 * @param string $name The name of the method being called
 * @param array $arguments An enumerated array containing the parameters passed to the method
 * @return mixed Method return value
 * @throws RedisSourceException
 */
	public function __call($name, $arguments) {
		if (!method_exists($this->_connection, $name)) {
			throw new RedisSourceException(__d('redis', 'Method (%s) does not exist.', $name));
			throw new RedisSourceException(/** @scrutinizer ignore-call */ __d('redis', 'Method (%s) does not exist.', $name));
		}

		try {
			return call_user_func_array([$this->_connection, $name], $arguments);
		} catch (RedisException $e) {
			throw new RedisSourceException(__d('redis', 'Method (%s) failed: %s.', $name, $e->getMessage()));
		}
	}

/**
 * Check that the redis extension is loaded.
 *
 * @return bool Whether or not the extension is loaded
 */
	public function enabled() {
		return extension_loaded('redis');
	}

/**
 * Connects to the database using options in the given configuration array.
 *
 *  "Connects" means:
 *  - connect
 *  - authenticate
 *  - select
 *  - setPrefix
 *
 * @return bool True if all of the above steps succeed, else false
 * @throws RedisSourceException
 */
	public function connect() {
		if (!$this->_connect()) {
			throw new RedisSourceException(__d('redis', 'Could not connect.'));
			throw new RedisSourceException(/** @scrutinizer ignore-call */ __d('redis', 'Could not connect.'));
		}

		if (!$this->_authenticate()) {
			throw new RedisSourceException(__d('redis', 'Could not authenticate.'));
		}

		if (!$this->_select()) {
			throw new RedisSourceException(__d('redis', 'Could not select.'));
		}

		if (!$this->_setPrefix()) {
			throw new RedisSourceException(__d('redis', 'Could not set prefix.'));
		}

		$this->connected = true;

		return $this->connected;
	}

/**
 * Connects to the database using options in the given configuration array.
 *
 * @return bool True if connecting to the DataSource succeeds, else false
 */
	protected function _connect() {
		$unixSocket = $this->config['unix_socket'];
		$persistent = $this->config['persistent'];
		$host = $this->config['host'];
		$port = $this->config['port'];
		$timeout = $this->config['timeout'];

		if ($unixSocket) {
			return $this->_connection->connect($unixSocket);
		} elseif ($persistent) {
			return $this->_connection->pconnect($host, $port, $timeout, $persistent);
		} else {
			return $this->_connection->connect($host, $port, $timeout);
		}
	}

/**
 * Authenticates to the database (if needed) using options in the given configuration array.
 *
 * @return bool True if the authentication succeeded or no password was specified, else false
 */
	protected function _authenticate() {
		if ($this->config['password']) {
			return $this->_connection->auth($this->config['password']);
		}

		return true;
	}

/**
 * Selects a database (if needed) using options in the given configuration array.
 *
 * @return bool True if the select succeeded or no database was specified, else false
 */
	protected function _select() {
		if ($this->config['database']) {
			return $this->_connection->select($this->config['database']);
		}

		return true;
	}

/**
 * Sets a prefix for all keys (if needed) using options in the given configuration array.
 *
 * @return bool True if setting the prefix succeeded or no prefix was specified, else false
 */
	protected function _setPrefix() {
		if ($this->config['prefix']) {
			return $this->_connection->setOption(Redis::OPT_PREFIX, $this->config['prefix']);
		}

		return true;
	}

/**
 * Closes a connection.
 *
 * @return bool Always true
 */
	public function close() {
		if ($this->isConnected()) {
			$this->_connection->close();
		}

		$this->connected = false;
		$this->_connection = null;

		return true;
	}

/**
 * Checks if the source is connected to the database.
 *
 * @return bool True if the database is connected, else false
 */
	public function isConnected() {
		return $this->connected;
	}

/**
 * Caches/returns cached results for child instances.
 *
 * @param mixed $data List of tables
 * @return array Array of sources available in this datasource
 */
	public function listSources($data = null) {
		return parent::listSources($data);
	}

/**
 * Returns a Model description (metadata) or null if none found.
 *
 * @param Model|string $model Name of database table to inspect or model instance
filter:
    dependency_paths: ["lib/*"]
 * @return array Array of Metadata for the $model
 */
	public function describe($model) {
		return parent::describe($model);
	}

}

/**
 * Redis Source Exception class.
 *
 */
class RedisSourceException extends CakeException {
filter:
    dependency_paths: ["lib/*"]
}

Oefenweb / cakephp-redis

RedisSource::__construct() A last analyzed 2019-01-23 12:27 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

RedisSource::__construct() A
last analyzed 2019-01-23 12:27 UTC
