lib/Cache.php

   1 <?php
   2 /*
   3   +---------------------------------------------------------------------------------+
   4   | Copyright (c) 2010 ActiveMongo                                                  |
   5   +---------------------------------------------------------------------------------+
   6   | Redistribution and use in source and binary forms, with or without              |
   7   | modification, are permitted provided that the following conditions are met:     |
   8   | 1. Redistributions of source code must retain the above copyright               |
   9   |    notice, this list of conditions and the following disclaimer.                |
  10   |                                                                                 |
  11   | 2. Redistributions in binary form must reproduce the above copyright            |
  12   |    notice, this list of conditions and the following disclaimer in the          |
  13   |    documentation and/or other materials provided with the distribution.         |
  14   |                                                                                 |
  15   | 3. All advertising materials mentioning features or use of this software        |
  16   |    must display the following acknowledgement:                                  |
  17   |    This product includes software developed by César D. Rodas.                  |
  18   |                                                                                 |
  19   | 4. Neither the name of the César D. Rodas nor the                               |
  20   |    names of its contributors may be used to endorse or promote products         |
  21   |    derived from this software without specific prior written permission.        |
  22   |                                                                                 |
  23   | THIS SOFTWARE IS PROVIDED BY CÉSAR D. RODAS ''AS IS'' AND ANY                   |
  24   | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED       |
  25   | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE          |
  26   | DISCLAIMED. IN NO EVENT SHALL CÉSAR D. RODAS BE LIABLE FOR ANY                  |
  27   | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES      |
  28   | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;    |
  29   | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND     |
  30   | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT      |
  31   | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS   |
  32   | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE                     |
  33   +---------------------------------------------------------------------------------+
  34   | Authors: César Rodas <crodas@php.net>                                           |
  35   +---------------------------------------------------------------------------------+
  36 */
  37
  38 /**
  39  *  Cursor used for cached items
  40  */
  41 class CacheCursor Extends MongoCursor
  42 {
  43     protected $var;
  44     protected $size;
  45     protected $pos;
  46
  47     function __construct()
  48     {
  49     }
  50
  51     function setResultArray(Array $array)
  52     {
  53         $this->var  = array_values($array);
  54         $this->size = count($array);
  55         $this->pos  = 0;
  56     }
  57
  58     function reset()
  59     {
  60         $this->pos = -1;
  61     }
  62
  63     function key()
  64     {
  65         return (string)$this->var[$this->pos]['_id'];
  66     }
  67
  68     function current()
  69     {
  70         if (!$this->valid()) {
  71             return array();
  72         }
  73         return $this->var[$this->pos];
  74     }
  75
  76     function next()
  77     {
  78         ++$this->pos;
  79     }
  80
  81     function valid()
  82     {
  83         return isset($this->var[$this->pos]);
  84     }
  85
  86     function rewind()
  87     {
  88         $this->reset();
  89         $this->next();
  90     }
  91
  92     function getNext()
  93     {
  94         $this->rewind();
  95         return $this->var[$this->pos];
  96     }
  97
  98     function count()
  99     {
 100         return count($this->var);
 101     }
 102
 103     function getID()
 104     {
 105         return $this->_id;
 106     }
 107 }
 108
 109 abstract class CacheDriver
 110 {
 111
 112     // Serialization {{{
 113     /**
 114      *  serialize -- by default with BSON
 115      *
 116      *  @param object $object
 117      *
 118      *  @return string
 119      */
 120     function serialize($object)
 121     {
 122         return bson_encode($object);
 123     }
 124
 125     /**
 126      *  deserialize -- by default with BSON
 127      *
 128      *  @param string $string
 129      *
 130      *  @return object
 131      */
 132     function deserialize($string)
 133     {
 134         return bson_decode($string);
 135     }
 136     // }}}
 137
 138     abstract function get($key, &$object);
 139
 140     abstract function set($key, $document, $ttl);
 141
 142     function getMulti(Array $keys, Array &$object)
 143     {
 144         foreach ($keys as $key) {
 145             if ($this->get($key, $object[$key]) === FALSE) {
 146                 $object[$key] = FALSE;
 147             }
 148         }
 149     }
 150
 151     function setMulti(Array $objects, Array $ttl)
 152     {
 153         foreach ($objects as $id => $value) {
 154             if (!isset($ttl[$id])) {
 155                 $ttl[$id] = 3600;
 156             }
 157             $this->set($id, $value, $ttl[$id]);
 158         }
 159     }
 160
 161     abstract function delete(Array $key);
 162 }
 163
 164 final class ActiveMongo_Cache
 165 {
 166     private static $instance;
 167     private $enabled;
 168     private $driver;
 169
 170     private function __construct()
 171     {
 172         ActiveMongo::addEvent('before_query', array($this, 'QueryRead'));
 173         ActiveMongo::addEvent('after_query',  array($this, 'QuerySave'));
 174         ActiveMongo::addEvent('after_create', array($this, 'UpdateHook'));
 175         ActiveMongo::addEvent('after_update', array($this, 'UpdateHook'));
 176     }
 177
 178     public static function Init()
 179     {
 180         if (self::$instance) {
 181             return;
 182         }
 183         self::$instance = new ActiveMongo_Cache;
 184     }
 185
 186     public static function setDriver(CacheDriver $driver)
 187     {
 188         self::Init();
 189         self::$instance->driver = $driver;
 190     }
 191
 192     public static function enable()
 193     {
 194         self::Init();
 195         self::$instance->enabled = TRUE;
 196     }
 197
 198     public static function disable()
 199     {
 200         self::Init();
 201         self::$instance->enabled = FALSE;
 202     }
 203
 204     final protected function hasCache($class)
 205     {
 206         if (!$this->driver InstanceOf CacheDriver) {
 207             return FALSE;
 208         }
 209         $enable = isset($class::$cacheable) ? $class::$cacheable : $this->enabled;
 210         return $enable;
 211     }
 212
 213     final protected function getQueryID($query_document)
 214     {
 215         /* TODO: Peform some sort of sorting */
 216         /* to treat queries with same parameters but */
 217         /* different order equal */
 218
 219         $id = $this->driver->serialize($query_document);
 220
 221         return sha1($id);
 222     }
 223
 224     /**
 225      *
 226      */
 227     function QueryRead($class, $query_document, &$resultset)
 228     {
 229         if (!$this->hasCache($class)) {
 230             return;
 231         }
 232
 233         $query_id = $this->getQueryID($query_document);
 234
 235         if ($this->driver->get($query_id, $query_result) === FALSE) {
 236             return;
 237         }
 238
 239         if (!is_array($query_result) || count($query_result) == 0) {
 240             return;
 241         }
 242
 243         $toquery = array();
 244         $result  = array();
 245
 246         $cache_ids = array_combine(array_keys($query_result), array_keys($query_result));
 247         $this->driver->getMulti($cache_ids, $result);
 248
 249         foreach ($result as $id => $doc) {
 250             if (!is_array($doc)) {
 251                 $toquery[] = $id;
 252             }
 253         }
 254
 255         if (count($toquery) > 0) {
 256             $db = new $class;
 257             $db->where('_id IN', array_values($toquery));
 258             foreach ($db as $doc) {
 259                 foreach ($toquery as $id) {
 260                     if ($id == $doc['_id']) {
 261                         break;
 262                     }
 263                 }
 264                 $result[$id] = $doc;
 265             }
 266         }
 267
 268         $resultset = new CacheCursor;
 269         $resultset->setResultArray($result);
 270
 271         /* Return FALSE to prevent the execution of
 272          * any hook similar hook
 273          */
 274         return FALSE;
 275     }
 276
 277     /**
 278      *
 279      *
 280      */
 281     function QuerySave($class, $query_document, $cursor)
 282     {
 283         if (!$this->hasCache($class)) {
 284             return;
 285         }
 286
 287         $query_id = $this->getQueryID($query_document);
 288         $ids      = array();
 289         $ttl      = array();
 290         $docs     = array();
 291
 292         foreach ($cursor as $id=>$document) {
 293             $ids[$id]  = $document['_id'];
 294             $docs[$id] = $document;
 295             $ttl[$id]  = 3600;
 296         }
 297
 298         $this->driver->setMulti($docs, $ttl);
 299         $this->driver->set($query_id, $ids, 3600);
 300     }
 301
 302     // UpdateHook($class, $document, $obj) {{{
 303     /**
 304      *  Update Hook
 305      *
 306      *  Save or Replace an object (document)
 307      *  into the cache.
 308      *
 309      *  @param string $class    Class name
 310      *  @param object $document Document sent to mongodb
 311      *  @param object $obj      ActiveMongo Object
 312      *
 313      *  @return NULL
 314      */
 315     function UpdateHook($class, $document, $obj)
 316     {
 317         if (!$this->hasCache($class)) {
 318             return;
 319         }
 320
 321         if (!isset($obj['_id'])) {
 322             if (!isset($document['_id'])) {
 323                 return; /* Weird condition */
 324             }
 325             $obj['_id'] = $document['_id'];
 326         }
 327
 328         $this->driver->set((string)$obj['_id'], $obj, 3600);
 329     }
 330     // }}}
 331
 332 }
 333
 334 ActiveMongo_Cache::Init();
 335
 336 /*
 337  * Local variables:
 338  * tab-width: 4
 339  * c-basic-offset: 4
 340  * End:
 341  * vim600: sw=4 ts=4 fdm=marker
 342  * vim<600: sw=4 ts=4
 343  */