shimmie2/core/cacheengine.php

<?php

declare(strict_types=1);

namespace Shimmie2;

interface CacheEngine
{
    public function get(string $key);
    public function set(string $key, $val, int $time=0): void;
    public function delete(string $key): void;
}

class NoCache implements CacheEngine
{
    public function get(string $key)
    {
        return false;
    }
    public function set(string $key, $val, int $time=0): void
    {
    }
    public function delete(string $key): void
    {
    }
}

class MemcachedCache implements CacheEngine
{
    public ?\Memcached $memcache=null;

    public function __construct(string $args)
    {
        $hp = explode(":", $args);
        $this->memcache = new \Memcached();
        #$this->memcache->setOption(\Memcached::OPT_COMPRESSION, False);
        #$this->memcache->setOption(\Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_PHP);
        #$this->memcache->setOption(\Memcached::OPT_PREFIX_KEY, phpversion());
        $this->memcache->addServer($hp[0], (int)$hp[1]);
    }

    public function get(string $key)
    {
        $key = urlencode($key);

        $val = $this->memcache->get($key);
        $res = $this->memcache->getResultCode();

        if ($res == \Memcached::RES_SUCCESS) {
            return $val;
        } elseif ($res == \Memcached::RES_NOTFOUND) {
            return false;
        } else {
            error_log("Memcached error during get($key): $res");
            return false;
        }
    }

    public function set(string $key, $val, int $time=0): void
    {
        $key = urlencode($key);

        $this->memcache->set($key, $val, $time);
        $res = $this->memcache->getResultCode();
        if ($res != \Memcached::RES_SUCCESS) {
            error_log("Memcached error during set($key): $res");
        }
    }

    public function delete(string $key): void
    {
        $key = urlencode($key);

        $this->memcache->delete($key);
        $res = $this->memcache->getResultCode();
        if ($res != \Memcached::RES_SUCCESS && $res != \Memcached::RES_NOTFOUND) {
            error_log("Memcached error during delete($key): $res");
        }
    }
}

class APCCache implements CacheEngine
{
    public function __construct(string $args)
    {
        // $args is not used, but is passed in when APC cache is created.
    }

    public function get(string $key)
    {
        return apc_fetch($key);
    }

    public function set(string $key, $val, int $time=0): void
    {
        apc_store($key, $val, $time);
    }

    public function delete(string $key): void
    {
        apc_delete($key);
    }
}

class RedisCache implements CacheEngine
{
    private \Redis $redis;

    public function __construct(string $args)
    {
        $this->redis = new \Redis();
        $hp = explode(":", $args);
        $this->redis->pconnect($hp[0], (int)$hp[1]);
        $this->redis->setOption(\Redis::OPT_SERIALIZER, \Redis::SERIALIZER_PHP);
        $this->redis->setOption(\Redis::OPT_PREFIX, 'shm:');
    }

    public function get(string $key)
    {
        return $this->redis->get($key);
    }

    public function set(string $key, $val, int $time=0): void
    {
        if ($time > 0) {
            $this->redis->setEx($key, $time, $val);
        } else {
            $this->redis->set($key, $val);
        }
    }

    public function delete(string $key): void
    {
        $this->redis->del($key);
    }
}

class CacheWithStats implements \Psr\SimpleCache\CacheInterface
{
    public $engine;
    public int $hits=0;
    public int $misses=0;
    public int $time=0;

    public function __construct(CacheEngine $c)
    {
        $this->engine = $c;
    }

    public function get(string $key, mixed $default=null): mixed
    {
        global $_tracer;
        $_tracer->begin("Cache Query", ["key"=>$key]);
        $val = $this->engine->get($key);
        if ($val !== false) {
            $res = "hit";
            $this->hits++;
        } else {
            $res = "miss";
            $val = $default;
            $this->misses++;
        }
        $_tracer->end(null, ["result"=>$res]);
        return $val;
    }

    public function set(string $key, mixed $value, \DateInterval|int|null $ttl = null): bool
    {
        global $_tracer;
        $_tracer->begin("Cache Set", ["key"=>$key, "ttl"=>$ttl]);
        $this->engine->set($key, $value, $ttl ?? 0);
        $_tracer->end();
        return true;
    }

    public function delete(string $key): bool
    {
        global $_tracer;
        $_tracer->begin("Cache Delete", ["key"=>$key]);
        $this->engine->delete($key);
        $_tracer->end();
        return true;
    }

    public function clear(): bool
    {
        throw new Exception("Not implemented");
    }

    public function getMultiple(iterable $keys, mixed $default = null): iterable
    {
        $results = [];
        foreach($keys as $key) {
            $results[$key] = $this->get($key, $default);
        }
        return $results;
    }

    public function setMultiple(iterable $values, \DateInterval|int|null $ttl = null): bool {
        foreach($values as $key => $value) {
            $this->set($key, $value, $ttl);
        }
        return true;
    }

    public function deleteMultiple(iterable $keys): bool {
        foreach($keys as $key) {
            $this->delete($key);
        }
    }
    public function has(string $key): bool {
        $sentinel = 4345345735673;
        return $this->get($key, $sentinel) != $sentinel;
    }

    public function get_hits(): int
    {
        return $this->hits;
    }
    public function get_misses(): int
    {
        return $this->misses;
    }
}

function loadCache(?string $dsn): CacheWithStats {
    $matches = [];
    $c = null;
    if ($dsn && preg_match("#(.*)://(.*)#", $dsn, $matches) && !isset($_GET['DISABLE_CACHE'])) {
        if ($matches[1] == "memcached" || $matches[1] == "memcache") {
            $c = new MemcachedCache($matches[2]);
        } elseif ($matches[1] == "apc") {
            $c = new APCCache($matches[2]);
        } elseif ($matches[1] == "redis") {
            $c = new RedisCache($matches[2]);
        }
    } else {
        $c = new NoCache();
    }
    return new CacheWithStats($c);
}