TphpCache

Classe permettant la mise en cache mémoire

Fonction del

Permet de supprimer un valeur dans le cache.

Appel :

$cache->del($key, $param=[]);

$key : la clé de cache à supprimer
$param : Paramètres à transmettre à la fonction de suppression du driver.

Retour :

boolean : true | false

Fonction isValid

Est-ce que le cache est valide (connexion établie ou filesystem accessible en écriture).

Appel :

$cache->isValid();

Retour :

boolean : true | false

Fonction supportClear

Est-ce que le driver supporte la purge du précache PHP de données.

Appel :

$cache->supportClear();

Retour :

boolean : true | false

Fonction supportFlush

Est-ce que le driver supporte le flush des données en mémoire.

Appel :

$cache->supportFlush();

Retour :

boolean : true | false

Fonction supportPreload

Est-ce que le driver supporte le preload de données.

Appel :

$cache->supportPreload();

Retour :

boolean : true | false

Code source TphpCache :

<?php
class TphpCache {
	private static $cache=array();
	public static $conf=array();
	
	protected $name=null;
	protected $type=null;

    /**
     * @param string $name
     *
     * @throws Exception
     */
	public function __construct($name='noName') {
		$this->name=$name;
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			$this->type=TphpCache::$cache[$this->name]->type;
		}
	}

	public function __destruct() {
		//TphpCache::$cache[$this->name] = null; permet de conserver les connection memcache
	}

	public function supportPreload() {
		return ($this->type === 'memcache');
	}
	
	public function supportClear() {
		return ($this->type === 'fs');
	}
	
	public function supportFlush() {
		return in_array($this->type,array('fs','memcache'));
	}

    /**
     * @throws \Exception
     */
	public function isValid() {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->isValid();
		}
		return false;
	}

    /**
     * @param       $key
     * @param array $param
     *
     * @return bool
     * @throws Exception
     */
	public function del($key,$param=array()) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->del($key,$param);
		}
		return false;
	}

    /**
     * @param       $keys
     * @param array $param
     *
     * @return bool
     * @throws Exception
     */
	public function delMulti($keys,$param=array()) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->delMulti($keys,$param);
		}
		return false;
	}

    /**
     * @param $key
     *
     * @return bool
     * @throws Exception
     */
	public function isExpired($key) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->isExpired($key);
		}
		return true;
	}

    /**
     * @param $key
     *
     * @return bool
     * @throws Exception
     */
	public function lock($key) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->lock($key);
		}
		return false;
	}

    /**
     * @param $key
     *
     * @return bool
     * @throws Exception
     */
	public function unLock($key) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->unLock($key);
		}
		return false;
	}

    /**
     * @param       $key
     * @param       $val
     * @param array $param
     *
     * @return bool
     * @throws Exception
     */
	public function set($key,$val,$param=array()) {
		$this->load();
		if (isset(TphpCache::$cache[$this->name])) {
			return TphpCache::$cache[$this->name]->set($key,$val,$param);
		}
		return false;
	}

    /**
     * @throws \Exception
     */
	private function load() {
		if (isset(self::$conf[$this->name]) && !isset(self::$cache[$this->name])) {
			$param=self::$conf[$this->name];
			$param['name']=$this->name;
			if (isset($param['type'])) {
				$this->type=$param['type'];
			} else {
				$this->type='noType';
			}
			if ($this->type==='memcache') {
				TphpCache::$cache[$this->name] = new TphpCacheMemCache($param);
			} elseif ($this->type==='fs') {
				TphpCache::$cache[$this->name] = new TphpCacheFs($param);
			} else {
				TphpCache::$cache[$this->name]=null;
			}
		}
	}
	
	
	public function preload($keys=array()) {
		if ($this->type==='memcache') {
			return TphpCache::$cache[$this->name]->preload($keys);
		}
		return false;
	}
	
	public static function setConf($name,$param=array()) {
		$param['name']=$name;
		self::$conf[$name]=$param;
	}

    /**
     * @param $method
     * @param $args
     *
     * @return mixed
     * @throws Exception
     */
	public function __call($method,$args) {
		if (in_array($method,array('get','delClsCache','isClsCached','setTtl','clear','flush','set','getStats'))) {
			$this->load();
			if (isset(TphpCache::$cache[$this->name]) && !is_null(TphpCache::$cache[$this->name])) {
				return call_user_func_array(array(TphpCache::$cache[$this->name],$method),$args);
			}
			throw new \Exception(__CLASS__.'['.$this->name.'].method['.$method.'].notExist');
		}
		throw new \Exception(__CLASS__.'['.$this->name.'].method['.$method.'].notExist');
	}

    /**
     * @param $method
     * @param $args
     *
     * @throws Exception
     */
	public static function __callStatic($method,$args) {
		throw new \Exception(__CLASS__.'.staticMethod['.$method.'].notExist');
	}
}

