cacheenginefiles.php

<?php
namespace Bitrix\Main\Data;
 
use Bitrix\Main;
 
class CacheEngineFiles implements CacheEngineInterface, CacheEngineStatInterface
{
    private $ttl;
 
    //cache stats
    private $written = false;
    private $read = false;
    private $path = '';
 
    protected $useLock = false;
    protected static $lockHandles = array();
 
    public function __construct($options = [])
    {
        $config = Main\Config\Configuration::getValue("cache");
        if ($config && is_array($config) && isset($config["use_lock"]))
        {
            $this->useLock = (bool)$config["use_lock"];
        }
 
        if (!empty($options) && isset($options['actual_data']))
        {
            $this->useLock = !((bool) $options['actual_data']);
        }
    }
 
    public function getReadBytes()
    {
        return $this->read;
    }
 
    public function getWrittenBytes()
    {
        return $this->written;
    }
 
    public function getCachePath()
    {
        return $this->path;
    }
 
    public function isAvailable()
    {
        return true;
    }
 
    private static function unlink($fileName)
    {
        if (isset(self::$lockHandles[$fileName]) && self::$lockHandles[$fileName])
        {
            fclose(self::$lockHandles[$fileName]);
            unset(self::$lockHandles[$fileName]);
        }
 
        if (file_exists($fileName))
        {
            @chmod($fileName, BX_FILE_PERMISSIONS);
            @unlink($fileName);
        }
    }
 
    private static function addAgent()
    {
        global $APPLICATION;
 
        static $agentAdded = false;
        if (!$agentAdded)
        {
            $agentAdded = true;
            $agents = \CAgent::GetList(array("ID" => "DESC"), array("NAME" => "\\Bitrix\\Main\\Data\\CacheEngineFiles::delayedDelete(%"));
            if (!$agents->Fetch())
            {
                $res = \CAgent::AddAgent(
                    "\\Bitrix\\Main\\Data\\CacheEngineFiles::delayedDelete();",
                    "main", //module
                    "Y", //period
                    1 //interval
                );
 
                if (!$res)
                    $APPLICATION->ResetException();
            }
        }
    }
 
    private static function randomizeFile($fileName)
    {
        $documentRoot = Main\Loader::getDocumentRoot();
        for ($i = 0; $i < 99; $i++)
        {
            $suffix = rand(0, 999999);
            if (!file_exists($documentRoot.$fileName.$suffix))
                return $fileName.$suffix;
        }
        return "";
    }
 
    public function clean($baseDir, $initDir = '', $filename = '')
    {
        $documentRoot = Main\Loader::getDocumentRoot();
        if (($filename !== false) && ($filename !== ""))
        {
            static::unlink($documentRoot.$baseDir.$initDir.$filename);
        }
        else
        {
            $initDir = trim($initDir, "/");
            if ($initDir == "")
            {
                $sourceDir = $documentRoot."/".trim($baseDir, "/");
                if (file_exists($sourceDir) && is_dir($sourceDir))
                {
                    $dh = opendir($sourceDir);
                    if (is_resource($dh))
                    {
                        while ($entry = readdir($dh))
                        {
                            if (preg_match("/^(\\.|\\.\\.|.*\\.~\\d+)\$/", $entry))
                                continue;
 
                            if (is_dir($sourceDir."/".$entry))
                                static::clean($baseDir, $entry);
                            elseif (is_file($sourceDir."/".$entry))
                                static::unlink($sourceDir."/".$entry);
                        }
                    }
                }
            }
            else
            {
                $source = "/".trim($baseDir, "/")."/".$initDir;
                $source = rtrim($source, "/");
                $delayedDelete = false;
 
                if (!preg_match("/^(\\.|\\.\\.|.*\\.~\\d+)\$/", $source) && file_exists($documentRoot.$source))
                {
                    if (is_file($documentRoot.$source))
                    {
                        static::unlink($documentRoot.$source);
                    }
                    else
                    {
                        $target = static::randomizeFile($source.".~");
                        if ($target != '')
                        {
                            $con = Main\Application::getConnection();
                            $con->queryExecute("INSERT INTO b_cache_tag (SITE_ID, CACHE_SALT, RELATIVE_PATH, TAG) VALUES ('*', '*', '".$con->getSqlHelper()->forSql($target)."', '*')");
                            if (@rename($documentRoot.$source, $documentRoot.$target))
                            {
                                $delayedDelete = true;
                            }
                        }
                    }
                }
 
                if ($delayedDelete)
                    static::addAgent();
                else
                    DeleteDirFilesEx($baseDir.$initDir);
            }
        }
    }
 
    protected function lock($fileName)
    {
        $wouldBlock = 0;
        self::$lockHandles[$fileName] = @fopen($fileName, "r+");
        if (self::$lockHandles[$fileName])
        {
            flock(self::$lockHandles[$fileName], LOCK_EX | LOCK_NB, $wouldBlock);
            //$wouldBlock === 1 someone else has the lock.
        }
        return $wouldBlock !== 1;
    }
 
    protected function unlock($fileName)
    {
        if (self::$lockHandles[$fileName])
        {
            fclose(self::$lockHandles[$fileName]);
            unset(self::$lockHandles[$fileName]);
        }
    }
 
