deja_vu.inc

<?php
// We use a control file to enable/disable Deja Vu, since it must be flushed
// each time it is turned off. See scripts/dejavu_management.php
define('SQ_DEJA_VU_CONTROL', SQ_DATA_PATH.'/private/conf/.dejavu');
define('SQ_DEJA_VU_MEMCACHE_PREFIX', 'sq_deja_vu|');

// Storage types
define('SQ_DEJA_VU_ASSET', 'asset');
define('SQ_DEJA_VU_LOCALE', 'locale_manager');

class Deja_Vu extends MySource_Object
{
    private $_memcache;


    private $_enabled;


    function __construct()
    {
        $this->_enabled = 0;
        if (is_file(SQ_DEJA_VU_CONTROL)) {
            $this->_enabled = (int) file_get_contents(SQ_DEJA_VU_CONTROL);
            if ($this->_enabled !== 1) $this->_enabled = 0;
        }

        if ($this->enabled() === 1) {
            assert_true(extension_loaded('memcache'), 'Cannot use Deja Vu; it requires the memcache PECL extension installed within , which is not installed');
            assert_true(file_exists(SQ_DATA_PATH.'/private/conf/memcache.inc'), 'Cannot use Deja Vu; 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 Deja Vu; no hosts are defined in the Memcache configuration file');
            assert_true(array_key_exists('deja_vu', $services) === TRUE, 'Cannot use Deja Vu; no Memcache hosts are assigned');
            assert_true(count($services['deja_vu']) > 0, 'Cannot use Deja Vu; no Memcache hosts are assigned');

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

            foreach ($services['deja_vu'] as $host_key => $weight) {
                assert_true(array_key_exists($host_key, $hosts) === TRUE, 'Cannot use Deja Vu; host key "'.$host_key.'" assigned for use for Deja Vu 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']);

            // Register for updates, so that we can keep our memories fresh.
            $em = $GLOBALS['SQ_SYSTEM']->getEventManager();
            $em->addEventListener($this, Array( 'AssetStatusUpdate',
                                                'assetDeleted',
                                                'AssetUpdate',
                                                'ContentsUpdated',
                                                'attributeChange',
                                                'AssetTypeUpdate',
                                                'MetadataUpdate',
                                                'MetadataDeleted',
                                                )
                                            );
        }

    }//end constructor


    public function enabled()
    {
        return $this->_enabled;

    }//end enabled()


    public function recall($type, $assetid = NULL, $contextid = NULL)
    {
        //ignore shadow assets
        if (strpos($assetid, ':') !== FALSE) return NULL;
        // bug fix #5831 Inconsistent contents when using Deja Vu and Rollback
        // If in rollback don't worry about getting cached content for assets
        if (defined('SQ_ROLLBACK_VIEW') && SQ_ROLLBACK_VIEW) return null;
        $cache_key = $this->_getCacheKey($type, $assetid, $contextid);
        switch ($type) {
        case 'asset':
            $obj = $this->_memcache->get($cache_key);
            if (!$obj) {
            //  Cache miss for $cache_key
                return NULL;
            }

            // If $obj is an undefined object, it's an asset stored without the class being included yet.
            // We must include the correct asset and try again.
            if ($obj instanceof __PHP_Incomplete_Class) {
                $obj_def = (array) $obj;
                // Determine the correct type code
                $type_code = strtolower($obj_def['__PHP_Incomplete_Class_Name']);

                $am =& $GLOBALS['SQ_SYSTEM']->am;
                if ($am->installed($type_code)) {
                    $am->includeAsset($type_code);

                    // We need to re-get the object to re-unserialize.
                    $obj = $this->_memcache->get($cache_key);
                } else {
                    // Should never happen, but just in case..
                    log_error('Deja Vu could not load asset type "'.$type_code.'" for #'.$assetid.'. Assuming the asset type has been uninstalled, so forgetting this asset.');
                    $this->forget($assetid, $type);
                    return NULL;
                }
            }//end if

            return $obj;
            break;

        default:
            $data = $this->_memcache->get($cache_key);

            if (!$data) {
                return NULL;
            } else {
                return $data;
            }
            break;

        }//end switch

    }//end recall


    public function remember($type, $assetid, $object, $contextid = NULL)
    {
        //ignore shadow assets
        if (strpos($assetid, ':') !== FALSE) return NULL;
        // bug fix #5831 Inconsistent contents when using Deja Vu and Rollback
        // If in rollback we shouldn't be really caching the content for asset
        if (defined('SQ_ROLLBACK_VIEW') && SQ_ROLLBACK_VIEW) return null;
        return $this->_memcache->set($this->_getCacheKey($type, $assetid, $contextid), $object);
    }//end remember()


    public function forget($type, $assetid = NULL, $contextid = NULL)
    {
        return $this->_memcache->delete($this->_getCacheKey($type, $assetid, $contextid));
    }//end forget()


    public function forgetAll()
    {
        return $this->_memcache->flush();

    }//end forgetAll()


    private function _getCacheKey($type, $assetid = NULL, $contextid = NULL)
    {
        switch ($type) {
            case SQ_DEJA_VU_LOCALE:
                return SQ_DEJA_VU_MEMCACHE_PREFIX.'|'.$type;
                break;
            default:
                $contextid = is_null($contextid) ? $GLOBALS['SQ_SYSTEM']->getContextId() : $contextid;
                return SQ_DEJA_VU_MEMCACHE_PREFIX.$contextid.'\\'.$assetid.'|'.$type;
                break;
        }

    }//end _getCacheKey()


    /******* EVENT HANDLERS *************************************************/


    public function onAssetStatusUpdate(&$broadcaster, $vars)
    {
        // Status is non contextable, so forget everything..
        $contexts = $GLOBALS['SQ_SYSTEM']->getAllContexts();
        foreach ($contexts as $contextid => $context) {
            $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id, $contextid);
        }

    }//end onAssetStatusUpdate

    public function onAssetDeleted(&$broadcaster, $vars)
    {
        $contexts = $GLOBALS['SQ_SYSTEM']->getAllContexts();
        foreach ($contexts as $contextid => $context) {
            $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id, $contextid);
        }

    }//end onAssetDeleted


    public function onAssetUpdate(&$broadcaster, $vars = Array())
    {
        $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id);

    }//end onAssetUpdate


    public function onContentsUpdated(&$broadcaster, $vars)
    {
        $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id);

    }//end onContentsUpdated


    public function onAttributeChange(&$broadcaster, $vars)
    {
        $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id);

    }//end onAttributeChange


    public function onAssetTypeUpdate(&$broadcaster, $vars = Array())
    {
        $contexts = $GLOBALS['SQ_SYSTEM']->getAllContexts();
        foreach ($contexts as $contextid => $context) {
            $this->forget(SQ_DEJA_VU_ASSET, $broadcaster->id, $contextid);
        }

    }//end onAssetTypeUpdate


    /******* UTILITIES *************************************************/


    public function enable()
    {
        if (!$this->enabled()) {
            $rv = (bool) file_put_contents(SQ_DEJA_VU_CONTROL, '1');
            if ($rv) {
                $this->_enabled = 1;
            }
        }
        return $rv;

    }//end enable()


    public function disable()
    {
        $rv = FALSE;
        if ($this->enabled()) {
            $rv = (bool) file_put_contents(SQ_DEJA_VU_CONTROL, '0');
            if ($rv) {
                $this->_enabled = 0;
            }
        }
        return $rv;

    }//end disable()


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

    }//end failureCallback()


}//end class

?>