vendor/symfony/cache/Adapter/MemcachedAdapter.php line 266

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\Adapter;
  14. use Symfony\Component\Cache\Exception\CacheException;
  15. use Symfony\Component\Cache\Exception\InvalidArgumentException;
  16. use Symfony\Component\Cache\Marshaller\DefaultMarshaller;
  17. use Symfony\Component\Cache\Marshaller\MarshallerInterface;
  19. /**
  20.  * @author Rob Frawley 2nd <rmf@src.run>
  21.  * @author Nicolas Grekas <p@tchwork.com>
  22.  */
  23. class MemcachedAdapter extends AbstractAdapter
  24. {
  25.     /**
  26.      * We are replacing characters that are illegal in Memcached keys with reserved characters from
  27.      * {@see \Symfony\Contracts\Cache\ItemInterface::RESERVED_CHARACTERS} that are legal in Memcached.
  28.      * Note: don’t use {@see \Symfony\Component\Cache\Adapter\AbstractAdapter::NS_SEPARATOR}.
  29.      */
  30.     private const RESERVED_MEMCACHED = " \n\r\t\v\f\0";
  31.     private const RESERVED_PSR6 = '@()\{}/';
  33.     protected $maxIdLength = 250;
  35.     private const DEFAULT_CLIENT_OPTIONS = [
  36.         'persistent_id' => null,
  37.         'username' => null,
  38.         'password' => null,
  39.         \Memcached::OPT_SERIALIZER => \Memcached::SERIALIZER_PHP,
  40.     ];
  42.     private $marshaller;
  43.     private $client;
  44.     private $lazyClient;
  46.     /**
  47.      * Using a MemcachedAdapter with a TagAwareAdapter for storing tags is discouraged.
  48.      * Using a RedisAdapter is recommended instead. If you cannot do otherwise, be aware that:
  49.      * - the Memcached::OPT_BINARY_PROTOCOL must be enabled
  50.      *   (that's the default when using MemcachedAdapter::createConnection());
  51.      * - tags eviction by Memcached's LRU algorithm will break by-tags invalidation;
  52.      *   your Memcached memory should be large enough to never trigger LRU.
  53.      *
  54.      * Using a MemcachedAdapter as a pure items store is fine.
  55.      */
  56.     public function __construct(\Memcached $client, string $namespace = '', int $defaultLifetime = 0, MarshallerInterface $marshaller = null)
  57.     {
  58.         if (!static::isSupported()) {
  59.             throw new CacheException('Memcached '.(\PHP_VERSION_ID >= 80100 ? '> 3.1.5' : '>= 2.2.0').' is required.');
  60.         }
  61.         if ('Memcached' === \get_class($client)) {
  62.             $opt = $client->getOption(\Memcached::OPT_SERIALIZER);
  63.             if (\Memcached::SERIALIZER_PHP !== $opt && \Memcached::SERIALIZER_IGBINARY !== $opt) {
  64.                 throw new CacheException('MemcachedAdapter: "serializer" option must be "php" or "igbinary".');
  65.             }
  66.             $this->maxIdLength -= \strlen($client->getOption(\Memcached::OPT_PREFIX_KEY));
  67.             $this->client = $client;
  68.         } else {
  69.             $this->lazyClient = $client;
  70.         }
  72.         parent::__construct($namespace, $defaultLifetime);
  73.         $this->enableVersioning();
  74.         $this->marshaller = $marshaller ?? new DefaultMarshaller();
  75.     }
  77.     public static function isSupported()
  78.     {
  79.         return \extension_loaded('memcached') && version_compare(phpversion('memcached'), \PHP_VERSION_ID >= 80100 ? '3.1.6' : '2.2.0', '>=');
  80.     }
  82.     /**
  83.      * Creates a Memcached instance.
  84.      *
  85.      * By default, the binary protocol, no block, and libketama compatible options are enabled.
  86.      *
  87.      * Examples for servers:
  88.      * - 'memcached://user:pass@localhost?weight=33'
  89.      * - [['localhost', 11211, 33]]
  90.      *
  91.      * @param array[]|string|string[] $servers An array of servers, a DSN, or an array of DSNs
  92.      *
  93.      * @return \Memcached
  94.      *
  95.      * @throws \ErrorException When invalid options or servers are provided
  96.      */
  97.     public static function createConnection($servers, array $options = [])
  98.     {
  99.         if (\is_string($servers)) {
  100.             $servers = [$servers];
  101.         } elseif (!\is_array($servers)) {
  102.             throw new InvalidArgumentException(sprintf('MemcachedAdapter::createClient() expects array or string as first argument, "%s" given.', get_debug_type($servers)));
  103.         }
  104.         if (!static::isSupported()) {
  105.             throw new CacheException('Memcached '.(\PHP_VERSION_ID >= 80100 ? '> 3.1.5' : '>= 2.2.0').' is required.');
  106.         }
  107.         set_error_handler(function ($type, $msg, $file, $line) { throw new \ErrorException($msg, 0, $type, $file, $line); });
  108.         try {
  109.             $options += static::DEFAULT_CLIENT_OPTIONS;
  110.             $client = new \Memcached($options['persistent_id']);
  111.             $username = $options['username'];
  112.             $password = $options['password'];
  114.             // parse any DSN in $servers
  115.             foreach ($servers as $i => $dsn) {
  116.                 if (\is_array($dsn)) {
  117.                     continue;
  118.                 }
  119.                 if (!str_starts_with($dsn, 'memcached:')) {
  120.                     throw new InvalidArgumentException(sprintf('Invalid Memcached DSN: "%s" does not start with "memcached:".', $dsn));
  121.                 }
  122.                 $params = preg_replace_callback('#^memcached:(//)?(?:([^@]*+)@)?#', function ($m) use (&$username, &$password) {
  123.                     if (!empty($m[2])) {
  124.                         [$username, $password] = explode(':', $m[2], 2) + [1 => null];
  125.                     }
  127.                     return 'file:'.($m[1] ?? '');
  128.                 }, $dsn);
  129.                 if (false === $params = parse_url($params)) {
  130.                     throw new InvalidArgumentException(sprintf('Invalid Memcached DSN: "%s".', $dsn));
  131.                 }
  132.                 $query = $hosts = [];
  133.                 if (isset($params['query'])) {
  134.                     parse_str($params['query'], $query);
  136.                     if (isset($query['host'])) {
  137.                         if (!\is_array($hosts = $query['host'])) {
  138.                             throw new InvalidArgumentException(sprintf('Invalid Memcached DSN: "%s".', $dsn));
  139.                         }
  140.                         foreach ($hosts as $host => $weight) {
  141.                             if (false === $port = strrpos($host, ':')) {
  142.                                 $hosts[$host] = [$host, 11211, (int) $weight];
  143.                             } else {
  144.                                 $hosts[$host] = [substr($host, 0, $port), (int) substr($host, 1 + $port), (int) $weight];
  145.                             }
  146.                         }
  147.                         $hosts = array_values($hosts);
  148.                         unset($query['host']);
  149.                     }
  150.                     if ($hosts && !isset($params['host']) && !isset($params['path'])) {
  151.                         unset($servers[$i]);
  152.                         $servers = array_merge($servers, $hosts);
  153.                         continue;
  154.                     }
  155.                 }
  156.                 if (!isset($params['host']) && !isset($params['path'])) {
  157.                     throw new InvalidArgumentException(sprintf('Invalid Memcached DSN: "%s".', $dsn));
  158.                 }
  159.                 if (isset($params['path']) && preg_match('#/(\d+)$#', $params['path'], $m)) {
  160.                     $params['weight'] = $m[1];
  161.                     $params['path'] = substr($params['path'], 0, -\strlen($m[0]));
  162.                 }
  163.                 $params += [
  164.                     'host' => $params['host'] ?? $params['path'],
  165.                     'port' => isset($params['host']) ? 11211 : null,
  166.                     'weight' => 0,
  167.                 ];
  168.                 if ($query) {
  169.                     $params += $query;
  170.                     $options = $query + $options;
  171.                 }
  173.                 $servers[$i] = [$params['host'], $params['port'], $params['weight']];
  175.                 if ($hosts) {
  176.                     $servers = array_merge($servers, $hosts);
  177.                 }
  178.             }
  180.             // set client's options
  181.             unset($options['persistent_id'], $options['username'], $options['password'], $options['weight'], $options['lazy']);
  182.             $options = array_change_key_case($options, \CASE_UPPER);
  183.             $client->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
  184.             $client->setOption(\Memcached::OPT_NO_BLOCK, true);
  185.             $client->setOption(\Memcached::OPT_TCP_NODELAY, true);
  186.             if (!\array_key_exists('LIBKETAMA_COMPATIBLE', $options) && !\array_key_exists(\Memcached::OPT_LIBKETAMA_COMPATIBLE, $options)) {
  187.                 $client->setOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
  188.             }
  189.             foreach ($options as $name => $value) {
  190.                 if (\is_int($name)) {
  191.                     continue;
  192.                 }
  193.                 if ('HASH' === $name || 'SERIALIZER' === $name || 'DISTRIBUTION' === $name) {
  194.                     $value = \constant('Memcached::'.$name.'_'.strtoupper($value));
  195.                 }
  196.                 unset($options[$name]);
  198.                 if (\defined('Memcached::OPT_'.$name)) {
  199.                     $options[\constant('Memcached::OPT_'.$name)] = $value;
  200.                 }
  201.             }
  202.             $client->setOptions($options);
  204.             // set client's servers, taking care of persistent connections
  205.             if (!$client->isPristine()) {
  206.                 $oldServers = [];
  207.                 foreach ($client->getServerList() as $server) {
  208.                     $oldServers[] = [$server['host'], $server['port']];
  209.                 }
  211.                 $newServers = [];
  212.                 foreach ($servers as $server) {
  213.                     if (1 < \count($server)) {
  214.                         $server = array_values($server);
  215.                         unset($server[2]);
  216.                         $server[1] = (int) $server[1];
  217.                     }
  218.                     $newServers[] = $server;
  219.                 }
  221.                 if ($oldServers !== $newServers) {
  222.                     $client->resetServerList();
  223.                     $client->addServers($servers);
  224.                 }
  225.             } else {
  226.                 $client->addServers($servers);
  227.             }
  229.             if (null !== $username || null !== $password) {
  230.                 if (!method_exists($client, 'setSaslAuthData')) {
  231.                     trigger_error('Missing SASL support: the memcached extension must be compiled with --enable-memcached-sasl.');
  232.                 }
  233.                 $client->setSaslAuthData($username, $password);
  234.             }
  236.             return $client;
  237.         } finally {
  238.             restore_error_handler();
  239.         }
  240.     }
  242.     /**
  243.      * {@inheritdoc}
  244.      */
  245.     protected function doSave(array $values, int $lifetime)
  246.     {
  247.         if (!$values = $this->marshaller->marshall($values, $failed)) {
  248.             return $failed;
  249.         }
  251.         if ($lifetime && $lifetime > 30 * 86400) {
  252.             $lifetime += time();
  253.         }
  255.         $encodedValues = [];
  256.         foreach ($values as $key => $value) {
  257.             $encodedValues[self::encodeKey($key)] = $value;
  258.         }
  260.         return $this->checkResultCode($this->getClient()->setMulti($encodedValues, $lifetime)) ? $failed : false;
  261.     }
  263.     /**
  264.      * {@inheritdoc}
  265.      */
  266.     protected function doFetch(array $ids)
  267.     {
  268.         try {
  269.             $encodedIds = array_map([__CLASS__, 'encodeKey'], $ids);
  271.             $encodedResult = $this->checkResultCode($this->getClient()->getMulti($encodedIds));
  273.             $result = [];
  274.             foreach ($encodedResult as $key => $value) {
  275.                 $result[self::decodeKey($key)] = $this->marshaller->unmarshall($value);
  276.             }
  278.             return $result;
  279.         } catch (\Error $e) {
  280.             throw new \ErrorException($e->getMessage(), $e->getCode(), \E_ERROR, $e->getFile(), $e->getLine());
  281.         }
  282.     }
  284.     /**
  285.      * {@inheritdoc}
  286.      */
  287.     protected function doHave(string $id)
  288.     {
  289.         return false !== $this->getClient()->get(self::encodeKey($id)) || $this->checkResultCode(\Memcached::RES_SUCCESS === $this->client->getResultCode());
  290.     }
  292.     /**
  293.      * {@inheritdoc}
  294.      */
  295.     protected function doDelete(array $ids)
  296.     {
  297.         $ok = true;
  298.         $encodedIds = array_map([__CLASS__, 'encodeKey'], $ids);
  299.         foreach ($this->checkResultCode($this->getClient()->deleteMulti($encodedIds)) as $result) {
  300.             if (\Memcached::RES_SUCCESS !== $result && \Memcached::RES_NOTFOUND !== $result) {
  301.                 $ok = false;
  302.             }
  303.         }
  305.         return $ok;
  306.     }
  308.     /**
  309.      * {@inheritdoc}
  310.      */
  311.     protected function doClear(string $namespace)
  312.     {
  313.         return '' === $namespace && $this->getClient()->flush();
  314.     }
  316.     private function checkResultCode($result)
  317.     {
  318.         $code = $this->client->getResultCode();
  320.         if (\Memcached::RES_SUCCESS === $code || \Memcached::RES_NOTFOUND === $code) {
  321.             return $result;
  322.         }
  324.         throw new CacheException('MemcachedAdapter client error: '.strtolower($this->client->getResultMessage()));
  325.     }
  327.     private function getClient(): \Memcached
  328.     {
  329.         if ($this->client) {
  330.             return $this->client;
  331.         }
  333.         $opt = $this->lazyClient->getOption(\Memcached::OPT_SERIALIZER);
  334.         if (\Memcached::SERIALIZER_PHP !== $opt && \Memcached::SERIALIZER_IGBINARY !== $opt) {
  335.             throw new CacheException('MemcachedAdapter: "serializer" option must be "php" or "igbinary".');
  336.         }
  337.         if ('' !== $prefix = (string) $this->lazyClient->getOption(\Memcached::OPT_PREFIX_KEY)) {
  338.             throw new CacheException(sprintf('MemcachedAdapter: "prefix_key" option must be empty when using proxified connections, "%s" given.', $prefix));
  339.         }
  341.         return $this->client = $this->lazyClient;
  342.     }
  344.     private static function encodeKey(string $key): string
  345.     {
  346.         return strtr($key, self::RESERVED_MEMCACHED, self::RESERVED_PSR6);
  347.     }
  349.     private static function decodeKey(string $key): string
  350.     {
  351.         return strtr($key, self::RESERVED_PSR6, self::RESERVED_MEMCACHED);
  352.     }
  353. }