Driver code source TphpCacheFs :

<?php

class TphpCacheFs {
	private $cache=array();

    /**
     * @param array $param
     *
     * @throws Exception
     */
	public function __construct($param=array()) {
		$this->conf=array();
		$this->type=$param['type'];
		$this->name=isset($param['name'])?$param['name']:'unknow';
		$this->fs_name=isset($param['fs_name'])?$param['fs_name']:'unknow';
		$fs=TphpFs::get($this->fs_name);
		$this->is_valid=(!is_null($fs) && ''!=$fs->getPath() && is_dir($fs->getPath()) && is_writable($fs->getPath()));
		if (!$this->is_valid) {
			throw new \Exception(__CLASS__.'.name['.$this->name.'].notValid');
		}
	}

	public function isValid() {
		return $this->is_valid;
	}

	public function __destruct() {}

	public function set($key,$value=null,$param=array()) {
		if ($this->is_valid) {
			$key_tmp=$this->getKeyFromArray($key);
			$header=array('date'=>time());
			if (isset($param['ttl'])) {
				$header['ttl']=$param['ttl'];
			} else {
				$header['ttl']=60;
			}
			$push=(isset($param['push']) && $param['push'])?true:false;
			$ret=TphpFs::get($this->fs_name)->add($key_tmp,'header:'.base64_encode(serialize($header))."#data:".base64_encode(serialize($value)),$push);
			$this->unLock($key);
			return $ret;
		}
		return false;
	}

    /**
     * @param $key
     *
     * @return mixed|null
     * @throws Exception
     */
	public function get($key) {
		if (isset($this->cache[$key])) {
			$data=$this->cache[$key];
			unset($this->cache[$key]);
			return $data;
		}
        if ($this->is_valid) {
            $key_tmp=$this->getKeyFromArray($key);
            if (is_null($content=TphpFs::get($this->fs_name)->getFileContent($key_tmp))) {
                return null;
            }
            $lines=explode('#',$content);
            for($i=0;$i<count($lines);$i++) {
                if (substr($lines[$i],0,4)=='data') {
                    return unserialize(base64_decode(substr($lines[$i],5)));
                }
            }
            return null;
        }
        return null;
	}

    /**
     * @param       $key
     * @param array $param
     *
     * @return bool
     * @throws Exception
     */
	public function del($key,$param=array()) {
		if ($this->is_valid) {
			$key_tmp=$this->getKeyFromArray($key);
			$push=(isset($param['push']) && $param['push'])?true:false;
			return TphpFs::get($this->fs_name)->delete($key_tmp,$push);
		}
		return false;
	}

    /**
     * @param string $prefix
     * @param array  $param
     *
     * @return bool
     * @throws Exception
     */
	public function clear($prefix='',$param=array()) {
		if ($this->is_valid) {
			$key_tmp=substr($this->getKeyFromArray($prefix),0,-6);
			$push=(isset($param['push']) && $param['push'])?true:false;
			return TphpFs::get($this->fs_name)->clear($key_tmp,$push);
		}
		return false;
	}

	public function flush($param) {
		if ($this->is_valid) {
			return $this->clear('',$param);
		}
		return false;
	}

	public function isClsCached($key) {
		if (isset($this->cache[$key])) {
			return true;
		}
		return false;
	}

	public function delClsCache($keys) {
		foreach($keys as $key) {
			if (isset($this->cache[$key])) unset($this->cache[$key]);
		}
	}

