cacheengine.php

<?php
namespace Bitrix\Main\Data;
 
use Bitrix\Main\Config;
use Bitrix\Main\Application;
use Bitrix\Main\Data\LocalStorage;
 
abstract class CacheEngine implements CacheEngineInterface, LocalStorage\Storage\CacheEngineInterface
{
    const BX_BASE_LIST = '|bx_base_list|';
    const BX_DIR_LIST = '|bx_dir_list|';
 
    protected static $engine = null;
    protected static array $locks = [];
    protected static bool $isConnected = false;
    protected static array $baseDirVersion = [];
    protected static array $initDirVersion = [];
 
    protected static array $listKeys = [];
 
    protected string $sid = 'BX';
    protected bool $useLock = false;
    protected int $ttlMultiplier = 1;
    protected int $ttlOld = 2;
    protected bool $old = false;
    protected bool $fullClean = false;
 
    abstract public function getConnectionName(): string;
    abstract public static function getConnectionClass();
 
    abstract public function set($key, $ttl, $value);
    abstract public function get($key);
    abstract public function del($key);
 
    abstract public function setNotExists($key, $ttl , $value);
    abstract public function addToSet($key, $value);
    abstract public function getSet($key) : array;
    abstract public function delFromSet($key, $member);
 
    abstract public function deleteBySet($key, $prefix = '');
 
    public function __construct(array $options = [])
    {
        static $config = [];
        if (self::$engine == null)
        {
            if (empty($config))
            {
                $config = $this->configure($options);
            }
        }
 
        $this->connect($config);
    }
 
    protected function connect($config)
    {
        $connectionPool = Application::getInstance()->getConnectionPool();
        $connectionPool->setConnectionParameters($this->getConnectionName(), $config);
 
        $engineConnection = $connectionPool->getConnection($this->getConnectionName());
        self::$engine = $engineConnection->getResource();
        self::$isConnected = $engineConnection->isConnected();
    }
 
    protected function configure($options = []) : array
    {
        $config = [];
        $cacheConfig = Config\Configuration::getValue('cache');
 
        if (!$cacheConfig || !is_array($cacheConfig))
        {
            return $config;
        }
 
        if (isset($options['type']))
        {
            $type = $options['type'];
        }
        else
        {
            if (is_array($cacheConfig['type']) && is_set($cacheConfig['type']['extension']))
            {
                $type = $cacheConfig['type']['extension'];
            }
            else
            {
                $type = $cacheConfig['type'];
            }
        }
 
        $config['type'] = $type;
        $config['className'] = static::getConnectionClass();
 
        if (!isset($config['servers']) || !is_array($config['servers']))
        {
            $config['servers'] = [];
        }
 
        if (isset($cacheConfig[$type]) && is_array($cacheConfig[$type]) && !empty($cacheConfig[$type]['host']))
        {
            $config['servers'][] = [
                'host' => $cacheConfig[$type]['host'],
                'port' => (int) ($cacheConfig[$type]['port'] ?? 0)
            ];
        }
 
        // Settings from .settings.php
        if (isset($cacheConfig['servers']) && is_array($cacheConfig['servers']))
        {
            $config['servers'] = array_merge($config['servers'], $cacheConfig['servers']);
        }
 
        // Setting from cluster config
        if (isset($options['servers']) && is_array($options['servers']))
        {
            $config['servers'] = array_merge($config['servers'], $options['servers']);
        }
 
        if (isset($cacheConfig['use_lock']))
        {
            $this->useLock = (bool) $cacheConfig['use_lock'];
        }
 
        if (isset($cacheConfig['sid']) && ($cacheConfig['sid'] != ''))
        {
            $this->sid = $cacheConfig['sid'];
        }
 
        // Only redis
        if (isset($cacheConfig['serializer']))
        {
            $config['serializer'] = (int) $cacheConfig['serializer'];
        }
 
        $config['persistent'] = true;
        if (isset($cacheConfig['persistent']) && $cacheConfig['persistent'] == 0)
        {
            $config['persistent'] = false;
        }
 
        if (isset($cacheConfig['actual_data']))
        {
            $this->useLock = !$cacheConfig['actual_data'];
        }
 
        if (!$this->useLock)
        {
            $this->ttlMultiplier = 1;
        }
 
        if (isset($cacheConfig['ttl_multiplier']) && $this->useLock)
        {
            $this->ttlMultiplier = (int) $cacheConfig['ttl_multiplier'];
            if ($this->ttlMultiplier < 1)
            {
                $this->ttlMultiplier = 1;
            }
        }
 
        if (isset($cacheConfig['full_clean']))
        {
            $this->fullClean = (bool) $cacheConfig['full_clean'];
        }
 
        return $config;
    }
 
