CompositeCache.php

Go to the documentation of this file.

<?php

namespace Elgg\Cache;

use DateTime;
use Elgg\Config;
use ElggCache;
use Stash\Driver\Apc;
use Stash\Driver\BlackHole;
use Stash\Driver\Composite;
use Stash\Driver\Ephemeral;
use Stash\Driver\FileSystem;
use Stash\Driver\Memcache;
use Stash\Driver\Redis;
use Stash\Pool;

class CompositeCache extends ElggCache {

    protected $ttl = 86400;

    protected $config;

    protected $flags;

    protected $pool;

    protected $namespace;

    public function __construct($namespace, Config $config, $flags) {
        parent::__construct();

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

    public function getPool() {
        return $this->pool;
    }

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

        if (!is_string($key) && !is_int($key)) {
            throw new \InvalidArgumentException('key must be string or integer');
        }

        $item = $this->pool->getItem($this->namespaceKey($key));
        $item->lock();

        $item->setTTL($ttl ? : $this->ttl);

        return $item->set($data)->save();
    }

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

        if (!is_string($key) && !is_int($key)) {
            throw new \InvalidArgumentException('key must be string or integer');
        }

        $item = $this->pool->getItem($this->namespaceKey($key));
    
        if (is_array($invalidation_method)) {
            call_user_func_array([$item, 'setInvalidationMethod'], $invalidation_method);
        }
        
        try {
            if ($item->isMiss()) {
                return null;
            }
            
            return $item->get();
        } catch (\Error $e) {
            // catching parsing errors in file driver, because of potential race conditions during write
            // this will cause corrupted data in the file and will crash the site when reading the file
            elgg_log(__METHOD__ . " failed for key: {$this->getNamespace()}/{$key} with error: {$e->getMessage()}", 'ERROR');
            
            // remove the item from the cache so it can try to generate this item again
            $this->delete($key);
        }

        return null;
    }

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

        if (!is_string($key) && !is_int($key)) {
            throw new \InvalidArgumentException('key must be string or integer');
        }

        $this->pool->deleteItem($this->namespaceKey($key));

        return true;
    }

    public function clear() {
        $this->pool->deleteItems([$this->namespaceKey('')]);

        return true;
    }

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

    public function getNamespace() {
        return $this->namespace;
    }

    public function namespaceKey($key) {
        return "/{$this->getNamespace()}/$key";
    }

    protected function createPool() {
        $drivers = [];
        $drivers[] = $this->buildEphemeralDriver();
        $drivers[] = $this->buildApcDriver();
        $drivers[] = $this->buildRedisDriver();
        $drivers[] = $this->buildMemcachedDriver();
        $drivers[] = $this->buildFileSystemDriver();
        $drivers[] = $this->buildBlackHoleDriver();
        $drivers = array_filter($drivers);

        if (empty($drivers)) {
            throw new \ConfigurationException("Unable to initialize composite cache without drivers");
        }

        if (count($drivers) > 1) {
            $driver = new Composite([
                'drivers' => $drivers,
            ]);
        } else {
            $driver = array_shift($drivers);
        }

        return new Pool($driver);
    }

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

        if (!extension_loaded('apc') || !ini_get('apc.enabled')) {
            return null;
        }

        return new Apc();
    }

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

        if (!$this->config->redis || empty($this->config->redis_servers)) {
            return null;
        }

        return new Redis([
            'servers' => $this->config->redis_servers,
        ]);
    }

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

        if (!$this->config->memcache || empty($this->config->memcache_servers)) {
            return null;
        }
            
        $has_class = class_exists('Memcache') || class_exists('Memcached');
        if (!$has_class) {
            return null;
        }

        return new Memcache([
            'servers' => $this->config->memcache_servers,
            'options' => [
                'prefix_key' => $this->config->memcache_namespace_prefix,
            ]
        ]);
    }

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

        $path = $this->config->cacheroot ? : $this->config->dataroot;
        if (!$path) {
            return null;
        }

        return new FileSystem([
            'path' => $path,
        ]);
    }

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

        return new Ephemeral();
    }

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

        return new BlackHole();
    }
}