RemoteSynchronizedCache.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Cache\Backend;

class RemoteSynchronizedCache extends \Zend_Cache_Backend implements \Zend_Cache_Backend_ExtendedInterface
{
    private $local;

    private $remote;

    protected $cacheInvalidationTime;

    protected $_options = [
        'remote_backend' => '',
        'remote_backend_invalidation_time_id' => 'default_remote_backend_invalidation_time',
        'remote_backend_custom_naming' => true,
        'remote_backend_autoload' => true,
        'remote_backend_options' => [],
        'local_backend' => '',
        'local_backend_options' => [],
        'local_backend_custom_naming' => true,
        'local_backend_autoload' => true
    ];

    public function __construct(array $options = [])
    {
        parent::__construct($options);

        $universalOptions = array_diff_key($options, $this->_options);

        if ($this->_options['remote_backend'] === null) {
            \Zend_Cache::throwException('remote_backend option must be set');
        } elseif ($this->_options['remote_backend'] instanceof \Zend_Cache_Backend_ExtendedInterface) {
            $this->remote = $this->_options['remote_backend'];
        } else {
            $this->remote = \Zend_Cache::_makeBackend(
                $this->_options['remote_backend'],
                array_merge($universalOptions, $this->_options['remote_backend_options']),
                $this->_options['remote_backend_custom_naming'],
                $this->_options['remote_backend_autoload']
            );
            if (!($this->remote instanceof \Zend_Cache_Backend_ExtendedInterface)) {
                \Zend_Cache::throwException(
                    'remote_backend must implement the Zend_Cache_Backend_ExtendedInterface interface'
                );
            }
        }

        if ($this->_options['local_backend'] === null) {
            \Zend_Cache::throwException('local_backend option must be set');
        } elseif ($this->_options['local_backend'] instanceof \Zend_Cache_Backend_ExtendedInterface) {
            $this->local = $this->_options['local_backend'];
        } else {
            $this->local = \Zend_Cache::_makeBackend(
                $this->_options['local_backend'],
                array_merge($universalOptions, $this->_options['local_backend_options']),
                $this->_options['local_backend_custom_naming'],
                $this->_options['local_backend_autoload']
            );
            if (!($this->local instanceof \Zend_Cache_Backend_ExtendedInterface)) {
                \Zend_Cache::throwException(
                    'local_backend must implement the Zend_Cache_Backend_ExtendedInterface interface'
                );
            }
        }
    }

    private function updateRemoteCacheStatusInfo()
    {
        $this->remote->save(time(), $this->_options['remote_backend_invalidation_time_id'], [], null);
        $this->cacheInvalidationTime = null;
    }

    public function setDirectives($directives)
    {
        return $this->local->setDirectives($directives);
    }

    public function load($id, $doNotTestCacheValidity = false)
    {
        $dataModificationTime = $this->local->test($id);
        if ($this->cacheInvalidationTime === null) {
            $this->cacheInvalidationTime = $this->remote->load($this->_options['remote_backend_invalidation_time_id']);
        }
        if ($dataModificationTime >= $this->cacheInvalidationTime) {
            return $this->local->load($id, $doNotTestCacheValidity);
        } else {
            return false;
        }
    }

    public function test($id)
    {
        return $this->local->test($id);
    }

    public function save($data, $id, $tags = [], $specificLifetime = false)
    {
        return $this->local->save($data, $id, $tags, $specificLifetime);
    }

    public function remove($id)
    {
        $this->updateRemoteCacheStatusInfo();
        return $this->local->remove($id);
    }

    public function clean($mode = \Zend_Cache::CLEANING_MODE_ALL, $tags = [])
    {
        $this->updateRemoteCacheStatusInfo();
        return $this->local->clean($mode, $tags);
    }

    public function getIds()
    {
        return $this->local->getIds();
    }

    public function getTags()
    {
        return $this->local->getTags();
    }

    public function getIdsMatchingTags($tags = [])
    {
        return $this->local->getIdsMatchingTags($tags);
    }

    public function getIdsNotMatchingTags($tags = [])
    {
        return $this->local->getIdsNotMatchingTags($tags);
    }

    public function getIdsMatchingAnyTags($tags = [])
    {
        return $this->local->getIdsMatchingAnyTags($tags);
    }

    public function getFillingPercentage()
    {
        return $this->local->getFillingPercentage();
    }

    public function getMetadatas($id)
    {
        return $this->local->getMetadatas($id);
    }

    public function touch($id, $extraLifetime)
    {
        return $this->local->touch($id, $extraLifetime);
    }

    public function getCapabilities()
    {
        return $this->local->getCapabilities();
    }
}