RedisSource

Complexity

Total Complexity

27

Size/Duplication

Total Lines	252
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	enabled()	0	2	1
A	_setPrefix()	0	6	2
A	_connect()	0	13	3
A	__call()	0	9	3
A	isConnected()	0	2	1
A	listSources()	0	2	1
A	connect()	0	20	5
A	close()	0	9	2
A	_authenticate()	0	6	2
A	describe()	0	2	1
A	__destruct()	0	3	2
A	_select()	0	6	2
A	__construct()	0	10	2

<?php
App::uses('DataSource', 'Model/Datasource');

/**
 * Redis Source class
 *
 */
class RedisSource extends DataSource {

The type DataSource was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * 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.'));

The function __d was not found. Maybe you did not declare it correctly or list all dependencies?

		}

		$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));

The function __d was not found. Maybe you did not declare it correctly or list all dependencies?

		}

		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.'));

The function __d was not found. Maybe you did not declare it correctly or list all dependencies?

		}

		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

The type Model was not found. Maybe you did not declare it correctly or list all dependencies?

 * @return array Array of Metadata for the $model
 */
	public function describe($model) {
		return parent::describe($model);
	}

}

/**
 * Redis Source Exception class.
 *
 */
class RedisSourceException extends CakeException {

The type CakeException was not found. Maybe you did not declare it correctly or list all dependencies?

}