    /**
     * @param $key
     *
     * @return bool
     * @throws Exception
     */
	public function isExpired($key) {
		if (isset($this->cache[$key])) {
		    return false;
		}
		
		$path = $this->getKeyFromArray($key);
		$file_mtime=0;
		
		$fs=TphpFs::get($this->fs_name);
		if (file_exists($fs->getPath().$path)) {
			$file_mtime=filemtime($fs->getPath().$path);
			$content=$fs->getFileContent($path);
			$lines=explode('#',$content);
			unset($content);
			if (substr($lines[0],0,6)=='header') {
				$header=unserialize(base64_decode(substr($lines[0],7)));
				if (isset($header['date']) && time()-$header['date']>$header['ttl']) {

				} else if (filemtime($fs->getPath().$path)<time()-$header['ttl']) {

				} else {
					if (substr($lines[1],0,4)=='data') {
						$this->cache[$key]=unserialize(base64_decode(substr($lines[1],5)));
						return false;
					}
				}
			}
			unset($lines);
		}

		// Si un .lock est présent depuis plus de 4 minutes, on marque le cache comme expiré
		if (file_exists($fs->getPath().$path.'.lock')) {
			$lock_mtime=filemtime($fs->getPath().$path.'.lock');
			if ($lock_mtime && $lock_mtime<time()-240) {
				return true;
			}
		} else {
			return true;
		}
		$file_mtime_base=$file_mtime;
		$cptr = 0;
		while (file_exists($fs->getPath().$path.'.lock') && (!$file_mtime || ($file_mtime && $file_mtime==$file_mtime_base))) {
			if ($cptr++<30) {
				sleep(1);
				if (file_exists($fs->getPath().$path)) {
					$file_mtime=filemtime($fs->getPath().$path);
				} else {
					$file_mtime=false;
				}
			} else {
				return true;
			}
		}
		if (file_exists($fs->getPath().$path) && $file_mtime!=$file_mtime_base) {
			$content=$fs->getFileContent($path);
			$lines=explode('#',$content);
			unset($content);
			if (substr($lines[0],0,6)=='header') {
				if (substr($lines[1],0,4)=='data') {
					$this->cache[$key]=unserialize(base64_decode(substr($lines[1],5)));
					return false;
				}
			}
			unset($lines);
			return true;
		}
		return true;
	}

	public function lock($key) {
		if ($this->is_valid) {
			$path = $this->getKeyFromArray($key).'.lock';
			return TphpFs::get($this->fs_name)->add($path,'lock',false);
		}
		return false;
	}

    /**
     * @param $key
     *
     * @return bool
     * @throws Exception
     */
	public function unLock($key) {
		if ($this->is_valid) {
			$path = $this->getKeyFromArray($key).'.lock';
			return TphpFs::get($this->fs_name)->delete($path,false);
		}
		return false;
	}

	public function getKeyFromArray($key) {
		$tab_key=explode('/',$key);
		foreach($tab_key as &$key_elem) {
			$pos=strpos($key_elem,'~~');
			if ($pos!==false) {
				$key_elem=str_replace('//','/',substr($key_elem,0,$pos).'/'.substr($key_elem,$pos+2,3).'/'.substr($key_elem,$pos+5,3).'/'.substr($key_elem,$pos+8));
			}
			$pos=strpos($key_elem,'~');
			if ($pos!==false) {
				$key_elem=str_replace('//','/',substr($key_elem,0,$pos).'/'.substr($key_elem,$pos+1,3).'/'.substr($key_elem,$pos+4));
			}
		}
		$key=implode('/',$tab_key);
		$key .= '.cache';
		return $key;
	}

	public static function touch($path) {
		touch($path);
		return true;
	}
}

Driver code source TphpCacheMemCache :

