cache.php

См. документацию.

<?php

 
namespace Bitrix\Main\Data;
 
use Bitrix\Main;
use Bitrix\Main\Config;
use Bitrix\Main\Diag;
 
class Cache
{
    protected CacheEngineInterface $cacheEngine;
 
    protected $content;
    protected $vars;
    protected int $ttl = 0;
    protected string $uniqueString = '';
    protected string $baseDir = 'cache';
    protected string $initDir = '';
    protected string $filename = '';
    protected bool $isStarted = false;
 
    protected static $showCacheStat = false;
    protected static $clearCache = null;
    protected static $clearCacheSession = null;
 
    protected bool $forceRewriting = false;
    protected bool $hasOutput = true;
 
    public function __construct($cacheEngine)
    {
        $this->cacheEngine = $cacheEngine;
    }
 
    public static function createCacheEngine($params = [])
    {
        static $instances = [];
 
        $hash = sha1(serialize($params));
        if (isset($instances[$hash]))
        {
            return clone $instances[$hash];
        }
 
        $cacheEngine = null;
 
        // Events can't be used here because events use cache
        $cacheType = 'files';
        $v = Config\Configuration::getValue('cache');
        if (!empty($v['type']))
        {
            $cacheType = $v['type'];
        }
 
        if (is_array($cacheType))
        {
            if (isset($cacheType['class_name']))
            {
                if (!isset($cacheType['extension']) || extension_loaded($cacheType['extension']))
                {
                    if (isset($cacheType['required_file']) && ($requiredFile = Main\Loader::getLocal($cacheType['required_file'])) !== false)
                    {
                        require_once($requiredFile);
                    }
 
                    if (isset($cacheType['required_remote_file']))
                    {
                        require_once($cacheType['required_remote_file']);
                    }
 
                    $className = $cacheType['class_name'];
                    if (class_exists($className))
                    {
                        $cacheEngine = new $className($params);
                    }
                }
            }
        }
        else
        {
            switch ($cacheType)
            {
                case 'redis':
                    $cacheEngine = new CacheEngineRedis($params);
                    break;
                case 'memcached':
                    $cacheEngine = new CacheEngineMemcached($params);
                    break;
                case 'memcache':
                    $cacheEngine = new CacheEngineMemcache($params);
                    break;
                case 'apc':
                case 'apcu':
                    $cacheEngine = new CacheEngineApc($params);
                    break;
                case 'files':
                    $cacheEngine = new CacheEngineFiles($params);
                    break;
                default:
                    $cacheEngine = new CacheEngineNone();
                    break;
            }
        }
 
        if ($cacheEngine === null)
        {
            $cacheEngine = new CacheEngineNone();
            trigger_error('Cache engine is not found', E_USER_WARNING);
        }
 
        if (!$cacheEngine->isAvailable())
        {
            $cacheEngine = new CacheEngineNone();
            trigger_error('Cache engine is not available', E_USER_WARNING);
        }
 
        $instances[$hash] = $cacheEngine;
 
        return $cacheEngine;
    }
 
    public static function getCacheEngineType()
    {
        $obj = static::createCacheEngine();
        $class = get_class($obj);
        if (($pos = strrpos($class, "\\")) !== false)
        {
            $class = substr($class, $pos + 1);
        }
 
        return strtolower($class);
    }

    public static function createInstance($params = [])
    {
        $cacheEngine = static::createCacheEngine($params);
        return new static($cacheEngine);
    }
 
    public static function setShowCacheStat($showCacheStat)
    {
        static::$showCacheStat = $showCacheStat;
    }
 
    public static function getShowCacheStat()
    {
        return static::$showCacheStat;
    }

    public static function setClearCache($clearCache)
    {
        static::$clearCache = $clearCache;
    }

    public static function setClearCacheSession($clearCacheSession)
    {
        static::$clearCacheSession = $clearCacheSession;
    }
 
    public static function getSalt()
    {
        $context = Main\Application::getInstance()->getContext();
        $server = $context->getServer();
 
        $scriptName = $server->get('SCRIPT_NAME');
        if ($scriptName == '/bitrix/urlrewrite.php' && (($v = $server->get('REAL_FILE_PATH')) != null))
        {
            $scriptName = $v;
        }
        elseif ($scriptName == '/404.php' && (($v = $server->get('REAL_FILE_PATH')) != null))
        {
            $scriptName = $v;
        }
        return '/' . mb_substr(md5($scriptName), 0, 3);
    }

    public static function shouldClearCache()
    {
        global $USER;
 
        $application = Main\Application::getInstance();
 
        if (!$application->isInitialized())
        {
            return false;
        }
 
        $kernelSession = $application->getKernelSession();
 
        if (isset(static::$clearCacheSession) || isset(static::$clearCache))
        {
            if ($USER instanceof \CUser && $USER->CanDoOperation('cache_control'))
            {
                if (isset(static::$clearCacheSession))
                {
                    if (static::$clearCacheSession === true)
                    {
                        $kernelSession['SESS_CLEAR_CACHE'] = 'Y';
                    }
                    else
                    {
                        unset($kernelSession['SESS_CLEAR_CACHE']);
                    }
                }
 
                if (isset(static::$clearCache) && (static::$clearCache === true))
                {
                    return true;
                }
            }
        }
 
        if (isset($kernelSession['SESS_CLEAR_CACHE']) && $kernelSession['SESS_CLEAR_CACHE'] === 'Y')
        {
            return true;
        }
 
        return false;
    }
 
    public static function getPath($uniqueString)
    {
        $un = md5($uniqueString);
        return mb_substr($un, 0, 2) . '/' . $un . '.php';
    }
 
