page.php

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

<?php
namespace Bitrix\Main\Composite;
 
use Bitrix\Main\Composite\Data\CacheProvider;
use Bitrix\Main\Composite\Debug\Logger;
use Bitrix\Main\Composite\Internals\Model\PageTable;
use Bitrix\Main\Composite\Internals\PageManager;

class Page
{
    protected static $instance = null;
    private $cacheKey = null;
    private $canCache = true;

    private $storage = null;

    private $cacheProvider = null;
 
    private $voting = true;
    public function __construct($requestUri = null, $host = null, $privateKey = null)
    {
        if (func_num_args())
        {
            $cacheKey = static::convertUriToPath($requestUri, $host, $privateKey);
            $this->init($cacheKey);
        }
    }
 
    protected function init($cacheKey)
    {
        if (is_string($cacheKey) && mb_strlen($cacheKey))
        {
            $this->cacheKey = $cacheKey;
            $this->storage = $this->getStaticHtmlStorage($this->cacheKey);
        }
    }
 
    public static function createFromCacheKey($cacheKey)
    {
        $storage = new static();
        $storage->init($cacheKey);
 
        return $storage;
    }

    public static function getInstance()
    {
        if (!isset(static::$instance))
        {
            $cacheProvider = static::getCacheProvider();
            $privateKey = $cacheProvider !== null ? $cacheProvider->getCachePrivateKey() : null;
 
            static::$instance = new static(
                Helper::getRequestUri(),
                Helper::getHttpHost(),
                Helper::getRealPrivateKey($privateKey)
            );
 
            if ($cacheProvider !== null)
            {
                static::$instance->setCacheProvider($cacheProvider);
            }
        }
 
        return static::$instance;
    }

    public function getStorage()
    {
        return $this->storage;
    }
 
    public function setCacheProvider(CacheProvider $provider)
    {
        $this->cacheProvider = $provider;
    }

    private static function getCacheProvider()
    {
        foreach (GetModuleEvents("main", "OnGetStaticCacheProvider", true) as $arEvent)
        {
            $provider = ExecuteModuleEventEx($arEvent);
            if (is_object($provider) && $provider instanceof CacheProvider)
            {
                return $provider;
            }
        }
 
        return null;
    }
 
    /*
     * Returns private cache key
     */
    public static function getPrivateKey()
    {
        $cacheProvider = static::getCacheProvider();
        return $cacheProvider !== null ? $cacheProvider->getCachePrivateKey() : null;
    }

    public static function convertUriToPath($uri, $host = null, $privateKey = null)
    {
        return Helper::convertUriToPath($uri, $host, $privateKey);
    }

    public function getCacheKey()
    {
        return $this->cacheKey;
    }

    public function write($content, $md5)
    {
        if ($this->storage === null)
        {
            return false;
        }
 
        $cacheSize = $this->storage->getSize();
        $written = $this->storage->write($content."<!--".$md5."-->", $md5);
        if ($written !== false && $this->storage->shouldCountQuota())
        {
            $delta = $cacheSize !== false ? $written - $cacheSize : $written;
            if ($delta !== 0)
            {
                Helper::updateCacheFileSize($delta);
            }
        }
 
        return $written;
    }

    public function read()
    {
        if ($this->storage !== null)
        {
            return $this->storage->read();
        }
 
        return false;
    }

    public function delete()
    {
        if ($this->storage === null)
        {
            return false;
        }
 
        $deletedSize = $this->storage->delete();
        if ($deletedSize !== false && $this->storage->shouldCountQuota())
        {
            Helper::updateCacheFileSize(-$deletedSize);
        }
 
        PageManager::deleteByCacheKey($this->cacheKey);
 
        return $deletedSize;
    }

    public function deleteAll()
    {
        if ($this->storage === null)
        {
            return false;
        }
 
        $this->storage->deleteAll();
 
        if ($this->storage->shouldCountQuota())
        {
            Helper::updateCacheFileSize(false);
        }
 
        PageTable::deleteAll();
 
        return true;
    }

