9.5/_redis_backend_8php_source.html

<?php

namespace ‪TYPO3\CMS\Core\Cache\Backend;


/*

 * This file is part of the TYPO3 CMS project.

 *

 * It is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, either version 2

 * of the License, or any later version.

 *

 * For the full copyright and license information, please read the

 * LICENSE.txt file that was distributed with this source code.

 *

 * The TYPO3 project - inspiring people to share!

 */


use ‪TYPO3\CMS\Core\Cache\Exception;

use ‪TYPO3\CMS\Core\Cache\Exception\InvalidDataException;

use ‪TYPO3\CMS\Core\Utility\StringUtility;


class ‪RedisBackend extends ‪AbstractBackend implements ‪TaggableBackendInterface

{

    const ‪FAKED_UNLIMITED_LIFETIME = 31536000;

    const ‪IDENTIFIER_DATA_PREFIX = 'identData:';

    const ‪IDENTIFIER_TAGS_PREFIX = 'identTags:';

    const ‪TAG_IDENTIFIERS_PREFIX = 'tagIdents:';

    protected ‪$redis;


    protected ‪$connected = false;


    protected ‪$persistentConnection = false;


    protected ‪$hostname = '127.0.0.1';


    protected ‪$port = 6379;


    protected ‪$database = 0;


    protected ‪$password = '';


    protected ‪$compression = false;


    protected ‪$compressionLevel = -1;


    protected ‪$connectionTimeout = 0;


    public function ‪__construct(‪$context, array $options = [])

    {

        if (!extension_loaded('redis')) {

            throw new ‪Exception('The PHP extension "redis" must be installed and loaded in order to use the redis backend.', 1279462933);

        }

        parent::__construct(‪$context, $options);

    }


    public function ‪initializeObject()

    {

        $this->redis = new \Redis();

        try {

            if ($this->persistentConnection) {

                $this->connected = $this->redis->pconnect($this->hostname, $this->port, $this->connectionTimeout, (string)$this->database);

            } else {

                $this->connected = $this->redis->connect($this->hostname, $this->port, $this->connectionTimeout);

            }

        } catch (\Exception $e) {

            $this->logger->alert('Could not connect to redis server.', ['exception' => $e]);

        }

        if ($this->connected) {

            if ($this->password !== '') {

                $success = $this->redis->auth($this->password);

                if (!$success) {

                    throw new Exception('The given password was not accepted by the redis server.', 1279765134);

                }

            }

            if ($this->database >= 0) {

                $success = $this->redis->select($this->database);

                if (!$success) {

                    throw new Exception('The given database "' . $this->database . '" could not be selected.', 1279765144);

                }

            }

        }

    }


    public function ‪setPersistentConnection(‪$persistentConnection)

    {

        $this->persistentConnection = ‪$persistentConnection;

    }


    public function ‪setHostname(‪$hostname)

    {

        $this->hostname = ‪$hostname;

    }


    public function ‪setPort(‪$port)

    {

        $this->port = ‪$port;

    }


    public function ‪setDatabase(‪$database)

    {

        if (!is_int(‪$database)) {

            throw new \InvalidArgumentException('The specified database number is of type "' . gettype(‪$database) . '" but an integer is expected.', 1279763057);

        }

        if (‪$database < 0) {

            throw new \InvalidArgumentException('The specified database "' . ‪$database . '" must be greater or equal than zero.', 1279763534);

        }

        $this->database = ‪$database;

    }


    public function ‪setPassword(‪$password)

    {

        $this->password = ‪$password;

    }


    public function ‪setCompression(‪$compression)

    {

        if (!is_bool(‪$compression)) {

            throw new \InvalidArgumentException('The specified compression of type "' . gettype(‪$compression) . '" but a boolean is expected.', 1289679153);

        }

        $this->compression = ‪$compression;

    }


    public function ‪setCompressionLevel(‪$compressionLevel)

    {

        if (!is_int(‪$compressionLevel)) {

            throw new \InvalidArgumentException('The specified compression of type "' . gettype(‪$compressionLevel) . '" but an integer is expected.', 1289679154);

        }

        if (‪$compressionLevel >= -1 && ‪$compressionLevel <= 9) {

            $this->compressionLevel = ‪$compressionLevel;

        } else {

            throw new \InvalidArgumentException('The specified compression level must be an integer between -1 and 9.', 1289679155);

        }

    }


