class.ilGlobalCache.php

Go to the documentation of this file.

<?php
require_once('./Services/GlobalCache/classes/Memcache/class.ilMemcache.php');
require_once('./Services/GlobalCache/classes/Xcache/class.ilXcache.php');
require_once('./Services/GlobalCache/classes/Apc/class.ilApc.php');
require_once('./Services/GlobalCache/classes/Static/class.ilStaticCache.php');
require_once('Settings/class.ilGlobalCacheSettings.php');

class ilGlobalCache
{
    const MSG = 'Global Cache not active, can not access cache';
    const ACTIVE = true;
    const TYPE_STATIC = 0;
    const TYPE_XCACHE = 1;
    const TYPE_MEMCACHED = 2;
    const TYPE_APC = 3;
    const TYPE_FALLBACK = self::TYPE_STATIC;
    const COMP_CLNG = 'clng';
    const COMP_OBJ_DEF = 'obj_def';
    const COMP_TEMPLATE = 'tpl';
    const COMP_ILCTRL = 'ilctrl';
    const COMP_PLUGINS = 'plugins';
    const COMP_COMPONENT = 'comp';
    const COMP_RBAC_UA = 'rbac_ua';
    const COMP_EVENTS = 'events';
    const COMP_TPL_BLOCKS = 'tpl_blocks';
    const COMP_TPL_VARIABLES = 'tpl_variables';
    const COMP_GLOBAL_SCREEN = 'global_screen';
    protected static $types = array(
        self::TYPE_MEMCACHED,
        self::TYPE_XCACHE,
        self::TYPE_APC,
        self::TYPE_STATIC,
    );
    protected static $available_types = array(
        self::TYPE_MEMCACHED,
        self::TYPE_XCACHE,
        self::TYPE_APC,
        self::TYPE_STATIC,
    );
    protected static $active_components = array();
    protected static $available_components = array(
        self::COMP_CLNG,
        self::COMP_OBJ_DEF,
        self::COMP_ILCTRL,
        self::COMP_COMPONENT,
        self::COMP_TEMPLATE,
        self::COMP_TPL_BLOCKS,
        self::COMP_TPL_VARIABLES,
        self::COMP_EVENTS,
        self::COMP_GLOBAL_SCREEN,
    );
    protected static $type_per_component = array();
    protected static $unique_service_id = null;
    protected static $instances;
    protected $global_cache;
    protected $component;
    protected $active = true;
    protected $service_type = ilGlobalCache::TYPE_STATIC;
    protected static $settings;

    public static function setup(ilGlobalCacheSettings $ilGlobalCacheSettings)
    {
        self::setSettings($ilGlobalCacheSettings);
        self::setActiveComponents($ilGlobalCacheSettings->getActivatedComponents());
    }

    public static function getInstance($component)
    {
        if (!isset(self::$instances[$component])) {
            $service_type  = self::getSettings()->getService();
            $ilGlobalCache = new self($service_type);
            $ilGlobalCache->setComponent($component);
            $ilGlobalCache->initCachingService();

            self::$instances[$component] = $ilGlobalCache;
        }

        return self::$instances[$component];
    }

    protected function __construct($service_type)
    {
        $this->checkSettings();
        self::generateServiceId();
        $this->setServiceType($service_type);
    }

    protected function initCachingService()
    {
        if (!$this->getComponent()) {
            $this->setComponent('default');
        }
        $serviceName          = self::lookupServiceClassName($this->getServiceType());
        $ilGlobalCacheService = new $serviceName(self::$unique_service_id, $this->getComponent());
        $ilGlobalCacheService->setServiceType($this->getServiceType());
        $this->global_cache = $ilGlobalCacheService;
        $this->setActive(in_array($this->getComponent(), self::getActiveComponents()));
    }

    protected function checkSettings()
    {
        if (!$this->getSettings() instanceof ilGlobalCacheSettings) {
            $ilGlobalCacheSettings = new ilGlobalCacheSettings();
            $this->setSettings($ilGlobalCacheSettings);
        }
    }

