RedisBackend.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Cache\Backend;

class RedisBackend extends \TYPO3\CMS\Core\Cache\Backend\AbstractBackend implements \TYPO3\CMS\Core\Cache\Backend\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 $hostname = '127.0.0.1';

    protected $port = 6379;

    protected $database = 0;

    protected $password = '';

    protected $compression = FALSE;

    protected $compressionLevel = -1;

    public function __construct($context, array $options = array()) {
        if (!extension_loaded('redis')) {
            throw new \TYPO3\CMS\Core\Cache\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 {
            $this->connected = $this->redis->connect($this->hostname, $this->port);
        } catch (\Exception $e) {
            \TYPO3\CMS\Core\Utility\GeneralUtility::sysLog('Could not connect to redis server.', 'core', \TYPO3\CMS\Core\Utility\GeneralUtility::SYSLOG_SEVERITY_ERROR);
        }
        if ($this->connected) {
            if (strlen($this->password)) {
                $success = $this->redis->auth($this->password);
                if (!$success) {
                    throw new \TYPO3\CMS\Core\Cache\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 \TYPO3\CMS\Core\Cache\Exception('The given database "' . $this->database . '" could not be selected.', 1279765144);
                }
            }
        }
    }

    public function setHostname($hostname) {
        $this->hostname = $hostname;
    }

    public function setPort($port) {
        $this->port = $port;
    }

    public function setDatabase($database) {
        if (!is_integer($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_integer($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 set($entryIdentifier, $data, array $tags = array(), $lifetime = NULL) {
        if (!is_string($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" but a string is expected.', 1279470252);
        }
        if (!is_string($data)) {
            throw new \TYPO3\CMS\Core\Cache\Exception\InvalidDataException('The specified data is of type "' . gettype($data) . '" but a string is expected.', 1279469941);
        }
        $lifetime = $lifetime === NULL ? $this->defaultLifetime : $lifetime;
        if (!is_integer($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 = array();
            $existingTags = $this->redis->sMembers(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier);
            if (!empty($existingTags)) {
                $addTags = array_diff($tags, $existingTags);
                $removeTags = array_diff($existingTags, $tags);
            }
            if (count($removeTags) > 0 || count($addTags) > 0) {
                $queue = $this->redis->multi(\Redis::PIPELINE);
                foreach ($removeTags as $tag) {
                    $queue->sRemove(self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier, $tag);
                    $queue->sRemove(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 (!is_string($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" but a string is expected.', 1279470253);
        }
        $storedEntry = FALSE;
        if ($this->connected) {
            $storedEntry = $this->redis->get(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier);
        }
        if ($this->compression && strlen($storedEntry) > 0) {
            $storedEntry = gzuncompress($storedEntry);
        }
        return $storedEntry;
    }

    public function has($entryIdentifier) {
        if (!is_string($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" but a string is expected.', 1279470254);
        }
        return $this->connected && $this->redis->exists(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier);
    }

    public function remove($entryIdentifier) {
        if (!is_string($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified identifier is of type "' . gettype($entryIdentifier) . '" but a string is expected.', 1279470255);
        }
        $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->sRemove(self::TAG_IDENTIFIERS_PREFIX . $tag, $entryIdentifier);
                }
                $queue->delete(self::IDENTIFIER_DATA_PREFIX . $entryIdentifier, self::IDENTIFIER_TAGS_PREFIX . $entryIdentifier);
                $queue->exec();
                $elementsDeleted = TRUE;
            }
        }
        return $elementsDeleted;
    }

    public function findIdentifiersByTag($tag) {
        if (!is_string($tag)) {
            throw new \InvalidArgumentException('The specified tag is of type "' . gettype($tag) . '" but a string is expected.', 1279569759);
        }
        $foundIdentifiers = array();
        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 (!is_string($tag)) {
            throw new \InvalidArgumentException('The specified tag is of type "' . gettype($tag) . '" but a string is expected.', 1279578078);
        }
        if ($this->connected) {
            $identifiers = $this->redis->sMembers(self::TAG_IDENTIFIERS_PREFIX . $tag);
            if (count($identifiers) > 0) {
                $this->removeIdentifierEntriesAndRelations($identifiers, array($tag));
            }
        }
    }

    public function collectGarbage() {
        $identifierToTagsKeys = $this->redis->getKeys(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->delete($identifierToTagsKey);
                foreach ($tagsToRemoveIdentifierFrom as $tag) {
                    $queue->sRemove(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:' . uniqid('', TRUE);
        $prefixedKeysToDelete = array($uniqueTempKey);
        $prefixedIdentifierToTagsKeysToDelete = array();
        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->delete(array_merge($prefixedKeysToDelete, $prefixedIdentifierToTagsKeysToDelete));
        $queue->exec();
    }

}