    protected function lock(string $key = '', int $ttl = 0) : bool
    {
        if ($key == '')
        {
            return false;
        }
 
        $key .= '~';
        if (isset(self::$locks[$key]))
        {
            return true;
        }
        else
        {
            if ($this->setNotExists($key, $ttl, $this->ttlOld))
            {
                self::$locks[$key] = true;
                return true;
            }
        }
 
        return false;
    }
 
    protected function unlock(string $key = '', int $ttl = 0) : void
    {
        if ($key != '')
        {
            $key .= '~';
 
            if ($ttl > 0)
            {
                $this->set($key, $ttl, 1);
            }
            else
            {
                $this->del($key);
            }
 
            unset(self::$locks[$key]);
        }
    }
 
    function close() : void
    {
        if (self::$engine != null)
        {
            self::$engine->close();
            self::$engine = null;
        }
    }
 
    public function isAvailable()
    {
        return self::$isConnected;
    }
 
    public function isCacheExpired($path)
    {
        return false;
    }
 
    protected function getPartition($key) : string
    {
        return '|' . substr(sha1($key), 0, 2) . '|';
    }
 
    protected function getInitDirKey($baseDir, $initDir = false) : string
    {
        return $this->sid . '|' . $this->getBaseDirVersion($baseDir) . '|init_dir|' . sha1($initDir);
    }
 
    protected function getInitDirVersion($baseDir, $initDir = false, $generateNew = true) : string
    {
        $key = $this->getInitDirKey($baseDir, $initDir);
 
        if (!array_key_exists($key, static::$initDirVersion))
        {
            static::$initDirVersion[$key] = $this->get($key);
        }
 
        if (
            static::$initDirVersion[$key] === false
            || (static::$initDirVersion[$key] == '' && $generateNew)
        )
        {
            if ($generateNew)
            {
                static::$initDirVersion[$key] = sha1(mt_rand() . '|' . microtime());
                $this->set($key, 0, static::$initDirVersion[$key]);
            }
            else
            {
                static::$initDirVersion[$key] = '';
            }
        }
 
        return static::$initDirVersion[$key];
    }
 
    protected function getBaseDirVersion($baseDir) : string
    {
        $baseDirHash = sha1($baseDir);
        $key = $this->sid . '|base_dir|' . $baseDirHash;
 
        if (!isset(static::$baseDirVersion[$key]))
        {
            static::$baseDirVersion[$key] = $this->get($key);
        }
 
        if (static::$baseDirVersion[$key] === false)
        {
            static::$baseDirVersion[$key] = sha1($baseDirHash . '|' . mt_rand() . '|' . microtime());
            $this->set($key, 0, static::$baseDirVersion[$key]);
        }
 
        return static::$baseDirVersion[$key];
    }
 
    public function read(&$vars, $baseDir, $initDir, $filename, $ttl)
    {
        $initDirVersion = $this->getInitDirVersion($baseDir, $initDir, false);
 
        if ($initDirVersion == '')
        {
            return false;
        }
 
        $key = $this->sid . '|' . sha1($this->getBaseDirVersion($baseDir) . '|' . $initDirVersion) . '|' .$filename;
 
        if ($this->useLock)
        {
            $cachedData = $this->get($key);
 
            if (!is_array($cachedData))
            {
                $cachedData = $this->get($key . '|old');
                if (is_array($cachedData))
                {
                    $this->old = true;
                }
            }
 
            if (!is_array($cachedData))
            {
                return false;
            }
 
            if ($this->lock($key, $ttl))
            {
                if ($this->old || $cachedData['datecreate'] < (time() - $ttl))
                {
                    return false;
                }
            }
 
            $vars = $cachedData['content'];
        }
        else
        {
            $vars = $this->get($key);
        }
 
        return $vars !== false;
    }
 