    public function clean($uniqueString, $initDir = false, $baseDir = 'cache')
    {
        $personalRoot = Main\Application::getPersonalRoot();
        $baseDir = $personalRoot . '/' . $baseDir . '/';
        $filename = $this->getPath($uniqueString);
 
        if (static::$showCacheStat)
        {
            Diag\CacheTracker::add(0, '', $baseDir, $initDir, '/' . $filename, 'C');
        }
 
        return $this->cacheEngine->clean($baseDir, $initDir, '/' . $filename);
    }
 
    public function cleanDir($initDir = false, $baseDir = 'cache')
    {
        $personalRoot = Main\Application::getPersonalRoot();
        $baseDir = $personalRoot . '/' . $baseDir . '/';
 
        if (static::$showCacheStat)
        {
            Diag\CacheTracker::add(0, "", $baseDir, $initDir, "", "C");
        }
 
        $this->cacheEngine->clean($baseDir, $initDir);
    }
 
    public function initCache($ttl, $uniqueString, $initDir = false, $baseDir = 'cache')
    {
        if ($initDir === false)
        {
            $initDir = 'default';
        }
 
        $personalRoot = Main\Application::getPersonalRoot();
        $this->baseDir = $personalRoot . '/' . $baseDir . '/';
        $this->initDir = $initDir;
        $this->filename = '/' . $this->getPath($uniqueString);
        $this->ttl = $ttl;
        $this->uniqueString = $uniqueString;
        $this->vars = false;
 
        if ($ttl <= 0 || $this->forceRewriting || static::shouldClearCache())
        {
            return false;
        }
 
        $data = ['CONTENT' => '', 'VARS' => ''];
        if (!$this->cacheEngine->read($data, $this->baseDir, $this->initDir, $this->filename, $this->ttl))
        {
            return false;
        }
 
        if (!is_array($data) || empty($data) || !isset($data['CONTENT']) || !isset($data['VARS']))
        {
            return false;
        }
 
        if (static::$showCacheStat)
        {
            $read = 0;
            $path = '';
            if ($this->cacheEngine instanceof CacheEngineStatInterface)
            {
                $read = $this->cacheEngine->getReadBytes();
                $path = $this->cacheEngine->getCachePath();
            }
 
            Diag\CacheTracker::addCacheStatBytes($read);
            Diag\CacheTracker::add($read, $path, $this->baseDir, $this->initDir, $this->filename, 'R');
        }
 
        $this->content = $data['CONTENT'];
        $this->vars = $data['VARS'];
 
        return true;
    }
 
    public function output()
    {
        if ($this->hasOutput)
        {
            echo $this->content;
        }
    }
 
    public function noOutput()
    {
        $this->hasOutput = false;
    }
 
    public function getVars()
    {
        return $this->vars;
    }
 
    public function startDataCache($TTL = false, $uniqueString = false, $initDir = false, $vars = array(), $baseDir = 'cache')
    {
        $narg = func_num_args();
        if ($narg <= 0)
        {
            $TTL = $this->ttl;
        }
 
        if ($narg <= 1)
        {
            $uniqueString = $this->uniqueString;
        }
 
        if ($narg <= 2)
        {
            $initDir = $this->initDir;
        }
 
        if ($narg <= 3)
        {
            $vars = $this->vars;
        }
 
        if ($this->initCache($TTL, $uniqueString, $initDir, $baseDir))
        {
            $this->output();
            return false;
        }
 
        if ($TTL <= 0)
        {
            return true;
        }
 
        if ($this->hasOutput)
        {
            ob_start();
        }
 
        $this->vars = $vars;
        $this->isStarted = true;
 
        return true;
    }
 
    public function abortDataCache()
    {
        if (!$this->isStarted)
        {
            return;
        }
 
        $this->isStarted = false;
        if ($this->hasOutput)
        {
            ob_end_flush();
        }
    }
 
    public function endDataCache($vars = false)
    {
        if (!$this->isStarted)
        {
            return;
        }
 
        $this->isStarted = false;
        $data = [
            'CONTENT' => $this->hasOutput ? ob_get_contents() : '',
            'VARS' => ($vars !== false ? $vars : $this->vars),
        ];
 
        $this->cacheEngine->write($data, $this->baseDir, $this->initDir, $this->filename, $this->ttl);
 
        if (static::$showCacheStat)
        {
            $written = 0;
            $path = '';
            if ($this->cacheEngine instanceof CacheEngineStatInterface)
            {
                $written = $this->cacheEngine->getWrittenBytes();
                $path = $this->cacheEngine->getCachePath();
            }
 
            Diag\CacheTracker::addCacheStatBytes($written);
            Diag\CacheTracker::add($written, $path, $this->baseDir, $this->initDir, $this->filename, 'W');
        }
 
        if ($this->hasOutput)
        {
            if (ob_get_contents() <> '')
            {
                ob_end_flush();
            }
            else
            {
                ob_end_clean();
            }
        }
    }
 
    public function isCacheExpired($path)
    {
        return $this->cacheEngine->isCacheExpired($path);
    }
 
    public function isStarted()
    {
        return $this->isStarted;
    }

    public static function clearCache($full = false, $initDir = ''): void
    {
        if ($initDir === '' && is_string($full))
        {
            $initDir = $full;
            $full = true;
        }
 
        if ($full === true)
        {
            $cache = static::createInstance();
            $cache->cleanDir($initDir);
        }
    }

    public function forceRewriting($mode)
    {
        $this->forceRewriting = (bool) $mode;
    }
}