aboutsummaryrefslogtreecommitdiff
path: root/lib/classes/StudipCacheProxy.php
blob: 686f8129d687e130f474167b32ff4f14a2096532 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
<?php
/**
 * Proxies a StudipCache and stores the expire operation in the database.
 * These operations are lateron applied to the cache they should have
 * been applied to in the beginning.
 *
 * @author  Jan-Hendrik Willms <tleilax+studip@gmail.com>
 * @license GPL2 or any later version
 * @since   Stud.IP 3.3
 */
class StudipCacheProxy implements StudipCache
{
    protected $actual_cache;
    protected $proxy_these;

    /**
     * @param StudipCache $cache       The actual cache object
     * @param mixed       $proxy_these List of operations to proxy (should be
     *                                 an array but a space seperated string
     *                                 is also valid)
     */
    public function __construct(StudipCache $cache, $proxy_these = ['expire'])
    {
        if (!is_array($proxy_these)) {
            $proxy_these = words($proxy_these);
        }

        $this->actual_cache = $cache;
        $this->proxy_these  = is_array($proxy_these)
                            ? $proxy_these
                            : words($proxy_these);
    }

    /**
     * Expires just a single key.
     *
     * @param string $key The item's key
     */
    public function expire($key)
    {
        if (in_array('expire', $this->proxy_these)) {
            try {
                $operation = new StudipCacheOperation([$key, 'expire']);
                $operation->parameters = serialize([]);
                $operation->store();
            } catch (Exception $e) {
            }
        }

        return $this->actual_cache->expire($key);
    }

    /**
     * Expire all items from the cache.
     */
    public function flush()
    {
        if (in_array('flush', $this->proxy_these)) {
            try {
                $operation = new StudipCacheOperation(['', 'flush']);
                $operation->parameters = serialize([]);
                $operation->store();
            } catch (Exception $e) {
            }
        }

        return $this->actual_cache->flush();
    }

    /**
     * Reads just a single key from the cache.
     *
     * @param  string $key The item's key
     * @return mixed The corresponding value
     */
    public function read($key)
    {
        return $this->actual_cache->read($key);
    }

    /**
     * Store data at the server.
     *
     * @param string $key     The item's key
     * @param string $content The item's conten
     * @param int    $expires The item's expiry time in seconds, defaults to 12h
     * @return bool  Returns TRUE on success or FALSE on failure
     */
    public function write($key, $content, $expires = self::DEFAULT_EXPIRATION)
    {
        if (in_array('write', $this->proxy_these)) {
            try {
                $operation = new StudipCacheOperation([$key, 'write']);
                $operation->parameters = serialize([$content, $expires]);
                $operation->store();
            } catch (Exception $e) {
            }
        }

        return $this->actual_cache->write($key, $content, $expires);
    }

    public static function getDisplayName(): string
    {
        return static::class;
    }

    public function getStats(): array
    {
        return $this->actual_cache->getStats();
    }

    public static function getConfig(): array
    {
        return [];
    }
}