361 lines
12 KiB
PHP
361 lines
12 KiB
PHP
<?php
|
|
|
|
namespace Illuminate\Redis\Connectors;
|
|
|
|
use Illuminate\Contracts\Redis\Connector;
|
|
use Illuminate\Redis\Connections\PhpRedisClusterConnection;
|
|
use Illuminate\Redis\Connections\PhpRedisConnection;
|
|
use Illuminate\Support\Arr;
|
|
use Illuminate\Support\Facades\Redis as RedisFacade;
|
|
use Illuminate\Support\Str;
|
|
use InvalidArgumentException;
|
|
use LogicException;
|
|
use Redis;
|
|
use RedisCluster;
|
|
|
|
class PhpRedisConnector implements Connector
|
|
{
|
|
/**
|
|
* Create a new connection.
|
|
*
|
|
* @param array $config
|
|
* @param array $options
|
|
* @return \Illuminate\Redis\Connections\PhpRedisConnection
|
|
*/
|
|
public function connect(array $config, array $options)
|
|
{
|
|
$formattedOptions = Arr::pull($config, 'options', []);
|
|
|
|
if (isset($config['prefix'])) {
|
|
$formattedOptions['prefix'] = $config['prefix'];
|
|
}
|
|
|
|
$connector = function () use ($config, $options, $formattedOptions) {
|
|
return $this->createClient(array_merge(
|
|
$config, $options, $formattedOptions
|
|
));
|
|
};
|
|
|
|
return new PhpRedisConnection($connector(), $connector, $config);
|
|
}
|
|
|
|
/**
|
|
* Create a new clustered PhpRedis connection.
|
|
*
|
|
* @param array $config
|
|
* @param array $clusterOptions
|
|
* @param array $options
|
|
* @return \Illuminate\Redis\Connections\PhpRedisClusterConnection
|
|
*/
|
|
public function connectToCluster(array $config, array $clusterOptions, array $options)
|
|
{
|
|
$options = array_merge($options, $clusterOptions, Arr::pull($config, 'options', []));
|
|
|
|
return new PhpRedisClusterConnection($this->createRedisClusterInstance(
|
|
array_map($this->buildClusterConnectionString(...), $config), $options
|
|
));
|
|
}
|
|
|
|
/**
|
|
* Build a single cluster seed string from an array.
|
|
*
|
|
* @param array $server
|
|
* @return string
|
|
*/
|
|
protected function buildClusterConnectionString(array $server)
|
|
{
|
|
return $this->formatHost($server).':'.$server['port'];
|
|
}
|
|
|
|
/**
|
|
* Create the Redis client instance.
|
|
*
|
|
* @param array $config
|
|
* @return \Redis
|
|
*
|
|
* @throws \LogicException
|
|
*/
|
|
protected function createClient(array $config)
|
|
{
|
|
return tap(new Redis, function ($client) use ($config) {
|
|
if ($client instanceof RedisFacade) {
|
|
throw new LogicException(
|
|
extension_loaded('redis')
|
|
? 'Please remove or rename the Redis facade alias in your "app" configuration file in order to avoid collision with the PHP Redis extension.'
|
|
: 'Please make sure the PHP Redis extension is installed and enabled.'
|
|
);
|
|
}
|
|
|
|
$this->establishConnection($client, $config);
|
|
|
|
if (array_key_exists('max_retries', $config)) {
|
|
$client->setOption(Redis::OPT_MAX_RETRIES, $config['max_retries']);
|
|
}
|
|
|
|
if (array_key_exists('backoff_algorithm', $config)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_ALGORITHM, $this->parseBackoffAlgorithm($config['backoff_algorithm']));
|
|
}
|
|
|
|
if (array_key_exists('backoff_base', $config)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_BASE, $config['backoff_base']);
|
|
}
|
|
|
|
if (array_key_exists('backoff_cap', $config)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_CAP, $config['backoff_cap']);
|
|
}
|
|
|
|
if (! empty($config['password'])) {
|
|
if (isset($config['username']) && $config['username'] !== '' && is_string($config['password'])) {
|
|
$client->auth([$config['username'], $config['password']]);
|
|
} else {
|
|
$client->auth($config['password']);
|
|
}
|
|
}
|
|
|
|
if (isset($config['database'])) {
|
|
$client->select((int) $config['database']);
|
|
}
|
|
|
|
if (! empty($config['prefix'])) {
|
|
$client->setOption(Redis::OPT_PREFIX, $config['prefix']);
|
|
}
|
|
|
|
if (! empty($config['read_timeout'])) {
|
|
$client->setOption(Redis::OPT_READ_TIMEOUT, $config['read_timeout']);
|
|
}
|
|
|
|
if (! empty($config['scan'])) {
|
|
$client->setOption(Redis::OPT_SCAN, $config['scan']);
|
|
}
|
|
|
|
if (! empty($config['name'])) {
|
|
$client->client('SETNAME', $config['name']);
|
|
}
|
|
|
|
if (array_key_exists('serializer', $config)) {
|
|
$client->setOption(Redis::OPT_SERIALIZER, $config['serializer']);
|
|
}
|
|
|
|
if (array_key_exists('compression', $config)) {
|
|
$client->setOption(Redis::OPT_COMPRESSION, $config['compression']);
|
|
}
|
|
|
|
if (array_key_exists('compression_level', $config)) {
|
|
$client->setOption(Redis::OPT_COMPRESSION_LEVEL, $config['compression_level']);
|
|
}
|
|
|
|
if (! empty($config['tcp_keepalive'])) {
|
|
$client->setOption(Redis::OPT_TCP_KEEPALIVE, $config['tcp_keepalive']);
|
|
}
|
|
|
|
if (defined('Redis::OPT_PACK_IGNORE_NUMBERS') &&
|
|
array_key_exists('pack_ignore_numbers', $config)) {
|
|
$client->setOption(Redis::OPT_PACK_IGNORE_NUMBERS, $config['pack_ignore_numbers']);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Establish a connection with the Redis host.
|
|
*
|
|
* @param \Redis $client
|
|
* @param array $config
|
|
* @return void
|
|
*/
|
|
protected function establishConnection($client, array $config)
|
|
{
|
|
$persistent = $config['persistent'] ?? false;
|
|
|
|
$parameters = [
|
|
$this->formatHost($config),
|
|
$config['port'],
|
|
Arr::get($config, 'timeout', 0.0),
|
|
$persistent ? Arr::get($config, 'persistent_id', null) : null,
|
|
Arr::get($config, 'retry_interval', 0),
|
|
];
|
|
|
|
if (version_compare(phpversion('redis'), '3.1.3', '>=')) {
|
|
$parameters[] = Arr::get($config, 'read_timeout', 0.0);
|
|
}
|
|
|
|
if (version_compare(phpversion('redis'), '5.3.0', '>=') && ! is_null($context = Arr::get($config, 'context'))) {
|
|
$parameters[] = $this->normalizeContext($context);
|
|
}
|
|
|
|
$client->{$persistent ? 'pconnect' : 'connect'}(...$parameters);
|
|
}
|
|
|
|
/**
|
|
* Create a new redis cluster instance.
|
|
*
|
|
* @param array $servers
|
|
* @param array $options
|
|
* @return \RedisCluster
|
|
*/
|
|
protected function createRedisClusterInstance(array $servers, array $options)
|
|
{
|
|
$parameters = [
|
|
null,
|
|
array_values($servers),
|
|
$options['timeout'] ?? 0,
|
|
$options['read_timeout'] ?? 0,
|
|
isset($options['persistent']) && $options['persistent'],
|
|
];
|
|
|
|
if (version_compare(phpversion('redis'), '5.3.2', '>=')) {
|
|
$parameters[] = $this->formatClusterPassword($options);
|
|
|
|
if (! is_null($context = Arr::get($options, 'context'))) {
|
|
$parameters[] = $this->normalizeClusterContext($context);
|
|
}
|
|
} elseif (version_compare(phpversion('redis'), '4.3.0', '>=')) {
|
|
$parameters[] = $options['password'] ?? null;
|
|
}
|
|
|
|
return tap(new RedisCluster(...$parameters), function ($client) use ($options) {
|
|
if (! empty($options['prefix'])) {
|
|
$client->setOption(Redis::OPT_PREFIX, $options['prefix']);
|
|
}
|
|
|
|
if (! empty($options['scan'])) {
|
|
$client->setOption(Redis::OPT_SCAN, $options['scan']);
|
|
}
|
|
|
|
if (! empty($options['failover'])) {
|
|
$client->setOption(RedisCluster::OPT_SLAVE_FAILOVER, $options['failover']);
|
|
}
|
|
|
|
if (array_key_exists('serializer', $options)) {
|
|
$client->setOption(Redis::OPT_SERIALIZER, $options['serializer']);
|
|
}
|
|
|
|
if (array_key_exists('compression', $options)) {
|
|
$client->setOption(Redis::OPT_COMPRESSION, $options['compression']);
|
|
}
|
|
|
|
if (array_key_exists('compression_level', $options)) {
|
|
$client->setOption(Redis::OPT_COMPRESSION_LEVEL, $options['compression_level']);
|
|
}
|
|
|
|
if (! empty($options['tcp_keepalive'])) {
|
|
$client->setOption(Redis::OPT_TCP_KEEPALIVE, $options['tcp_keepalive']);
|
|
}
|
|
|
|
if (array_key_exists('max_retries', $options)) {
|
|
$client->setOption(Redis::OPT_MAX_RETRIES, $options['max_retries']);
|
|
}
|
|
|
|
if (array_key_exists('backoff_algorithm', $options)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_ALGORITHM, $this->parseBackoffAlgorithm($options['backoff_algorithm']));
|
|
}
|
|
|
|
if (array_key_exists('backoff_base', $options)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_BASE, $options['backoff_base']);
|
|
}
|
|
|
|
if (array_key_exists('backoff_cap', $options)) {
|
|
$client->setOption(Redis::OPT_BACKOFF_CAP, $options['backoff_cap']);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Format the host using the scheme if available.
|
|
*
|
|
* @param array $options
|
|
* @return string
|
|
*/
|
|
protected function formatHost(array $options)
|
|
{
|
|
if (isset($options['scheme'])) {
|
|
return Str::start($options['host'], "{$options['scheme']}://");
|
|
}
|
|
|
|
return $options['host'];
|
|
}
|
|
|
|
/**
|
|
* Normalize the SSL context for a single Redis connection.
|
|
*
|
|
* Redis::connect() expects the context as ['stream' => ['verify_peer' => false, ...]].
|
|
*
|
|
* @param array $context
|
|
* @return array
|
|
*/
|
|
protected function normalizeContext(array $context)
|
|
{
|
|
if (isset($context['stream'])) {
|
|
return $context;
|
|
}
|
|
|
|
if (isset($context['ssl']) && is_array($context['ssl'])) {
|
|
return ['stream' => $context['ssl']];
|
|
}
|
|
|
|
return ['stream' => $context];
|
|
}
|
|
|
|
/**
|
|
* Normalize the SSL context for a RedisCluster connection.
|
|
*
|
|
* RedisCluster::__construct() expects a flat context ['verify_peer' => false, ...].
|
|
*
|
|
* @param array $context
|
|
* @return array
|
|
*/
|
|
protected function normalizeClusterContext(array $context)
|
|
{
|
|
if (isset($context['ssl']) && is_array($context['ssl'])) {
|
|
return $context['ssl'];
|
|
}
|
|
|
|
if (isset($context['stream']) && is_array($context['stream'])) {
|
|
return $context['stream'];
|
|
}
|
|
|
|
return $context;
|
|
}
|
|
|
|
/**
|
|
* Format the password for a Redis cluster connection.
|
|
*
|
|
* @param array $options
|
|
* @return string|array|null
|
|
*/
|
|
protected function formatClusterPassword(array $options)
|
|
{
|
|
$password = $options['password'] ?? null;
|
|
|
|
if (isset($options['username']) && $options['username'] !== '' && is_string($password)) {
|
|
return [$options['username'], $password];
|
|
}
|
|
|
|
return $password;
|
|
}
|
|
|
|
/**
|
|
* Parse a "friendly" backoff algorithm name into an integer.
|
|
*
|
|
* @param mixed $algorithm
|
|
* @return int
|
|
*
|
|
* @throws \InvalidArgumentException
|
|
*/
|
|
protected function parseBackoffAlgorithm(mixed $algorithm)
|
|
{
|
|
if (is_int($algorithm)) {
|
|
return $algorithm;
|
|
}
|
|
|
|
return match ($algorithm) {
|
|
'default' => Redis::BACKOFF_ALGORITHM_DEFAULT,
|
|
'decorrelated_jitter' => Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER,
|
|
'equal_jitter' => Redis::BACKOFF_ALGORITHM_EQUAL_JITTER,
|
|
'exponential' => Redis::BACKOFF_ALGORITHM_EXPONENTIAL,
|
|
'uniform' => Redis::BACKOFF_ALGORITHM_UNIFORM,
|
|
'constant' => Redis::BACKOFF_ALGORITHM_CONSTANT,
|
|
default => throw new InvalidArgumentException("Algorithm [{$algorithm}] is not a valid PhpRedis backoff algorithm.")
|
|
};
|
|
}
|
|
}
|