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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
<?php defined('SYSPATH') OR die('No direct access allowed.');
/**
* Memcache-based Cache driver.
*
* $Id: Memcache.php 4102 2009-03-19 12:55:54Z Shadowhand $
*
* @package Cache
* @author Kohana Team
* @copyright (c) 2007-2008 Kohana Team
* @license http://kohanaphp.com/license.html
*/
class Cache_Memcache_Driver implements Cache_Driver {
const TAGS_KEY = 'memcache_tags_array';
// Cache backend object and flags
protected $backend;
protected $flags;
// Tags array
protected static $tags;
// Have the tags been changed?
protected static $tags_changed = FALSE;
public function __construct()
{
if ( ! extension_loaded('memcache'))
throw new Kohana_Exception('cache.extension_not_loaded', 'memcache');
$this->backend = new Memcache;
$this->flags = Kohana::config('cache_memcache.compression') ? MEMCACHE_COMPRESSED : FALSE;
$servers = Kohana::config('cache_memcache.servers');
foreach ($servers as $server)
{
// Make sure all required keys are set
$server += array('host' => '127.0.0.1', 'port' => 11211, 'persistent' => FALSE);
// Add the server to the pool
$this->backend->addServer($server['host'], $server['port'], (bool) $server['persistent'])
or Kohana::log('error', 'Cache: Connection failed: '.$server['host']);
}
// Load tags
self::$tags = $this->backend->get(self::TAGS_KEY);
if ( ! is_array(self::$tags))
{
// Create a new tags array
self::$tags = array();
// Tags have been created
self::$tags_changed = TRUE;
}
}
public function __destruct()
{
if (self::$tags_changed === TRUE)
{
// Save the tags
$this->backend->set(self::TAGS_KEY, self::$tags, $this->flags, 0);
// Tags are now unchanged
self::$tags_changed = FALSE;
}
}
public function find($tag)
{
if (isset(self::$tags[$tag]) AND $results = $this->backend->get(self::$tags[$tag]))
{
// Return all the found caches
return $results;
}
else
{
// No matching tags
return array();
}
}
public function get($id)
{
return (($return = $this->backend->get($id)) === FALSE) ? NULL : $return;
}
public function set($id, $data, array $tags = NULL, $lifetime)
{
if ( ! empty($tags))
{
// Tags will be changed
self::$tags_changed = TRUE;
foreach ($tags as $tag)
{
// Add the id to each tag
self::$tags[$tag][$id] = $id;
}
}
if ($lifetime !== 0)
{
// Memcache driver expects unix timestamp
$lifetime += time();
}
// Set a new value
return $this->backend->set($id, $data, $this->flags, $lifetime);
}
public function delete($id, $tag = FALSE)
{
// Tags will be changed
self::$tags_changed = TRUE;
if ($id === TRUE)
{
if ($status = $this->backend->flush())
{
// Remove all tags, all items have been deleted
self::$tags = array();
// We must sleep after flushing, or overwriting will not work!
// @see http://php.net/manual/en/function.memcache-flush.php#81420
sleep(1);
}
return $status;
}
elseif ($tag === TRUE)
{
if (isset(self::$tags[$id]))
{
foreach (self::$tags[$id] as $_id)
{
// Delete each id in the tag
$this->backend->delete($_id);
}
// Delete the tag
unset(self::$tags[$id]);
}
return TRUE;
}
else
{
foreach (self::$tags as $tag => $_ids)
{
if (isset(self::$tags[$tag][$id]))
{
// Remove the id from the tags
unset(self::$tags[$tag][$id]);
}
}
return $this->backend->delete($id);
}
}
public function delete_expired()
{
// Tags will be changed
self::$tags_changed = TRUE;
foreach (self::$tags as $tag => $_ids)
{
foreach ($_ids as $id)
{
if ( ! $this->backend->get($id))
{
// This id has disappeared, delete it from the tags
unset(self::$tags[$tag][$id]);
}
}
if (empty(self::$tags[$tag]))
{
// The tag no longer has any valid ids
unset(self::$tags[$tag]);
}
}
// Memcache handles garbage collection internally
return TRUE;
}
} // End Cache Memcache Driver
|
