cacheenginexcache.php

<?php
namespace Bitrix\Main\Data;
 
 
use Bitrix\Main\Data\LocalStorage;
 
class CacheEngineXCache
    implements ICacheEngine, ICacheEngineStat, LocalStorage\Storage\CacheEngineInterface
{
    private $sid = "BX";
    //cache stats
    private $written = false;
    private $read = false;
 
    protected $useLock = false;
    protected $ttlMultiplier = 2;
    protected static $locks = array();
 
    function __construct($options = [])
    {
        $config = \Bitrix\Main\Config\Configuration::getValue("cache");
 
        if ($config && is_array($config))
        {
            if (isset($config["use_lock"]))
            {
                $this->useLock = (bool)$config["use_lock"];
            }
 
            if (isset($config["sid"]) && ($config["sid"] != ""))
            {
                $this->sid = $config["sid"];
            }
 
            if (isset($config["ttl_multiplier"]) && $this->useLock)
            {
                $this->ttlMultiplier = (integer)$config["ttl_multiplier"];
            }
        }
 
        if (!empty($options) && isset($options['actual_data']))
        {
            $this->useLock = !((bool) $options['actual_data']);
        }
 
        $this->sid .= !$this->useLock;
 
        if (!$this->useLock)
        {
            $this->ttlMultiplier = 1;
        }
    }
 
    public function getReadBytes()
    {
        return $this->read;
    }
 
    public function getWrittenBytes()
    {
        return $this->written;
    }
 
    public function getCachePath()
    {
        return "";
    }
 
    public function isAvailable()
    {
        return function_exists('xcache_get');
    }
 
    protected function lock($baseDir, $initDir, $key, $TTL)
    {
        if (
            isset(self::$locks[$baseDir])
            && isset(self::$locks[$baseDir][$initDir])
            && isset(self::$locks[$baseDir][$initDir][$key])
        )
        {
            return true;
        }
        elseif (xcache_get($key)) //another process has the lock
        {
            return false;
        }
        else
        {
            $lock = xcache_inc($key, 1, intval($TTL));
            if ($lock === 1) //we are lucky to be the first
            {
                self::$locks[$baseDir][$initDir][$key] = true;
                return true;
            }
            //xcache_dec have to be never called due to concurrency with xcache_set($key."~", 1, intval($TTL));
        }
 
        return false;
    }
 
    protected function unlock($baseDir, $initDir = false, $key = false, $TTL = 0)
    {
        if ($key !== false)
        {
            if ($TTL > 0)
            {
                xcache_set($key, 1, intval($TTL));
            }
            else
            {
                xcache_unset($key);
            }
 
            unset(self::$locks[$baseDir][$initDir][$key]);
        }
        elseif ($initDir !== false)
        {
            if (isset(self::$locks[$baseDir][$initDir]))
            {
                foreach (self::$locks[$baseDir][$initDir] as $subKey)
                {
                    $this->unlock($baseDir, $initDir, $subKey, $TTL);
                }
                unset(self::$locks[$baseDir][$initDir]);
            }
        }
        elseif ($baseDir !== false)
        {
            if (isset(self::$locks[$baseDir]))
            {
                foreach (self::$locks[$baseDir] as $subInitDir)
                {
                    $this->unlock($baseDir, $subInitDir, false, $TTL);
                }
            }
        }
    }
 
    public function clean($baseDir, $initDir = false, $filename = false)
    {
        $key = false;
        if($filename <> '')
        {
            $baseDirVersion = xcache_get($this->sid.$baseDir);
            if($baseDirVersion === null)
            {
                return;
            }
 
            if($initDir !== false)
            {
                $initDirVersion = xcache_get($baseDirVersion."|".$initDir);
                if($initDirVersion === null)
                {
                    return;
                }
            }
            else
            {
                $initDirVersion = "";
            }
 
            $key = $baseDirVersion."|".$initDirVersion."|".$filename;
            xcache_unset($key);
        }
        else
        {
            if($initDir <> '')
            {
                $baseDirVersion = xcache_get($this->sid.$baseDir);
                if($baseDirVersion === null)
                {
                    return;
                }
 
                xcache_unset($baseDirVersion."|".$initDir);
            }
            else
            {
                xcache_unset($this->sid.$baseDir);
            }
        }
        $this->unlock($baseDir, $initDir, $key."~");
    }
 
    public function read(&$allVars, $baseDir, $initDir, $filename, $TTL)
    {
        $baseDirVersion = xcache_get($this->sid.$baseDir);
        if ($baseDirVersion === null)
            return false;
 
        if ($initDir !== false)
        {
            $initDirVersion = xcache_get($baseDirVersion."|".$initDir);
            if ($initDirVersion === null)
                return false;
        }
        else
        {
            $initDirVersion = "";
        }
 
        $key = $baseDirVersion."|".$initDirVersion."|".$filename;
        $allVars = xcache_get($key);
 
        if ($allVars === null)
        {
            return false;
        }
        else
        {
            if ($this->useLock)
            {
                if ($this->lock($baseDir, $initDir, $key."~", $TTL))
                {
                    return false;
                }
            }
 
            $this->read = mb_strlen($allVars);
            $allVars = unserialize($allVars);
        }
 
        return true;
    }
 
    public function write($allVars, $baseDir, $initDir, $filename, $TTL)
    {
        $baseDirVersion = xcache_get($this->sid.$baseDir);
        if ($baseDirVersion === null)
        {
            $baseDirVersion = md5(mt_rand());
            if (!xcache_set($this->sid.$baseDir, $baseDirVersion))
                return;
        }
 
        if ($initDir !== false)
        {
            $initDirVersion = xcache_get($baseDirVersion."|".$initDir);
            if ($initDirVersion === null)
            {
                $initDirVersion = md5(mt_rand());
                if (!xcache_set($baseDirVersion."|".$initDir, $initDirVersion))
                    return;
            }
        }
        else
        {
            $initDirVersion = "";
        }
 
        $allVars = serialize($allVars);
        $this->written = mb_strlen($allVars);
 
        $key = $baseDirVersion."|".$initDirVersion."|".$filename;
        xcache_set($key, $allVars, intval($TTL) * $this->ttlMultiplier);
 
        if ($this->useLock)
        {
            $this->unlock($baseDir, $initDir, $key."~", $TTL);
        }
    }
 
    public function isCacheExpired($path)
    {
        return false;
    }
}