    public function getLastModified()
    {
        if ($this->storage !== null)
        {
            return $this->storage->getLastModified();
        }
 
        return false;
    }

    public function exists()
    {
        if ($this->storage !== null)
        {
            return $this->storage->exists();
        }
 
        return false;
    }

    public function getMd5()
    {
        if ($this->storage !== null)
        {
            return $this->storage->getMd5();
        }
 
        return false;
    }

    public function getSize()
    {
        if ($this->storage !== null)
        {
            return $this->storage->getSize();
        }
 
        return false;
    }

    public function isCacheable()
    {
        if ($this->storage === null)
        {
            return false;
        }
 
        if ($this->cacheProvider !== null && $this->cacheProvider->isCacheable() === false)
        {
            return false;
        }
 
        if (isset(\Bitrix\Main\Application::getInstance()->getKernelSession()["SESS_SHOW_TIME_EXEC"]) && (\Bitrix\Main\Application::getInstance()->getKernelSession()["SESS_SHOW_TIME_EXEC"] == 'Y'))
        {
            return false;
        }
        elseif (isset(\Bitrix\Main\Application::getInstance()->getKernelSession()["SHOW_SQL_STAT"]) && (\Bitrix\Main\Application::getInstance()->getKernelSession()["SHOW_SQL_STAT"] == 'Y'))
        {
            return false;
        }
        elseif (isset(\Bitrix\Main\Application::getInstance()->getKernelSession()["SHOW_CACHE_STAT"]) && (\Bitrix\Main\Application::getInstance()->getKernelSession()["SHOW_CACHE_STAT"] == 'Y'))
        {
            return false;
        }
 
        $httpStatus = intval(\CHTTP::GetLastStatus());
        if ($httpStatus == 200 || $httpStatus === 0)
        {
            return $this->canCache;
        }
 
        return false;
    }

    public function markNonCacheable()
    {
        $this->canCache = false;
 
        if (Logger::isOn())
        {
            $debugBacktrace = debug_backtrace();
 
            Logger::log(array(
                "TYPE" => Debug\Logger::TYPE_PAGE_NOT_CACHEABLE,
                "MESSAGE" => "File: ".$debugBacktrace[0]["file"].":".$debugBacktrace[0]["line"]
            ));
        }
    }
 
    public function setUserPrivateKey()
    {
        if ($this->cacheProvider !== null)
        {
            $this->cacheProvider->setUserPrivateKey();
        }
    }
 
    public function onBeforeEndBufferContent()
    {
        if ($this->cacheProvider !== null)
        {
            $this->cacheProvider->onBeforeEndBufferContent();
        }
    }

    public static function getStaticHtmlStorage($cacheKey)
    {
        $configuration = array();
        $htmlCacheOptions = Helper::getOptions();
        $storage = $htmlCacheOptions["STORAGE"] ?? false;
 
        if (in_array($storage, array("memcached", "memcached_cluster")))
        {
            if (extension_loaded("memcache"))
            {
                return new Data\MemcachedStorage($cacheKey, $configuration, $htmlCacheOptions);
            }
            else
            {
                return null;
            }
        }
        else
        {
            return new Data\FileStorage($cacheKey, $configuration, $htmlCacheOptions);
        }
    }
 
    public function enableVoting()
    {
        $this->voting = true;
    }
 
    public function disableVoting()
    {
        $this->voting = false;
    }
 
    public function isVotingEnabled()
    {
        return $this->voting;
    }

    public function giveNegativeComponentVote($context = "")
    {
        if (
            defined("USE_HTML_STATIC_CACHE")
            && USE_HTML_STATIC_CACHE === true
            && StaticArea::getCurrentDynamicId() === false //Voting doesn't work inside a dynamic area
        )
        {
            if (!$this->isVotingEnabled())
            {
                return;
            }
 
            $this->canCache = false;
 
            Debug\Logger::log(array(
                "TYPE" => Debug\Logger::TYPE_COMPONENT_VOTING,
                "MESSAGE" => $context
            ));
        }
    }
}
 
class_alias("Bitrix\\Main\\Composite\\Page", "Bitrix\\Main\\Data\\StaticHtmlCache");