Source for file CacheLite.php

Documentation is available at CacheLite.php

  1. <?php
  2. /**
  3.  * OpenID_Store_CacheLite
  4.  * 
  5.  * PHP Version 5.2.0+
  6.  * 
  7.  * @uses      OpenID_Store_Interface
  8.  * @category  Auth
  9.  * @package   OpenID
  10.  * @author    Bill Shupp <hostmaster@shupp.org>
  11.  * @author    Rich Schumacher <rich.schu@gmail.com>
  12.  * @copyright 2009 Bill Shupp, Rich Schumacher
  13.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  14.  * @link      http://pearopenid.googlecode.com
  15.  */
  16.  
  17. /**
  18.  * Required files
  19.  */
  20. require_once 'Cache/Lite.php';
  21. require_once 'OpenID/Store/Interface.php';
  22.  
  23. /**
  24.  * PEAR Cache_Lite driver for storage.  This is the default driver used.
  25.  * 
  26.  * @uses      OpenID_Store_Interface
  27.  * @category  Auth
  28.  * @package   OpenID
  29.  * @author    Bill Shupp <hostmaster@shupp.org>
  30.  * @author    Rich Schumacher <rich.schu@gmail.com>
  31.  * @copyright 2009 Bill Shupp, Rich Schumacher
  32.  * @license   http://www.opensource.org/licenses/bsd-license.php FreeBSD
  33.  * @link      http://pearopenid.googlecode.com
  34.  */
  35. class OpenID_Store_CacheLite implements OpenID_Store_Interface
  36. {
  37.     /**
  38.      * Instance of Cache_Lite
  39.      * 
  40.      * @var Cache_Lite 
  41.      */
  42.     protected $cache = null;
  43.  
  44.     /**
  45.      * Default options for Cache_Lite
  46.      * 
  47.      * @var array 
  48.      */
  49.     protected $defaultOptions = array(
  50.         'cacheDir'             => '/tmp',
  51.         'lifeTime'             => 3600,
  52.         'hashedDirectoryLevel' => 2
  53.     );
  54.  
  55.     /**
  56.      * Sub-directory storage for each type of store
  57.      * 
  58.      * @var array 
  59.      */
  60.     protected $storeDirectories = array(
  61.         self::TYPE_ASSOCIATION => 'association',
  62.         self::TYPE_DISCOVER    => 'discover',
  63.         self::TYPE_NONCE       => 'nonce'
  64.     );
  65.  
  66.     /**
  67.      * Instantiate Cache_Lite.  Allows for options to be passed to Cache_Lite.
  68.      * 
  69.      * @param array $options Options for Cache_Lite constructor
  70.      * 
  71.      * @return void 
  72.      */
  73.     public function __construct(array $options = array())
  74.     {
  75.         $options     = array_merge($this->defaultOptions, $options);
  76.         $this->cache = new Cache_Lite($options);
  77.     }
  78.  
  79.     /**
  80.      * Gets an OpenID_Assocation instance from storage
  81.      * 
  82.      * @param string $uri    The OP endpoint URI to get an association for
  83.      * @param string $handle The handle if available
  84.      * 
  85.      * @return OpenID_Association 
  86.      */
  87.     public function getAssociation($uri, $handle = null)
  88.     {
  89.         $this->setOptions(self::TYPE_ASSOCIATION);
  90.         if ($handle !== null) {
  91.             $key = $uri . $handle;
  92.         } else {
  93.             $key = $uri;
  94.         }
  95.  
  96.         return unserialize($this->cache->get(md5($key)));
  97.     }
  98.  
  99.     /**
  100.      * Stores an OpenID_Association instance.  Details (such as endpoint url and
  101.      * expiration) are retrieved from the object itself.
  102.      * 
  103.      * @param OpenID_Association $association Instance of OpenID_Association
  104.      * 
  105.      * @return void 
  106.      */
  107.     public function setAssociation(OpenID_Association $association)
  108.     {
  109.         $this->setOptions(self::TYPE_ASSOCIATION, $association->expiresIn);
  110.  
  111.         // Store URI based key
  112.         $this->cache->save(serialize($association), md5($association->uri));
  113.         // Store URI + Handle based key
  114.         $this->cache->save(serialize($association),
  115.                            md5($association->uri . $association->assocHandle));
  116.     }
  117.  
  118.     /**
  119.      * Deletes an association from storage
  120.      * 
  121.      * @param string $uri OP Endpoint URI
  122.      * 
  123.      * @return void 
  124.      */
  125.     public function deleteAssociation($uri)
  126.     {
  127.         $this->setOptions(self::TYPE_ASSOCIATION);
  128.  
  129.         return $this->cache->remove(md5($uri));
  130.     }
  131.  
  132.     /**
  133.      * Gets an OpenID_Discover object from storage
  134.      * 
  135.      * @param string $identifier The normalized identifier that discovery was
  136.      *                            performed on
  137.      * 
  138.      * @return OpenID_Discover 
  139.      */
  140.     public function getDiscover($identifier)
  141.     {
  142.         $this->setOptions(self::TYPE_DISCOVER);
  143.  
  144.         $result = $this->cache->get($this->getDiscoverCacheKey($identifier));
  145.         if ($result === false) {
  146.             return $result;
  147.         }
  148.         return unserialize($result);
  149.     }
  150.  
  151.     /**
  152.      * Stores an instance of OpenID_Discover
  153.      * 
  154.      * @param OpenID_Discover $discover Instance of OpenID_Discover
  155.      * @param int             $expire   How long to cache it for, in seconds
  156.      * 
  157.      * @return void 
  158.      */
  159.     public function setDiscover(OpenID_Discover $discover, $expire = null)
  160.     {
  161.         $this->setOptions(self::TYPE_DISCOVER, $expire);
  162.  
  163.         $key = $this->getDiscoverCacheKey($discover->identifier);
  164.  
  165.         return $this->cache->save(serialize($discover), $key);
  166.     }
  167.  
  168.     /**
  169.      * Deletes a cached OpenID_Discover object
  170.      * 
  171.      * @param string $identifier The Identifier
  172.      * 
  173.      * @return void 
  174.      */
  175.     public function deleteDiscover($identifier)
  176.     {
  177.         $this->setOptions(self::TYPE_DISCOVER);
  178.  
  179.         $key = $this->getDiscoverCacheKey($identifier);
  180.  
  181.         return $this->cache->remove($key);
  182.     }
  183.  
  184.     /**
  185.      * Common method for creating a cache key based on the normalized identifier
  186.      * 
  187.      * @param string $identifier User supplied identifier
  188.      * 
  189.      * @return string md5 of the normalized identifier
  190.      */
  191.     protected function getDiscoverCacheKey($identifier)
  192.     {
  193.         return md5(OpenID::normalizeIdentifier($identifier));
  194.     }
  195.  
  196.     /**
  197.      * Gets a nonce from storage
  198.      * 
  199.      * @param string $nonce The nonce itself
  200.      * @param string $opURL The OP Endpoint URL it was used with
  201.      * 
  202.      * @return string 
  203.      */
  204.     public function getNonce($nonce, $opURL)
  205.     {
  206.         $this->setOptions(self::TYPE_NONCE);
  207.  
  208.         $key = $this->getNonceCacheKey($nonce, $opURL);
  209.         return $this->cache->get($key);
  210.     }
  211.  
  212.     /**
  213.      * Stores a nonce for an OP endpoint URL
  214.      * 
  215.      * @param string $nonce The nonce itself
  216.      * @param string $opURL The OP endpoint URL it was associated with
  217.      * 
  218.      * @return void 
  219.      */
  220.     public function setNonce($nonce, $opURL)
  221.     {
  222.         $this->setOptions(self::TYPE_NONCE);
  223.  
  224.         return $this->cache->save($nonce, $this->getNonceCacheKey($nonce, $opURL));
  225.     }
  226.  
  227.     /**
  228.      * Deletes a nonce from storage
  229.      * 
  230.      * @param string $nonce The nonce to delete
  231.      * @param string $opURL The OP endpoint URL it is associated with
  232.      * 
  233.      * @return void 
  234.      */
  235.     public function deleteNonce($nonce, $opURL)
  236.     {
  237.         $this->setOptions(self::TYPE_NONCE);
  238.  
  239.         return $this->cache->remove($this->getNonceCacheKey($nonce, $opURL));
  240.     }
  241.  
  242.     /**
  243.      * Common method for creating a nonce key based on both the nonce and the OP
  244.      * endpoint URL
  245.      * 
  246.      * @param string $nonce The nonce
  247.      * @param string $opURL The OP endpoint URL it is associated with
  248.      * 
  249.      * @return string Cache key
  250.      */
  251.     protected function getNonceCacheKey($nonce, $opURL)
  252.     {
  253.         return md5('OpenID.Nonce.' . $opURL . $nonce);
  254.     }
  255.  
  256.     /**
  257.      * Sets options for Cache_Lite based on the needs of the current method.
  258.      * Options set include the subdirectory to be used, and the expiration.
  259.      * 
  260.      * @param string $key    The sub-directory of the cacheDir
  261.      * @param string $expire The cache lifetime (expire) to be used
  262.      * 
  263.      * @return void 
  264.      */
  265.     protected function setOptions($key, $expire = null)
  266.     {
  267.         $cacheDir  = $this->defaultOptions['cacheDir'] . '/openid/';
  268.         $cacheDir .= rtrim($this->storeDirectories[$key], '/') . '/';
  269.  
  270.         $this->ensureDirectoryExists($cacheDir);
  271.  
  272.         $this->cache->setOption('cacheDir', $cacheDir);
  273.  
  274.         if ($expire !== null) {
  275.             $this->cache->setOption('lifeTime', $expire);
  276.         }
  277.     }
  278.  
  279.     /**
  280.      * Make sure the given sub directory exists.  If not, create it.
  281.      * 
  282.      * @param string $dir The full path to the sub director we plan to write to
  283.      * 
  284.      * @return void 
  285.      */
  286.     protected function ensureDirectoryExists($dir)
  287.     {
  288.         if (!file_exists($dir)) {
  289.             mkdir($dir, 0777, true);
  290.         }
  291.     }
  292. }
  293. ?>

Documentation generated on Tue, 15 Dec 2009 19:00:51 -0800 by phpDocumentor 1.4.3