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();
                $list = ilMemcacheServer::where(array( 'status' => ilMemcacheServer::STATUS_ACTIVE ))
                                        ->get();
                foreach ($list 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($complete = false)
    {
        // currently a partial flushing is missing
        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;
    }
}