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');

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';
        protected static $types = array(
                //              self::TYPE_MEMCACHED,
                //              self::TYPE_XCACHE,
                self::TYPE_APC,
                self::TYPE_STATIC
        );
        protected static $active_components = array(
                self::COMP_CLNG,
                self::COMP_OBJ_DEF,
                self::COMP_ILCTRL,
                self::COMP_COMPONENT,
                self::COMP_TEMPLATE,
                self::COMP_EVENTS,
                //'ctrl_mm'
        );
        protected static $type_per_component = array();
        protected static $unique_service_id = NULL;
        protected static $instances;
        protected $global_cache;
        protected $service_id = '';
        protected $component;
        protected $active = true;
        protected $service_type = ilGlobalCache::TYPE_STATIC;


        protected static function getComponentType($component = NULL) {
                $component = 0; // In this Version All Components have the same Caching-Type
                if (!isset(self::$type_per_component[$component])) {
                        global $ilClientIniFile;
                        if ($ilClientIniFile instanceof ilIniFile) {
                                self::$type_per_component[$component] = $ilClientIniFile->readVariable('cache', 'global_cache_service_type');
                        }
                }

                if (self::$type_per_component[$component]) {
                        return self::$type_per_component[$component];
                }

                return self::TYPE_FALLBACK;
        }


        public static function getInstance($component) {
                if (!isset(self::$instances[$component])) {
                        $service_type = self::getComponentType($component);
                        $ilGlobalCache = new self($service_type, $component);

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

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


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

                return self::$unique_service_id;
        }


        public static function flushAll() {
                foreach (self::$types as $type) {
                        $serviceName = self::lookupServiceName($type);
                        $service = new $serviceName(self::generateServiceId(), 'flush');
                        if ($service->isActive()) {
                                $service->flush();
                        }
                }
        }


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

                return $types;
        }


        public static function getAllTypes() {
                $types = array();
                foreach (self::$types as $type) {
                        $obj = new self($type);
                        $types[$type] = $obj;
                }

                return $types;
        }


        protected function __construct($service_type_id, $component = NULL) {
                $this->setComponent($component);
                $this->setServiceid(self::generateServiceId());
                $this->setActive(in_array($component, self::$active_components));
                $serviceName = self::lookupServiceName($service_type_id);
                $this->global_cache = new $serviceName($this->getServiceid(), $this->getComponent());
                $this->global_cache->setServiceType($service_type_id);
        }


        protected static function lookupServiceName($type_id) {
                switch ($type_id) {
                        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;
                }
        }


        public function isActive() {
                if (!self::ACTIVE) {

                        return false;
                }
                global $ilClientIniFile;
                if ($ilClientIniFile instanceof ilIniFile) {
                        if ($ilClientIniFile->readVariable('cache', 'activate_global_cache') != '1') {
                                return false;
                        }
                } else {
                        return false;
                }
                if (!$this->getActive()) {
                        return false;
                }

                return $this->global_cache->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;
                }
                $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) {

                        if ($this->global_cache->isValid($key)) {

                                return $unserialized_return;
                        } else {
                                //                              var_dump($key); // FSX
                        }
                }

                return NULL;
        }


        public function delete($key) {
                if (!$this->isActive()) {

                        return false;
                        throw new RuntimeException(self::MSG);
                }

                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 setServiceid($service_id) {
                $this->service_id = $service_id;
        }


        public function getServiceid() {
                return $this->service_id;
        }


        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) {
                $this->global_cache->setServiceType($service_type);
        }


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

?>