<?php
class TphpCacheMemCache {
	private $cache=array();
	public function __construct($param=array()) {
		$this->name=isset($param['name'])?$param['name']:'unknow';
		$this->servers=isset($param['servers'])?$param['servers']:array(array('host'=>'127.0.0.1','port'=>'11211','name'=>'localhost'));
		$this->servers_push=(isset($param['servers_push']) && is_array($param['servers_push']) && count($param['servers_push'])>0)?$param['servers_push']:null;
		$this->servers_push_flush=(isset($param['servers_push_flush']) && is_array($param['servers_push_flush']) && count($param['servers_push_flush'])>0)?$param['servers_push_flush']:null;
		$this->servers_push_del=(isset($param['servers_push_del']) && is_array($param['servers_push_del']) && count($param['servers_push_del'])>0)?$param['servers_push_del']:null;
		$this->servers_push_set=(isset($param['servers_push_set']) && is_array($param['servers_push_set']) && count($param['servers_push_set'])>0)?$param['servers_push_set']:null;
		$this->obj=null;
		$this->tab_obj_push=array();
		$this->type=$param['type'];
		$this->prefix=isset($param['prefix'])?($param['prefix']):'';
	}
	public function connect() {
		$this->obj=new Memcache();
		$tab_srv=array();
		foreach($this->servers as $srv) {
			$this->obj->addServer($srv['host'],$srv['port'],true,((isset($srv['weight']))?$srv['weight']:floor(100/count($this->servers))));
		}
	}
	
	public function isValid() {
		//@TODO A revoir
		if (is_null($this->obj)) {$this->connect();}
		return true;
	}
	
	public function preload($keys) {
		if (is_null($this->obj)) {$this->connect();}
		$tab=$this->obj->get($keys);
		foreach($tab as $k=>$v) {
			$this->cache[$k]=$v;
		}
		
	}
	
	public function delClsCache($keys) {
		foreach($keys as $key) {
			if (isset($this->cache[$key])) unset($this->cache[$key]);
		}
	}
	
	public function set($key,$val,$param=array()) {
		$ttl=isset($param['ttl'])?$param['ttl']:(isset($param['cache_ttl'])?$param['cache_ttl']:60);
		if (is_null($this->obj)) {$this->connect();}
		$ret=$this->obj->set($this->prefix.$key,$val,MEMCACHE_COMPRESSED,$ttl);
		$this->unLock($key);
		if (isset($param['push']) && $param['push']) {
			$this->pushSet($key,$val,$param);
		}
		return $ret;
	}
	
	public function get($key) {
		if (isset($this->cache[$key])) {
			$data=$this->cache[$key];
			unset($this->cache[$key]);
			return $data;
		} else {
			if (is_null($this->obj)) {$this->connect();}
			return $this->obj->get($this->prefix.$key,MEMCACHE_COMPRESSED);
		}
	}
	
	public function setTtl($key,$ttl=60) {
		if (is_null($this->obj)) {$this->connect();}
		$val=$this->obj->get($this->prefix.$key,MEMCACHE_COMPRESSED);
		return $this->obj->set($this->prefix.$key,$val,MEMCACHE_COMPRESSED,(($ttl!=0)?(time()+$ttl):0));
	}
	
	public function isExist($key) {
		return !$this->isExpired($key);
	}

	public function isClsCached($key) {
		if (isset($this->cache[$key])) {
			return true;
		} else {
			return false;
		}
	}
	
	public function isExpired($key) {
		if (isset($this->cache[$key])) {
			return false;
		}
		
		if (is_null($this->obj)) {$this->connect();}
		$data=$this->obj->get($this->prefix.$key,MEMCACHE_COMPRESSED);
		
		if ($data!==false) {
			$this->cache[$key]=$data;
			return false;
		} else {
			$cptr=0;
			while ($this->obj->get($this->prefix.$key.'.lock')!==false && $data===false) {
				if ($cptr++<10) {
					sleep(1);
					$data=$this->obj->get($this->prefix.$key,MEMCACHE_COMPRESSED);
				} else {
					return true;
				}
			}
			if ($data===false) {
				usleep(300);
				if ($this->obj->get($this->prefix.$key.'.lock')!==false) {
					return true;
				}
			} else {
				$this->cache[$key]=$data;
				return false;
			}
			return true;
		}
	}

