ForwardFW
[ class tree: ForwardFW ] [ index: ForwardFW ] [ all elements ]
Packages:
ForwardFW

Source for file Frontend.php

Documentation is available at Frontend.php

  1. <?php
  2. declare(encoding = "utf-8");
  3. /**
  4.  * This file is part of ForwardFW a web application framework.
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  * PHP version 5
  21.  *
  22.  * @category   Cache
  23.  * @package    ForwardFW
  24.  * @subpackage Main
  25.  * @author     Alexander Opitz <opitz.alexander@primacom.net>
  26.  * @copyright  2009-2010 The Authors
  27.  * @license    http://www.gnu.org/copyleft/gpl.html GNU General Public License
  28.  * @version    SVN: $Id: $
  29.  * @link       http://forwardfw.sourceforge.net
  30.  * @since      File available since Release 0.0.8
  31.  */
  32.  
  33. require_once 'ForwardFW/Config/Cache/Data.php';
  34. require_once 'ForwardFW/Config/Cache/Frontend.php';
  35. require_once 'ForwardFW/Interface/Application.php';
  36. require_once 'ForwardFW/Interface/Cache/Backend.php';
  37. require_once 'ForwardFW/Interface/Cache/Frontend.php';
  38.  
  39. require_once 'ForwardFW/Cache/Exception/TimeOut.php';
  40. require_once 'ForwardFW/Cache/Exception/NoData.php';
  41. require_once 'ForwardFW/Cache/Exception/IsGenerating.php';
  42.  
  43. /**
  44.  * Interface for a Cache.
  45.  *
  46.  * @category   Cache
  47.  * @package    ForwardFW
  48.  * @subpackage Main
  49.  * @author     Alexander Opitz <opitz.alexander@primacom.net>
  50.  * @license    http://www.gnu.org/copyleft/gpl.html GNU General Public License
  51.  * @link       http://forwardfw.sourceforge.net
  52.  */
  53. abstract class ForwardFW_Cache_Frontend implements ForwardFW_Interface_Cache_Frontend
  54. {
  55.     /**
  56.      * Constructor
  57.      *
  58.      * @param ForwardFW_Interface_Application   $application The running application
  59.      * @param ForwardFW_Interface_Cache_Backend $backend     Backend instance.
  60.      *
  61.      * @return void 
  62.      */
  63.     public function __construct(
  64.         ForwardFW_Interface_Application $application,
  65.         ForwardFW_Interface_Cache_Backend $backend
  66.     ) {
  67.         $this->application = $application;
  68.         $this->backend = $backend;
  69.     }
  70.  
  71.     /**
  72.      * Builds an instance of cache
  73.      *
  74.      * @param ForwardFW_Interface_Application $application The running application
  75.      * @param ForwardFW_Config_Cache_Frontend $config      Configuration of caching
  76.      *
  77.      * @return ForwardFW_Interface_Cache_Frontend The cache Frontend
  78.      */
  79.     public static function getInstance(
  80.         ForwardFW_Interface_Application $application,
  81.         ForwardFW_Config_Cache_Frontend $config
  82.     ) {
  83.         $backend = self::getBackend(
  84.             $application,
  85.             $config->getCacheBackend(),
  86.             $config->getBackendConfig()
  87.         );
  88.         $frontend = self::getFrontend($application, $config, $backend);
  89.         return $frontend;
  90.     }
  91.  
  92.     /**
  93.      * Builds Backend of a cache configuration
  94.      *
  95.      * @param ForwardFW_Interface_Application $application     The running application
  96.      * @param string                          $strCacheBackend Configuration of caching
  97.      * @param ForwardFW_Config_Cache_Backend  $config          Configuration of caching
  98.      *
  99.      * @return ForwardFW_Interface_Cache_Backend Caching Backend.
  100.      */
  101.     public static function getBackend(
  102.         ForwardFW_Interface_Application $application,
  103.         $strCacheBackend,
  104.         ForwardFW_Config_Cache_Backend $config
  105.     ) {
  106.         if (isset($GLOBALS['Cache']['backend'][$strCacheBackend])) {
  107.             $return = $GLOBALS['Cache']['backend'][$strCacheBackend];
  108.         } else {
  109.             include_once str_replace('_', '/', $strCacheBackend) . '.php';
  110.             $return = new $strCacheBackend($application, $config);
  111.             $GLOBALS['Cache']['backend'][$strCacheBackend] = $return;
  112.         }
  113.         return $return;
  114.     }
  115.  
  116.     /**
  117.      * Builds Backend of a cache configuration
  118.      *
  119.      * @param ForwardFW_Interface_Application   $application The running application
  120.      * @param ForwardFW_Config_Cache_Frontend   $config      Configuration of caching
  121.      * @param ForwardFW_Interface_Cache_Backend $backend     Backend for the frontend
  122.      *
  123.      * @return ForwardFW_Interface_Cache_Frontend Caching Frontend.
  124.      */
  125.     public static function getFrontend(
  126.         ForwardFW_Interface_Application $application,
  127.         ForwardFW_Config_Cache_Frontend $config,
  128.         ForwardFW_Interface_Cache_Backend $backend
  129.     ) {
  130.         $class = $config->getCacheFrontend();
  131.         if (isset($GLOBALS['Cache']['frontend'][$class])) {
  132.             $return = $GLOBALS['Cache']['frontend'][$class];
  133.         } else {
  134.             include_once str_replace('_', '/', $class) . '.php';
  135.             $return = new $class($application, $backend);
  136.             $GLOBALS['Cache']['frontend'][$class] = $return;
  137.         }
  138.         return $return;
  139.     }
  140.  
  141.     /**
  142.      * Returns content from cache or gathers the data
  143.      *
  144.      * @param ForwardFW_Config_Cache_Data $config What data should be get from cache
  145.      *
  146.      * @return mixed The data you requested.
  147.      */
  148.     public function getCache(ForwardFW_Config_Cache_Data $config)
  149.     {
  150.         $strHash = $this->calculateHash($config);
  151.         switch ($config->getTimeout()) {
  152.         case -1:
  153.             $nTime = 0;
  154.             break;
  155.         case 0:
  156.             $nTime = time();
  157.             break;
  158.         default:
  159.             $nTime = time() - $config->getTimeout();
  160.         }
  161.         try {
  162.             $mData = $this->backend->getData($strHash, $nTime);
  163.         } catch (ForwardFW_Cache_Exception_NoData $eNoData) {
  164.             $mData = $this->getRealData($strHash, $config, false);
  165.         } catch (ForwardFW_Cache_Exception_TimeOut $eTimeOut) {
  166.             $mData = $this->getRealData($strHash, $config, true);
  167.         } catch (ForwardFW_Cache_Exception_IsGenerating $eIsGenerating) {
  168.             usleep(500);
  169.             $mData = $this->getCache($config);
  170.         }
  171.  
  172.         return $mData;
  173.     }
  174.  
  175.  
  176.     /**
  177.      * Returns the real data and add it to cache. If real data fails tries to
  178.      * get old data from cache if available.
  179.      *
  180.      * @param String                      $strHash       Hash of cache
  181.      * @param ForwardFW_Config_Cache_Data $config        What data should be get
  182.      *                                                    from cache.
  183.      * @param boolean                     $bOldAvailable True if backend has old
  184.      *                                                    data for hash.
  185.      *
  186.      * @return mixed The data you requested.
  187.      */
  188.     protected function getRealData(
  189.         $strHash, 
  190.         ForwardFW_Config_Cache_Data $config,
  191.         $bOldAvailable
  192.     ) {
  193.         try {
  194.             $mData = $this->getDataToCache($config);
  195.             $this->backend->setData($strHash, $mData);
  196.         } catch (Exception $e) {
  197.             if ($config->getReserveOld() && $bOldAvailable) {
  198.                 $mData = $this->backend->getData($strHash, 0);
  199.             }
  200.         }
  201.  
  202.         return $mData;
  203.     }
  204.  
  205.     abstract protected function calculateHash(ForwardFW_Config_Cache_Data $config);
  206.  
  207.     abstract protected function getDataToCache(ForwardFW_Config_Cache_Data $config);
  208.  
  209.     /**
  210.      * Calculates a hash by serialize and md5.
  211.      *
  212.      * @param mixed $mValue The data from which the hash should be gathered.
  213.      *
  214.      * @return string The hash.
  215.      */
  216.     public function getHash($mValue)
  217.     {
  218.         return md5(serialize($mValue));
  219.     }
  220. }
  221. ?>
Documentation generated on Sun, 30 Jan 2011 20:46:42 +0100 by phpDocumentor 1.4.3