cache_manager.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';
require_once SQ_FUDGE_PATH.'/general/file_system.inc';
require_once SQ_FUDGE_PATH.'/db_extras/db_extras.inc';

class Cache_Manager extends Asset
{


    protected $_storage;
    
    public $global_cache = FALSE;


    function __construct($assetid=0)
    {
        $this->_ser_attrs = TRUE;
        parent::__construct($assetid);

        $storage_type = $this->attr('cache_storage_type');
        $this->_loadCacheStorage($storage_type);

    }//end constructor
    
    
    function __wakeup() 
    {
        $storage_type = $this->attr('cache_storage_type');
        $this->_loadCacheStorage($storage_type);
        
    }//end wakeup


    function create(&$link)
    {
        require_once SQ_CORE_PACKAGE_PATH.'/system/system_asset_fns.inc';
        if (!system_asset_fns_create_pre_check($this)) {
            return FALSE;
        }
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        if ($linkid = parent::create($link)) {
            if (!system_asset_fns_create_cleanup($this)) {
                $linkid = FALSE;
            }
        }

        if ($linkid) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        } else {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
        }

        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return $linkid;

    }//end create()


    function _getName($short_name=FALSE)
    {
        return $GLOBALS['SQ_SYSTEM']->am->getTypeInfo($this->type(), 'name');

    }//end _getName()


    function canDelete()
    {
        return FALSE;

    }//end canDelete()


    function canClone()
    {
        return FALSE;

    }//end canClone()


    function loadFromCache($assetid, $asset_type, $cache_key='', $use_url=TRUE)
    {   
        
        if (basename($_SERVER['PHP_SELF']) == SQ_CONF_RECACHE_SUFFIX) {
            return FALSE;
        }

        // this will not check specifically set root node options
        // if any root node specific options are configured, it will return TRUE blindly and the DB will be checked for a cache entry
        if (!$this->cacheEnabled($asset_type)) return FALSE;

        $perm_key = $this->_getPermKey($assetid, $cache_key);

        if (empty($perm_key)) return FALSE;

        if ($use_url && !$this->global_cache) {
            $url = current_url();
            // append the query string (if any)
            if (isset($_SERVER['QUERY_STRING']) && !empty($_SERVER['QUERY_STRING'])) {
                $url = $this->_formUniqueUrl($url);
            }
        } else {
            $url = $assetid;
        }
        $cache_key = md5($cache_key.$assetid);

        return $this->_storage->read($cache_key, $perm_key, $url, $assetid);

    }//end loadFromCache()


    function saveToCache($assetid, $asset_type, $cache_key, $contents, $use_url=TRUE, $expiry_override='')
    {
        if (!$this->cacheEnabled($asset_type, $assetid)) return FALSE;
        $perm_key = $this->_getPermKey($assetid, $cache_key);
        
        if (empty($perm_key)) return FALSE;

        if ($use_url && !$this->global_cache) {
            $url = current_url();
            // append the query string (if any)
            if (isset($_SERVER['QUERY_STRING']) && !empty($_SERVER['QUERY_STRING'])) {
                $url = $this->_formUniqueUrl($url);
            }
        } else {
            $url = $assetid;
        }
        $cache_key = md5($cache_key.$assetid);

        $now = time();
        if (is_int($expiry_override) && ($expiry_override >= 0) && ($expiry_override + $now > $now)) {
            $expiry = $expiry_override + $now;
        } else {
            $expiry = $now + $this->getExpiry($asset_type, $assetid);
        }
        return $this->_storage->store($cache_key, $perm_key, $url, $assetid, $contents, $expiry);

    }//end saveToCache()


    function _formUniqueUrl($url)
    {
        // we don't want this query vars for cache key, e.g. SQ_ACTION=login
        $query_vars=Array();
        parse_str($_SERVER['QUERY_STRING'], $query_vars);
        $mute_list = array_intersect(array_keys($query_vars), Array('SQ_BACKEND_PAGE', 'SQ_ACTION', 'SQ_DESIGN_NAME', 'SQ_CONTEXT_NAME'));
        foreach ($mute_list as $name) {
            unset($query_vars[$name]);
        }

        if (!empty($query_vars)) {
            $new_query_str = '';
            foreach ($query_vars as $key => $val) {
                if (is_array($val)) {
                    foreach($val as $mkey => $mval) {
                        $new_query_str .= $key.'['.$mkey.']='.$mval.'&';
                    }
                } else {
                    $new_query_str .= $key.'='.$val.'&';
                }
            }
            $url .= '?'.rtrim($new_query_str, '&');
        }

        return $url;

    }//end _formUniqueUrl()


    function clearCache($assetids)
    {
        if ($this->_storage->clear($assetids) === FALSE) {
            return FALSE;
        }

        foreach ($assetids as $assetid) {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
            $GLOBALS['SQ_SYSTEM']->broadcastTriggerEvent('trigger_event_matrix_cache_cleared', $asset, NULL);
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($asset);
            unset($asset);
        }

        return TRUE;

    }//end clearCache()


    function getFilePaths($assetids)
    {
        return $this->_storage->getFilePaths($assetids);

    }//end getFilePaths()


    public function canClearByAssetid()
    {
        if (is_object($this->_storage)) {
            return $this->_storage->canClearByAssetid();
        } else {
            return NULL;
        }

    }//end canClearByAssetid()


    function clearAllCache()
    {
        $this->_storage->clearAll();

    }//end clearAllCache()


    function getAllFilePaths($option='')
    {
        return $this->_storage->getAllFilePaths($option);

    }//end getAllFilePaths()


    function _getPermKey($assetid, $cache_key)
    {
        $perm_key = '';
        $current_user = $GLOBALS['SQ_SYSTEM']->user;
        if (is_null($current_user) || ($current_user instanceof Public_User)) {
            // if your not logged in and public level caching is on - you get the public copy
            if ($this->attr('public_caching')) {
                if (is_null($current_user)) {
                    $perm_key = 'public';
                } else {
                    // get the group that this public user is in
                    // for which satisfies the security restrictions
                    $groups = array_values($current_user->getUserGroups());
                    sort($groups);
                    $perm_key = 'public'.implode('|',$groups);
                }
            }
        } else {
            if (empty($cache_key)) {
                // if permission level caching is on - check read/write/admin access for this asset
                // if the key is blank (representing a non list style asset)
                if ($this->attr('permission_caching')) {
                    $groups = array_keys($current_user->getGroups());
                    $userids = Array((string) $current_user->id) + $groups;

                    // note that we dont use the cache in rollback view mode so we dont have
                    // to run this query through the rollback functions
                    try {
                        $bind_vars = Array(
                                        'assetid'   => $assetid,
                                        'userids'   => $userids,
                                     );
                        $permission = MatrixDAL::executeOne('cache_manager', 'getHighestPermissionForUsers', $bind_vars);
                    } catch (DALException $e) {
                        throw new Exception('Unable to get maximum permission level of asset ID #'.$assetid.' due to database error: '.$e->getMessage());
                    }

                    switch ($permission) {
                        case SQ_PERMISSION_READ  :
                            $perm_key .= ':read';
                        break;
                        case SQ_PERMISSION_WRITE :
                            $perm_key .= ':write';
                        break;
                        case SQ_PERMISSION_ADMIN :
                            $perm_key .= ':admin';
                        break;
                    }
                }
            } else {
                // if group level caching is on - check the groups the user is in if they are logged in
                // and if user satisfies the group security restrictions
                if ($this->attr('group_caching')) {
                    $groups = array_values($current_user->getUserGroups());
                    sort($groups);
                    $perm_key = implode('|', $groups);
                }
            }
        }//end else - if logged in
        $perm_key = (empty($perm_key)) ? '' : md5($perm_key);
        return $perm_key;

    }//end _getPermKey()


    function getAssetHash($assetid=0)
    {
        $assetid = trim($assetid);

        $hash = 0;
        $bucketsize = $this->attr('num_cache_dirs');
        $len = strlen($assetid);
        for ($i = 0; $i < $len; $i++) {
            if (!is_numeric($assetid{$i})) {
                $hash += ord($assetid{$i});
            } else {
                $hash += (int) $assetid{$i};
            }
        }
        $hash = $hash % $bucketsize;

        while (strlen($hash) != strlen($bucketsize)) {
            $hash = '0'.$hash;
        }
        return $hash;

    }//end getAssetHash()


    function cacheEnabled($type_code='', $assetid='')
    {
        // first check some obvious things
        if (SQ_ROLLBACK_VIEW) return FALSE;
        if (basename($_SERVER['PHP_SELF']) == SQ_CONF_NOCACHE_SUFFIX) {
            return FALSE;
        }
        if (array_get_index($_GET, 'SQ_ACTION') == 'diff') {
            return FALSE;
        }
        if(defined('SQ_IN_PERFORMANCE_TIMING') && isset($_SESSION['SQ_PERFORMANCE_SETTING']['caching'])) {
            if($_SESSION['SQ_PERFORMANCE_SETTING']['caching'] === 'Off') return FALSE;
        }

        // check if the current URL is excluded
        $current_url = current_url(FALSE, TRUE);
        $root_urls = explode("\n", SQ_CONF_SYSTEM_ROOT_URLS);
        $current_root_url = '';
        foreach ($root_urls as $url) {
            if (0 === strpos($current_url, $url)) {
                if (strlen($url) > strlen($current_root_url)) {
                    $current_root_url = $url;
                }
            }
        }
        if (in_array($current_root_url, $this->attr('non_cachable_urls'))) {
            return FALSE;
        }

        // check type code and root node specific settings
        // these take priority over the global setting
        // in order for a cache entry to be saved and therefore loaded, a valid perm key must be attained
        // this perm key is only attainable if a cache level is specified
        $specific = $this->_specificCacheManagementSettings($type_code, $assetid, 'enabled');
        if ($specific !== FALSE) {
            return $specific;
        }

        return $this->attr('enabled');

    }//end cacheEnabled()


    function sendCacheableHeaders($type_code='', $assetid='')
    {
        // first check some obvious things
        if (SQ_ROLLBACK_VIEW) return FALSE;
        if (basename($_SERVER['PHP_SELF']) == SQ_CONF_NOCACHE_SUFFIX) {
            return FALSE;
        }
        if (array_get_index($_GET, 'SQ_ACTION') == 'diff') {
            return FALSE;
        }
        if(defined('SQ_IN_PERFORMANCE_TIMING')) return FALSE;

        // check if the current URL is excluded
        $current_url = current_url(FALSE, TRUE);
        $root_urls = explode("\n", SQ_CONF_SYSTEM_ROOT_URLS);
        $current_root_url = '';
        foreach ($root_urls as $url) {
            if (0 === strpos($current_url, $url)) {
                if (strlen($url) > strlen($current_root_url)) {
                    $current_root_url = $url;
                }
            }
        }
        
        if (in_array($current_root_url, $this->attr('non_cacheable_header_urls'))) {
            return FALSE;
        }
        
        // check type code and root node specific settings
        // these take priority over the global setting
        $specific = $this->_specificCacheManagementSettings($type_code, $assetid, 'send_cacheable_header');
        if ($specific !== FALSE) {
            return $specific;
        }
        
        $is_public = $GLOBALS['SQ_SYSTEM']->user instanceof Public_User;
        if (!$is_public && in_array($current_root_url, $this->attr('user_cacheable_header_urls'))) {
            return TRUE;
        }

        return $is_public && SQ_CONF_SEND_CACHEABLE_HEADER;

    }//end sendCacheableHeaders()


    function getExpiry($type_code='', $assetid='')
    {
        $specific = $this->_specificCacheManagementSettings($type_code, $assetid, 'expiry');
        if ($specific !== FALSE) {
            return $specific;
        }

        return $this->attr('expiry');

    }//end getExpiry()


    function getBrowserCacheExpiry($type_code='', $assetid='')
    {
        $specific = $this->_specificCacheManagementSettings($type_code, $assetid, 'browser_cache_expiry');
        if ($specific !== FALSE) {
            return $specific;
        }

        return $this->attr('browser_cache_expiry');

    }//end getBrowserCacheExpiry()


    function _specificCacheManagementSettings($type_code, $assetid, $value)
    {
        // check for type-code-specific settings
        $type_codes = $this->attr('type_codes');
        if (isset($type_codes[$type_code][$value])) {
            return $type_codes[$type_code][$value];
        }

        $root_nodes = $this->attr('root_nodes');

        // an empty assetid indicates the caller does not want to perform the search for possible tree locations
        // if there are configured root node specific options return TRUE blindly
        if (empty($assetid) && !empty($root_nodes)) {
            return TRUE;
        } else if (!empty($root_nodes)) {
            // check for root node specific settings
            if (isset($root_nodes[$assetid][$value])) {
                return $root_nodes[$assetid][$value];
            } else {
                // there are possible tree locations set so search for them because an exact match was not found
                // if there are a few root nodes, we should use isUnderRootNodes for performance sake
                if(count($root_nodes) < 10) {
                    $matched_roots = $GLOBALS['SQ_SYSTEM']->am->isUnderRootNodes($assetid, array_keys($root_nodes), TRUE);
                }
                else {
                    $matched_roots = array_keys($GLOBALS['SQ_SYSTEM']->am->getParents($assetid));
                }
                foreach ($matched_roots as $rootid) {
                    // check that this entry actually manages child entries
                    if (isset($root_nodes[$rootid]['all_underneath']) && $root_nodes[$rootid]['all_underneath']) {
                        // check the value of the option that was asked for
                        if (isset($root_nodes[$rootid][$value])) {
                            return $root_nodes[$rootid][$value];
                        }
                    }
                }//end foreach
            }
        }

        return FALSE;

    }//end _specificCacheManagementSettings()


    //--        CACHE STORAGE         --//


    public function getCacheStorage()
    {
        return $this->_storage;

    }//end getCacheStorage()


    protected function _loadCacheStorage($storage_type)
    {
        $asset_type = 'cache_storage_'.strtolower($storage_type);

        if ($GLOBALS['SQ_SYSTEM']->am->installed($asset_type) === FALSE) {
            trigger_error('Unable to find "'.$storage_type.'" storage type, reverting to default', E_USER_WARNING);
            $asset_type = 'cache_storage_default';
        }

        $GLOBALS['SQ_SYSTEM']->am->includeAsset($asset_type);

        if (eval('return '.$asset_type.'::isAvailable();') === FALSE) {
            trigger_error('The cache storage type "'.$storage_type.'" cannot be used under current conditions, reverting to default', E_USER_WARNING);
            $asset_type = 'cache_storage_default';
            $GLOBALS['SQ_SYSTEM']->am->includeAsset($asset_type);
        }

        $this->_storage = new $asset_type();

    }//end _loadCacheStorage()

    public function clearCachedAssetsByUrl($url)
    {
        if (empty($url)) {
            return FALSE;
        }

        return $this->_storage->clearCachedAssetsByUrl($url);

    }//end clearCachedAssetsByUrl()
    

    public function setAttrValue($name, $value)
    {
        $success = parent::setAttrValue($name, $value);

        // If the cache type is being set then cache storage needs to be reloaded
        if ($name === 'cache_storage_type' && $success) {
            $this->_loadCacheStorage($value);
        }
        
        return $success;        

    }//end setAttrValue()


    public function cacheableHeadersEnabledForCurrentProtocol()
    {
        $protocol_setting = $this->attr('cacheale_header_protocol');
        if ($protocol_setting != 'both') {
            return current_protocol() == 'http' ? $protocol_setting == 'http' : $protocol_setting == 'https';
        }//end if

        return TRUE;

    }//end cacheableHeadersEnabledForCurrentProtocol()


    public function cacheControlLevel()
    {
        return current_protocol() == 'http' ? $this->attr('cache_control_http') : $this->attr('cache_control_https');
    
    }//end cacheControlLevel()


}//end class

?>