    public function ‪setConnectionTimeout(‪$connectionTimeout)

    {

        if (!is_int(‪$connectionTimeout)) {

            throw new \InvalidArgumentException('The specified connection timeout is of type "' . gettype(‪$connectionTimeout) . '" but an integer is expected.', 1487849315);

        }


        if (‪$connectionTimeout < 0) {

            throw new \InvalidArgumentException('The specified connection timeout "' . ‪$connectionTimeout . '" must be greater or equal than zero.', 1487849326);

        }


        $this->connectionTimeout = ‪$connectionTimeout;

    }


    public function set($entryIdentifier, $data, array $tags = [], $lifetime = null)

    {

        if (!$this->‪canBeUsedInStringContext($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" which can\'t be converted to string.', 1377006651);

        }

        if (!is_string($data)) {

            throw new InvalidDataException('The specified data is of type "' . gettype($data) . '" but a string is expected.', 1279469941);

        }

        $lifetime = $lifetime ?? ‪$this->defaultLifetime;

        if (!is_int($lifetime)) {

            throw new \InvalidArgumentException('The specified lifetime is of type "' . gettype($lifetime) . '" but an integer or NULL is expected.', 1279488008);

        }

        if ($lifetime < 0) {

            throw new \InvalidArgumentException('The specified lifetime "' . $lifetime . '" must be greater or equal than zero.', 1279487573);

        }

        if ($this->connected) {

            $expiration = $lifetime === 0 ? ‪self::FAKED_UNLIMITED_LIFETIME : $lifetime;

            if ($this->compression) {

                $data = gzcompress($data, $this->compressionLevel);

            }

            $this->redis->setex(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier, $expiration, $data);

            $addTags = $tags;

            $removeTags = [];

            $existingTags = $this->redis->sMembers(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier);

            if (!empty($existingTags)) {

                $addTags = array_diff($tags, $existingTags);

                $removeTags = array_diff($existingTags, $tags);

            }

            if (!empty($removeTags) || !empty($addTags)) {

                $queue = $this->redis->multi(\Redis::PIPELINE);

                foreach ($removeTags as $tag) {

                    $queue->sRem(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier, $tag);

                    $queue->sRem(self::TAG_IDENTIFIERS_PREFIX . $tag, $entryIdentifier);

                }

                foreach ($addTags as $tag) {

                    $queue->sAdd(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier, $tag);

                    $queue->sAdd(self::TAG_IDENTIFIERS_PREFIX . $tag, $entryIdentifier);

                }

                $queue->exec();

            }

        }

    }


    public function get($entryIdentifier)

    {

        if (!$this->‪canBeUsedInStringContext($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" which can\'t be converted to string.', 1377006652);

        }

        $storedEntry = false;

        if ($this->connected) {

            $storedEntry = $this->redis->get(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier);

        }

        if ($this->compression && (string)$storedEntry !== '') {

            $storedEntry = gzuncompress($storedEntry);

        }

        return $storedEntry;

    }


    public function ‪has($entryIdentifier)

    {

        if (!$this->‪canBeUsedInStringContext($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" which can\'t be converted to string.', 1377006653);

        }

        return $this->connected && $this->redis->exists(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier);

    }


    public function remove($entryIdentifier)

    {

        if (!$this->‪canBeUsedInStringContext($entryIdentifier)) {

            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" which can\'t be converted to string.', 1377006654);

        }

        $elementsDeleted = false;

        if ($this->connected) {

            if ($this->redis->exists(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier)) {

                $assignedTags = $this->redis->sMembers(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier);

                $queue = $this->redis->multi(\Redis::PIPELINE);

                foreach ($assignedTags as $tag) {

                    $queue->sRem(self::TAG_IDENTIFIERS_PREFIX . $tag, $entryIdentifier);

                }

                $queue->del(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier, self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier);

                $queue->exec();

                $elementsDeleted = true;

            }

        }

        return $elementsDeleted;

    }


    public function ‪findIdentifiersByTag($tag)

    {

        if (!$this->‪canBeUsedInStringContext($tag)) {

            throw new \InvalidArgumentException('The specified tag is of type "' . gettype($tag) . '" which can\'t be converted to string.', 1377006655);

        }

        $foundIdentifiers = [];

        if ($this->connected) {

            $foundIdentifiers = $this->redis->sMembers(self::TAG_IDENTIFIERS_PREFIX . $tag);

        }

        return $foundIdentifiers;

    }


    public function ‪flush()

    {

        if ($this->connected) {

            $this->redis->flushDB();

        }

    }


    public function ‪flushByTag($tag)

    {

        if (!$this->‪canBeUsedInStringContext($tag)) {

            throw new \InvalidArgumentException('The specified tag is of type "' . gettype($tag) . '" which can\'t be converted to string.', 1377006656);

        }

        if ($this->connected) {

            $identifiers = $this->redis->sMembers(self::TAG_IDENTIFIERS_PREFIX . $tag);

            if (!empty($identifiers)) {

                $this->‪removeIdentifierEntriesAndRelations($identifiers, [$tag]);

            }

        }

    }


    public function ‪collectGarbage()

    {

        $identifierToTagsKeys = $this->redis->keys(self::IDENTIFIER_TAGS_PREFIX . '*');

        foreach ($identifierToTagsKeys as $identifierToTagsKey) {

            list(, $identifier) = explode(':', $identifierToTagsKey);

            // Check if the data entry still exists

            if (!$this->redis->exists(self::IDENTIFIER_DATA_PREFIX . $identifier)) {

                $tagsToRemoveIdentifierFrom = $this->redis->sMembers($identifierToTagsKey);

                $queue = $this->redis->multi(\Redis::PIPELINE);

                $queue->del($identifierToTagsKey);

                foreach ($tagsToRemoveIdentifierFrom as $tag) {

                    $queue->sRem(self::TAG_IDENTIFIERS_PREFIX . $tag, $identifier);

                }

                $queue->exec();

            }

        }

    }


    protected function ‪removeIdentifierEntriesAndRelations(array $identifiers, array $tags)

    {

        // Set a temporary entry which holds all identifiers that need to be removed from

        // the tag to identifiers sets

        $uniqueTempKey = 'temp:' . ‪StringUtility::getUniqueId();

        $prefixedKeysToDelete = [$uniqueTempKey];

        $prefixedIdentifierToTagsKeysToDelete = [];

        foreach ($identifiers as $identifier) {

            $prefixedKeysToDelete[] = self::IDENTIFIER_DATA_PREFIX . $identifier;

            $prefixedIdentifierToTagsKeysToDelete[] = self::IDENTIFIER_TAGS_PREFIX . $identifier;

        }

        foreach ($tags as $tag) {

            $prefixedKeysToDelete[] = self::TAG_IDENTIFIERS_PREFIX . $tag;

        }

        $tagToIdentifiersSetsToRemoveIdentifiersFrom = $this->redis->sUnion($prefixedIdentifierToTagsKeysToDelete);

        // Remove the tag to identifier set of the given tags, they will be removed anyway

        $tagToIdentifiersSetsToRemoveIdentifiersFrom = array_diff($tagToIdentifiersSetsToRemoveIdentifiersFrom, $tags);

        // Diff all identifiers that must be removed from tag to identifiers sets off from a

        // tag to identifiers set and store result in same tag to identifiers set again

        $queue = $this->redis->multi(\Redis::PIPELINE);

        foreach ($identifiers as $identifier) {

            $queue->sAdd($uniqueTempKey, $identifier);

        }

        foreach ($tagToIdentifiersSetsToRemoveIdentifiersFrom as $tagToIdentifiersSet) {

            $queue->sDiffStore(self::TAG_IDENTIFIERS_PREFIX . $tagToIdentifiersSet, self::TAG_IDENTIFIERS_PREFIX . $tagToIdentifiersSet, $uniqueTempKey);

        }

        $queue->del(array_merge($prefixedKeysToDelete, $prefixedIdentifierToTagsKeysToDelete));

        $queue->exec();

    }


    protected function ‪canBeUsedInStringContext($variable)

    {

        return is_scalar($variable) || (is_object($variable) && method_exists($variable, '__toString'));

    }

}