· 8 years ago · Dec 26, 2017, 10:44 PM
1<?php
2/* Revision 620
3 * ALl EXAMPLE & DOCUMENT ARE ON www.phpFastCache.com
4 * IF YOU FOUND A BUG, PLEASE GO THERE: http://www.codehelper.io <-- Post your issues and I will fix it.
5 * Open new issue and I will fix it for you in 24 hours
6 * I stopped support issues on GitHub
7 */
8
9class phpFastCache {
10 // Public OPTIONS
11 // Can be set by phpFastCache::$option_name = $value|array|string
12 public static $storage = "auto"; // PDO | mpdo | Auto | Files | memcache | apc | wincache | xcache
13 public static $files_cleanup_after = 1; // hour | auto clean up files after this
14 public static $autosize = 40; // Megabytes
15 public static $path = "./cache/"; // PATH/TO/CACHE/ default will be current path
16 public static $securityKey = "cache.storage"; // phpFastCache::$securityKey = "newKey";
17 public static $securityHtAccess = true; // auto create .htaccess
18 public static $option = array();
19 public static $server = array(array("localhost",11211)); // for MemCache
20 public static $useTmpCache = false; // use for get from Tmp Memory, will be faster in checking cache on LOOP.
21 public static $debugging = false; // turn true for debugging
22
23
24 // NOTHING TO CHANGE FROM HERE
25 private static $step_debugging = 0;
26 private static $Tmp = array();
27 private static $supported_api = array("pdo","mpdo","files","memcache","memcached","apc","xcache","wincache");
28 private static $filename = "pdo.caching";
29 private static $table = "objects";
30 private static $autodb = "";
31 private static $multiPDO = array();
32
33
34 public static $sys = array();
35 private static $checked = array(
36 "path" => false,
37 "servers" => array(),
38 "config_file" => "",
39 );
40 private static $objects = array(
41 "memcache" => "",
42 "memcached" => "",
43 "pdo" => "",
44 );
45
46
47 private static function getOS() {
48 $os = array(
49 "os" => PHP_OS,
50 "php" => PHP_SAPI,
51 "system" => php_uname(),
52 "unique" => md5(php_uname().PHP_OS.PHP_SAPI)
53 );
54 return $os;
55 }
56
57
58
59 public static function systemInfo() {
60 // self::startDebug(self::$sys,"Check Sys",__LINE__,__FUNCTION__);
61
62 if(count(self::$sys) == 0 ) {
63
64 // self::startDebug("Start System Info");
65
66 self::$sys['os'] = self::getOS();
67
68 self::$sys['errors'] = array();
69 self::$sys['storage'] = "";
70 self::$sys['method'] = "pdo";
71 self::$sys['drivers'] = array(
72 "apc" => false,
73 "xcache" => false,
74 "memcache" => false,
75 "memcached" => false,
76 "wincache" => false,
77 "pdo" => false,
78 "mpdo" => false,
79 "files" => false,
80
81 );
82
83
84
85 // Check apc
86 if(extension_loaded('apc') && ini_get('apc.enabled'))
87 {
88 self::$sys['drivers']['apc'] = true;
89 self::$sys['storage'] = "memory";
90 self::$sys['method'] = "apc";
91 }
92
93 // Check xcache
94 if(extension_loaded('xcache') && function_exists("xcache_get"))
95 {
96 self::$sys['drivers']['xcache'] = true;
97 self::$sys['storage'] = "memory";
98 self::$sys['method'] = "xcache";
99 }
100
101 if(extension_loaded('wincache') && function_exists("wincache_ucache_set"))
102 {
103 self::$sys['drivers']['wincache'] = true;
104 self::$sys['storage'] = "memory";
105 self::$sys['method'] = "wincache";
106 }
107
108 // Check memcache
109 if(function_exists("memcache_connect")) {
110 self::$sys['drivers']['memcache'] = true;
111
112 try {
113 memcache_connect("127.0.0.1");
114 self::$sys['storage'] = "memory";
115 self::$sys['method'] = "memcache";
116 } catch (Exception $e) {
117
118 }
119 }
120
121
122 // Check memcached
123 if(class_exists("memcached")) {
124 self::$sys['drivers']['memcached'] = true;
125
126 try {
127 $memcached = new memcached();
128 $memcached->addServer("127.0.0.1","11211");
129 self::$sys['storage'] = "memory";
130 self::$sys['method'] = "memcached";
131
132 } catch (Exception $e) {
133
134 }
135 }
136
137 if(extension_loaded('pdo_sqlite')) {
138 self::$sys['drivers']['pdo'] = true;
139 self::$sys['drivers']['mpdo'] = true;
140 }
141
142 if(is_writable(self::getPath(true))) {
143 self::$sys['drivers']['files'] = true;
144 }
145
146 if(self::$sys['storage'] == "") {
147
148 if(extension_loaded('pdo_sqlite')) {
149 self::$sys['storage'] = "disk";
150 self::$sys['method'] = "pdo";
151
152 } else {
153
154 self::$sys['storage'] = "disk";
155 self::$sys['method'] = "files";
156
157 }
158
159 }
160
161
162
163 if(self::$sys['storage'] == "disk" && !is_writable(self::getPath())) {
164 self::$sys['errors'][] = "Please Create & CHMOD 0777 or any Writeable Mode for ".self::getPath();
165 }
166
167
168
169
170 }
171
172 // self::startDebug(self::$sys);
173 return self::$sys;
174 }
175
176 // return Folder Cache PATH
177 // PATH Edit by SecurityKey
178 // Auto create, Chmod and Warning
179
180 // Revision 618
181 // PHP_SAPI = apache2handler should go to tmp
182 private static function isPHPModule() {
183 if(PHP_SAPI == "apache2handler") {
184 return true;
185 } else {
186 if(strpos(PHP_SAPI,"handler") !== false) {
187 return true;
188 }
189 }
190 return false;
191 }
192 // Revision 618
193 // Security with .htaccess
194 static function htaccessGen($path = "") {
195 if(self::$securityHtAccess == true) {
196
197 if(!file_exists($path."/.htaccess")) {
198 // echo "write me";
199 $html = "order deny, allow \r\n
200deny from all \r\n
201allow from 127.0.0.1";
202 $f = @fopen($path."/.htaccess","w+");
203 @fwrite($f,$html);
204 @fclose($f);
205 } else {
206 // echo "got me";
207 }
208 }
209
210 }
211
212 private static function getPath($skip_create = false) {
213
214 if (self::$path=='')
215 {
216 // revision 618
217 if(self::isPHPModule()) {
218 $tmp_dir = ini_get('upload_tmp_dir') ? ini_get('upload_tmp_dir') : sys_get_temp_dir();
219 self::$path = $tmp_dir;
220 } else {
221 self::$path = dirname(__FILE__);
222 }
223
224 }
225
226 if($skip_create == false && self::$checked['path'] == false) {
227 if(!file_exists(self::$path."/".self::$securityKey."/") || !is_writable(self::$path."/".self::$securityKey."/")) {
228 if(!file_exists(self::$path."/".self::$securityKey."/")) {
229 @mkdir(self::$path."/".self::$securityKey."/",0777);
230 }
231 if(!is_writable(self::$path."/".self::$securityKey."/")) {
232 @chmod(self::$path."/".self::$securityKey."/",0777);
233 }
234 if(!file_exists(self::$path."/".self::$securityKey."/") || !is_writable(self::$path."/".self::$securityKey."/")) {
235 die("Sorry, Please create ".self::$path."/".self::$securityKey."/ and SET Mode 0777 or any Writable Permission!" );
236 }
237
238 }
239
240 self::$checked['path'] = true;
241 // Revision 618
242 self::htaccessGen(self::$path."/".self::$securityKey."/");
243
244 }
245
246
247
248 return self::$path."/".self::$securityKey."/";
249
250
251 }
252
253 // return method automatic;
254 // APC will be TOP, then Memcached, Memcache, PDO and Files
255 public static function autoconfig($name = "") {
256 // self::startDebug($name,"Check Name",__LINE__,__FUNCTION__);
257
258 $cache = self::cacheMethod($name);
259 if($cache != "" && $cache != self::$storage && $cache!="auto") {
260 return $cache;
261 }
262
263 // self::startDebug($cache,"Check Cache",__LINE__,__FUNCTION__);
264
265 $os = self::getOS();
266 // self::startDebug(self::$storage,"User Set",__LINE__,__FUNCTION__);
267 if(self::$storage == "" || self::$storage == "auto") {
268 // self::startDebug(self::$storage,"User Set Auto",__LINE__,__FUNCTION__);
269
270 if(extension_loaded('apc') && ini_get('apc.enabled') && strpos(PHP_SAPI,"CGI") === false)
271 {
272
273 self::$sys['drivers']['apc'] = true;
274 self::$sys['storage'] = "memory";
275 self::$sys['method'] = "apc";
276
277 // self::startDebug(self::$sys,"GOT APC",__LINE__,__FUNCTION__);
278
279 }elseif(extension_loaded('xcache'))
280 {
281 self::$sys['drivers']['xcache'] = true;
282 self::$sys['storage'] = "memory";
283 self::$sys['method'] = "xcache";
284 // self::startDebug(self::$sys,"GOT XCACHE",__LINE__,__FUNCTION__);
285
286 } else {
287 // fix PATH for existing
288 $reconfig = false;
289 // self::startDebug(self::getPath()."/config.".$os['unique'].".cache.ini","CHECK CONFIG FILE",__LINE__,__FUNCTION__);
290
291
292 if (file_exists(self::getPath()."/config.".$os['unique'].".cache.ini"))
293 {
294 $info = self::decode(file_get_contents(self::getPath()."/config.".$os['unique'].".cache.ini"));
295
296 // self::startDebug($info,"CHECK INFO",__LINE__,__FUNCTION__);
297
298 if(!isset($info['value'])) {
299 $reconfig = true;
300
301 } else {
302 $info = $info['value'];
303 self::$sys = $info;
304
305 }
306
307
308 } else {
309
310 $info = self::systemInfo();
311 // self::startDebug($info,"CHECK INFO BY SYSTEM INFO",__LINE__,__FUNCTION__);
312 }
313
314 if(isset($info['os']['unique'])) {
315
316 if($info['os']['unique'] != $os['unique']) {
317 $reconfig = true;
318 }
319 } else {
320 $reconfig = true;
321 }
322
323 if(!file_exists(self::getPath()."/config.".$os['unique'].".cache.ini") || $reconfig == true) {
324
325 $info = self::systemInfo();
326 self::$sys = $info;
327 // self::startDebug($info,"Check Info",__LINE__,__FUNCTION__);
328
329 try {
330 $f = fopen(self::getPath()."/config.".$os['unique'].".cache.ini","w+");
331 fwrite($f,self::encode($info));
332 fclose($f);
333
334 } catch (Exception $e) {
335 die("Please chmod 0777 ".self::getPath()."/config.".$os['unique'].".cache.ini");
336 }
337 } else {
338
339 }
340
341 }
342
343
344
345 self::$storage = self::$sys['method'];
346
347
348 } else {
349
350 if(in_array(self::$storage,array("files","pdo","mpdo"))) {
351 self::$sys['storage'] = "disk";
352 }elseif(in_array(self::$storage,array("apc","memcache","memcached","wincache","xcache"))) {
353 self::$sys['storage'] = "memory";
354 } else {
355 self::$sys['storage'] = "";
356 }
357
358 if(self::$sys['storage'] == "" || !in_array(self::$storage,self::$supported_api)) {
359 die("Don't have this Cache ".self::$storage." In your System! Please double check!");
360 }
361
362 self::$sys['method'] = strtolower(self::$storage);
363
364 }
365
366 if(self::$sys['method'] == "files") {
367 $last_cleanup = self::files_get("last_cleanup_cache");
368 if($last_cleanup == null) {
369 self::files_cleanup();
370 self::files_set("last_cleanup_cache",@date("U"),3600*self::$files_cleanup_after);
371 }
372 }
373
374 // self::startDebug(self::$sys,"Check RETURN SYS",__LINE__,__FUNCTION__);
375
376 return self::$sys['method'];
377
378 }
379
380
381
382 private static function cacheMethod($name = "") {
383 $cache = self::$storage;
384 if(is_array($name)) {
385 $key = array_keys($name);
386 $key = $key[0];
387 if(in_array($key,self::$supported_api)) {
388 $cache = $key;
389 }
390 }
391 return $cache;
392 }
393
394
395 public static function safename($name) {
396 return strtolower(preg_replace("/[^a-zA-Z0-9_\s\.]+/","",$name));
397 }
398
399
400
401
402
403 private static function encode($value,$time_in_second = "") {
404 $value = serialize(array(
405 "time" => @date("U"),
406 "value" => $value,
407 "endin" => $time_in_second
408 ));
409 return $value;
410 }
411
412 private static function decode($value) {
413 $x = @unserialize($value);
414 if($x == false) {
415 return $value;
416 } else {
417 return $x;
418 }
419 }
420
421 /*
422 * Start Public Static
423 */
424
425 public static function cleanup($option = "") {
426 $api = self::autoconfig();
427 self::$Tmp = array();
428
429 switch ($api) {
430 case "pdo":
431 return self::pdo_cleanup($option);
432 break;
433 case "mpdo":
434 return self::pdo_cleanup($option);
435 break;
436 case "files":
437 return self::files_cleanup($option);
438 break;
439 case "memcache":
440 return self::memcache_cleanup($option);
441 break;
442 case "memcached":
443 return self::memcached_cleanup($option);
444 break;
445 case "wincache":
446 return self::wincache_cleanup($option);
447 break;
448 case "apc":
449 return self::apc_cleanup($option);
450 break;
451 case "xcache":
452 return self::xcache_cleanup($option);
453 break;
454 default:
455 return self::pdo_cleanup($option);
456 break;
457 }
458
459 }
460
461 public static function delete($name = "string|array(db->item)") {
462
463 $api = self::autoconfig($name);
464 if(self::$useTmpCache == true) {
465 $tmp_name = md5(serialize($api.$name));
466 if(isset(self::$Tmp[$tmp_name])) {
467 unset(self::$Tmp[$tmp_name]);
468 }
469 }
470
471 switch ($api) {
472 case "pdo":
473 return self::pdo_delete($name);
474 break;
475 case "mpdo":
476 return self::pdo_delete($name);
477 break;
478 case "files":
479 return self::files_delete($name);
480 break;
481 case "memcache":
482 return self::memcache_delete($name);
483 break;
484 case "memcached":
485 return self::memcached_delete($name);
486 break;
487 case "wincache":
488 return self::wincache_delete($name);
489 break;
490 case "apc":
491 return self::apc_delete($name);
492 break;
493 case "xcache":
494 return self::xcache_delete($name);
495 break;
496 default:
497 return self::pdo_delete($name);
498 break;
499 }
500
501 }
502
503
504 public static function exists($name = "string|array(db->item)") {
505
506 $api = self::autoconfig($name);
507 switch ($api) {
508 case "pdo":
509 return self::pdo_exist($name);
510 break;
511 case "mpdo":
512 return self::pdo_exist($name);
513 break;
514 case "files":
515 return self::files_exist($name);
516 break;
517 case "memcache":
518 return self::memcache_exist($name);
519 break;
520 case "memcached":
521 return self::memcached_exist($name);
522 break;
523 case "wincache":
524 return self::wincache_exist($name);
525 break;
526 case "apc":
527 return self::apc_exist($name);
528 break;
529 case "xcache":
530 return self::xcache_exist($name);
531 break;
532 default:
533 return self::pdo_exist($name);
534 break;
535 }
536
537 }
538
539 public static function deleteMulti($object = array()) {
540 $res = array();
541 foreach($object as $driver=>$name) {
542 if(!is_numeric($driver)) {
543 $n = $driver."_".$name;
544 $name = array($driver=>$name);
545 } else {
546 $n = $name;
547 }
548 $res[$n] = self::delete($name);
549 }
550 return $res;
551
552 }
553
554 public static function setMulti($mname = array(), $time_in_second_for_all = 600, $skip_for_all = false) {
555 $res = array();
556
557 foreach($mname as $object){
558 // print_r($object);
559
560 $keys = array_keys($object);
561
562 if($keys[0] != "0") {
563 $k = $keys[0];
564 $name = isset($object[$k]) ? array($k => $object[$k]) : "";
565 $n = $k."_".$object[$k];
566 $x=0;
567 } else {
568 $name = isset($object[0]) ? $object[0] : "";
569 $x=1;
570 $n = $name;
571 }
572
573 $value = isset($object[$x]) ? $object[$x] : "";$x++;
574 $time = isset($object[$x]) ? $object[$x] : $time_in_second_for_all;$x++;
575 $skip = isset($object[$x]) ? $object[$x] : $skip_for_all;$x++;
576
577 if($name!="" && $value!="") {
578 $res[$n] = self::set($name,$value, $time, $skip);
579 }
580 // echo "<br> ----- <br>";
581
582 }
583
584 return $res;
585 }
586
587
588
589 public static function set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
590 $api = self::autoconfig($name);
591 if(self::$useTmpCache == true) {
592 $tmp_name = md5(serialize($api.$name));
593 self::$Tmp[$tmp_name] = $value;
594 }
595
596 switch ($api) {
597 case "pdo":
598 return self::pdo_set($name,$value,$time_in_second, $skip_if_existing);
599 break;
600 case "mpdo":
601 return self::pdo_set($name,$value,$time_in_second, $skip_if_existing);
602 break;
603 case "files":
604 return self::files_set($name,$value,$time_in_second, $skip_if_existing);
605 break;
606 case "memcache":
607 return self::memcache_set($name,$value,$time_in_second, $skip_if_existing);
608 break;
609 case "memcached":
610 return self::memcached_set($name,$value,$time_in_second, $skip_if_existing);
611 break;
612 case "wincache":
613 return self::wincache_set($name,$value,$time_in_second, $skip_if_existing);
614 break;
615 case "apc":
616 return self::apc_set($name,$value,$time_in_second, $skip_if_existing);
617 break;
618 case "xcache":
619 return self::xcache_set($name,$value,$time_in_second, $skip_if_existing);
620 break;
621 default:
622 return self::pdo_set($name,$value,$time_in_second, $skip_if_existing);
623 break;
624 }
625
626 }
627
628
629
630
631
632
633 public static function decrement($name, $step = 1) {
634 $api = self::autoconfig($name);
635 if(self::$useTmpCache == true) {
636 $tmp_name = md5(serialize($api.$name));
637 if(isset(self::$Tmp[$tmp_name])) {
638 self::$Tmp[$tmp_name] = (Int)self::$Tmp[$tmp_name] - $step;
639 } else {
640 self::$Tmp[$tmp_name] = $step;
641 }
642
643 }
644 switch ($api) {
645 case "pdo":
646 return self::pdo_decrement($name, $step);
647 break;
648 case "mpdo":
649 return self::pdo_decrement($name, $step);
650 break;
651 case "files":
652 return self::files_decrement($name, $step);
653 break;
654 case "memcache":
655 return self::memcache_decrement($name, $step);
656 break;
657 case "memcached":
658 return self::memcached_decrement($name, $step);
659 break;
660 case "wincache":
661 return self::wincache_decrement($name, $step);
662 break;
663 case "apc":
664 return self::apc_decrement($name, $step);
665 break;
666 case "xcache":
667 return self::xcache_decrement($name, $step);
668 break;
669 default:
670 return self::pdo_decrement($name, $step);
671 break;
672 }
673 }
674
675
676
677 public static function get($name) {
678 $api = self::autoconfig($name);
679 if(self::$useTmpCache == true) {
680 $tmp_name = md5(serialize($api.$name));
681 if(isset(self::$Tmp[$tmp_name])) {
682 return self::$Tmp[$tmp_name];
683 }
684 }
685
686 // self::startDebug($api,"API",__LINE__,__FUNCTION__);
687
688 // for files, check it if NULL and "empty" string
689 switch ($api) {
690 case "pdo":
691 return self::pdo_get($name);
692 break;
693 case "mpdo":
694 return self::pdo_get($name);
695
696 break;
697 case "files":
698 return self::files_get($name);
699 break;
700 case "memcache":
701 return self::memcache_get($name);
702 break;
703 case "memcached":
704 return self::memcached_get($name);
705 break;
706 case "wincache":
707 return self::wincache_get($name);
708 break;
709 case "apc":
710 return self::apc_get($name);
711 break;
712 case "xcache":
713 return self::xcache_get($name);
714 break;
715 default:
716 return self::pdo_get($name);
717 break;
718 }
719
720 }
721
722
723 public static function getMulti($object = array()) {
724 $res = array();
725 foreach($object as $driver=>$name) {
726 if(!is_numeric($driver)) {
727 $n = $driver."_".$name;
728 $name = array($driver=>$name);
729 } else {
730 $n = $name;
731 }
732 $res[$n] = self::get($name);
733 }
734 return $res;
735
736 }
737
738
739
740 public static function stats() {
741 $api = self::autoconfig();
742 switch ($api) {
743 case "pdo":
744 return self::pdo_stats();
745 break;
746 case "mpdo":
747 return self::pdo_stats();
748 break;
749 case "files":
750 return self::files_stats();
751 break;
752 case "memcache":
753 return self::memcache_stats();
754 break;
755 case "memcached":
756 return self::memcached_stats();
757 break;
758 case "wincache":
759 return self::wincache_stats();
760 break;
761 case "apc":
762 return self::apc_stats();
763 break;
764 case "xcache":
765 return self::xcache_stats();
766 break;
767 default:
768 return self::pdo_stats();
769 break;
770 }
771 }
772
773 public static function increment($name, $step = 1) {
774 $api = self::autoconfig($name);
775
776 if(self::$useTmpCache == true) {
777 $tmp_name = md5(serialize($api.$name));
778 if(isset(self::$Tmp[$tmp_name])) {
779 self::$Tmp[$tmp_name] = (Int)self::$Tmp[$tmp_name] + $step;
780 } else {
781 self::$Tmp[$tmp_name] = $step;
782 }
783
784 }
785
786 switch ($api) {
787 case "pdo":
788 return self::pdo_increment($name, $step);
789 break;
790 case "mpdo":
791 return self::pdo_increment($name, $step);
792 break;
793 case "files":
794 return self::files_increment($name, $step);
795 break;
796 case "memcache":
797 return self::memcache_increment($name, $step);
798 break;
799 case "memcached":
800 return self::memcached_increment($name, $step);
801 break;
802 case "wincache":
803 return self::wincache_increment($name, $step);
804 break;
805 case "apc":
806 return self::apc_increment($name, $step);
807 break;
808 case "xcache":
809 return self::xcache_increment($name, $step);
810 break;
811 default:
812 return self::pdo_increment($name, $step);
813 break;
814 }
815 }
816
817
818 /*
819 * Begin FILES Cache Static
820 * Use Files & Folders to cache
821 */
822
823 private static function files_exist($name) {
824 $data = self::files_get($name);
825 if($data == null) {
826 return false;
827 } else {
828 return true;
829 }
830 }
831
832
833
834 private static function files_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
835
836 $db = self::selectDB($name);
837 $name = $db['item'];
838 $folder = $db['db'];
839
840 $path = self::getPath();
841 $tmp = explode("/",$folder);
842 foreach($tmp as $dir) {
843 if($dir!="" && $dir !="." && $dir!="..") {
844 $path.="/".$dir;
845 if(!file_exists($path)) {
846 mkdir($path,0777);
847 }
848 }
849 }
850
851 $file = $path."/".$name.".c.html";
852
853 $write = true;
854 if(file_exists($file)) {
855 $data = self::decode(file_get_contents($file));
856 if($skip_if_existing == true && ((Int)$data['time'] + (Int)$data['endin'] > @date("U")) ) {
857 $write = false;
858 }
859 }
860
861 if($write == true ) {
862 try {
863 $f = fopen($file,"w+");
864 fwrite($f,self::encode($value,$time_in_second));
865 fclose($f);
866 } catch (Exception $e) {
867 die("Sorry, can't write cache to file :".$file );
868 }
869 }
870
871 return $value;
872 }
873
874 private static function files_get($name) {
875 $db = self::selectDB($name);
876 $name = $db['item'];
877 $folder = $db['db'];
878
879 $path = self::getPath();
880 $tmp = explode("/",$folder);
881 foreach($tmp as $dir) {
882 if($dir!="" && $dir !="." && $dir!="..") {
883 $path.="/".$dir;
884 }
885 }
886
887 $file = $path."/".$name.".c.html";
888
889 if(!file_exists($file)) {
890 return null;
891 }
892
893 $data = self::decode(file_get_contents($file));
894
895 if(!isset($data['time']) || !isset($data['endin']) || !isset($data['value'])) {
896 return null;
897 }
898
899 if($data['time'] + $data['endin'] < @date("U")) {
900 // exp
901 unlink($file);
902 return null;
903 }
904
905 return isset($data['value']) ? $data['value'] : null;
906 }
907
908 private static function files_stats($dir = "") {
909 $total = array(
910 "expired" => 0,
911 "size" => 0,
912 "files" => 0
913 );
914 if($dir == "") {
915 $dir = self::getPath();
916 }
917 $d = opendir($dir);
918 while($file = readdir($d))
919 {
920 if($file!="." && $file != "..") {
921 $path = $dir."/".$file;
922 if(is_dir($path)) {
923 $in = self::files_stats($path);
924 $total['expired'] = $total['expired'] + $in['expired'];
925 $total['size'] = $total['size'] + $in['size'];
926 $total['files'] = $total['files'] + $in['files'];
927 }
928
929 elseif(strpos($path,".c.html")!== false) {
930 $data = self::decode($path);
931 if(isset($data['value']) && isset($data['time']) && isset($data['endin'])) {
932 $total['files']++;
933 if($data['time'] + $data['endin'] < @date("U")) {
934 $total['expired']++;
935 }
936 $total['size'] = $total['size'] + filesize($path);
937 }
938 }
939 }
940
941 }
942 if($total['size'] > 0) {
943 $total['size'] = $total['size']/1024/1024;
944 }
945 return $total;
946 }
947
948 private static function files_cleanup($dir = "") {
949 $total = 0;
950 if($dir == "") {
951 $dir = self::getPath();
952 }
953 $d = opendir($dir);
954 while($file = readdir($d))
955 {
956 if($file!="." && $file != "..") {
957 $path = $dir."/".$file;
958 if(is_dir($path)) {
959 $total = $total + self::files_cleanup($path);
960 try {
961 @unlink($path);
962 } catch (Exception $e) {
963 // nothing;
964 }
965 }
966 elseif(strpos($path,".c.html")!==false) {
967 $data = self::decode($path);
968 if(isset($data['value']) && isset($data['time']) && isset($data['endin'])) {
969 if((Int)$data['time'] + (Int)$data['endin'] < @date("U")) {
970 unlink($path);
971 $total++;
972 }
973 } else {
974 unlink($path);
975 $total++;
976 }
977 }
978 }
979
980 }
981 return $total;
982 }
983
984 private static function files_delete($name) {
985 $db = self::selectDB($name);
986 $name = $db['item'];
987 $folder = $db['db'];
988
989 $path = self::getPath();
990 $tmp = explode("/",$folder);
991 foreach($tmp as $dir) {
992 if($dir!="" && $dir !="." && $dir!="..") {
993 $path.="/".$dir;
994 }
995 }
996
997 $file = $path."/".$name.".c.html";
998 if(file_exists($file)) {
999 try {
1000 unlink($file);
1001 return true;
1002 } catch(Exception $e) {
1003 return false;
1004 }
1005
1006 }
1007 return true;
1008 }
1009
1010 private static function files_increment($name, $step = 1) {
1011 $db = self::selectDB($name);
1012 $name = $db['item'];
1013 $folder = $db['db'];
1014
1015 $path = self::getPath();
1016 $tmp = explode("/",$folder);
1017 foreach($tmp as $dir) {
1018 if($dir!="" && $dir !="." && $dir!="..") {
1019 $path.="/".$dir;
1020 }
1021 }
1022
1023 $file = $path."/".$name.".c.html";
1024 if(!file_exists($file)) {
1025 self::files_set($name,$step,3600);
1026 return $step;
1027 }
1028
1029 $data = self::decode(file_get_contents($file));
1030 if(isset($data['time']) && isset($data['value']) && isset($data['endin'])) {
1031 $data['value'] = $data['value'] + $step;
1032 self::files_set($name,$data['value'],$data['endin']);
1033 }
1034 return $data['value'];
1035 }
1036
1037 private static function files_decrement($name, $step = 1) {
1038 $db = self::selectDB($name);
1039 $name = $db['item'];
1040 $folder = $db['db'];
1041
1042 $path = self::getPath();
1043 $tmp = explode("/",$folder);
1044 foreach($tmp as $dir) {
1045 if($dir!="" && $dir !="." && $dir!="..") {
1046 $path.="/".$dir;
1047 }
1048 }
1049
1050 $file = $path."/".$name.".c.html";
1051 if(!file_exists($file)) {
1052 self::files_set($name,$step,3600);
1053 return $step;
1054 }
1055
1056 $data = self::decode(file_get_contents($file));
1057 if(isset($data['time']) && isset($data['value']) && isset($data['endin'])) {
1058 $data['value'] = $data['value'] - $step;
1059 self::files_set($name,$data['value'],$data['endin']);
1060 }
1061 return $data['value'];
1062 }
1063
1064 private static function getMemoryName($name) {
1065 $db = self::selectDB($name);
1066 $name = $db['item'];
1067 $folder = $db['db'];
1068 $name = $folder."_".$name;
1069
1070 // connect memory server
1071 if(self::$sys['method'] == "memcache" || $db['db'] == "memcache") {
1072 self::memcache_addserver();
1073 }elseif(self::$sys['method'] == "memcached" || $db['db'] == "memcached") {
1074 self::memcached_addserver();
1075 }elseif(self::$sys['method'] == "wincache") {
1076 // init WinCache here
1077
1078 }
1079
1080 return $name;
1081 }
1082
1083
1084 /*
1085 * Begin XCache Static
1086 * http://xcache.lighttpd.net/wiki/XcacheApi
1087 */
1088
1089 private static function xcache_exist($name) {
1090 $name = self::getMemoryName($name);
1091 if(xcache_isset($name)) {
1092 return true;
1093 } else {
1094 return false;
1095 }
1096 }
1097
1098
1099 private static function xcache_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1100 $name = self::getMemoryName($name);
1101 if($skip_if_existing == true) {
1102 if(!self::xcache_exist($name)) {
1103 return xcache_set($name,$value,$time_in_second);
1104 }
1105 } else {
1106 return xcache_set($name,$value,$time_in_second);
1107 }
1108 return false;
1109 }
1110
1111 private static function xcache_get($name) {
1112
1113 $name = self::getMemoryName($name);
1114
1115 $data = xcache_get($name);
1116
1117 if($data === false || $data == "") {
1118 return null;
1119 }
1120 return $data;
1121
1122 }
1123
1124 private static function xcache_stats() {
1125 try {
1126 return xcache_list(XC_TYPE_VAR,100);
1127 } catch(Exception $e) {
1128 return array();
1129 }
1130 }
1131
1132 private static function xcache_cleanup($option = array()) {
1133 // Revision 621
1134
1135 $cnt = xcache_count(XC_TYPE_VAR);
1136 for ($i=0; $i < $cnt; $i++) {
1137 xcache_clear_cache(XC_TYPE_VAR, $i);
1138 }
1139 return true;
1140 }
1141
1142 private static function xcache_delete($name) {
1143 $name = self::getMemoryName($name);
1144 return xcache_unset($name);
1145 }
1146
1147 private static function xcache_increment($name, $step = 1) {
1148 $orgi = $name;
1149 $name = self::getMemoryName($name);
1150 $ret =xcache_inc($name, $step);
1151 if($ret === false) {
1152 self::xcache_set($orgi,$step,3600);
1153 return $step;
1154 } else {
1155 return $ret;
1156 }
1157 }
1158
1159 private static function xcache_decrement($name, $step = 1) {
1160 $orgi = $name;
1161 $name = self::getMemoryName($name);
1162 $ret = xcache_dec($name, $step);
1163 if($ret === false) {
1164 self::xcache_set($orgi,$step,3600);
1165 return $step;
1166 } else {
1167 return $ret;
1168 }
1169 }
1170
1171
1172 /*
1173 * Begin APC Static
1174 * http://www.php.net/manual/en/ref.apc.php
1175 */
1176
1177 private static function apc_exist($name) {
1178 $name = self::getMemoryName($name);
1179 if(apc_exists($name)) {
1180 return true;
1181 } else {
1182 return false;
1183 }
1184 }
1185
1186
1187 private static function apc_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1188 $name = self::getMemoryName($name);
1189 if($skip_if_existing == true) {
1190 return apc_add($name,$value,$time_in_second);
1191 } else {
1192 return apc_store($name,$value,$time_in_second);
1193 }
1194 }
1195
1196 private static function apc_get($name) {
1197
1198 $name = self::getMemoryName($name);
1199
1200 $data = apc_fetch($name,$bo);
1201
1202 if($bo === false) {
1203 return null;
1204 }
1205 return $data;
1206
1207 }
1208
1209 private static function apc_stats() {
1210 try {
1211 return apc_cache_info("user");
1212 } catch(Exception $e) {
1213 return array();
1214 }
1215 }
1216
1217 private static function apc_cleanup($option = array()) {
1218 return apc_clear_cache("user");
1219 }
1220
1221 private static function apc_delete($name) {
1222 $name = self::getMemoryName($name);
1223 return apc_delete($name);
1224 }
1225
1226 private static function apc_increment($name, $step = 1) {
1227 $orgi = $name;
1228 $name = self::getMemoryName($name);
1229 $ret = apc_inc($name, $step, $fail);
1230 if($ret === false) {
1231 self::apc_set($orgi,$step,3600);
1232 return $step;
1233 } else {
1234 return $ret;
1235 }
1236 }
1237
1238 private static function apc_decrement($name, $step = 1) {
1239 $orgi = $name;
1240 $name = self::getMemoryName($name);
1241 $ret = apc_dec($name, $step, $fail);
1242 if($ret === false) {
1243 self::apc_set($orgi,$step,3600);
1244 return $step;
1245 } else {
1246 return $ret;
1247 }
1248 }
1249
1250
1251 /*
1252 * Begin Memcache Static
1253 * http://www.php.net/manual/en/class.memcache.php
1254 */
1255 public static function memcache_addserver() {
1256 if(!isset(self::$checked['memcache'])) {
1257 self::$checked['memcache'] = array();
1258 }
1259
1260 if(self::$objects['memcache'] == "") {
1261 self::$objects['memcache'] = new Memcache();
1262
1263 foreach(self::$server as $server) {
1264 $name = isset($server[0]) ? $server[0] : "";
1265 $port = isset($server[1]) ? $server[1] : 11211;
1266 if(!in_array($server, self::$checked['memcache']) && $name !="") {
1267 self::$objects['memcache']->addServer($name,$port);
1268 self::$checked['memcache'][] = $name;
1269 }
1270 }
1271
1272 }
1273
1274 }
1275
1276
1277
1278 private static function memcache_exist($name) {
1279 $x = self::memcache_get($name);
1280 if($x == null) {
1281 return false;
1282 } else {
1283 return true;
1284 }
1285 }
1286
1287
1288
1289
1290
1291
1292 private static function memcache_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1293 $orgi = $name;
1294 $name = self::getMemoryName($name);
1295 if($skip_if_existing == false) {
1296 return self::$objects['memcache']->set($name, $value, false, $time_in_second );
1297 } else {
1298 return self::$objects['memcache']->add($name, $value, false, $time_in_second );
1299 }
1300
1301 }
1302
1303 private static function memcache_get($name) {
1304 $name = self::getMemoryName($name);
1305 $x = self::$objects['memcache']->get($name);
1306 if($x == false) {
1307 return null;
1308 } else {
1309 return $x;
1310 }
1311 }
1312
1313 private static function memcache_stats() {
1314 self::memcache_addserver();
1315 return self::$objects['memcache']->getStats();
1316 }
1317
1318 private static function memcache_cleanup($option = "") {
1319 self::memcache_addserver();
1320 self::$objects['memcache']->flush();
1321 return true;
1322 }
1323
1324 private static function memcache_delete($name) {
1325 $name = self::getMemoryName($name);
1326 return self::$objects['memcache']->delete($name);
1327 }
1328
1329 private static function memcache_increment($name, $step = 1) {
1330 $name = self::getMemoryName($name);
1331 return self::$objects['memcache']->increment($name, $step);
1332 }
1333
1334 private static function memcache_decrement($name, $step = 1) {
1335 $name = self::getMemoryName($name);
1336 return self::$objects['memcache']->decrement($name, $step);
1337 }
1338
1339
1340
1341 /*
1342 * Begin Memcached Static
1343 */
1344
1345 public static function memcached_addserver() {
1346 if(!isset(self::$checked['memcached'])) {
1347 self::$checked['memcached'] = array();
1348 }
1349
1350 if(self::$objects['memcached'] == "") {
1351 self::$objects['memcached'] = new Memcached();
1352
1353 foreach(self::$server as $server) {
1354 $name = isset($server[0]) ? $server[0] : "";
1355 $port = isset($server[1]) ? $server[1] : 11211;
1356 $sharing = isset($server[2]) ? $server[2] : 0;
1357 if(!in_array($server, self::$checked['memcached']) && $name !="") {
1358 if($sharing >0 ) {
1359 self::$objects['memcached']->addServer($name,$port,$sharing);
1360 } else {
1361 self::$objects['memcached']->addServer($name,$port);
1362 }
1363
1364 self::$checked['memcached'][] = $name;
1365 }
1366 }
1367
1368 }
1369 }
1370
1371
1372 private static function memcached_exist($name) {
1373 $x = self::memcached_get($name);
1374 if($x == null) {
1375 return false;
1376 } else {
1377 return true;
1378 }
1379 }
1380
1381
1382
1383 private static function memcached_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1384 $orgi = $name;
1385 $name = self::getMemoryName($name);
1386 if($skip_if_existing == false) {
1387 return self::$objects['memcached']->set($name, $value, time() + $time_in_second );
1388 } else {
1389 return self::$objects['memcached']->add($name, $value, time() + $time_in_second );
1390 }
1391
1392 }
1393
1394 private static function memcached_get($name) {
1395 $name = self::getMemoryName($name);
1396 $x = self::$objects['memcached']->get($name);
1397 if($x == false) {
1398 return null;
1399 } else {
1400 return $x;
1401 }
1402 }
1403
1404 private static function memcached_stats() {
1405 self::memcached_addserver();
1406 return self::$objects['memcached']->getStats();
1407 }
1408
1409 private static function memcached_cleanup($option = "") {
1410 self::memcached_addserver();
1411 self::$objects['memcached']->flush();
1412 return true;
1413 }
1414
1415 private static function memcached_delete($name) {
1416 $name = self::getMemoryName($name);
1417 return self::$objects['memcached']->delete($name);
1418 }
1419
1420 private static function memcached_increment($name, $step = 1) {
1421 $name = self::getMemoryName($name);
1422 return self::$objects['memcached']->increment($name, $step);
1423 }
1424
1425 private static function memcached_decrement($name, $step = 1) {
1426 $name = self::getMemoryName($name);
1427 return self::$objects['memcached']->decrement($name, $step);
1428 }
1429
1430 /*
1431 * Begin WinCache Static
1432 */
1433
1434 private static function wincache_exist($name) {
1435 $name = self::getMemoryName($name);
1436 if(wincache_ucache_exists($name)) {
1437 return true;
1438 } else {
1439 return false;
1440 }
1441 }
1442
1443
1444
1445
1446 private static function wincache_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1447 $orgi = $name;
1448 $name = self::getMemoryName($name);
1449 if($skip_if_existing == false) {
1450 return wincache_ucache_set($name, $value, $time_in_second );
1451 } else {
1452 return wincache_ucache_add($name, $value, $time_in_second );
1453 }
1454
1455 }
1456
1457 private static function wincache_get($name) {
1458 $name = self::getMemoryName($name);
1459
1460 $x = wincache_ucache_get($name,$suc);
1461
1462 if($suc == false) {
1463 return null;
1464 } else {
1465 return $x;
1466 }
1467 }
1468
1469 private static function wincache_stats() {
1470 return wincache_scache_info();
1471 }
1472
1473 private static function wincache_cleanup($option = "") {
1474 wincache_ucache_clear();
1475 return true;
1476 }
1477
1478 private static function wincache_delete($name) {
1479 $name = self::getMemoryName($name);
1480 return wincache_ucache_delete($name);
1481 }
1482
1483 private static function wincache_increment($name, $step = 1) {
1484 $name = self::getMemoryName($name);
1485 return wincache_ucache_inc($name, $step);
1486 }
1487
1488 private static function wincache_decrement($name, $step = 1) {
1489 $name = self::getMemoryName($name);
1490 return wincache_ucache_dec($name, $step);
1491 }
1492
1493
1494 /*
1495 * Begin PDO Static
1496 */
1497
1498 private static function pdo_exist($name) {
1499 $db = self::selectDB($name);
1500 $name = $db['item'];
1501
1502 $x = self::db(array('db'=>$db['db']))->prepare("SELECT COUNT(*) as `total` FROM ".self::$table." WHERE `name`=:name");
1503
1504 $x->execute(array(
1505 ":name" => $name,
1506 ));
1507
1508 $row = $x->fetch(PDO::FETCH_ASSOC);
1509 if($row['total'] >0 ){
1510 return true;
1511 } else {
1512 return false;
1513 }
1514
1515 }
1516
1517
1518 private static function pdo_cleanup($option = "") {
1519 self::db(array("skip_clean" => true))->exec("drop table if exists ".self::$table);
1520 self::initDatabase();
1521 return true;
1522 }
1523
1524 private static function pdo_stats($full = false) {
1525 $res = array();
1526 if($full == true) {
1527 $stm = self::db()->prepare("SELECT * FROM ".self::$table."");
1528 $stm->execute();
1529 $result = $stm->fetchAll();
1530 $res['data'] = $result;
1531 }
1532 $stm = self::db()->prepare("SELECT COUNT(*) as `total` FROM ".self::$table."");
1533 $stm->execute();
1534 $result = $stm->fetch();
1535 $res['record'] = $result['total'];
1536 if(self::$path!="memory") {
1537 $res['size'] = filesize(self::getPath()."/".self::$filename);
1538 }
1539
1540 return $res;
1541 }
1542
1543
1544 // for PDO return DB name,
1545 // For Files, return Dir
1546 private static function selectDB($object) {
1547 $res = array(
1548 'db' => "",
1549 'item' => "",
1550 );
1551 if(is_array($object)) {
1552 $key = array_keys($object);
1553 $key = $key[0];
1554 $res['db'] = $key;
1555 $res['item'] = self::safename($object[$key]);
1556 } else {
1557 $res['item'] = self::safename($object);
1558 }
1559
1560 if($res['db'] == "" && self::$sys['method'] == "files") {
1561 $res['db'] = "files";
1562 }
1563
1564 // for auto database
1565 if($res['db'] == "" && self::$storage== "mpdo") {
1566 $create_table = false;
1567 if(!file_exists('sqlite:'.self::getPath().'/phpfastcache.c')) {
1568 $create_table = true;
1569 }
1570 if(self::$autodb == "") {
1571 try {
1572 self::$autodb = new PDO('sqlite:'.self::getPath().'/phpfastcache.c');
1573 self::$autodb->setAttribute(PDO::ATTR_ERRMODE,
1574 PDO::ERRMODE_EXCEPTION);
1575
1576 } catch (PDOexception $e) {
1577 die("Please CHMOD 0777 or Writable Permission for ".self::getPath());
1578 }
1579
1580 }
1581
1582 if($create_table == true) {
1583 self::$autodb->exec('CREATE TABLE IF NOT EXISTS "main"."db" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE , "item" VARCHAR NOT NULL UNIQUE , "dbname" INTEGER NOT NULL )');
1584 }
1585
1586 $db = self::$autodb->prepare("SELECT * FROM `db` WHERE `item`=:item");
1587 $db->execute(array(
1588 ":item" => $res['item'],
1589 ));
1590 $row = $db->fetch(PDO::FETCH_ASSOC);
1591 if(isset($row['dbname'])) {
1592 // found key
1593 $res['db'] = $row['dbname'];
1594 } else {
1595 // not key // check filesize
1596 if((Int)self::$autosize < 10) {
1597 self::$autosize = 10;
1598 }
1599 // get last key
1600 $db = self::$autodb->prepare("SELECT * FROM `db` ORDER BY `id` DESC");
1601 $db->execute();
1602 $row = $db->fetch(PDO::FETCH_ASSOC);
1603 $dbname = isset($row['dbname']) ? $row['dbname'] : 1;
1604 $fsize = file_exists(self::getPath()."/".$dbname.".cache") ? filesize(self::getPath()."/".$dbname.".cache") : 0;
1605 if($fsize > (1024*1024*(Int)self::$autosize)) {
1606 $dbname = (Int)$dbname + 1;
1607 }
1608 try {
1609 $insert = self::$autodb->prepare("INSERT INTO `db` (`item`,`dbname`) VALUES(:item,:dbname)");
1610 $insert->execute(array(
1611 ":item" => $res['item'],
1612 ":dbname" => $dbname
1613 ));
1614 } catch (PDOexception $e) {
1615 die('Database Error - Check A look at self::$autodb->prepare("INSERT INTO ');
1616 }
1617
1618 $res['db'] = $dbname;
1619
1620 }
1621 }
1622
1623 return $res;
1624
1625 }
1626
1627 private static function pdo_get($name) {
1628 $db = self::selectDB($name);
1629 $name = $db['item'];
1630 // array('db'=>$db['db'])
1631
1632 // self::startDebug($db,"",__LINE__,__FUNCTION__);
1633
1634 $stm = self::db(array('db'=>$db['db']))->prepare("SELECT * FROM ".self::$table." WHERE `name`='".$name."'");
1635 $stm->execute();
1636 $res = $stm->fetch(PDO::FETCH_ASSOC);
1637
1638 if(!isset($res['value'])) {
1639 return null;
1640 } elseif((Int)$res['added'] + (Int)$res['endin'] <= (Int)@date("U")) {
1641 return null;
1642 } else {
1643 // decode value on SQL;
1644 $data = self::decode($res['value']);
1645 // check if VALUE on string encode
1646 return isset($data['value']) ? $data['value'] : null;
1647 }
1648 }
1649
1650 private static function pdo_decrement($name, $step = 1) {
1651 $db = self::selectDB($name);
1652 $name = $db['item'];
1653 // array('db'=>$db['db'])
1654
1655 $int = self::get($name);
1656 try {
1657 $stm = self::db(array('db'=>$db['db']))->prepare("UPDATE ".self::$table." SET `value`=:new WHERE `name`=:name ");
1658 $stm->execute(array(
1659 ":new" => self::encode($int - $step),
1660 ":name" => $name,
1661 ));
1662
1663 } catch (PDOexception $e) {
1664 die("Sorry! phpFastCache don't allow this type of value - Name: ".$name." -> Decrement: ".$step);
1665 }
1666 return $int - $step;
1667
1668 }
1669
1670 private static function pdo_increment($name ,$step = 1) {
1671 $db = self::selectDB($name);
1672 $name = $db['item'];
1673 // array('db'=>$db['db'])
1674
1675 $int = self::get($name);
1676 // echo $int."xxx";
1677 try {
1678 $stm = self::db(array('db'=>$db['db']))->prepare("UPDATE ".self::$table." SET `value`=:new WHERE `name`=:name ");
1679 $stm->execute(array(
1680 ":new" => self::encode($int + $step),
1681 ":name" => $name,
1682 ));
1683
1684 } catch (PDOexception $e) {
1685 die("Sorry! phpFastCache don't allow this type of value - Name: ".$name." -> Increment: ".$step);
1686 }
1687 return $int + $step;
1688
1689 }
1690
1691 private static function pdo_delete($name) {
1692 $db = self::selectDB($name);
1693 $name = $db['item'];
1694
1695 return self::db(array('db'=>$db['db']))->exec("DELETE FROM ".self::$table." WHERE `name`='".$name."'");
1696 }
1697
1698 private static function pdo_set($name,$value,$time_in_second = 600, $skip_if_existing = false) {
1699 $db = self::selectDB($name);
1700 $name = $db['item'];
1701 // array('db'=>$db['db'])
1702
1703 if($skip_if_existing == true) {
1704 try {
1705 $insert = self::db(array('db'=>$db['db']))->prepare("INSERT OR IGNORE INTO ".self::$table." (name,value,added,endin) VALUES(:name,:value,:added,:endin)");
1706 try {
1707 $value = self::encode($value);
1708 } catch(Exception $e) {
1709 die("Sorry! phpFastCache don't allow this type of value - Name: ".$name);
1710 }
1711
1712 $insert->execute(array(
1713 ":name" => $name,
1714 ":value" => $value,
1715 ":added" => @date("U"),
1716 ":endin" => (Int)$time_in_second
1717 ));
1718
1719 return true;
1720 } catch (PDOexception $e) {
1721 return false;
1722 }
1723
1724 } else {
1725 try {
1726 $insert = self::db(array('db'=>$db['db']))->prepare("INSERT OR REPLACE INTO ".self::$table." (name,value,added,endin) VALUES(:name,:value,:added,:endin)");
1727 try {
1728 $value = self::encode($value);
1729 } catch(Exception $e) {
1730 die("Sorry! phpFastCache don't allow this type of value - Name: ".$name);
1731 }
1732
1733 $insert->execute(array(
1734 ":name" => $name,
1735 ":value" => $value,
1736 ":added" => @date("U"),
1737 ":endin" => (Int)$time_in_second
1738 ));
1739
1740 return true;
1741 } catch (PDOexception $e) {
1742 return false;
1743 }
1744 }
1745 }
1746
1747
1748
1749 private static function db($option = array()) {
1750 $vacuum = false;
1751 $dbname = isset($option['db']) ? $option['db'] : "";
1752 $dbname = $dbname != "" ? $dbname : self::$filename;
1753 if($dbname!=self::$filename) {
1754 $dbname = $dbname.".cache";
1755 }
1756 // debuging
1757 // self::startDebug(self::$storage,"Check Storage",__LINE__,__FUNCTION__);
1758 $initDB = false;
1759
1760 if(self::$storage == "pdo") {
1761 // start self PDO
1762 if(self::$objects['pdo']=="") {
1763
1764 // self::$objects['pdo'] == new PDO("sqlite:".self::$path."/cachedb.sqlite");
1765 if(!file_exists(self::getPath()."/".$dbname)) {
1766 $initDB = true;
1767 } else {
1768 if(!is_writable(self::getPath()."/".$dbname)) {
1769 @chmod(self::getPath()."/".$dbname,0777);
1770 if(!is_writable(self::getPath()."/".$dbname)) {
1771 die("Please CHMOD 0777 or any Writable Permission for ".self::getPath()."/".$dbname);
1772 }
1773 }
1774 }
1775
1776
1777
1778 try {
1779 self::$objects['pdo'] = new PDO("sqlite:".self::getPath()."/".$dbname);
1780 self::$objects['pdo']->setAttribute(PDO::ATTR_ERRMODE,
1781 PDO::ERRMODE_EXCEPTION);
1782
1783 if($initDB == true) {
1784 self::initDatabase();
1785 }
1786
1787 $time = filemtime(self::getPath()."/".$dbname);
1788 if($time + (3600*24) < @date("U")) {
1789 $vacuum = true;
1790 }
1791
1792 // Revision 619
1793 // auto Vaccuum() every 48 hours
1794 if($vacuum == true) {
1795 if(!isset($option['skip_clean'])) {
1796 self::$objects['pdo']->exec("DELETE FROM ".self::$table." WHERE (`added` + `endin`) < ".@date("U"));
1797 }
1798 self::$objects['pdo']->exec('VACUUM');
1799 }
1800
1801
1802
1803 } catch (PDOexception $e) {
1804 die("Can't connect to caching file ".self::getPath()."/".$dbname);
1805 }
1806
1807
1808
1809
1810
1811
1812 return self::$objects['pdo'];
1813
1814 } else {
1815 return self::$objects['pdo'];
1816 }
1817 // end self pdo
1818
1819 } elseif(self::$storage == "mpdo") {
1820
1821 // start self PDO
1822 if(!isset(self::$multiPDO[$dbname])) {
1823 // self::$objects['pdo'] == new PDO("sqlite:".self::$path."/cachedb.sqlite");
1824 if(self::$path!="memory") {
1825 if(!file_exists(self::getPath()."/".$dbname)) {
1826 $initDB = true;
1827 } else {
1828 if(!is_writable(self::getPath()."/".$dbname)) {
1829 @chmod(self::getPath()."/".$dbname,0777);
1830 if(!is_writable(self::getPath()."/".$dbname)) {
1831 die("Please CHMOD 0777 or any Writable Permission for PATH ".self::getPath());
1832 }
1833 }
1834 }
1835
1836
1837
1838 try {
1839 self::$multiPDO[$dbname] = new PDO("sqlite:".self::getPath()."/".$dbname);
1840 self::$multiPDO[$dbname]->setAttribute(PDO::ATTR_ERRMODE,
1841 PDO::ERRMODE_EXCEPTION);
1842
1843 if($initDB == true) {
1844 self::initDatabase(self::$multiPDO[$dbname]);
1845 }
1846
1847 $time = filemtime(self::getPath()."/".$dbname);
1848 if($time + (3600*24) < @date("U")) {
1849 $vacuum = true;
1850 }
1851
1852 // Revision 619
1853 if($vacuum == true) {
1854 if(!isset($option['skip_clean'])) {
1855 self::$multiPDO[$dbname]->exec("DELETE FROM ".self::$table." WHERE (`added` + `endin`) < ".@date("U"));
1856 }
1857 self::$multiPDO[$dbname]->exec('VACUUM');
1858 }
1859
1860 } catch (PDOexception $e) {
1861 // Revision 619
1862 die("Can't connect to caching file ".self::getPath()."/".$dbname);
1863 }
1864
1865
1866 }
1867
1868
1869
1870
1871 return self::$multiPDO[$dbname];
1872
1873 } else {
1874 return self::$multiPDO[$dbname];
1875 }
1876 // end self pdo
1877
1878 }
1879
1880
1881
1882
1883
1884 }
1885
1886 private static function initDatabase($object = null) {
1887 if($object == null) {
1888 self::db(array("skip_clean" => true))->exec('CREATE TABLE IF NOT EXISTS "'.self::$table.'" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE , "name" VARCHAR UNIQUE NOT NULL , "value" BLOB, "added" INTEGER NOT NULL DEFAULT 0, "endin" INTEGER NOT NULL DEFAULT 0)');
1889 self::db(array("skip_clean" => true))->exec('CREATE INDEX "lookup" ON "'.self::$table.'" ("added" ASC, "endin" ASC)');
1890 self::db(array("skip_clean" => true))->exec('VACUUM');
1891 } else {
1892 $object->exec('CREATE TABLE IF NOT EXISTS "'.self::$table.'" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL UNIQUE , "name" VARCHAR UNIQUE NOT NULL , "value" BLOB, "added" INTEGER NOT NULL DEFAULT 0, "endin" INTEGER NOT NULL DEFAULT 0)');
1893 $object->exec('CREATE INDEX "lookup" ON "'.self::$table.'" ("added" ASC, "endin" ASC)');
1894 $object->exec('VACUUM');
1895 }
1896 }
1897
1898 // send all bugs to my email
1899 // you can replace it to your email
1900 // maximum 1 email per hour
1901 // you can use phpFastCache::bugs($title, $e) in any code
1902 public static function bugs($title, $e) {
1903 $code = md5("error_".$title);
1904 $send = self::get($code);
1905 if($send == null) {
1906 $to = "khoaofgod@yahoo.com";
1907 $subject = "Bugs: ".$title;
1908 $message = "Error Serialize:".serialize($e);
1909 $from = "root@".$_SERVER['HTTP_HOST'];
1910 $headers = "From:" . $from;
1911 @mail($to,$subject,$message,$headers);
1912 self::set($code,1,3600);
1913 }
1914 }
1915
1916 // use for debug
1917 // public function, you can use phpFastCache::debug($e|array|string) any time in any code
1918 public static function debug($e, $exit = false) {
1919 echo "<pre>";
1920 print_r($e);
1921 echo "</pre>";
1922 if($exit == true) {
1923 exit;
1924 }
1925 }
1926
1927 public static function startDebug($value,$text = "", $line = __LINE__, $func = __FUNCTION__) {
1928 if(self::$debugging == true) {
1929 self::$step_debugging++;
1930 if(!is_array($value)) {
1931 echo "<br>".self::$step_debugging." => ".$line." | ".$func." | ".$text." | ".$value;
1932 } else {
1933 echo "<br>".self::$step_debugging." => ".$line." | ".$func." | ".$text." | ";
1934 print_r($value);
1935 }
1936
1937 }
1938 }
1939
1940}