cache_storage_memcache.inc

<?php
require_once SQ_CORE_PACKAGE_PATH.'/system/cache_storage/cache_storage/cache_storage.inc';

define('SQ_CACHE_MEMCACHE_PREFIX', 'sq_cache|');
define('SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX', 'sq_cache_asset_index|');
define('SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX', 'sq_cache_url_index|');

class Cache_Storage_Memcache extends Cache_Storage
{
    private $_memcache;


    function __construct($assetid=0)
    {
        parent::__construct($assetid);

    }//end constructor


    public function initMemcache()
    {
        assert_true(extension_loaded('memcache'), 'Cannot use Memcache Cache Storage; it requires the memcache PECL extension installed within PHP, which is not installed');
        assert_true(is_file(SQ_DATA_PATH.'/private/conf/memcache.inc'), 'Cannot use Memcache Cache Storage; the Memcache configuration file is not set');

        $memcache_conf = require(SQ_DATA_PATH.'/private/conf/memcache.inc');
        $hosts =& $memcache_conf['hosts'];
        $services =& $memcache_conf['services'];

        assert_true(count($hosts) > 0, 'Cannot use Memcache Cache Storage; no hosts are defined in the Memcache configuration file');
        assert_true(array_key_exists('cache_manager', $services) === TRUE, 'Cannot use Memcache Cache Storage; no Memcache hosts are assigned to cache manager');
        assert_true(count($services['cache_manager']) > 0, 'Cannot use Memcache Cache Storage; no Memcache hosts are assigned to cache manager');

        // If PHP has the memcache module installed, instantiate it and try to load some config.
        $this->_memcache = new Memcache;

        foreach ($services['cache_manager'] as $host_key => $weight) {
            assert_true(array_key_exists($host_key, $hosts) === TRUE, 'Cannot use Memcache Cache Storage; host key "'.$host_key.'" assigned for use for cache manager but not defined as a host');
            $host = $hosts[$host_key];
            $this->_memcache->addServer($host['host'], $host['port'], $host['persistent'], $weight, $host['timeout'], $host['retry_interval'], $host['status'], Array($this, 'failureCallback'));
        }

        $this->_memcache->setCompressThreshold($memcache_conf['compression_threshold'], $memcache_conf['compression_min_saving']);

    }//end initMemcache()


    public static function isAvailable()
    {
        if (extension_loaded('memcache') === TRUE) {
            if (is_file(SQ_DATA_PATH.'/private/conf/memcache.inc')) {
                return TRUE;
            } else {
                return FALSE;
            }
        } else {
            return FALSE;
        }

    }//end isAvailable()


    function store($cache_key, $perm_key, $url, $assetid, $data, $expiry)
    {
        if (!$this->_memcache) $this->initMemcache();
        
        if ($this->_memcache) {
            // 0 is handled as infinite rather than 0 seconds in memcache. If we have 0,
            // don't set in cache, so that we're compatible with the standard cache storage.
            $expiry_length = $expiry - time();
            if ($expiry_length === 0) return FALSE;
            
            // For the indexes, we want just the base URL, no query string or trailing slash.
            $index_url = md5(trim(preg_replace('/\?.*/', '', $url), '/'));
            
            $url = md5($url);
            $mcache_key = SQ_CACHE_MEMCACHE_PREFIX."$cache_key|$perm_key|$url|$assetid";
            
            // Get both the indexes at once (faster).
            $indexes = $this->_memcache->get(Array(SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid, SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX.$index_url));
            
            // Update the assetid index if necessary.
            $assetid_hits = isset($indexes[SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid]) ? $indexes[SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid] : Array();
            if (!in_array($mcache_key, $assetid_hits)) {
                array_push($assetid_hits, $mcache_key);
                $this->_memcache->set(SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid, $assetid_hits);
            }
            
            // Update the url index if necessary.
            $url_hits = isset($indexes[SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX.$index_url]) ? $indexes[SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX.$index_url] : Array();
            if (!in_array($mcache_key, $url_hits)) {
                array_push($url_hits, $mcache_key);
                $this->_memcache->set(SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX.$index_url, $url_hits);
            }

            // Save the actual cache entry
            $ok = $this->_memcache->set($mcache_key, $data, FALSE, $expiry_length);
            return $ok;
        } else {
            return FALSE;
        }

    }//end store()


    function read($cache_key, $perm_key, $url, $assetid)
    {
        if (!$this->_memcache) $this->initMemcache();

        if ($this->_memcache) {
            $url = md5($url);
            return $this->_memcache->get(SQ_CACHE_MEMCACHE_PREFIX."$cache_key|$perm_key|$url|$assetid", FALSE);
        } else {
            return FALSE;
        }

    }//end read()


    function clearAll()
    {
        if (!$this->_memcache) $this->initMemcache();

        if ($this->_memcache) {
            return $this->_memcache->flush();
        } else {
            return FALSE;
        }

    }//end clearAll()


    function cleanExpiredEntries()
    {
        return TRUE;

    }//end cleanExpiredEntries()


    function canClearByAssetid()
    {
        return TRUE;

    }//end canClearByAssetid()


    function clear($assetids)
    {
        if (!$this->_memcache) $this->initMemcache();
        
        // For each assetid, fetch the asset index and delete everything we find. Including the index.
        foreach ($assetids as $assetid) {
            $assetid_hits = $this->_memcache->get(SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid, FALSE);
            if ($assetid_hits) {
                foreach ($assetid_hits as $key) {
                    $this->_memcache->delete($key);
                }
                $this->_memcache->delete(SQ_CACHE_MEMCACHE_ASSET_INDEX_PREFIX.$assetid);
            }
        }
        

    }//end clear()
    
    
    function clearCachedAssetsByUrl($url)
    {
        if (!$this->_memcache) $this->initMemcache();
        
        // Fetch the URL index and delete anything we find. Including the index.
        $index_key = SQ_CACHE_MEMCACHE_URL_INDEX_PREFIX.md5($url);
        $url_hits = $this->_memcache->get($index_key);
        
        if ($url_hits) {
            foreach ($url_hits as $key) {
                $this->_memcache->delete($key);
            }
            $this->_memcache->delete($index_key);
        }
        
    }//end clearCachedAssetsByUrl


    function getFilePaths($assetids)
    {
        return Array();

    }//end getFilePaths()


    function getAllFilePaths($option='')
    {
        return Array();

    }//end getAllFilePaths()
    

    function failureCallback($hostname, $port)
    {
        log_error(get_class()." failure communicating with $hostname:$port", E_USER_WARNING);

    }//end failureCallback()


}//end class

?>