vendor/symfony/cache/Traits/RedisTrait.php line 415

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Cache\Traits;
  14. use Predis\Command\Redis\UNLINK;
  15. use Predis\Connection\Aggregate\ClusterInterface;
  16. use Predis\Connection\Aggregate\RedisCluster;
  17. use Predis\Connection\Aggregate\ReplicationInterface;
  18. use Predis\Connection\Cluster\ClusterInterface as Predis2ClusterInterface;
  19. use Predis\Connection\Cluster\RedisCluster as Predis2RedisCluster;
  20. use Predis\Response\ErrorInterface;
  21. use Predis\Response\Status;
  22. use Symfony\Component\Cache\Exception\CacheException;
  23. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  24. use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
  25. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
  27. /**
  28.  * @author Aurimas Niekis <aurimas@niekis.lt>
  29.  * @author Nicolas Grekas <p@tchwork.com>
  30.  *
  31.  * @internal
  32.  */
  33. trait RedisTrait
  34. {
  35.     private static $defaultConnectionOptions = [
  36.         'class' => null,
  37.         'persistent' => 0,
  38.         'persistent_id' => null,
  39.         'timeout' => 30,
  40.         'read_timeout' => 0,
  41.         'retry_interval' => 0,
  42.         'tcp_keepalive' => 0,
  43.         'lazy' => null,
  44.         'redis_cluster' => false,
  45.         'redis_sentinel' => null,
  46.         'dbindex' => 0,
  47.         'failover' => 'none',
  48.         'ssl' => null, // see https://php.net/context.ssl
  49.     ];
  50.     private $redis;
  51.     private $marshaller;
  53.     /**
  54.      * @param \Redis|\RedisArray|\RedisCluster|\Predis\ClientInterface|RedisProxy|RedisClusterProxy $redis
  55.      */
  56.     private function init($redis, string $namespace, int $defaultLifetime, ?MarshallerInterface $marshaller)
  57.     {
  58.         parent::__construct($namespace, $defaultLifetime);
  60.         if (preg_match('#[^-+_.A-Za-z0-9]#', $namespace, $match)) {
  61.             throw new InvalidArgumentException(sprintf('RedisAdapter namespace contains "%s" but only characters in [-+_.A-Za-z0-9] are allowed.', $match[0]));
  62.         }
  64.         if (!$redis instanceof \Redis && !$redis instanceof \RedisArray && !$redis instanceof \RedisCluster && !$redis instanceof \Predis\ClientInterface && !$redis instanceof RedisProxy && !$redis instanceof RedisClusterProxy) {
  65.             throw new InvalidArgumentException(sprintf('"%s()" expects parameter 1 to be Redis, RedisArray, RedisCluster or Predis\ClientInterface, "%s" given.', __METHOD__, get_debug_type($redis)));
  66.         }
  68.         if ($redis instanceof \Predis\ClientInterface && $redis->getOptions()->exceptions) {
  69.             $options = clone $redis->getOptions();
  70.             \Closure::bind(function () { $this->options['exceptions'] = false; }, $options, $options)();
  71.             $redis = new $redis($redis->getConnection(), $options);
  72.         }
  74.         $this->redis = $redis;
  75.         $this->marshaller = $marshaller ?? new DefaultMarshaller();
  76.     }
  78.     /**
  79.      * Creates a Redis connection using a DSN configuration.
  80.      *
  81.      * Example DSN:
  82.      *   - redis://localhost
  83.      *   - redis://example.com:1234
  84.      *   - redis://secret@example.com/13
  85.      *   - redis:///var/run/redis.sock
  86.      *   - redis://secret@/var/run/redis.sock/13
  87.      *
  88.      * @param array $options See self::$defaultConnectionOptions
  89.      *
  90.      * @return \Redis|\RedisArray|\RedisCluster|RedisClusterProxy|RedisProxy|\Predis\ClientInterface According to the "class" option
  91.      *
  92.      * @throws InvalidArgumentException when the DSN is invalid
  93.      */
  94.     public static function createConnection(string $dsn, array $options = [])
  95.     {
  96.         if (str_starts_with($dsn, 'redis:')) {
  97.             $scheme = 'redis';
  98.         } elseif (str_starts_with($dsn, 'rediss:')) {
  99.             $scheme = 'rediss';
  100.         } else {
  101.             throw new InvalidArgumentException('Invalid Redis DSN: it does not start with "redis[s]:".');
  102.         }
  104.         if (!\extension_loaded('redis') && !class_exists(\Predis\Client::class)) {
  105.             throw new CacheException('Cannot find the "redis" extension nor the "predis/predis" package.');
  106.         }
  108.         $params = preg_replace_callback('#^'.$scheme.':(//)?(?:(?:[^:@]*+:)?([^@]*+)@)?#', function ($m) use (&$auth) {
  109.             if (isset($m[2])) {
  110.                 $auth = rawurldecode($m[2]);
  112.                 if ('' === $auth) {
  113.                     $auth = null;
  114.                 }
  115.             }
  117.             return 'file:'.($m[1] ?? '');
  118.         }, $dsn);
  120.         if (false === $params = parse_url($params)) {
  121.             throw new InvalidArgumentException('Invalid Redis DSN.');
  122.         }
  124.         $query = $hosts = [];
  126.         $tls = 'rediss' === $scheme;
  127.         $tcpScheme = $tls ? 'tls' : 'tcp';
  129.         if (isset($params['query'])) {
  130.             parse_str($params['query'], $query);
  132.             if (isset($query['host'])) {
  133.                 if (!\is_array($hosts = $query['host'])) {
  134.                     throw new InvalidArgumentException('Invalid Redis DSN: query parameter "host" must be an array.');
  135.                 }
  136.                 foreach ($hosts as $host => $parameters) {
  137.                     if (\is_string($parameters)) {
  138.                         parse_str($parameters, $parameters);
  139.                     }
  140.                     if (false === $i = strrpos($host, ':')) {
  141.                         $hosts[$host] = ['scheme' => $tcpScheme, 'host' => $host, 'port' => 6379] + $parameters;
  142.                     } elseif ($port = (int) substr($host, 1 + $i)) {
  143.                         $hosts[$host] = ['scheme' => $tcpScheme, 'host' => substr($host, 0, $i), 'port' => $port] + $parameters;
  144.                     } else {
  145.                         $hosts[$host] = ['scheme' => 'unix', 'path' => substr($host, 0, $i)] + $parameters;
  146.                     }
  147.                 }
  148.                 $hosts = array_values($hosts);
  149.             }
  150.         }
  152.         if (isset($params['host']) || isset($params['path'])) {
  153.             if (!isset($params['dbindex']) && isset($params['path'])) {
  154.                 if (preg_match('#/(\d+)?$#', $params['path'], $m)) {
  155.                     $params['dbindex'] = $m[1] ?? $query['dbindex'] ?? '0';
  156.                     $params['path'] = substr($params['path'], 0, -\strlen($m[0]));
  157.                 } elseif (isset($params['host'])) {
  158.                     throw new InvalidArgumentException('Invalid Redis DSN: parameter "dbindex" must be a number.');
  159.                 }
  160.             }
  162.             if (isset($params['host'])) {
  163.                 array_unshift($hosts, ['scheme' => $tcpScheme, 'host' => $params['host'], 'port' => $params['port'] ?? 6379]);
  164.             } else {
  165.                 array_unshift($hosts, ['scheme' => 'unix', 'path' => $params['path']]);
  166.             }
  167.         }
  169.         if (!$hosts) {
  170.             throw new InvalidArgumentException('Invalid Redis DSN: missing host.');
  171.         }
  173.         if (isset($params['dbindex'], $query['dbindex']) && $params['dbindex'] !== $query['dbindex']) {
  174.             throw new InvalidArgumentException('Invalid Redis DSN: path and query "dbindex" parameters mismatch.');
  175.         }
  177.         $params += $query + $options + self::$defaultConnectionOptions;
  179.         if (isset($params['redis_sentinel']) && !class_exists(\Predis\Client::class) && !class_exists(\RedisSentinel::class)) {
  180.             throw new CacheException('Redis Sentinel support requires the "predis/predis" package or the "redis" extension v5.2 or higher.');
  181.         }
  183.         if (isset($params['lazy'])) {
  184.             $params['lazy'] = filter_var($params['lazy'], \FILTER_VALIDATE_BOOLEAN);
  185.         }
  186.         $params['redis_cluster'] = filter_var($params['redis_cluster'], \FILTER_VALIDATE_BOOLEAN);
  188.         if ($params['redis_cluster'] && isset($params['redis_sentinel'])) {
  189.             throw new InvalidArgumentException('Cannot use both "redis_cluster" and "redis_sentinel" at the same time.');
  190.         }
  192.         if (null === $params['class'] && \extension_loaded('redis')) {
  193.             $class = $params['redis_cluster'] ? \RedisCluster::class : (1 < \count($hosts) && !isset($params['redis_sentinel']) ? \RedisArray::class : \Redis::class);
  194.         } else {
  195.             $class = $params['class'] ?? \Predis\Client::class;
  197.             if (isset($params['redis_sentinel']) && !is_a($class, \Predis\Client::class, true) && !class_exists(\RedisSentinel::class)) {
  198.                 throw new CacheException(sprintf('Cannot use Redis Sentinel: class "%s" does not extend "Predis\Client" and ext-redis >= 5.2 not found.', $class));
  199.             }
  200.         }
  202.         if (is_a($class, \Redis::class, true)) {
  203.             $connect = $params['persistent'] || $params['persistent_id'] ? 'pconnect' : 'connect';
  204.             $redis = new $class();
  206.             $initializer = static function ($redis) use ($connect, $params, $auth, $hosts, $tls) {
  207.                 $hostIndex = 0;
  208.                 do {
  209.                     $host = $hosts[$hostIndex]['host'] ?? $hosts[$hostIndex]['path'];
  210.                     $port = $hosts[$hostIndex]['port'] ?? 0;
  211.                     $passAuth = \defined('Redis::OPT_NULL_MULTIBULK_AS_NULL') && isset($params['auth']);
  212.                     $address = false;
  214.                     if (isset($hosts[$hostIndex]['host']) && $tls) {
  215.                         $host = 'tls://'.$host;
  216.                     }
  218.                     if (!isset($params['redis_sentinel'])) {
  219.                         break;
  220.                     }
  222.                     if (version_compare(phpversion('redis'), '6.0.0', '>=')) {
  223.                         $options = [
  224.                             'host' => $host,
  225.                             'port' => $port,
  226.                             'connectTimeout' => $params['timeout'],
  227.                             'persistent' => $params['persistent_id'],
  228.                             'retryInterval' => $params['retry_interval'],
  229.                             'readTimeout' => $params['read_timeout'],
  230.                         ];
  232.                         if ($passAuth) {
  233.                             $options['auth'] = $params['auth'];
  234.                         }
  236.                         $sentinel = new \RedisSentinel($options);
  237.                     } else {
  238.                         $extra = $passAuth ? [$params['auth']] : [];
  240.                         $sentinel = new \RedisSentinel($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...$extra);
  241.                     }
  243.                     try {
  244.                         if ($address = $sentinel->getMasterAddrByName($params['redis_sentinel'])) {
  245.                             [$host, $port] = $address;
  246.                         }
  247.                     } catch (\RedisException $e) {
  248.                     }
  249.                 } while (++$hostIndex < \count($hosts) && !$address);
  251.                 if (isset($params['redis_sentinel']) && !$address) {
  252.                     throw new InvalidArgumentException(sprintf('Failed to retrieve master information from sentinel "%s".', $params['redis_sentinel']));
  253.                 }
  255.                 try {
  256.                     $extra = [
  257.                         'stream' => $params['ssl'] ?? null,
  258.                     ];
  259.                     $booleanStreamOptions = [
  260.                         'allow_self_signed',
  261.                         'capture_peer_cert',
  262.                         'capture_peer_cert_chain',
  263.                         'disable_compression',
  264.                         'SNI_enabled',
  265.                         'verify_peer',
  266.                         'verify_peer_name',
  267.                     ];
  269.                     foreach ($extra['stream'] ?? [] as $streamOption => $value) {
  270.                         if (\in_array($streamOption, $booleanStreamOptions, true) && \is_string($value)) {
  271.                             $extra['stream'][$streamOption] = filter_var($value, \FILTER_VALIDATE_BOOL);
  272.                         }
  273.                     }
  275.                     if (isset($params['auth'])) {
  276.                         $extra['auth'] = $params['auth'];
  277.                     }
  278.                     @$redis->{$connect}($host, $port, $params['timeout'], (string) $params['persistent_id'], $params['retry_interval'], $params['read_timeout'], ...\defined('Redis::SCAN_PREFIX') ? [$extra] : []);
  280.                     set_error_handler(function ($type, $msg) use (&$error) { $error = $msg; });
  281.                     try {
  282.                         $isConnected = $redis->isConnected();
  283.                     } finally {
  284.                         restore_error_handler();
  285.                     }
  286.                     if (!$isConnected) {
  287.                         $error = preg_match('/^Redis::p?connect\(\): (.*)/', $error ?? $redis->getLastError() ?? '', $error) ? sprintf(' (%s)', $error[1]) : '';
  288.                         throw new InvalidArgumentException('Redis connection failed: '.$error.'.');
  289.                     }
  291.                     if ((null !== $auth && !$redis->auth($auth))
  292.                         // Due to a bug in phpredis we must always select the dbindex if persistent pooling is enabled
  293.                         // @see https://github.com/phpredis/phpredis/issues/1920
  294.                         // @see https://github.com/symfony/symfony/issues/51578
  295.                         || (($params['dbindex'] || ('pconnect' === $connect && '0' !== \ini_get('redis.pconnect.pooling_enabled'))) && !$redis->select($params['dbindex']))
  296.                     ) {
  297.                         $e = preg_replace('/^ERR /', '', $redis->getLastError());
  298.                         throw new InvalidArgumentException('Redis connection failed: '.$e.'.');
  299.                     }
  301.                     if (0 < $params['tcp_keepalive'] && \defined('Redis::OPT_TCP_KEEPALIVE')) {
  302.                         $redis->setOption(\Redis::OPT_TCP_KEEPALIVE, $params['tcp_keepalive']);
  303.                     }
  304.                 } catch (\RedisException $e) {
  305.                     throw new InvalidArgumentException('Redis connection failed: '.$e->getMessage());
  306.                 }
  308.                 return true;
  309.             };
  311.             if ($params['lazy']) {
  312.                 $redis = new RedisProxy($redis, $initializer);
  313.             } else {
  314.                 $initializer($redis);
  315.             }
  316.         } elseif (is_a($class, \RedisArray::class, true)) {
  317.             foreach ($hosts as $i => $host) {
  318.                 switch ($host['scheme']) {
  319.                     case 'tcp': $hosts[$i] = $host['host'].':'.$host['port']; break;
  320.                     case 'tls': $hosts[$i] = 'tls://'.$host['host'].':'.$host['port']; break;
  321.                     default: $hosts[$i] = $host['path'];
  322.                 }
  323.             }
  324.             $params['lazy_connect'] = $params['lazy'] ?? true;
  325.             $params['connect_timeout'] = $params['timeout'];
  327.             try {
  328.                 $redis = new $class($hosts, $params);
  329.             } catch (\RedisClusterException $e) {
  330.                 throw new InvalidArgumentException('Redis connection failed: '.$e->getMessage());
  331.             }
  333.             if (0 < $params['tcp_keepalive'] && \defined('Redis::OPT_TCP_KEEPALIVE')) {
  334.                 $redis->setOption(\Redis::OPT_TCP_KEEPALIVE, $params['tcp_keepalive']);
  335.             }
  336.         } elseif (is_a($class, \RedisCluster::class, true)) {
  337.             $initializer = static function () use ($class, $params, $hosts) {
  338.                 foreach ($hosts as $i => $host) {
  339.                     switch ($host['scheme']) {
  340.                         case 'tcp': $hosts[$i] = $host['host'].':'.$host['port']; break;
  341.                         case 'tls': $hosts[$i] = 'tls://'.$host['host'].':'.$host['port']; break;
  342.                         default: $hosts[$i] = $host['path'];
  343.                     }
  344.                 }
  346.                 try {
  347.                     $redis = new $class(null, $hosts, $params['timeout'], $params['read_timeout'], (bool) $params['persistent'], $params['auth'] ?? '', ...\defined('Redis::SCAN_PREFIX') ? [$params['ssl'] ?? null] : []);
  348.                 } catch (\RedisClusterException $e) {
  349.                     throw new InvalidArgumentException('Redis connection failed: '.$e->getMessage());
  350.                 }
  352.                 if (0 < $params['tcp_keepalive'] && \defined('Redis::OPT_TCP_KEEPALIVE')) {
  353.                     $redis->setOption(\Redis::OPT_TCP_KEEPALIVE, $params['tcp_keepalive']);
  354.                 }
  355.                 switch ($params['failover']) {
  356.                     case 'error': $redis->setOption(\RedisCluster::OPT_SLAVE_FAILOVER, \RedisCluster::FAILOVER_ERROR); break;
  357.                     case 'distribute': $redis->setOption(\RedisCluster::OPT_SLAVE_FAILOVER, \RedisCluster::FAILOVER_DISTRIBUTE); break;
  358.                     case 'slaves': $redis->setOption(\RedisCluster::OPT_SLAVE_FAILOVER, \RedisCluster::FAILOVER_DISTRIBUTE_SLAVES); break;
  359.                 }
  361.                 return $redis;
  362.             };
  364.             $redis = $params['lazy'] ? new RedisClusterProxy($initializer) : $initializer();
  365.         } elseif (is_a($class, \Predis\ClientInterface::class, true)) {
  366.             if ($params['redis_cluster']) {
  367.                 $params['cluster'] = 'redis';
  368.             } elseif (isset($params['redis_sentinel'])) {
  369.                 $params['replication'] = 'sentinel';
  370.                 $params['service'] = $params['redis_sentinel'];
  371.             }
  372.             $params += ['parameters' => []];
  373.             $params['parameters'] += [
  374.                 'persistent' => $params['persistent'],
  375.                 'timeout' => $params['timeout'],
  376.                 'read_write_timeout' => $params['read_timeout'],
  377.                 'tcp_nodelay' => true,
  378.             ];
  379.             if ($params['dbindex']) {
  380.                 $params['parameters']['database'] = $params['dbindex'];
  381.             }
  382.             if (null !== $auth) {
  383.                 $params['parameters']['password'] = $auth;
  384.             }
  386.             if (isset($params['ssl'])) {
  387.                 foreach ($hosts as $i => $host) {
  388.                     if (!isset($host['ssl'])) {
  389.                         $hosts[$i]['ssl'] = $params['ssl'];
  390.                     }
  391.                 }
  392.             }
  394.             if (1 === \count($hosts) && !($params['redis_cluster'] || $params['redis_sentinel'])) {
  395.                 $hosts = $hosts[0];
  396.             } elseif (\in_array($params['failover'], ['slaves', 'distribute'], true) && !isset($params['replication'])) {
  397.                 $params['replication'] = true;
  398.                 $hosts[0] += ['alias' => 'master'];
  399.             }
  400.             $params['exceptions'] = false;
  402.             $redis = new $class($hosts, array_diff_key($params, self::$defaultConnectionOptions));
  403.             if (isset($params['redis_sentinel'])) {
  404.                 $redis->getConnection()->setSentinelTimeout($params['timeout']);
  405.             }
  406.         } elseif (class_exists($class, false)) {
  407.             throw new InvalidArgumentException(sprintf('"%s" is not a subclass of "Redis", "RedisArray", "RedisCluster" nor "Predis\ClientInterface".', $class));
  408.         } else {
  409.             throw new InvalidArgumentException(sprintf('Class "%s" does not exist.', $class));
  410.         }
  412.         return $redis;
  413.     }
  415.     protected function doFetch(array $ids)
  416.     {
  417.         if (!$ids) {
  418.             return [];
  419.         }
  421.         $result = [];
  423.         if ($this->redis instanceof \Predis\ClientInterface && ($this->redis->getConnection() instanceof ClusterInterface || $this->redis->getConnection() instanceof Predis2ClusterInterface)) {
  424.             $values = $this->pipeline(function () use ($ids) {
  425.                 foreach ($ids as $id) {
  426.                     yield 'get' => [$id];
  427.                 }
  428.             });
  429.         } else {
  430.             $values = $this->redis->mget($ids);
  432.             if (!\is_array($values) || \count($values) !== \count($ids)) {
  433.                 return [];
  434.             }
  436.             $values = array_combine($ids, $values);
  437.         }
  439.         foreach ($values as $id => $v) {
  440.             if ($v) {
  441.                 $result[$id] = $this->marshaller->unmarshall($v);
  442.             }
  443.         }
  445.         return $result;
  446.     }
  448.     protected function doHave(string $id)
  449.     {
  450.         return (bool) $this->redis->exists($id);
  451.     }
  453.     protected function doClear(string $namespace)
  454.     {
  455.         if ($this->redis instanceof \Predis\ClientInterface) {
  456.             $prefix = $this->redis->getOptions()->prefix ? $this->redis->getOptions()->prefix->getPrefix() : '';
  457.             $prefixLen = \strlen($prefix ?? '');
  458.         }
  460.         $cleared = true;
  461.         $hosts = $this->getHosts();
  462.         $host = reset($hosts);
  463.         if ($host instanceof \Predis\Client && $host->getConnection() instanceof ReplicationInterface) {
  464.             // Predis supports info command only on the master in replication environments
  465.             $hosts = [$host->getClientFor('master')];
  466.         }
  468.         foreach ($hosts as $host) {
  469.             if (!isset($namespace[0])) {
  470.                 $cleared = $host->flushDb() && $cleared;
  471.                 continue;
  472.             }
  474.             $info = $host->info('Server');
  475.             $info = !$info instanceof ErrorInterface ? $info['Server'] ?? $info : ['redis_version' => '2.0'];
  477.             if (!$host instanceof \Predis\ClientInterface) {
  478.                 $prefix = \defined('Redis::SCAN_PREFIX') && (\Redis::SCAN_PREFIX & $host->getOption(\Redis::OPT_SCAN)) ? '' : $host->getOption(\Redis::OPT_PREFIX);
  479.                 $prefixLen = \strlen($host->getOption(\Redis::OPT_PREFIX) ?? '');
  480.             }
  481.             $pattern = $prefix.$namespace.'*';
  483.             if (!version_compare($info['redis_version'], '2.8', '>=')) {
  484.                 // As documented in Redis documentation (http://redis.io/commands/keys) using KEYS
  485.                 // can hang your server when it is executed against large databases (millions of items).
  486.                 // Whenever you hit this scale, you should really consider upgrading to Redis 2.8 or above.
  487.                 $unlink = version_compare($info['redis_version'], '4.0', '>=') ? 'UNLINK' : 'DEL';
  488.                 $args = $this->redis instanceof \Predis\ClientInterface ? [0, $pattern] : [[$pattern], 0];
  489.                 $cleared = $host->eval("local keys=redis.call('KEYS',ARGV[1]) for i=1,#keys,5000 do redis.call('$unlink',unpack(keys,i,math.min(i+4999,#keys))) end return 1", $args[0], $args[1]) && $cleared;
  490.                 continue;
  491.             }
  493.             $cursor = null;
  494.             do {
  495.                 $keys = $host instanceof \Predis\ClientInterface ? $host->scan($cursor, 'MATCH', $pattern, 'COUNT', 1000) : $host->scan($cursor, $pattern, 1000);
  496.                 if (isset($keys[1]) && \is_array($keys[1])) {
  497.                     $cursor = $keys[0];
  498.                     $keys = $keys[1];
  499.                 }
  500.                 if ($keys) {
  501.                     if ($prefixLen) {
  502.                         foreach ($keys as $i => $key) {
  503.                             $keys[$i] = substr($key, $prefixLen);
  504.                         }
  505.                     }
  506.                     $this->doDelete($keys);
  507.                 }
  508.             } while ($cursor);
  509.         }
  511.         return $cleared;
  512.     }
  514.     protected function doDelete(array $ids)
  515.     {
  516.         if (!$ids) {
  517.             return true;
  518.         }
  520.         if ($this->redis instanceof \Predis\ClientInterface && ($this->redis->getConnection() instanceof ClusterInterface || $this->redis->getConnection() instanceof Predis2ClusterInterface)) {
  521.             static $del;
  522.             $del = $del ?? (class_exists(UNLINK::class) ? 'unlink' : 'del');
  524.             $this->pipeline(function () use ($ids, $del) {
  525.                 foreach ($ids as $id) {
  526.                     yield $del => [$id];
  527.                 }
  528.             })->rewind();
  529.         } else {
  530.             static $unlink = true;
  532.             if ($unlink) {
  533.                 try {
  534.                     $unlink = false !== $this->redis->unlink($ids);
  535.                 } catch (\Throwable $e) {
  536.                     $unlink = false;
  537.                 }
  538.             }
  540.             if (!$unlink) {
  541.                 $this->redis->del($ids);
  542.             }
  543.         }
  545.         return true;
  546.     }
  548.     protected function doSave(array $values, int $lifetime)
  549.     {
  550.         if (!$values = $this->marshaller->marshall($values, $failed)) {
  551.             return $failed;
  552.         }
  554.         $results = $this->pipeline(function () use ($values, $lifetime) {
  555.             foreach ($values as $id => $value) {
  556.                 if (0 >= $lifetime) {
  557.                     yield 'set' => [$id, $value];
  558.                 } else {
  559.                     yield 'setEx' => [$id, $lifetime, $value];
  560.                 }
  561.             }
  562.         });
  564.         foreach ($results as $id => $result) {
  565.             if (true !== $result && (!$result instanceof Status || Status::get('OK') !== $result)) {
  566.                 $failed[] = $id;
  567.             }
  568.         }
  570.         return $failed;
  571.     }
  573.     private function pipeline(\Closure $generator, ?object $redis = null): \Generator
  574.     {
  575.         $ids = [];
  576.         $redis = $redis ?? $this->redis;
  578.         if ($redis instanceof RedisClusterProxy || $redis instanceof \RedisCluster || ($redis instanceof \Predis\ClientInterface && ($redis->getConnection() instanceof RedisCluster || $redis->getConnection() instanceof Predis2RedisCluster))) {
  579.             // phpredis & predis don't support pipelining with RedisCluster
  580.             // see https://github.com/phpredis/phpredis/blob/develop/cluster.markdown#pipelining
  581.             // see https://github.com/nrk/predis/issues/267#issuecomment-123781423
  582.             $results = [];
  583.             foreach ($generator() as $command => $args) {
  584.                 $results[] = $redis->{$command}(...$args);
  585.                 $ids[] = 'eval' === $command ? ($redis instanceof \Predis\ClientInterface ? $args[2] : $args[1][0]) : $args[0];
  586.             }
  587.         } elseif ($redis instanceof \Predis\ClientInterface) {
  588.             $results = $redis->pipeline(static function ($redis) use ($generator, &$ids) {
  589.                 foreach ($generator() as $command => $args) {
  590.                     $redis->{$command}(...$args);
  591.                     $ids[] = 'eval' === $command ? $args[2] : $args[0];
  592.                 }
  593.             });
  594.         } elseif ($redis instanceof \RedisArray) {
  595.             $connections = $results = $ids = [];
  596.             foreach ($generator() as $command => $args) {
  597.                 $id = 'eval' === $command ? $args[1][0] : $args[0];
  598.                 if (!isset($connections[$h = $redis->_target($id)])) {
  599.                     $connections[$h] = [$redis->_instance($h), -1];
  600.                     $connections[$h][0]->multi(\Redis::PIPELINE);
  601.                 }
  602.                 $connections[$h][0]->{$command}(...$args);
  603.                 $results[] = [$h, ++$connections[$h][1]];
  604.                 $ids[] = $id;
  605.             }
  606.             foreach ($connections as $h => $c) {
  607.                 $connections[$h] = $c[0]->exec();
  608.             }
  609.             foreach ($results as $k => [$h, $c]) {
  610.                 $results[$k] = $connections[$h][$c];
  611.             }
  612.         } else {
  613.             $redis->multi(\Redis::PIPELINE);
  614.             foreach ($generator() as $command => $args) {
  615.                 $redis->{$command}(...$args);
  616.                 $ids[] = 'eval' === $command ? $args[1][0] : $args[0];
  617.             }
  618.             $results = $redis->exec();
  619.         }
  621.         if (!$redis instanceof \Predis\ClientInterface && 'eval' === $command && $redis->getLastError()) {
  622.             $e = new \RedisException($redis->getLastError());
  623.             $results = array_map(function ($v) use ($e) { return false === $v ? $e : $v; }, (array) $results);
  624.         }
  626.         if (\is_bool($results)) {
  627.             return;
  628.         }
  630.         foreach ($ids as $k => $id) {
  631.             yield $id => $results[$k];
  632.         }
  633.     }
  635.     private function getHosts(): array
  636.     {
  637.         $hosts = [$this->redis];
  638.         if ($this->redis instanceof \Predis\ClientInterface) {
  639.             $connection = $this->redis->getConnection();
  640.             if (($connection instanceof ClusterInterface || $connection instanceof Predis2ClusterInterface) && $connection instanceof \Traversable) {
  641.                 $hosts = [];
  642.                 foreach ($connection as $c) {
  643.                     $hosts[] = new \Predis\Client($c);
  644.                 }
  645.             }
  646.         } elseif ($this->redis instanceof \RedisArray) {
  647.             $hosts = [];
  648.             foreach ($this->redis->_hosts() as $host) {
  649.                 $hosts[] = $this->redis->_instance($host);
  650.             }
  651.         } elseif ($this->redis instanceof RedisClusterProxy || $this->redis instanceof \RedisCluster) {
  652.             $hosts = [];
  653.             foreach ($this->redis->_masters() as $host) {
  654.                 $hosts[] = new RedisClusterNodeProxy($host, $this->redis);
  655.             }
  656.         }
  658.         return $hosts;
  659.     }
  660. }