Source for file zcache.inc.php

Documentation is available at zcache.inc.php

  1. <?php
  2. /**
  3. *  This file is part of the VCL for PHP project
  4. *
  5. *  Copyright (c) 2004-2008 qadram software S.L. <support@qadram.com>
  6. *
  7. *  Checkout AUTHORS file for more information on the developers
  8. *
  9. *  This library is free software; you can redistribute it and/or
  10. *  modify it under the terms of the GNU Lesser General Public
  11. *  License as published by the Free Software Foundation; either
  12. *  version 2.1 of the License, or (at your option) any later version.
  13. *
  14. *  This library is distributed in the hope that it will be useful,
  15. *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. *  Lesser General Public License for more details.
  18. *
  19. *  You should have received a copy of the GNU Lesser General Public
  20. *  License along with this library; if not, write to the Free Software
  21. *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22. *  USA
  23. *
  24. */
  25.  
  26. require_once("vcl/vcl.inc.php");
  27. use_unit("Zend/zcommon.inc.php");
  28. use_unit("classes.inc.php");
  29. use_unit("cache.inc.php");
  30.  
  31. use_unit("Zend/framework/library/Zend/Cache.php");
  32.  
  33. define('cfCore', 'cfCore');
  34. define('cfOutput', 'cfOutput');
  35. define('cfFunction', 'cfFunction');
  36. define('cfClass', 'cfClass');
  37. define('cfFile', 'cfFile');
  38. define('cfPage', 'cfPage');
  39.  
  40. define('cbFile', 'cbFile');
  41. define('cbSQLite', 'cbSQLite');
  42. define('cbMemcached', 'cbMemcached');
  43. define('cbAPC', 'cbAPC');
  44. define('cbZendPlatform', 'cbPlatform');
  45.  
  46. define('rctCRC32', 'rctCRC32');
  47. define('rctMD5', 'rctMD5');
  48. define('rctADLER32', 'rctADLER32');
  49. define('rctSTRLEN', 'rctSTRLEN');
  50.  
  51. class ZCacheOptions extends Persistent
  52. {
  53.     protected $ZCache=null;
  54.  
  55.     function readOwner()
  56.     {
  57.         return($this->ZCache);
  58.     }
  59.  
  60.     function __construct($aowner)
  61.     {
  62.         parent::__construct();
  63.  
  64.         $this->ZCache=$aowner;
  65.     }
  66. }
  67.  
  68. class ZCacheFrontendFunctionOptions extends ZCacheOptions
  69. {
  70.       protected $_cachebydefault = "1";
  71.  
  72.       function getCacheByDefault() { return $this->_cachebydefault; }
  73.       function setCacheByDefault($value) { $this->_cachebydefault = $value; }
  74.       function defaultCacheByDefault() { return "1"; }
  75.  
  76.       protected $_cachedfunctions = array();
  77.  
  78.       function getCachedFunctions() { return $this->_cachedfunctions; }
  79.       function setCachedFunctions($value) { $this->_cachedfunctions = $value; }
  80.       function defaultCachedFunctions() { return array(); }
  81.  
  82.       protected $_noncachedfunctions = array();
  83.  
  84.       function getNonCachedFunctions() { return $this->_noncachedfunctions; }
  85.       function setNonCachedFunctions($value) { $this->_noncachedfunctions = $value; }
  86.       function defaultNonCachedFunctions() { return array(); }
  87. }
  88.  
  89. class ZCacheFrontendClassOptions extends ZCacheOptions
  90. {
  91.     protected $_cachedentity="";
  92.  
  93.     function getCachedEntity() { return $this->_cachedentity; }
  94.     function setCachedEntity($value) { $this->_cachedentity=$value; }
  95.     function defaultCachedEntity() { return ""; }
  96.  
  97.     protected $_cachebydefault="1";
  98.  
  99.     function getCacheByDefault() { return $this->_cachebydefault; }
  100.     function setCacheByDefault($value) { $this->_cachebydefault=$value; }
  101.     function defaultCacheByDefault() { return "1"; }
  102.  
  103.     protected $_cachedmethods=array();
  104.  
  105.     function getCachedMethods() { return $this->_cachedmethods; }
  106.     function setCachedMethods($value) { $this->_cachedmethods=$value; }
  107.     function defaultCachedMethods() { return array(); }
  108.  
  109.     protected $_noncachedmethods=array();
  110.  
  111.     function getNonCachedMethods() { return $this->_noncachedmethods; }
  112.     function setNonCachedMethods($value) { $this->_noncachedmethods=$value; }
  113.     function defaultNonCachedMethods() { return array(); }
  114. }
  115.  
  116. class ZCacheFrontendFileOptions extends ZCacheOptions
  117. {
  118.     protected $_masterfile="";
  119.  
  120.     function getMasterFile() { return $this->_masterfile; }
  121.     function setMasterFile($value) { $this->_masterfile=$value; }
  122.     function defaultMasterFile() { return ""; }
  123.  
  124.  
  125. }
  126.  
  127. class ZCacheFrontendPageOptions extends ZCacheOptions
  128. {
  129.     protected $_httpconditional="0";
  130.  
  131.     function getHTTPConditional() { return $this->_httpconditional; }
  132.     function setHTTPConditional($value) { $this->_httpconditional=$value; }
  133.     function defaultHTTPConditional() { return "0"; }
  134.  
  135.     protected $_debugheader="0";
  136.  
  137.     function getDebugHeader() { return $this->_debugheader; }
  138.     function setDebugHeader($value) { $this->_debugheader=$value; }
  139.     function defaultDebugHeader() { return "0"; }
  140.  
  141.     protected $_enabled="1";
  142.  
  143.     function getEnabled() { return $this->_enabled; }
  144.     function setEnabled($value) { $this->_enabled=$value; }
  145.     function defaultEnabled() { return "1"; }
  146.  
  147.     protected $_cachewithget="0";
  148.  
  149.     function getCacheWithGET() { return $this->_cachewithget; }
  150.     function setCacheWithGET($value) { $this->_cachewithget=$value; }
  151.     function defaultCacheWithGET() { return "0"; }
  152.  
  153.     protected $_cachewithpost="0";
  154.  
  155.     function getCacheWithPOST() { return $this->_cachewithpost; }
  156.     function setCacheWithPOST($value) { $this->_cachewithpost=$value; }
  157.     function defaultCacheWithPOST() { return "0"; }
  158.  
  159.     protected $_cachewithsession="0";
  160.  
  161.     function getCacheWithSESSION() { return $this->_cachewithsession; }
  162.     function setCacheWithSESSION($value) { $this->_cachewithsession=$value; }
  163.     function defaultCacheWithSESSION() { return "0"; }
  164.  
  165.     protected $_cachewithcookie="0";
  166.  
  167.     function getCacheWithCOOKIE() { return $this->_cachewithcookie; }
  168.     function setCacheWithCOOKIE($value) { $this->_cachewithcookie=$value; }
  169.     function defaultCacheWithCOOKIE() { return "0"; }
  170.  
  171.     protected $_idwithget="1";
  172.  
  173.     function getIDWithGET() { return $this->_idwithget; }
  174.     function setIDWithGET($value) { $this->_idwithget=$value; }
  175.     function defaultIDWithGET() { return "1"; }
  176.  
  177.     protected $_idwithpost="1";
  178.  
  179.     function getIDWithPOST() { return $this->_idwithpost; }
  180.     function setIDWithPOST($value) { $this->_idwithpost=$value; }
  181.     function defaultIDWithPOST() { return "1"; }
  182.  
  183.     protected $_idwithsession="1";
  184.  
  185.     function getIDWithSESSION() { return $this->_idwithsession; }
  186.     function setIDWithSESSION($value) { $this->_idwithsession=$value; }
  187.     function defaultIDWithSESSION() { return "1"; }
  188.  
  189.     protected $_idwithfiles="1";
  190.  
  191.     function getIDWithFiles() { return $this->_idwithfiles; }
  192.     function setIDWithFiles($value) { $this->_idwithfiles=$value; }
  193.     function defaultIDWithFiles() { return "1"; }
  194.  
  195.     protected $_idwithcookie="1";
  196.  
  197.     function getIDWithCOOKIE() { return $this->_idwithcookie; }
  198.     function setIDWithCOOKIE($value) { $this->_idwithcookie=$value; }
  199.     function defaultIDWithCOOKIE() { return "1"; }
  200.  
  201.  
  202.  
  203.  
  204.  
  205.     protected $_regexps=array();
  206.  
  207.     function getRegExps() { return $this->_regexps; }
  208.     function setRegExps($value) { $this->_regexps=$value; }
  209.     function defaultRegExps() { return array(); }
  210. }
  211.  
  212. class ZCacheBackendSQLiteOptions extends ZCacheOptions
  213. {
  214.     protected $_databasepath="";
  215.  
  216.     function getDatabasePath() { return $this->_databasepath; }
  217.     function setDatabasePath($value) { $this->_databasepath=$value; }
  218.     function defaultDatabasePath() { return ""; }
  219.  
  220.     protected $_vacuumfactor=10;
  221.  
  222.     function getVacuumFactor() { return $this->_vacuumfactor; }
  223.     function setVacuumFactor($value) { $this->_vacuumfactor=$value; }
  224.     function defaultVacuumFactor() { return 10; }
  225. }
  226.  
  227. class ZCacheBackendMemcachedOptions extends ZCacheOptions
  228. {
  229.     protected $_servers=array();
  230.  
  231.     function getServers() { return $this->_servers; }
  232.     function setServers($value) { $this->_servers=$value; }
  233.     function defaultServers() { return array(); }
  234.  
  235.     protected $_compression="0";
  236.  
  237.     function getCompression() { return $this->_compression; }
  238.     function setCompression($value) { $this->_compression=$value; }
  239.     function defaultCompression() { return "0"; }
  240.  
  241.  
  242. }
  243.  
  244. class ZCache extends Cache
  245. {
  246.       public $zend_cache=null;
  247.  
  248.       function startCache($control, $cachetype)
  249.       {
  250.           $id=$control->readNamePath().'_'.$cachetype;
  251.         $id=str_replace('.','_',$id);
  252.           return($this->start($id));
  253.       }
  254.  
  255.       function endCache()
  256.       {
  257.           $this->end();
  258.       }
  259.  
  260.       function load($id, $doNotTestCacheValidity = false, $doNotUnserialize = false)
  261.       {
  262.           return($this->zend_cache->load($id, $doNotTestCacheValidity, $doNotUnserialize));
  263.       }
  264.  
  265.       function save($data, $id = null, $tags = array(), $specificLifetime = false)
  266.       {
  267.           return($this->zend_cache->save($data, $id, $tags, $specificLifetime));
  268.       }
  269.  
  270.       function start($id, $doNotTestCacheValidity = false)
  271.       {
  272.           return($this->zend_cache->start($id, $doNotTestCacheValidity));
  273.       }
  274.  
  275.       function end($tags = array(), $specificLifetime = false)
  276.       {
  277.           return($this->zend_cache->end($tags, $specificLifetime));
  278.       }
  279.  
  280.       function remove($id)
  281.       {
  282.           return($this->zend_cache->remove($id));
  283.       }
  284.  
  285.       function cleanAll()
  286.       {
  287.           return($this->zend_cache->clean(Zend_Cache::CLEANING_MODE_ALL));
  288.       }
  289.  
  290.       function cleanOld()
  291.       {
  292.           return($this->zend_cache->clean(Zend_Cache::CLEANING_MODE_OLD));
  293.       }
  294.  
  295.       function cleanMatching($tags)
  296.       {
  297.           return($this->zend_cache->clean(Zend_Cache::CLEANING_MODE_MATCHING_TAG, $tags));
  298.       }
  299.  
  300.       function cleanNotMatching($tags)
  301.       {
  302.           return($this->zend_cache->clean(Zend_Cache::CLEANING_MODE_NOT_MATCHING_TAG, $tags));
  303.       }
  304.  
  305.       function call($name, $parameters = array(), $tags = array(), $specificLifetime = false)
  306.       {
  307.           return($this->zend_cache->call($name, $parameters, $tags, $specificLifetime));
  308.       }
  309.  
  310.  
  311.       function preinit()
  312.       {
  313.             $frontend='Output';
  314.             $backend='File';
  315.  
  316.             $frontendOptions=array();
  317.             $backendOptions=array();
  318.  
  319.             //Frontend common properties
  320.             $frontendOptions['caching']=$this->_enabled;
  321.             $frontendOptions['cache_id_prefix']=$this->_prefix;
  322.             $frontendOptions['lifetime']=$this->_lifetime;
  323.             $frontendOptions['logging']=$this->_logging;
  324.             $frontendOptions['write_control']=$this->_checkwrite;
  325.             $frontendOptions['automatic_serialization']=$this->_serialization;
  326.             $frontendOptions['automatic_cleaning_factor']=$this->_cleaningfactor;
  327.             $frontendOptions['ignore_user_abort']=$this->_ignoreuserabort;
  328.  
  329.             //Backend common properties
  330.             $backendOptions['cache_dir']=$this->_cachedir;
  331.             $backendOptions['file_locking']=$this->_filelocking;
  332.             $backendOptions['read_control']=$this->_checkread;
  333.  
  334.             //Convert read control type
  335.             $rct='crc32';
  336.             switch ($this->_readcontroltype) {
  337.                 case rctCRC32:  $rct='crc32'; break;
  338.                 case rctADLER32:  $rct='adler32'; break;
  339.                 case rctMD5:  $rct='md5'; break;
  340.                 case rctSTRLEN:  $rct='strlen'; break;
  341.             }
  342.             $backendOptions['read_control_type']=$rct;
  343.             $backendOptions['hashed_directory_level']=$this->_hasheddirectorylevel;
  344.             $backendOptions['hashed_directory_umask']=$this->_hasheddirectoryumask;
  345.             $backendOptions['file_name_prefix']=$this->_filenameprefix;
  346.             $backendOptions['cache_file_umask']=$this->_cachefileumask;
  347.             $backendOptions['metadatas_array_max_size']=$this->_metadatasize;
  348.  
  349.             switch ($this->_frontend)
  350.             {
  351.                 case cfCore:
  352.                 $frontend='Core';
  353.                 break;
  354.  
  355.                 case cfOutput:
  356.                 $frontend='Output';
  357.                 break;
  358.  
  359.                 case cfFunction:
  360.                 $frontend='Function';
  361.                 break;
  362.  
  363.                 case cfClass:
  364.                 $frontend='Class';
  365.                 break;
  366.  
  367.                 case cfFile:
  368.                 $frontend='File';
  369.                 break;
  370.  
  371.                 case cfPage:
  372.                 $frontend='Page';
  373.                 break;
  374.             }
  375.  
  376.             switch ($this->_backend)
  377.             {
  378.                 case cbFile:
  379.                 $backend='File';
  380.                 break;
  381.  
  382.                 case cbSQLite:
  383.                 $backend='Sqlite';
  384.                 break;
  385.  
  386.                 case cbMemcached:
  387.                 $backend='Memcached';
  388.                 break;
  389.  
  390.                 case cbAPC:
  391.                 $backend='Apc';
  392.                 break;
  393.  
  394.                 case cbZendPlatform:
  395.                 $backend='Zend Platform';
  396.                 break;
  397.             }
  398.  
  399.             $this->zend_cache=Zend_Cache::factory($frontend, $backend, $frontendOptions, $backendOptions);
  400.  
  401.             //Clean all cache when session is restored
  402.             if (isset($_GET['restore_session']))
  403.             {
  404.                 if (!isset($_POST['xajax']))
  405.                 {
  406.                     $this->cleanAll();
  407.                 }
  408.             }
  409.       }
  410.  
  411.       function __construct($aowner = null)
  412.       {
  413.             //Calls inherited constructor
  414.             parent::__construct($aowner);
  415.  
  416.             //Frontend properties
  417.             $this->_frontendfunctionoptions= new ZCacheFrontendFunctionOptions($this);
  418.             $this->_frontendclassoptions= new ZCacheFrontendClassOptions($this);
  419.             $this->_frontendfileoptions= new ZCacheFrontendFileOptions($this);
  420.             $this->_frontendpageoptions= new ZCacheFrontendPageOptions($this);
  421.  
  422.             //Backend properties
  423.             $this->_backendsqliteoptions=new ZCacheBackendSQLiteOptions($this);
  424.             $this->_backendmemcachedoptions=new ZCacheBackendMemcachedOptions($this);
  425.       }
  426.  
  427.       protected $_frontend = cfOutput;
  428.  
  429.       function getFrontend() { return $this->_frontend; }
  430.       function setFrontend($value) { $this->_frontend = $value; }
  431.       function defaultFrontend() { return cfOutput; }
  432.  
  433.       protected $_backend = cbFile;
  434.  
  435.       function getBackend() { return $this->_backend; }
  436.       function setBackend($value) { $this->_backend = $value; }
  437.       function defaultBackend() { return cbFile; }
  438.  
  439.       //Frontend properties
  440.       protected $_enabled = "1";
  441.  
  442.       function getEnabled() { return $this->_enabled; }
  443.       function setEnabled($value) { $this->_enabled = $value; }
  444.       function defaultEnabled() { return "1"; }
  445.  
  446.       protected $_prefix = "";
  447.  
  448.       function getPrefix() { return $this->_prefix; }
  449.       function setPrefix($value) { $this->_prefix = $value; }
  450.       function defaultPrefix() { return ""; }
  451.  
  452.       protected $_lifetime = 3600;
  453.  
  454.       function getLifetime() { return $this->_lifetime; }
  455.       function setLifetime($value) { $this->_lifetime = $value; }
  456.       function defaultLifetime() { return 3600; }
  457.  
  458.       protected $_logging = "0";
  459.  
  460.       function getLogging() { return $this->_logging; }
  461.       function setLogging($value) { $this->_logging = $value; }
  462.       function defaultLogging() { return "0"; }
  463.  
  464.       protected $_checkwrite = "1";
  465.  
  466.       function getCheckWrite() { return $this->_checkwrite; }
  467.       function setCheckWrite($value) { $this->_checkwrite = $value; }
  468.       function defaultCheckWrite() { return "1"; }
  469.  
  470.       protected $_serialization = "0";
  471.  
  472.       function getSerialization() { return $this->_serialization; }
  473.       function setSerialization($value) { $this->_serialization = $value; }
  474.       function defaultSerialization() { return "0"; }
  475.  
  476.       protected $_cleaningfactor = 10;
  477.  
  478.       function getCleaningFactor() { return $this->_cleaningfactor; }
  479.       function setCleaningFactor($value) { $this->_cleaningfactor = $value; }
  480.       function defaultCleaningFactor() { return 10; }
  481.  
  482.       protected $_ignoreuserabort = "0";
  483.  
  484.       function getIgnoreUserAbort() { return $this->_ignoreuserabort; }
  485.       function setIgnoreUserAbort($value) { $this->_ignoreuserabort = $value; }
  486.       function defaultIgnoreUserAbort() { return "0"; }
  487.  
  488.       //Backend properties
  489.       protected $_cachedir = '/tmp/';
  490.  
  491.       function getCacheDir() { return $this->_cachedir; }
  492.       function setCacheDir($value) { $this->_cachedir = $value; }
  493.       function defaultCacheDir() { return '/tmp/'; }
  494.  
  495.       protected $_filelocking = "1";
  496.  
  497.       function getFileLocking() { return $this->_filelocking; }
  498.       function setFileLocking($value) { $this->_filelocking = $value; }
  499.       function defaultFileLocking() { return "1"; }
  500.  
  501.       protected $_checkread = "1";
  502.  
  503.       function getCheckRead() { return $this->_checkread; }
  504.       function setCheckRead($value) { $this->_checkread = $value; }
  505.       function defaultCheckRead() { return "1"; }
  506.  
  507.       protected $_readcontroltype = rctCRC32;
  508.  
  509.       function getReadControlType() { return $this->_readcontroltype; }
  510.       function setReadControlType($value) { $this->_readcontroltype = $value; }
  511.       function defaultReadControlType() { return rctCRC32; }
  512.  
  513.       protected $_hasheddirectorylevel = 0;
  514.  
  515.       function getHashedDirectoryLevel() { return $this->_hasheddirectorylevel; }
  516.       function setHashedDirectoryLevel($value) { $this->_hasheddirectorylevel = $value; }
  517.       function defaultHashedDirectoryLevel() { return 0; }
  518.  
  519.       protected $_hasheddirectoryumask = '700';
  520.  
  521.       function getHashedDirectoryUmask() { return $this->_hasheddirectoryumask; }
  522.       function setHashedDirectoryUmask($value) { $this->_hasheddirectoryumask = $value; }
  523.       function defaultHashedDirectoryUmask() { return '700'; }
  524.  
  525.       protected $_filenameprefix = 'zend_cache';
  526.  
  527.       function getFileNamePrefix() { return $this->_filenameprefix; }
  528.       function setFileNamePrefix($value) { $this->_filenameprefix = $value; }
  529.       function defaultFileNamePrefix() { return 'zend_cache'; }
  530.  
  531.       protected $_cachefileumask = '700';
  532.  
  533.       function getCacheFileUmask() { return $this->_cachefileumask; }
  534.       function setCacheFileUmask($value) { $this->_cachefileumask = $value; }
  535.       function defaultCacheFileUmask() { return '700'; }
  536.  
  537.       protected $_metadatasize = 100;
  538.  
  539.       function getMetadataSize() { return $this->_metadatasize; }
  540.       function setMetadataSize($value) { $this->_metadatasize = $value; }
  541.       function defaultMetadataSize() { return 100; }
  542.  
  543.       //Options for FrontEnds
  544.       protected $_frontendfunctionoptions = null;
  545.  
  546.       function getFrontendFunctionOptions() { return $this->_frontendfunctionoptions; }
  547.       function setFrontendFunctionOptions($value) { $this->_frontendfunctionoptions = $value; }
  548.       function defaultFrontendFunctionOptions() { return null; }
  549.  
  550.     protected $_frontendclassoptions=null;
  551.  
  552.     function getFrontendClassOptions() { return $this->_frontendclassoptions; }
  553.     function setFrontendClassOptions($value) { $this->_frontendclassoptions=$value; }
  554.     function defaultFrontendClassOptions() { return null; }
  555.  
  556.     protected $_frontendfileoptions=null;
  557.  
  558.     function getFrontendFileOptions() { return $this->_frontendfileoptions; }
  559.     function setFrontendFileOptions($value) { $this->_frontendfileoptions=$value; }
  560.     function defaultFrontendFileOptions() { return null; }
  561.  
  562.     protected $_frontendpageoptions=null;
  563.  
  564.     function getFrontendPageOptions() { return $this->_frontendpageoptions; }
  565.     function setFrontendPageOptions($value) { $this->_frontendpageoptions=$value; }
  566.     function defaultFrontendPageOptions() { return null; }
  567.  
  568.     protected $_backendsqliteoptions=null;
  569.  
  570.     function getBackendSQLiteOptions() { return $this->_backendsqliteoptions; }
  571.     function setBackendSQLiteOptions($value) { $this->_backendsqliteoptions=$value; }
  572.     function defaultBackendSQLiteOptions() { return null; }
  573.  
  574.     protected $_backendmemcachedoptions=null;
  575.  
  576.     function getBackendMemcachedOptions() { return $this->_backendmemcachedoptions; }
  577.     function setBackendMemcachedOptions($value) { $this->_backendmemcachedoptions=$value; }
  578.     function defaultBackendMemcachedOptions() { return null; }
  579.  
  580. }
  581.  
  582. ?>
Documentation generated on Fri, 26 Dec 2008 11:46:55 +0100 by phpDocumentor 1.4.0a2