    public static function log($message, $log_level)
    {
        if ($log_level <= self::getSettings()->getLogLevel()) {
            global $DIC;
            $ilLog     = $DIC['ilLog'];
            $backtrace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 2);
            $function  = $backtrace[1]['function'];
            $class     = $backtrace[1]['class'];
            if ($ilLog instanceof ilComponentLogger) {
                $ilLog->alert($class . '::' . $function . '(): ' . $message);
            }
        }
    }

    protected static function generateServiceId()
    {
        if (!isset(self::$unique_service_id)) {
            $rawServiceId = '_';
            if (defined('CLIENT_ID')) {
                $rawServiceId .= 'il_' . CLIENT_ID;
            }
            self::$unique_service_id = substr(md5($rawServiceId), 0, 6);
        }
    }

    public static function flushAll()
    {
        self::log('requested...', ilGlobalCacheSettings::LOG_LEVEL_NORMAL);
        foreach (self::$types as $type) {
            $serviceName = self::lookupServiceClassName($type);
            $service     = new $serviceName(self::generateServiceId(), 'flush');
            if ($service->isActive()) {
                self::log('Told ' . $serviceName . ' to flush', ilGlobalCacheSettings::LOG_LEVEL_NORMAL);
                $returned = $service->flush();
                self::log($serviceName . ' returned status ' . ($returned ? 'ok' : 'failure'), ilGlobalCacheSettings::LOG_LEVEL_NORMAL);
            }
        }
    }

    public static function getAllInstallableTypes()
    {
        $types = array();
        foreach (self::getAllTypes() as $type) {
            if ($type->isCacheServiceInstallable()) {
                $types[] = $type;
            }
        }

        return $types;
    }

    public static function getAllTypes($only_available = true)
    {
        $types = array();
        foreach (self::$types as $type) {
            if ($only_available && !in_array($type, self::$available_types)) {
                continue;
            }
            $obj = new self($type);
            $obj->initCachingService();
            $types[$type] = $obj;
        }

        return $types;
    }

    public static function lookupServiceClassName($service_type)
    {
        switch ($service_type) {
            case self::TYPE_APC:
                return ilApc::class;
            case self::TYPE_MEMCACHED:
                return ilMemcache::class;
            case self::TYPE_XCACHE:
                return ilXcache::class;
            default:
                return ilStaticCache::class;
        }
    }

    public static function lookupServiceConfigName(int $service_type): string
    {
        switch ($service_type) {
            case self::TYPE_APC:
                return 'apc';
            case self::TYPE_MEMCACHED:
                return 'memcached';
            case self::TYPE_XCACHE:
                return 'xcache';
            default:
                return 'static';
        }
    }

    protected static $active_cache = array();

    public function isActive()
    {
        $c = $this->getComponent();
        if (isset(self::$active_cache[$c]) && self::$active_cache[$c] !== null) {
            return self::$active_cache[$c];
        }
        if (!self::ACTIVE) {
            self::$active_cache[$c] = false;

            return false;
        }
        if (!$this->getActive()) {
            self::log($c . '-wrapper is inactive...', ilGlobalCacheSettings::LOG_LEVEL_CHATTY);
            self::$active_cache[$c] = false;

            return false;
        }

        $isActive = $this->global_cache->isActive();
        self::log('component ' . $c . ', service is active: '
            . ($isActive ? 'yes' : 'no'), ilGlobalCacheSettings::LOG_LEVEL_CHATTY);
        self::$active_cache[$c] = $isActive;

        return $isActive;
    }

    public function isValid($key)
    {
        return $this->global_cache->isValid($key);
    }

    public function isInstallable()
    {
        return count(self::getAllInstallableTypes()) > 0;
    }

    public function isCacheServiceInstallable()
    {
        return $this->global_cache->isInstallable();
    }

    public function getInstallationFailureReason()
    {
        return $this->global_cache->getInstallationFailureReason();
    }

    public function exists($key)
    {
        if (!$this->global_cache->isActive()) {
            return false;
        }

        return $this->global_cache->exists($key);
    }

    public function set($key, $value, $ttl = null)
    {
        if (!$this->isActive()) {
            return false;
        }
        self::log($key . ' set in component ' . $this->getComponent(), ilGlobalCacheSettings::LOG_LEVEL_CHATTY);
        $this->global_cache->setValid($key);

        return $this->global_cache->set($key, $this->global_cache->serialize($value), $ttl);
    }

    public function get($key)
    {
        if (!$this->isActive()) {
            return false;
        }
        $unserialized_return = $this->global_cache->unserialize($this->global_cache->get($key));
        if ($unserialized_return) {
            $service_name = ' [' . self::lookupServiceClassName($this->getServiceType()) . ']';
            if ($this->global_cache->isValid($key)) {
                self::log($key . ' from component ' . $this->getComponent() . $service_name, ilGlobalCacheSettings::LOG_LEVEL_CHATTY);

                return $unserialized_return;
            } else {
                self::log($key . ' from component ' . $this->getComponent() . ' is invalid' . $service_name, ilGlobalCacheSettings::LOG_LEVEL_CHATTY);
            }
        }

        return null;
    }

    public function delete($key)
    {
        if (!$this->isActive()) {
            return false;
        }

        return $this->global_cache->delete($key);
    }

    public function flush($complete = false)
    {
        if ($this->global_cache->isActive()) {
            return $this->global_cache->flush($complete);
        }

        return false;
    }

    public function getInfo()
    {
        return $this->global_cache->getInfo();
    }

    public function setComponent($component)
    {
        $this->component = $component;
    }

    public function getComponent()
    {
        return $this->component;
    }

    public function setActive($active)
    {
        $this->active = $active;
    }

    public function getActive()
    {
        return $this->active;
    }

    public function setServiceType($service_type)
    {
        if ($this->global_cache instanceof ilGlobalCacheService) {
            $this->global_cache->setServiceType($service_type);
        }
        $this->service_type = $service_type;
    }

    public function getServiceType()
    {
        if ($this->global_cache instanceof ilGlobalCacheService) {
            return $this->global_cache->getServiceType();
        }

        return $this->service_type;
    }

    public static function getSettings()
    {
        return (self::$settings instanceof ilGlobalCacheSettings ? self::$settings : new ilGlobalCacheSettings());
    }

    public static function setSettings($settings)
    {
        self::$settings = $settings;
    }

    public static function getActiveComponents()
    {
        return self::$active_components;
    }

    public static function setActiveComponents($active_components)
    {
        self::$active_components = $active_components;
    }

    public static function getAvailableComponents()
    {
        return self::$available_components;
    }

    public static function setAvailableComponents($available_components)
    {
        self::$available_components = $available_components;
    }
}