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';
        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,
        );
        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)) {
                        self::$unique_service_id = substr(md5('il_' . CLIENT_ID), 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';
                                break;
                        case self::TYPE_MEMCACHED:
                                return 'ilMemcache';
                                break;
                        case self::TYPE_XCACHE:
                                return 'ilXcache';
                                break;
                        default:
                                return 'ilStaticCache';
                                break;
                }
        }


        protected static $active_cache = array();


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

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

                        return false;
                }

                $isActive = $this->global_cache->isActive();
                self::log('component ' . $this->getComponent() . ', service is active: '
                          . ($isActive ? 'yes' : 'no'), ilGlobalCacheSettings::LOG_LEVEL_CHATTY);
                self::$active_cache[$this->getComponent()] = $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()) {
                        if ($complete) {
                                return $this->global_cache->flush();
                        } else {
                                $this->global_cache->setInvalid();
                        }
                }

                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;
        }
}

?>