class.ilGlobalCacheService.php

Go to the documentation of this file.

<?php

abstract class ilGlobalCacheService {

        protected $current_time = 0;
        protected $valid_keys = array();
        protected static $active = array();
        protected static $installable = array();
        protected $service_id = '';
        protected $component = '';
        protected $service_type = ilGlobalCache::TYPE_STATIC;
        protected $valid_key_hash = '';


        public function __construct($service_id, $component) {
                $this->setComponent($component);
                $this->setServiceId($service_id);
                self::$active[get_called_class()] = $this->getActive();
                self::$installable[get_called_class()] = ($this->getInstallable() AND $this->checkMemory());
                //              $this->current_time = time();
                $this->readValid();
        }


        public function __destruct() {
                $this->saveValid();
        }


        protected function saveValid() {
                if ($this->isActive()) {
                        if ($this->valid_key_hash != md5(serialize($this->valid_keys))) {
                                $this->set('valid_keys', $this->serialize($this->valid_keys));
                        }
                }
        }


        protected function readValid() {
                if ($this->isActive()) {
                        $this->valid_keys = $this->unserialize($this->get('valid_keys'));
                        $this->valid_key_hash = md5(serialize($this->valid_keys));
                }
        }


        abstract protected function getActive();


        abstract protected function getInstallable();


        abstract public function unserialize($serialized_value);


        abstract public function get($key);


        abstract public function set($key, $serialized_value, $ttl = NULL);


        abstract public function serialize($value);


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


        public function setServiceId($service_id) {
                $this->service_id = $service_id;
        }


        public function setValid($key) {
                $this->valid_keys[$key] = true;
                //              $this->valid_keys[$key] = time();
        }


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


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


        public function setInvalid($key = NULL) {
                if ($key) {
                        unset($this->valid_keys[$key]);
                } else {
                        unset($this->valid_keys);
                }
        }


        public function isValid($key) {
                return isset($this->valid_keys[$key]);
        }


        public function isActive() {
                return self::$active[get_called_class()];
        }


        public function isInstallable() {
                return self::$installable[get_called_class()];
        }


        public function returnKey($key) {
                return $str = $this->getServiceId() . '_' . $this->getComponent() . '_' . $key;

                return str_replace('/', '_', $str);
        }


        public function getInfo() {
                return array();
        }


        public function getInstallationFailureReason() {
                if (! $this->getInstallable()) {
                        return 'Not installed';
                }
                if (! $this->checkMemory()) {
                        return 'Not enough Cache-Memory, set to at least ' . $this->getMinMemory() . 'M';
                }

                return 'Unknown reason';
        }


        protected function getMemoryLimit() {
                return 9999;
        }


        protected function getMinMemory() {
                return 0;
        }


        protected function checkMemory() {
                $matches = array();
                $memory_limit = $this->getMemoryLimit();
                if (preg_match('/([0-9]*)([M|K])/uism', $memory_limit, $matches)) {
                        switch ($matches[2]) {
                                case 'M':
                                        $memory_limit = $matches[1] * 1024 * 1024; // nnnM -> nnn MB
                                        break;
                                case 'K':
                                        $memory_limit = $matches[1] * 1024; // nnnK -> nnn KB
                                        break;
                        }
                } else {
                        $memory_limit = $memory_limit * 1024 * 1024; // nnnM -> nnn MB
                }

                return ($memory_limit >= $this->getMinMemory() * 1024 * 1024);
        }


        abstract public function exists($key);


        abstract public function delete($key);


        abstract public function flush();


        public function setServiceType($service_type) {
                $this->service_type = $service_type;
        }


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

?>