    public function read(&$vars, $baseDir, $initDir, $filename, $ttl)
    {
        $documentRoot = Main\Loader::getDocumentRoot();
        $fn = $documentRoot."/".ltrim($baseDir.$initDir, "/").$filename;
 
        if (!file_exists($fn))
            return false;
 
        $ser_content = "";
        $dateexpire = 0;
        $datecreate = 0;
        $zeroDanger = false;
 
        $handle = null;
        if (is_array($vars))
        {
            $INCLUDE_FROM_CACHE = 'Y';
 
            if (!@include($fn))
                return false;
        }
        else
        {
            $handle = fopen($fn, "rb");
            if (!$handle)
                return false;
 
            $datecreate = fread($handle, 2);
            if ($datecreate == "BX")
            {
                $datecreate = fread($handle, 12);
                $dateexpire = fread($handle, 12);
            }
            else
            {
                $datecreate .= fread($handle, 10);
            }
        }
 
        /* We suppress warning here in order not to break the compression under Zend Server */
        $this->read = @filesize($fn);
        $this->path = $fn;
 
        $res = true;
        if (intval($datecreate) < (time() - $ttl))
        {
            if ($this->useLock)
            {
                if ($this->lock($fn))
                {
                    $res = false;
                }
            }
            else
            {
                $res = false;
            }
        }
 
        if($res == true)
        {
            if (is_array($vars))
            {
                $vars = unserialize($ser_content);
            }
            else
            {
                $vars = fread($handle, $this->read);
            }
        }
 
        if($handle)
        {
            fclose($handle);
        }
 
        return $res;
    }
 
    public function write($vars, $baseDir, $initDir, $filename, $ttl)
    {
        static $search = array("\\", "'", "\0");
        static $replace = array("\\\\", "\\'", "'.chr(0).'");
        $documentRoot = Main\Loader::getDocumentRoot();
        $folder = $documentRoot."/".ltrim($baseDir.$initDir, "/");
        $fn = $folder.$filename;
        $fnTmp = $folder.md5(mt_rand()).".tmp";
 
        if (!CheckDirPath($fn))
            return;
 
        if ($handle = fopen($fnTmp, "wb+"))
        {
            if (is_array($vars))
            {
                $contents = "<?";
                $contents .= "\nif(\$INCLUDE_FROM_CACHE!='Y')return false;";
                $contents .= "\n\$datecreate = '".str_pad(time(), 12, "0", STR_PAD_LEFT)."';";
                $contents .= "\n\$dateexpire = '".str_pad(time() + intval($ttl), 12, "0", STR_PAD_LEFT)."';";
                $contents .= "\n\$ser_content = '".str_replace($search, $replace, serialize($vars))."';";
                $contents .= "\nreturn true;";
                $contents .= "\n?>";
            }
            else
            {
                $contents = "BX".str_pad(time(), 12, "0", STR_PAD_LEFT).str_pad(time() + intval($this->ttl), 12, "0", STR_PAD_LEFT);
                $contents .= $vars;
            }
 
            $this->written = fwrite($handle, $contents);
            $this->path = $fn;
            $len = strlen($contents);
 
            fclose($handle);
 
            static::unlink($fn);
 
            if ($this->written === $len)
                rename($fnTmp, $fn);
 
            static::unlink($fnTmp);
 
            if ($this->useLock)
            {
                $this->unlock($fn);
            }
        }
    }
 
    public function isCacheExpired($path)
    {
        if (!file_exists($path))
        {
            return true;
        }
 
        $fileHandler = fopen($path, "rb");
        if ($fileHandler)
        {
            $header = fread($fileHandler, 150);
            fclose($fileHandler);
        }
        else
        {
            return true;
        }
 
        if (
            preg_match("/dateexpire\\s*=\\s*'([\\d]+)'/im", $header, $match)
            || preg_match("/^BX\\d{12}(\\d{12})/", $header, $match)
            || preg_match("/^(\\d{12})/", $header, $match)
        )
        {
            if ($match[1] == '' || doubleval($match[1]) < time())
                return true;
        }
 
        return false;
    }
 
    protected static function deleteOneDir($etime = 0, $ar = false)
    {
        $deleteFromQueue = false;
        $dirName = Main\Loader::getDocumentRoot().$ar["RELATIVE_PATH"];
        if ($ar["RELATIVE_PATH"] != '' && file_exists($dirName))
        {
            if (is_file($dirName))
            {
                DeleteDirFilesEx($ar["RELATIVE_PATH"]);
                $deleteFromQueue = true;
            }
            else
            {
                $dh = opendir($dirName);
                if (is_resource($dh))
                {
                    $counter = 0;
                    while (($file = readdir($dh)) !== false)
                    {
                        if ($file != "." && $file != "..")
                        {
                            DeleteDirFilesEx($ar["RELATIVE_PATH"]."/".$file);
                            $counter++;
                            if (time() > $etime)
                                break;
                        }
                    }
                    closedir($dh);
 
                    if ($counter == 0)
                    {
                        rmdir($dirName);
                        $deleteFromQueue = true;
                    }
                }
            }
        }
        else
        {
            $deleteFromQueue = true;
        }
 
        if ($deleteFromQueue)
        {
            $con = Main\Application::getConnection();
            $con->queryExecute("DELETE FROM b_cache_tag WHERE ID = ".intval($ar["ID"]));
        }
    }
 
    public static function delayedDelete($count = 1)
    {
        $delta = 10;
        $deleted = 0;
        $etime = time() + 2;
 
        $count = (int) $count;
        if ($count < 1)
        {
            $count = 1;
        }
 
        $con = Main\Application::getConnection();
        $rs = $con->query("SELECT * from b_cache_tag WHERE TAG='*'", 0, $count + $delta);
        while ($ar = $rs->fetch())
        {
            $deleted++;
            static::deleteOneDir($etime, $ar);
 
            if (time() > $etime)
            {
                break;
            }
        }
 
        if ($deleted > $count)
        {
            $count = $deleted;
        }
        elseif ($deleted < $count && $count > 1)
        {
            $count--;
        }
 
        if ($deleted > 0)
        {
            return "\\Bitrix\\Main\\Data\\CacheEngineFiles::delayedDelete(" . $count . ");";
        }
        else
        {
            return "";
        }
    }
}