class.ilMemcache.php

Go to the documentation of this file.

<?php
 
require_once('./Services/GlobalCache/classes/class.ilGlobalCacheService.php');
require_once('class.ilMemcacheServer.php');
 
class ilMemcache extends ilGlobalCacheService {
 
        protected static $memcache_object;
 
 
        public function __construct($service_id, $component) {
                if (!(self::$memcache_object instanceof Memcached) AND $this->getInstallable()) {
                        $memcached = new Memcached();
 
                        if (ilMemcacheServer::count() > 0) {
 
                                $memcached->resetServerList();
                                $servers = array();
                                foreach (ilMemcacheServer::where(array( 'status' => ilMemcacheServer::STATUS_ACTIVE ))->get() as $ilMemcacheServer) {
                                        $servers[] = array( $ilMemcacheServer->getHost(), $ilMemcacheServer->getPort(), $ilMemcacheServer->getWeight() );
                                }
                                $memcached->addServers($servers);
                        }
 
                        self::$memcache_object = $memcached;
                }
                parent::__construct($service_id, $component);
        }
 
 
        protected function getMemcacheObject() {
                return self::$memcache_object;
        }
 
 
        public function exists($key) {
                return $this->getMemcacheObject()->get($this->returnKey($key)) != null;
        }
 
 
        public function set($key, $serialized_value, $ttl = null) {
                return $this->getMemcacheObject()->set($this->returnKey($key), $serialized_value, (int)$ttl);
        }
 
 
        public function get($key) {
                return $this->getMemcacheObject()->get($this->returnKey($key));
        }
 
 
        public function delete($key) {
                return $this->getMemcacheObject()->delete($this->returnKey($key));
        }
 
 
        public function flush() {
                return $this->getMemcacheObject()->flush();
        }
 
 
        protected function getActive() {
                if ($this->getInstallable()) {
                        $stats = $this->getMemcacheObject()->getStats();
 
                        if (!is_array($stats)) {
                                return false;
                        }
 
                        foreach ($stats as $server) {
                                if ($server['pid'] > 0) {
                                        return true;
                                }
                        }
 
                        return false;
                }
 
                return false;
        }
 
 
        protected function getInstallable() {
                return class_exists('Memcached');
        }
 
 
        public function getInstallationFailureReason() {
                if ($this->getMemcacheObject() instanceof Memcached) {
                        $stats = $this->getMemcacheObject()->getStats();
 
                        if (!$stats[self::STD_SERVER . ':' . self::STD_PORT]['pid'] > 0) {
                                return 'No Memcached-Server available';
                        }
                }
 
                return parent::getInstallationFailureReason();
        }
 
 
        public function serialize($value) {
                return serialize($value);
        }
 
 
        public function unserialize($serialized_value) {
                return unserialize($serialized_value);
        }
 
 
        public function getInfo() {
                if (self::isInstallable()) {
                        $return = array();
                        $return['__cache_info'] = $this->getMemcacheObject()->getStats();
                        foreach ($this->getMemcacheObject()->getAllKeys() as $key) {
                                $return[$key] = $this->getMemcacheObject()->get($key);
                        }
 
                        return $return;
                }
        }
 
 
        public function isValid($key) {
                return true;
        }
}