Source for file FileStorage.php

Documentation is available at FileStorage.php

1: <?php
2:
3: /**
4: * Nette Framework
5: *
6: * Copyright (c) 2004, 2009 David Grudl (http://davidgrudl.com)
7: *
8: * This source file is subject to the "Nette license" that is bundled
9: * with this package in the file license.txt.
10: *
11: * For more information please see https://nette.org
12: *
13: * @copyright Copyright (c) 2004, 2009 David Grudl
14: * @license https://nette.org/license Nette license
15: * @link https://nette.org
16: * @category Nette
17: * @package Nette\Caching
18: * @version $Id$
19: */
20:
21:
22:
23: require_once dirname(__FILE__) . '/../Object.php';
24:
25: require_once dirname(__FILE__) . '/../Caching/ICacheStorage.php';
26:
27:
28:
29: /**
30: * Cache file storage.
31: *
32: * @author David Grudl
33: * @copyright Copyright (c) 2004, 2009 David Grudl
34: * @package Nette\Caching
35: */
36: class FileStorage extends Object implements ICacheStorage
37: {
38: /**
39: * Atomic thread safe logic:
40: *
41: * 1) reading: open(r+b), lock(SH), read
42: * - delete?: lock(EX), truncate*, unlink*, close
43: * 2) deleting: open(r+b), lock(EX), truncate*, unlink*, close
44: * 3) writing: open(r+b || wb), lock(EX), truncate*, write data, write meta, close
45: *
46: * *unlink fails in windows
47: */
48:
49: /**#@+ internal cache file structure */
50: const META_HEADER_LEN = 28; // 22b signature + 6b meta-struct size + serialized meta-struct + data
51: // meta structure: array of
52: const META_TIME = 'time'; // timestamp
53: const META_SERIALIZED = 'serialized'; // is content serialized?
54: const META_PRIORITY = 'priority'; // priority
55: const META_EXPIRE = 'expire'; // expiration timestamp
56: const META_DELTA = 'delta'; // relative (sliding) expiration
57: const META_FILES = 'df'; // array of dependent files (file => timestamp)
58: const META_ITEMS = 'di'; // array of dependent items (file => timestamp)
59: const META_TAGS = 'tags'; // array of tags (tag => [foo])
60: const META_CONSTS = 'consts'; // array of constants (const => [value])
61: /**#@-*/
62:
63: /**#@+ additional cache structure */
64: const FILE = 'file';
65: const HANDLE = 'handle';
66: /**#@-*/
67:
68:
69: /** @var float probability that the clean() routine is started */
70: public static $gcProbability = 0.001;
71:
72: /** @var string */
73: protected $base;
74:
75:
76:
77: public function __construct($base)
78: {
79: $this->base = $base;
80: $dir = dirname($base . '-');
81:
82: if (!is_dir($dir) || !is_writable($dir)) {
83: throw new InvalidStateException("Temporary directory '$dir' is not writable.");
84: }
85:
86: if (mt_rand() / mt_getrandmax() < self::$gcProbability) {
87: $this->clean(array());
88: }
89: }
90:
91:
92:
93: /**
94: * Read from cache.
95: * @param string key
96: * @return mixed|NULL
97: */
98: public function read($key)
99: {
100: $meta = $this->readMeta($this->getCacheFile($key), LOCK_SH);
101: if ($meta && $this->verify($meta)) {
102: return $this->readData($meta); // calls fclose()
103:
104: } else {
105: return NULL;
106: }
107: }
108:
109:
110:
111: /**
112: * Verifies dependencies.
113: * @param array
114: * @return bool
115: */
116: private function verify($meta)
117: {
118: do {
119: /*if (!empty($meta[self::META_DELTA]) || !empty($meta[self::META_FILES])) {
120: clearstatcache();
121: }*/
122:
123: if (!empty($meta[self::META_DELTA])) {
124: // meta[file] was added by readMeta()
125: if (filemtime($meta[self::FILE]) + $meta[self::META_DELTA] < time()) break;
126: touch($meta[self::FILE]);
127:
128: } elseif (!empty($meta[self::META_EXPIRE]) && $meta[self::META_EXPIRE] < time()) {
129: break;
130: }
131:
132: if (!empty($meta[self::META_CONSTS])) {
133: foreach ($meta[self::META_CONSTS] as $const => $value) {
134: if (!defined($const) || constant($const) !== $value) break 2;
135: }
136: }
137:
138: if (!empty($meta[self::META_FILES])) {
139: foreach ($meta[self::META_FILES] as $depFile => $time) {
140: if (@filemtime($depFile) <> $time) break 2; // intentionally @
141: }
142: }
143:
144: if (!empty($meta[self::META_ITEMS])) {
145: foreach ($meta[self::META_ITEMS] as $depFile => $time) {
146: $m = $this->readMeta($depFile, LOCK_SH);
147: if ($m[self::META_TIME] !== $time) break 2;
148: if ($m && !$this->verify($m)) break 2;
149: }
150: }
151:
152: return TRUE;
153: } while (FALSE);
154:
155: // meta[handle] was added by readMeta()
156: flock($meta[self::HANDLE], LOCK_EX);
157: ftruncate($meta[self::HANDLE], 0);
158: @unlink($meta[self::FILE]); // intentionally @; meta[file] was added by readMeta()
159: fclose($meta[self::HANDLE]);
160: return FALSE;
161: }
162:
163:
164:
165: /**
166: * Writes item into the cache.
167: * @param string key
168: * @param mixed data
169: * @param array dependencies
170: * @return bool TRUE if no problem
171: */
172: public function write($key, $data, array $dp)
173: {
174: $meta = array(
175: self::META_TIME => microtime(),
176: );
177:
178: if (!is_string($data)) {
179: $data = serialize($data);
180: $meta[self::META_SERIALIZED] = TRUE;
181: }
182:
183: if (isset($dp[Cache::PRIORITY])) {
184: $meta[self::META_PRIORITY] = (int) $dp[Cache::PRIORITY];
185: }
186:
187: if (!empty($dp[Cache::EXPIRE])) {
188: $expire = (int) $dp[Cache::EXPIRE];
189: if ($expire <= Tools::YEAR) {
190: $expire += time();
191: }
192: if (empty($dp[Cache::REFRESH])) {
193: $meta[self::META_EXPIRE] = $expire; // absolute time
194: } else {
195: $meta[self::META_DELTA] = $expire - time(); // sliding time
196: }
197: }
198:
199: if (!empty($dp[Cache::TAGS]) && is_array($dp[Cache::TAGS])) {
200: $meta[self::META_TAGS] = array_flip(array_values($dp[Cache::TAGS]));
201: }
202:
203: if (!empty($dp[Cache::ITEMS])) {
204: foreach ($dp[Cache::ITEMS] as $item) {
205: $depFile = $this->getCacheFile($item);
206: $m = $this->readMeta($depFile, LOCK_SH);
207: $meta[self::META_ITEMS][$depFile] = $m[self::META_TIME];
208: unset($m);
209: }
210: }
211:
212: if (!empty($dp[Cache::FILES])) {
213: //clearstatcache();
214: foreach ((array) $dp[Cache::FILES] as $depFile) {
215: $meta[self::META_FILES][$depFile] = @filemtime($depFile); // intentionally @
216: }
217: }
218:
219: if (!empty($dp[Cache::CONSTS])) {
220: foreach ((array) $dp[Cache::CONSTS] as $const) {
221: $meta[self::META_CONSTS][$const] = constant($const);
222: }
223: }
224:
225: $cacheFile = $this->getCacheFile($key);
226: $handle = @fopen($cacheFile, 'r+b'); // intentionally @
227: if (!$handle) {
228: $handle = @fopen($cacheFile, 'wb'); // intentionally @
229:
230: if (!$handle) {
231: return FALSE;
232: }
233: }
234:
235: flock($handle, LOCK_EX);
236: ftruncate($handle, 0);
237:
238: $head = serialize($meta) . '?>';
239: $head = '<?php //netteCache[01]' . str_pad((string) strlen($head), 6, '0', STR_PAD_LEFT) . $head;
240: $headLen = strlen($head);
241: $dataLen = strlen($data);
242:
243: if (fwrite($handle, str_repeat("\x00", $headLen), $headLen) === $headLen) {
244: if (fwrite($handle, $data, $dataLen) === $dataLen) {
245: fseek($handle, 0);
246: if (fwrite($handle, $head, $headLen) === $headLen) {
247: fclose($handle);
248: return TRUE;
249: }
250: }
251: }
252:
253: ftruncate($handle, 0);
254: @unlink($cacheFile); // intentionally @
255: fclose($handle);
256: return TRUE;
257: }
258:
259:
260:
261: /**
262: * Removes item from the cache.
263: * @param string key
264: * @return bool TRUE if no problem
265: */
266: public function remove($key)
267: {
268: $cacheFile = $this->getCacheFile($key);
269: $meta = $this->readMeta($cacheFile, LOCK_EX);
270: if (!$meta) return TRUE;
271:
272: ftruncate($meta[self::HANDLE], 0);
273: @unlink($cacheFile); // intentionally @
274: fclose($meta[self::HANDLE]);
275: return TRUE;
276: }
277:
278:
279:
280: /**
281: * Removes items from the cache by conditions & garbage collector.
282: * @param array conditions
283: * @return bool TRUE if no problem
284: */
285: public function clean(array $conds)
286: {
287: $tags = isset($conds[Cache::TAGS]) ? array_flip($conds[Cache::TAGS]) : array();
288:
289: $priority = isset($conds[Cache::PRIORITY]) ? $conds[Cache::PRIORITY] : -1;
290:
291: $all = !empty($conds[Cache::ALL]);
292:
293: $now = time();
294:
295: foreach (glob($this->base . '*') as $cacheFile)
296: {
297: if (!is_file($cacheFile)) continue;
298:
299: do {
300: $meta = $this->readMeta($cacheFile, LOCK_SH);
301: if (!$meta || $all) continue 2;
302:
303: if (!empty($meta[self::META_EXPIRE]) && $meta[self::META_EXPIRE] < $now) {
304: break;
305: }
306:
307: if (!empty($meta[self::META_PRIORITY]) && $meta[self::META_PRIORITY] <= $priority) {
308: break;
309: }
310:
311: if (!empty($meta[self::META_TAGS]) && array_intersect_key($tags, $meta[self::META_TAGS])) {
312: break;
313: }
314:
315: fclose($meta[self::HANDLE]);
316: continue 2;
317: } while (FALSE);
318:
319: flock($meta[self::HANDLE], LOCK_EX);
320: ftruncate($meta[self::HANDLE], 0);
321: @unlink($cacheFile); // intentionally @
322: fclose($meta[self::HANDLE]);
323: }
324:
325: return TRUE;
326: }
327:
328:
329:
330: /**
331: * Reads cache data from disk.
332: * @param string file path
333: * @param int lock mode
334: * @return array|NULL
335: */
336: protected function readMeta($file, $lock)
337: {
338: $handle = @fopen($file, 'r+b'); // intentionally @
339: if (!$handle) return NULL;
340:
341: flock($handle, $lock);
342:
343: $head = stream_get_contents($handle, self::META_HEADER_LEN);
344: if ($head && strlen($head) === self::META_HEADER_LEN) {
345: $size = (int) substr($head, -6);
346: $meta = stream_get_contents($handle, $size, self::META_HEADER_LEN);
347: $meta = @unserialize($meta); // intentionally @
348: if (is_array($meta)) {
349: fseek($handle, $size + self::META_HEADER_LEN); // needed by PHP < 5.2.6
350: $meta[self::FILE] = $file;
351: $meta[self::HANDLE] = $handle;
352: return $meta;
353: }
354: }
355:
356: fclose($handle);
357: return NULL;
358: }
359:
360:
361:
362: /**
363: * Reads cache data from disk and closes cache file handle.
364: * @param array
365: * @return mixed
366: */
367: protected function readData($meta)
368: {
369: $data = stream_get_contents($meta[self::HANDLE]);
370: fclose($meta[self::HANDLE]);
371:
372: if (empty($meta[self::META_SERIALIZED])) {
373: return $data;
374: } else {
375: return @unserialize($data); // intentionally @
376: }
377: }
378:
379:
380:
381: /**
382: * Returns file name.
383: * @param string
384: * @return string
385: */
386: protected function getCacheFile($key)
387: {
388: return $this->base . urlencode($key);
389: }
390:
391: }

Source for file FileStorage.php

Namespaces