/**
* {@inheritdoc}
*/
public function getAdapter(array $config)
{
$client = new \Redis();
$dsn = $this->getDsn();
if (empty($dsn)) {
if (false === $client->connect($config['host'], $config['port'])) {
throw new ConnectException(sprintf('Could not connect to Redis database on "%s:%s".', $config['host'], $config['port']));
}
} else {
if (false === $client->connect($dsn->getFirstHost(), $dsn->getFirstPort())) {
throw new ConnectException(sprintf('Could not connect to Redis database on "%s:%s".', $dsn->getFirstHost(), $dsn->getFirstPort()));
}
if (!empty($dsn->getPassword())) {
if (false === $client->auth($dsn->getPassword())) {
throw new ConnectException('Could not connect authenticate connection to Redis database.');
}
}
if ($dsn->getDatabase() !== null) {
if (false === $client->select($dsn->getDatabase())) {
throw new ConnectException(sprintf('Could not select Redis database with index "%s".', $dsn->getDatabase()));
}
}
}
$pool = new RedisCachePool($client);
if (null !== $config['pool_namespace']) {
$pool = new NamespacedCachePool($pool, $config['pool_namespace']);
}
return $pool;
}
/**
* Returns the singleton instance of Redis. If no instance has
* been created, a new instance will be created.
*
* $redis = Koredis::factory();
*
* @return Kohana_Koredis
**/
public static function factory()
{
if (!Kohana_Koredis::$redis) {
// Make sure Redis installed
if (!class_exists('Redis', FALSE)) {
throw new Kohana_Exception('class Redis can not be found. make sure
you have installed phpredis extension');
}
Kohana_Koredis::$redis = new Redis();
// No config file found
if (!Kohana::$config->load('koredis')) {
Kohana_Koredis::$redis->pconnect('127.0.0.1', 6379, 1);
} else {
// Load config
$config = Kohana::$config->load('koredis');
$host = isset($config['host']) && $config['host'] ? $config['host'] : '127.0.0.1';
$port = isset($config['port']) && $config['port'] ? $config['port'] : 6379;
$timeout = isset($config['timeout']) && $config['timeout'] ? $config['timeout'] : 1;
$pconnect = isset($config['pconnect']) && $config['pconnect'] ? $config['pconnect'] : false;
// Persistent connection
if ($pconnect === TRUE) {
Kohana_Koredis::$redis->pconnect($host, $port, $timeout);
} else {
Kohana_Koredis::$redis->connect($host, $port, $timeout);
}
}
}
return Kohana_Koredis::$redis;
}
/**
* Constructor.
*
* @param string $uniqId to be used to separate objects in addition to their key identifiers, for instance in a
* multi-user scenario.
*
* @return \iveeCrest\RedisWrapper
*/
public function __construct($uniqId)
{
$this->redis = new \Redis();
$this->redis->connect(Config::getCacheHost(), Config::getCachePort());
$this->redis->setOption(\Redis::OPT_PREFIX, Config::getCachePrefix());
$this->uniqId = $uniqId;
}
public function __construct()
{
$this->redis = new \Redis();
if (!$this->redis->connect('127.0.0.1', 10000, 3)) {
exit('redis connect failed');
}
}
/**
* Connects to a Redis server
*
* @return bool True if Redis server was connected
*/
protected function _connect()
{
try {
$hash = "{$this->settings['server']}:{$this->settings['port']}:{$this->settings['database']}";
if (!empty(self::$instances[$hash])) {
$return = $this->_Redis = self::$instances[$hash];
} else {
$this->_Redis = new Redis();
self::$instances[$hash] = $this->_Redis;
if (!empty($this->settings['unix_socket'])) {
$return = $this->_Redis->connect($this->settings['unix_socket']);
} elseif (empty($this->settings['persistent'])) {
$return = $this->_Redis->connect($this->settings['server'], $this->settings['port'], $this->settings['timeout']);
} else {
$persistentId = $this->settings['port'] . $this->settings['timeout'] . $this->settings['database'];
$return = $this->_Redis->pconnect($this->settings['server'], $this->settings['port'], $this->settings['timeout'], $persistentId);
}
}
} catch (RedisException $e) {
$return = false;
}
if (!$return) {
return false;
}
if ($this->settings['password'] && !$this->_Redis->auth($this->settings['password'])) {
return false;
}
return $this->_Redis->select($this->settings['database']);
}
/**
* Connects to a Redis server
*
* @return bool True if Redis server was connected
*/
protected function _connect()
{
try {
$server = $this->_config['host'];
if (empty($server) && !empty($this->_config['server'])) {
$server = $this->_config['server'];
}
$this->_Redis = new \Redis();
if (!empty($this->settings['unix_socket'])) {
$return = $this->_Redis->connect($this->settings['unix_socket']);
} elseif (empty($this->_config['persistent'])) {
$return = $this->_Redis->connect($this->_config['server'], $this->_config['port'], $this->_config['timeout']);
} else {
$persistentId = $this->_config['port'] . $this->_config['timeout'] . $this->_config['database'];
$return = $this->_Redis->pconnect($this->_config['server'], $this->_config['port'], $this->_config['timeout'], $persistentId);
}
} catch (\RedisException $e) {
return false;
}
if ($return && $this->_config['password']) {
$return = $this->_Redis->auth($this->_config['password']);
}
if ($return) {
$return = $this->_Redis->select($this->_config['database']);
}
return $return;
}
/**
* @param ProvidesConnectionData $connectionData
*
* @throws CannotConnectToServer
*/
private function connectToServer(ProvidesConnectionData $connectionData)
{
$connected = $this->redis->connect($connectionData->getHost(), $connectionData->getPort(), $connectionData->getTimeout(), null, $connectionData->getRetryInterval());
if (!$connected) {
throw (new CannotConnectToServer())->withConnectionData($connectionData);
}
}
public function __construct($redis = FALSE, $opts = array())
{
if (is_array($redis)) {
$opts = $redis;
$redis = FALSE;
}
// Apply default arguments
$opts = array_merge(array('host' => 'localhost', 'port' => 6379), $opts);
if (!$redis) {
// Default to phpredis
if (extension_loaded('redis')) {
if (!isset($opts['socket']) && !isset($opts['host'])) {
throw new \Exception('Host should be provided when not providing a redis instance');
}
if (!isset($opts['socket']) && !isset($opts['port'])) {
throw new \Exception('Port should be provided when not providing a redis instance');
}
$redis = new \Redis();
if (isset($opts['socket'])) {
$redis->connect($opts['socket']);
} else {
$redis->connect($opts['host'], $opts['port']);
}
} else {
$redis = new \TinyRedisClient($opts['host'] . ':' . $opts['port']);
}
}
if (!is_callable(array($redis, 'publish'))) {
throw new \Exception('The Redis client provided is invalid. The client needs to implement the publish method. Try using the default client.');
}
$this->redis = $redis;
$this->key = (isset($opts['key']) ? $opts['key'] : 'socket.io') . '#/#';
$this->_rooms = array();
$this->_flags = array();
}
/**
* @param \Redis $redis
*/
public function __construct()
{
$this->redis = new \Redis();
$this->redis->connect('127.0.0.1', '6379');
$this->emitter = new Emitter($this->redis);
$this->user = new Emitter($this->redis);
}
public static function class_init()
{
/** @var Settings $settings */
$settings = resource(Settings::class);
self::$redis = new \Redis();
self::$redis->connect($settings->get("redis", "hostname"), $settings->get("redis", "connect_port"));
}
public function init()
{
$this->_redis = new \Redis();
if (!$this->_redis->connect($this->host, $this->port)) {
throw new InvalidConfigException("The redis host '{$this->host}' error.");
}
}
/**
* Constructor
*
* This is the constructor. The options passed can be the
* ip of the server, or an array of servers and their port.
*
* Example:
* <code>
*
* $options = array(
* 'hostname' => '127.0.0.1',
* 'port' => 6666
* );
*
* $cache = Frapi_Cache_Adapter_Redis($options);
* </code>
*
* @param array $options an array of options
* @return void
*/
public function __construct(array $options)
{
$this->redis = new Redis();
$defaults = array('hostname' => '127.0.0.1', 'port' => 6379);
$options += $defaults;
$this->redis->connect($options['hostname'], $options['port']);
}
public function __construct($prefix = '')
{
parent::__construct($prefix);
if (is_null(self::$cache)) {
// TODO allow configuring a RedisArray, see https://github.com/nicolasff/phpredis/blob/master/arrays.markdown#redis-arrays
self::$cache = new \Redis();
$config = \OC::$server->getSystemConfig()->getValue('redis', array());
if (isset($config['host'])) {
$host = $config['host'];
} else {
$host = '127.0.0.1';
}
if (isset($config['port'])) {
$port = $config['port'];
} else {
$port = 6379;
}
if (isset($config['timeout'])) {
$timeout = $config['timeout'];
} else {
$timeout = 0.0;
// unlimited
}
self::$cache->connect($host, $port, $timeout);
}
}
public function setUp()
{
$this->redis = new Redis();
$this->redis->connect('127.0.0.1', 6379);
// uncomment the following if you want to use authentication
// $this->assertTrue($this->redis->auth('foobared'));
}
/**
* @param string $host redis server host
* @param int $port redis server port
* @param int $database redis server database num
* @param string $channel redis queue key
* @param string $prefix prefix of redis queue key
*/
public function __construct($host = '127.0.0.1', $port = 6379, $database = 0, $channel = 'cache', $prefix = 'simple-fork-')
{
$this->redis = new \Redis();
$connection_result = $this->redis->connect($host, $port);
if (!$connection_result) {
throw new \RuntimeException('can not connect to the redis server');
}
if ($database != 0) {
$select_result = $this->redis->select($database);
if (!$select_result) {
throw new \RuntimeException('can not select the database');
}
}
if (empty($channel)) {
throw new \InvalidArgumentException('channel can not be empty');
}
$this->channel = $channel;
if (empty($prefix)) {
return;
}
$set_option_result = $this->redis->setOption(\Redis::OPT_PREFIX, $prefix);
if (!$set_option_result) {
throw new \RuntimeException('can not set the \\Redis::OPT_PREFIX Option');
}
}
function init()
{
list($ip, $port) = explode(':', $this->_defaults['server']);
$this->_handler = new Redis();
$this->_handler->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY);
$this->_handler->connect($ip, $port);
}
/**
* Establishes a DB connection.
* It does nothing if a DB connection has already been established.
* @return \Redis
* @throws Exception if connection fails
*/
public function open()
{
if ($this->_socket !== null) {
return;
}
$connection = ($this->unixSocket ?: $this->hostname . ':' . $this->port) . ', database=' . $this->database;
\Yii::trace('Opening redis DB connection: ' . $connection, __METHOD__);
$this->_socket = new \Redis();
if ($this->unixSocket) {
if ($this->persist) {
$this->_socket->pconnect($this->unixSocket, $this->port, $this->dataTimeout);
} else {
$this->_socket->connect($this->unixSocket, $this->port, $this->dataTimeout);
}
} else {
if ($this->persist) {
$this->_socket->pconnect($this->hostname, $this->port, $this->dataTimeout);
} else {
$this->_socket->connect($this->hostname, $this->port, $this->dataTimeout);
}
}
if (isset($this->password)) {
if ($this->_socket->auth($this->password) === false) {
throw new Exception('Redis authentication failed!');
}
}
$this->_socket->select($this->database);
return $this->_socket;
}
/**
* Return redis connection object
*
* @return mixed Redis connection object on success, void or boolean on failure
*
* @since 3.4
*
* @throws RuntimeException
*/
protected function getConnection()
{
if (static::isSupported() == false) {
return false;
}
$config = JFactory::getConfig();
$app = JFactory::getApplication();
$caching = (bool) $config->get('caching');
if ($caching == false) {
return false;
}
$this->_persistent = $config->get('redis_persist', true);
$server = array('host' => $config->get('redis_server_host', 'localhost'), 'port' => $config->get('redis_server_port', 6379), 'auth' => $config->get('redis_server_auth', null), 'db' => (int) $config->get('redis_server_db', null));
static::$_redis = new Redis();
if ($this->_persistent) {
try {
$connection = static::$_redis->pconnect($server['host'], $server['port']);
$auth = !empty($server['auth']) ? static::$_redis->auth($server['auth']) : true;
} catch (Exception $e) {
}
} else {
try {
$connection = static::$_redis->connect($server['host'], $server['port']);
$auth = !empty($server['auth']) ? static::$_redis->auth($server['auth']) : true;
} catch (Exception $e) {
}
}
if ($connection == false) {
static::$_redis = null;
if ($app->isAdmin()) {
JError::raiseWarning(500, 'Redis connection failed');
}
return;
}
if ($auth == false) {
if ($app->isAdmin()) {
JError::raiseWarning(500, 'Redis authentication failed');
}
return;
}
$select = static::$_redis->select($server['db']);
if ($select == false) {
static::$_redis = null;
if ($app->isAdmin()) {
JError::raiseWarning(500, 'Redis failed to select database');
}
return;
}
try {
static::$_redis->ping();
} catch (RedisException $e) {
static::$_redis = null;
if ($app->isAdmin()) {
JError::raiseWarning(500, 'Redis ping failed');
}
return;
}
return static::$_redis;
}
/**
* Gets the redis client
* @return Redis the redis client
*/
public function getClient()
{
if ($this->_client === null) {
$this->_client = new Redis();
$this->_client->connect($this->hostname, $this->port);
}
return $this->_client;
}
/**
* @param $host
* @param $port
* @param null $auth
* @param int $timeout
*/
public function __construct($host, $port, $auth = null, $timeout = 2)
{
$this->redis = new \Redis();
$this->redis->connect($host, $port, $timeout);
if (null !== $auth) {
$this->redis->auth($auth);
}
}
/**
* Create the Redis connector.
*
* We have a $use_redis parameter here so that we can allow devs the ability of using
* a development environment without using Redis. Passing false will mimic the data
* coming and going from Redis.
*
* @param boolean $use_redis
* @param string $redis_hostname
* @param string $redis_port
* @param string $redis_password
* @return $this
*/
public function connect($use_redis, $redis_hostname, $redis_port, $redis_password)
{
if ($use_redis === true) {
$this->redis = new \Redis();
$this->redis->connect($redis_hostname, $redis_port);
$this->redis->auth($redis_password);
}
return $this;
}
public function __construct($connectionOrHost, $port = 6379)
{
if ($connectionOrHost instanceof \Redis) {
$this->connection = $connectionOrHost;
} else {
$this->connection = new \Redis();
$this->connection->connect($connectionOrHost, $port);
$this->connection->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_PHP);
}
}
protected function setUp()
{
parent::setUp();
if (!class_exists('\\Redis')) {
$this->markTestSkipped("extension not loaded");
}
$this->_connection = new \Redis();
$this->_connection->connect('localhost', 6379);
$this->_adapter = new RedisAdapter($this->_connection);
}
public function __construct($host = '127.0.0.1', $port = '6379') {
$this->_host = $host;
$this->_port = $port;
$this->_redis = new Redis();
try {
$this->_redis->connect($this->_host, $this->_port);
} catch (Exception $e) {
$this->_error = $e->getMessage();
}
}
/**
* @param array $config
*
* @return \Redis
*/
private function getRedisConnection(array $config)
{
$redis = new \Redis();
$host = isset($config['host']) ? $config['host'] : 'localhost';
if (isset($config['port'])) {
$redis->connect($host, $config['port']);
} else {
$redis->connect($host);
}
return $redis;
}
public function __construct()
{
$configPath = realpath(__DIR__ . '/../../../') . '/config.php';
if (!file_exists($configPath)) {
throw new \Exception('Config file missing');
}
$this->config = (require $configPath);
$this->client = new Client($this->config['redis']['host'], $this->config['redis']['port']);
$this->redis = new \Redis();
$this->redis->connect($this->config['redis']['host'], $this->config['redis']['port']);
}
/**
* Create queue
*
* @param array $options
* @return Kue
*/
public function __construct(array $options = array())
{
$this->injectors = $options + $this->injectors;
$this->client =& $this->injectors['client'];
if (!$this->client) {
$this->client = new \Redis();
$this->client->connect($this->injectors['host'], $this->injectors['port']);
if ($this->injectors['db']) {
$this->client->select($this->injectors['db']);
}
}
}
/**
* @return \Redis
*/
public function getRedis()
{
if (null === $this->redis) {
if (class_exists('\\Redis')) {
$this->redis = new \Redis();
$this->redis->connect($this->params['host'], $this->params['port'], $this->params['timeout'], null, $this->params['retry_interval']);
} else {
throw new \RuntimeException('No Redis client is available');
}
}
return $this->redis;
}
/**
* 初始化Redis连接
*
* @throws RedisException
*/
private function initRedis()
{
$apf = APF::get_instance();
$config = $apf->get_config('house_updown', 'redis');
if (!isset($config['host']) || !isset($config['port'])) {
throw new RedisException('Host and port are needed to connect redis server.');
}
$this->redis = new Redis();
if (!$this->redis->connect($config['host'], $config['port'])) {
throw new RedisException("Failed to connect redis server: {$config['host']}:{$config['port']}");
}
}
private function create()
{
$this->instance = new \Redis();
// TODO allow configuring a RedisArray, see https://github.com/nicolasff/phpredis/blob/master/arrays.markdown#redis-arrays
$config = $this->config->getValue('redis', array());
if (isset($config['host'])) {
$host = $config['host'];
} else {
$host = '127.0.0.1';
}
if (isset($config['port'])) {
$port = $config['port'];
} else {
$port = 6379;
}
if (isset($config['timeout'])) {
$timeout = $config['timeout'];
} else {
$timeout = 0.0;
// unlimited
}
$this->instance->connect($host, $port, $timeout);
if (isset($config['password']) && $config['password'] !== '') {
$this->instance->auth($config['password']);
}
if (isset($config['dbindex'])) {
$this->instance->select($config['dbindex']);
}
}