    public function write($vars, $baseDir, $initDir, $filename, $ttl)
    {
        $baseDirVersion = $this->getBaseDirVersion($baseDir);
        $initDirVersion = $this->getInitDirVersion($baseDir, $initDir);
 
        $dir = sha1($baseDirVersion . '|' . $initDirVersion);
        $key = $this->sid. '|' . $dir . '|' . $filename;
        $exp = $this->ttlMultiplier * (int) $ttl;
 
        if ($this->useLock)
        {
            $this->set($key, $exp, ['datecreate' => time(), 'content' => $vars]);
            $this->del($key . '|old');
            $this->unlock($key, $ttl);
        }
        else
        {
            $this->set($key, $exp, $vars);
        }
 
        $initListKey = $this->sid . '|' . $dir . self::BX_DIR_LIST;
 
        $initPartition = $this->getPartition($filename);
        $initListKeyPartition = $initListKey . $initPartition;
 
        $this->addToSet($initListKeyPartition, $filename);
        $this->addToSet($initListKey, $initPartition);
 
        if ($this->fullClean)
        {
            $baseListKey = $this->sid . '|' . $baseDirVersion . self::BX_BASE_LIST;
            $baseListKeyPartition = $this->getPartition($initListKeyPartition);
            $this->addToSet($baseListKey . $baseListKeyPartition, $initListKeyPartition);
            $this->addToSet($baseListKey, $baseListKeyPartition);
        }
    }
 
    public function clean($baseDir, $initDir = false, $filename = false)
    {
        if (!self::isAvailable())
        {
            return;
        }
 
        $baseDirVersion = $this->getBaseDirVersion($baseDir);
        $initDirVersion = $this->getInitDirVersion($baseDir, $initDir);
 
        $dir = sha1($baseDirVersion . '|' . $initDirVersion);
        $initListKey = $this->sid . '|' .$dir . self::BX_DIR_LIST;
 
        if ($this->fullClean)
        {
            $baseListKey = $this->sid . '|' .$baseDirVersion . self::BX_BASE_LIST;
        }
 
        if ($filename <> '')
        {
            $key = $this->sid . '|' .$dir . '|' . $filename;
            $this->delFromSet($initListKey . $this->getPartition($filename), $filename);
 
            if ($this->useLock && $cachedData = $this->get($key))
            {
                $this->set($key . '|old', $this->ttlOld, $cachedData);
            }
 
            $this->del($key);
            if ($this->useLock)
            {
                $this->unlock($key);
            }
        }
        elseif ($initDir != '')
        {
            $keyPrefix = $this->sid . '|' .$dir . '|';
            $initDirKey = $this->getInitDirKey($baseDir, $initDir);
            $this->del($initDirKey);
            unset(static::$initDirVersion[$initDirKey]);
 
            $partitionKeys = $this->getSet($initListKey);
            foreach ($partitionKeys as $partition)
            {
                $delKey = $initListKey . $partition;
                $this->deleteBySet($delKey, $keyPrefix);
                $this->del($delKey);
                if ($this->fullClean)
                {
                    $this->delFromSet($baseListKey . $this->getPartition($delKey), $delKey);
                }
            }
            $this->del($initListKey);
        }
        else
        {
            $baseDirKey = $this->sid . '|base_dir|' . sha1 ($baseDir);
            $this->del($baseDirKey);
            unset(static::$baseDirVersion[$baseDirKey]);
 
            if ($this->fullClean)
            {
                $keyPrefix = $this->sid . '|' .$dir . '|';
                $partitionKeys = $this->getSet($baseListKey);
 
                foreach ($partitionKeys as $partition)
                {
                    $baseListKeyPartition = $baseListKey . $partition;
                    $keys = $this->getSet($baseListKeyPartition);
 
                    foreach ($keys as $initKey)
                    {
                        $this->deleteBySet($initKey, $keyPrefix);
                        $this->del($initKey);
                    }
 
                    $this->del($baseListKeyPartition);
                    unset($keys);
                }
 
                $this->del($baseListKey);
 
            }
        }
 
    }
}