CompositeCache.php

Go to the documentation of this file.

<?php

namespace Elgg\Cache;

use Elgg\Config;
use Elgg\Exceptions\ConfigurationException;
use Elgg\Exceptions\InvalidArgumentException;
use Elgg\Values;
use Phpfastcache\CacheManager;
use Phpfastcache\Cluster\ClusterAggregator;
use Phpfastcache\Config\ConfigurationOption;
use Phpfastcache\Core\Pool\ExtendedCacheItemPoolInterface;

class CompositeCache extends BaseCache {

    protected $ttl = 86400;

    protected $config;

    protected $flags;

    protected $pool;

    protected $namespace;
    
    protected $validate_lastcache;

    public function __construct($namespace, Config $config, $flags, bool $validate_lastcache = true) {
        parent::__construct();

        $this->namespace = $namespace;
        $this->config = $config;
        $this->flags = $flags;
        $this->pool = $this->createPool();
        $this->validate_lastcache = $validate_lastcache;
    }

    public function save($key, $data, $expire_after = null) {
        if ($this->disabled) {
            return false;
        }
        
        $expire_after = $expire_after ?: $this->ttl;

        $item = $this->pool->getItem($this->sanitizeItemKey($key));
        $item->set($data);
        
        if (is_int($expire_after)) {
            $item->expiresAfter($expire_after);
        } elseif ($expire_after instanceof \DateTime) {
            $item->expiresAt($expire_after);
        }
            
        return $this->pool->save($item);
    }

    public function load($key) {
        if ($this->disabled) {
            return null;
        }

        $item = $this->pool->getItem($this->sanitizeItemKey($key));
        if (!$item->isHit()) {
            return null;
        }
        
        if ($this->validate_lastcache && $this->config->lastcache) {
            $expiration_date = Values::normalizeTime($this->config->lastcache);
            
            if ($item->getCreationDate()->getTimestamp() < $expiration_date->getTimestamp()) {
                $this->delete($key);
                return null;
            }
        }
        
        return $item->get();
    }

    public function delete($key) {
        if ($this->disabled) {
            return false;
        }

        return $this->pool->deleteItem($this->sanitizeItemKey($key));
    }

    public function clear() {
        return $this->pool->clear();
    }
    
    public function invalidate() {
        // Phpfastcache doesn't have invalidation as an action.
        // This is handled during load
        return true;
    }
    
    public function purge() {
        // Phpfastcache doesn't have purge as an action
        return true;
    }

    public function setNamespace($namespace = 'default') {
        $this->namespace = $namespace;
    }

    public function getNamespace() {
        return $this->namespace;
    }
    
    protected function prefixInstanceId(string $id): string {
        return "{$this->getNamespace()}_{$id}";
    }
    
    protected function sanitizeItemKey($key): string {
        if (!is_string($key) && !is_int($key)) {
            throw new InvalidArgumentException('key must be string or integer');
        }
        
        return str_replace(['{', '}', '(', ')', '/', '\\', '@', ':'], '_', "{$key}");
    }

    protected function createPool() {
        
        $drivers = [];
        $drivers[] = $this->buildRedisDriver();
        $drivers[] = $this->buildMemcachedDriver();
        $drivers[] = $this->buildFileSystemDriver();
        $drivers[] = $this->buildLocalFileSystemDriver();
        $drivers[] = $this->buildBlackHoleDriver();
        $drivers = array_filter($drivers);
        
        if (empty($drivers)) {
            // the memory driver can only be used as a stand-alone driver (not combined in a cluster)
            // other drivers already have a built in memory storage (default allowed in config)
            $ephemeral = $this->buildEphemeralDriver();
            if (!empty($ephemeral)) {
                $drivers[] = $ephemeral;
            }
        }
        
        if (empty($drivers)) {
            throw new ConfigurationException('Unable to initialize composite cache without drivers');
        }
                
        if (count($drivers) === 1) {
            return array_shift($drivers);
        }
        
        $cluster = new ClusterAggregator($this->getNamespace());
        foreach ($drivers as $driver) {
            $cluster->aggregateDriver($driver);
        }
        
        $cluster_driver = $cluster->getCluster();
        $cluster_driver->setConfig(new ConfigurationOption([
            'preventCacheSlams' => true,
            'useStaticItemCaching' => true,
            'itemDetailedDate' => true,
        ]));
        
        return $cluster_driver;
    }

    protected function buildRedisDriver() {
        if (!($this->flags & ELGG_CACHE_PERSISTENT)) {
            return null;
        }

        if (!self::isRedisAvailable()) {
            return null;
        }
        
        $config = \Elgg\Cache\Config\Redis::fromElggConfig($this->namespace, $this->config);
        if (empty($config)) {
            return null;
        }
                
        return CacheManager::getInstance('Redis', $config, $this->prefixInstanceId('redis'));
    }

    protected function buildMemcachedDriver() {
        if (!($this->flags & ELGG_CACHE_PERSISTENT)) {
            return null;
        }
            
        if (!self::isMemcacheAvailable()) {
            return null;
        }
        
        $config = \Elgg\Cache\Config\Memcached::fromElggConfig($this->namespace, $this->config);
        if (empty($config)) {
            return null;
        }
        
        return CacheManager::getInstance('Memcached', $config, $this->prefixInstanceId('memcache'));
    }

    protected function buildFileSystemDriver() {
        if (!($this->flags & ELGG_CACHE_FILESYSTEM)) {
            return null;
        }
        
        $config = \Elgg\Cache\Config\Files::fromElggConfig($this->namespace, $this->config);
        if (empty($config)) {
            return null;
        }
        
        try {
            return CacheManager::getInstance('Files', $config, $this->prefixInstanceId('files'));
        } catch (\Phpfastcache\Exceptions\PhpfastcacheIOException $e) {
            if (!$this->config->installer_running) {
                elgg_log($e, 'ERROR');
            }
        }
        
        return null;
    }
    
    protected function buildLocalFileSystemDriver() {
        if (!($this->flags & ELGG_CACHE_LOCALFILESYSTEM)) {
            return null;
        }

        $config = \Elgg\Cache\Config\LocalFiles::fromElggConfig($this->namespace, $this->config);
        if (empty($config)) {
            return null;
        }
        
        try {
            return CacheManager::getInstance('Files', $config, $this->prefixInstanceId('local_files'));
        } catch (\Phpfastcache\Exceptions\PhpfastcacheIOException $e) {
            if (!$this->config->installer_running) {
                elgg_log($e, 'ERROR');
            }
        }
        
        return null;
    }

    protected function buildEphemeralDriver() {
        if (!($this->flags & ELGG_CACHE_RUNTIME)) {
            return null;
        }
        
        $config = new \Phpfastcache\Drivers\Memstatic\Config();
        
        $config->setUseStaticItemCaching(true);
        $config->setItemDetailedDate(true);
        
        return CacheManager::getInstance('Memstatic', $config, $this->prefixInstanceId('memstatic'));
    }

    protected function buildBlackHoleDriver() {
        if (!($this->flags & ELGG_CACHE_BLACK_HOLE)) {
            return null;
        }
        
        $config = new \Phpfastcache\Drivers\Devnull\Config();
        
        return CacheManager::getInstance('Devnull', $config, $this->prefixInstanceId('devnull'));
    }
    
    public static function isMemcacheAvailable(): bool {
        return class_exists('Memcached');
    }
    
    public static function isRedisAvailable(): bool {
        return extension_loaded('Redis');
    }
}