	public function del($key,$param=array()) {
		if (is_null($this->obj)) {$this->connect();}
		$ret=$this->obj->delete($this->prefix.$key,0);
		if (isset($param['push']) && $param['push']) {
			$this->pushDel($key);
		}
		return $ret;
	}

	public function delMulti($keys,$param=array()) {
		if (is_null($this->obj)) {$this->connect();}
		$rets=array();
		foreach($keys as &$key){
			$rets[]=$this->obj->delete($this->prefix.$key,0);
			if (isset($param['push']) && $param['push']) {
				$this->pushDel($key);
			}
		}
		return $rets;
	}

	public function lock($key) {
		if (is_null($this->obj)) {$this->connect();}
		$this->obj->set($this->prefix.$key.'.lock','lock');
	}

	public function unLock($key) {
		if (is_null($this->obj)) {$this->connect();}
		$this->obj->delete($this->prefix.$key.'.lock',0);
	}
	
	public function flush($param=array()) {
		if (is_null($this->obj)) {$this->connect();}
		$ret=$this->obj->flush();
		if (isset($param['push']) && $param['push']) {
		    $this->pushFlush($param);
		}
		return $ret;
	}
	
	private function pushFlush($param=array()) {
		$srv_list=null;
		if (!is_null($this->servers_push_flush)) {
			$srv_list=&$this->servers_push_flush;
		} else if (!is_null($this->servers_push)) {
			$srv_list=&$this->servers_push;
		}
		if (!is_null($srv_list)) {
			$ttl=isset($param['ttl'])?$param['ttl']:60;
			$ret_global=true;
			foreach($srv_list as &$srv) {
				if (!isset($srv['obj'])) {
					$srv['obj'] = new Memcache();
					$srv['obj']->addServer($srv['host'],$srv['port'],true);
				}
				$ret=$srv['obj']->flush();
				TphpCore::log('pushFlush['.$this->name.']['.$srv['host'].'].ret['.$ret.']',array('rub'=>'PUSH_MEM'));
				$ret_global=$ret_global && $ret;
			}
			return $ret_global;
		} else {
			return false;
		}
	}
	
	public function getStats() {
		if (is_null($this->obj)) {$this->connect();}
		return $this->obj->getStats();
	}
	
	private function pushSet($key,$value,$param=array()) {
		$srv_list=null;
		if (!is_null($this->servers_push_set)) {
			$srv_list=&$this->servers_push_set;
		} else if (!is_null($this->servers_push)) {
			$srv_list=&$this->servers_push;
		}
		if (!is_null($srv_list)) {
			$ttl=isset($param['ttl'])?$param['ttl']:60;
			$ret_global=true;
			$size=strlen(serialize($value));
			foreach($srv_list as &$srv) {
				if (!isset($srv['obj'])) {
					$srv['obj'] = new Memcache();
					$srv['obj']->addServer($srv['host'],$srv['port'],true);
				}
				$ret=$srv['obj']->set($this->prefix.$key,$value,MEMCACHE_COMPRESSED,$ttl);
				TphpCore::log('pushSet['.$this->name.']['.$srv['host'].']['.$this->prefix.$key.']['.$size.'].ret['.$ret.']',array('rub'=>'PUSH_MEM'));
				$ret_global=$ret_global && $ret;
			}
			return $ret_global;
		} else {
			return false;
		}
	}
	
	private function pushDel($key) {
		$srv_list=null;
		if (!is_null($this->servers_push_del)) {
			$srv_list=&$this->servers_push_del;
		} else if (!is_null($this->servers_push)) {
			$srv_list=&$this->servers_push;
		}
		if (!is_null($srv_list)) {
			$ret_global=true;
			foreach($srv_list as &$srv) {
				if (!isset($srv['obj'])) {
					$srv['obj'] = new Memcache();
					$srv['obj']->addServer($srv['host'],$srv['port'],true);
				}
				$ret=$srv['obj']->delete($this->prefix.$key);
				TphpCore::log('pushDel['.$this->name.']['.$srv['host'].']['.$this->prefix.$key.'].ret['.$ret.']',array('rub'=>'PUSH_MEM'));
				$ret_global=$ret_global && $ret;
			}
			return $ret_global;
		} else {
			return false;
		}
	}
	
}