classes/Memcached_DataObject.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2008, 2009, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program 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
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 if (!defined('STATUSNET') && !defined('LACONICA')) { exit(1); }
  21
  22 require_once INSTALLDIR.'/classes/Memcached_DataObject.php';
  23
  24 class Memcached_DataObject extends DB_DataObject
  25 {
  26    /**
  27      * Destructor to free global memory resources associated with
  28      * this data object when it's unset or goes out of scope.
  29      * DB_DataObject doesn't do this yet by itself.
  30      */
  31
  32     function __destruct()
  33     {
  34         $this->free();
  35         if (method_exists('DB_DataObject', '__destruct')) {
  36             parent::__destruct();
  37         }
  38     }
  39
  40     /**
  41      * Wrapper for DB_DataObject's static lookup using memcached
  42      * as backing instead of an in-process cache array.
  43      *
  44      * @param string $cls classname of object type to load
  45      * @param mixed $k key field name, or value for primary key
  46      * @param mixed $v key field value, or leave out for primary key lookup
  47      * @return mixed Memcached_DataObject subtype or false
  48      */
  49     function &staticGet($cls, $k, $v=null)
  50     {
  51         if (is_null($v)) {
  52             $v = $k;
  53             # XXX: HACK!
  54             $i = new $cls;
  55             $keys = $i->keys();
  56             $k = $keys[0];
  57             unset($i);
  58         }
  59         $i = Memcached_DataObject::getcached($cls, $k, $v);
  60         if ($i) {
  61             return $i;
  62         } else {
  63             $i = DB_DataObject::factory($cls);
  64             if (empty($i)) {
  65                 return false;
  66             }
  67             $result = $i->get($k, $v);
  68             if ($result) {
  69                 $i->encache();
  70                 return $i;
  71             } else {
  72                 return false;
  73             }
  74         }
  75     }
  76
  77     function &pkeyGet($cls, $kv)
  78     {
  79         $i = Memcached_DataObject::multicache($cls, $kv);
  80         if ($i) {
  81             return $i;
  82         } else {
  83             $i = new $cls();
  84             foreach ($kv as $k => $v) {
  85                 $i->$k = $v;
  86             }
  87             if ($i->find(true)) {
  88                 $i->encache();
  89             } else {
  90                 $i = null;
  91             }
  92             return $i;
  93         }
  94     }
  95
  96     function insert()
  97     {
  98         $result = parent::insert();
  99         return $result;
 100     }
 101
 102     function update($orig=null)
 103     {
 104         if (is_object($orig) && $orig instanceof Memcached_DataObject) {
 105             $orig->decache(); # might be different keys
 106         }
 107         $result = parent::update($orig);
 108         if ($result) {
 109             $this->encache();
 110         }
 111         return $result;
 112     }
 113
 114     function delete()
 115     {
 116         $this->decache(); # while we still have the values!
 117         return parent::delete();
 118     }
 119
 120     static function memcache() {
 121         return common_memcache();
 122     }
 123
 124     static function cacheKey($cls, $k, $v) {
 125         if (is_object($cls) || is_object($k) || is_object($v)) {
 126             $e = new Exception();
 127             common_log(LOG_ERR, __METHOD__ . ' object in param: ' .
 128                 str_replace("\n", " ", $e->getTraceAsString()));
 129         }
 130         return common_cache_key(strtolower($cls).':'.$k.':'.$v);
 131     }
 132
 133     static function getcached($cls, $k, $v) {
 134         $c = Memcached_DataObject::memcache();
 135         if (!$c) {
 136             return false;
 137         } else {
 138             return $c->get(Memcached_DataObject::cacheKey($cls, $k, $v));
 139         }
 140     }
 141
 142     function keyTypes()
 143     {
 144         global $_DB_DATAOBJECT;
 145         if (!isset($_DB_DATAOBJECT['INI'][$this->_database][$this->__table."__keys"])) {
 146             $this->databaseStructure();
 147
 148         }
 149         return $_DB_DATAOBJECT['INI'][$this->_database][$this->__table."__keys"];
 150     }
 151
 152     function encache()
 153     {
 154         $c = $this->memcache();
 155
 156         if (!$c) {
 157             return false;
 158         }
 159
 160         $keys = $this->_allCacheKeys();
 161
 162         foreach ($keys as $key) {
 163             $c->set($key, $this);
 164         }
 165     }
 166
 167     function decache()
 168     {
 169         $c = $this->memcache();
 170
 171         if (!$c) {
 172             return false;
 173         }
 174
 175         $keys = $this->_allCacheKeys();
 176
 177         foreach ($keys as $key) {
 178             $c->delete($key, $this);
 179         }
 180     }
 181
 182     function _allCacheKeys()
 183     {
 184         $ckeys = array();
 185
 186         $types = $this->keyTypes();
 187         ksort($types);
 188
 189         $pkey = array();
 190         $pval = array();
 191
 192         foreach ($types as $key => $type) {
 193
 194             assert(!empty($key));
 195
 196             if ($type == 'U') {
 197                 if (empty($this->$key)) {
 198                     continue;
 199                 }
 200                 $ckeys[] = $this->cacheKey($this->tableName(), $key, $this->$key);
 201             } else if ($type == 'K' || $type == 'N') {
 202                 $pkey[] = $key;
 203                 $pval[] = $this->$key;
 204             } else {
 205                 throw new Exception("Unknown key type $key => $type for " . $this->tableName());
 206             }
 207         }
 208
 209         assert(count($pkey) > 0);
 210
 211         // XXX: should work for both compound and scalar pkeys
 212         $pvals = implode(',', $pval);
 213         $pkeys = implode(',', $pkey);
 214
 215         $ckeys[] = $this->cacheKey($this->tableName(), $pkeys, $pvals);
 216
 217         return $ckeys;
 218     }
 219
 220     function multicache($cls, $kv)
 221     {
 222         ksort($kv);
 223         $c = Memcached_DataObject::memcache();
 224         if (!$c) {
 225             return false;
 226         } else {
 227             $pkeys = implode(',', array_keys($kv));
 228             $pvals = implode(',', array_values($kv));
 229             return $c->get(Memcached_DataObject::cacheKey($cls, $pkeys, $pvals));
 230         }
 231     }
 232
 233     function getSearchEngine($table)
 234     {
 235         require_once INSTALLDIR.'/lib/search_engines.php';
 236         static $search_engine;
 237         if (!isset($search_engine)) {
 238             if (Event::handle('GetSearchEngine', array($this, $table, &$search_engine))) {
 239                 if ('mysql' === common_config('db', 'type')) {
 240                     $type = common_config('search', 'type');
 241                     if ($type == 'like') {
 242                         $search_engine = new MySQLLikeSearch($this, $table);
 243                     } else if ($type == 'fulltext') {
 244                         $search_engine = new MySQLSearch($this, $table);
 245                     } else {
 246                         throw new ServerException('Unknown search type: ' . $type);
 247                     }
 248                 } else {
 249                     $search_engine = new PGSearch($this, $table);
 250                 }
 251             }
 252         }
 253         return $search_engine;
 254     }
 255
 256     static function cachedQuery($cls, $qry, $expiry=3600)
 257     {
 258         $c = Memcached_DataObject::memcache();
 259         if (!$c) {
 260             $inst = new $cls();
 261             $inst->query($qry);
 262             return $inst;
 263         }
 264         $key_part = common_keyize($cls).':'.md5($qry);
 265         $ckey = common_cache_key($key_part);
 266         $stored = $c->get($ckey);
 267         if ($stored) {
 268             return new ArrayWrapper($stored);
 269         }
 270
 271         $inst = new $cls();
 272         $inst->query($qry);
 273         $cached = array();
 274         while ($inst->fetch()) {
 275             $cached[] = clone($inst);
 276         }
 277         $inst->free();
 278         $c->set($ckey, $cached, MEMCACHE_COMPRESSED, $expiry);
 279         return new ArrayWrapper($cached);
 280     }
 281
 282     // We overload so that 'SET NAMES "utf8"' is called for
 283     // each connection
 284
 285     function _connect()
 286     {
 287         global $_DB_DATAOBJECT;
 288
 289         $sum = $this->_getDbDsnMD5();
 290
 291         if (!empty($_DB_DATAOBJECT['CONNECTIONS'][$sum]) &&
 292             !PEAR::isError($_DB_DATAOBJECT['CONNECTIONS'][$sum])) {
 293             $exists = true;
 294         } else {
 295             $exists = false;
 296        }
 297
 298         $result = parent::_connect();
 299
 300         if ($result && !$exists) {
 301             $DB = &$_DB_DATAOBJECT['CONNECTIONS'][$this->_database_dsn_md5];
 302             if (common_config('db', 'type') == 'mysql' &&
 303                 common_config('db', 'utf8')) {
 304                 $conn = $DB->connection;
 305                 if (!empty($conn)) {
 306                     if ($DB instanceof DB_mysqli) {
 307                         mysqli_set_charset($conn, 'utf8');
 308                     } else if ($DB instanceof DB_mysql) {
 309                         mysql_set_charset('utf8', $conn);
 310                     }
 311                 }
 312             }
 313         }
 314
 315         return $result;
 316     }
 317
 318     // XXX: largely cadged from DB_DataObject
 319
 320     function _getDbDsnMD5()
 321     {
 322         if ($this->_database_dsn_md5) {
 323             return $this->_database_dsn_md5;
 324         }
 325
 326         $dsn = $this->_getDbDsn();
 327
 328         if (is_string($dsn)) {
 329             $sum = md5($dsn);
 330         } else {
 331             /// support array based dsn's
 332             $sum = md5(serialize($dsn));
 333         }
 334
 335         return $sum;
 336     }
 337
 338     function _getDbDsn()
 339     {
 340         global $_DB_DATAOBJECT;
 341
 342         if (empty($_DB_DATAOBJECT['CONFIG'])) {
 343             DB_DataObject::_loadConfig();
 344         }
 345
 346         $options = &$_DB_DATAOBJECT['CONFIG'];
 347
 348         // if the databse dsn dis defined in the object..
 349
 350         $dsn = isset($this->_database_dsn) ? $this->_database_dsn : null;
 351
 352         if (!$dsn) {
 353
 354             if (!$this->_database) {
 355                 $this->_database = isset($options["table_{$this->__table}"]) ? $options["table_{$this->__table}"] : null;
 356             }
 357
 358             if ($this->_database && !empty($options["database_{$this->_database}"]))  {
 359                 $dsn = $options["database_{$this->_database}"];
 360             } else if (!empty($options['database'])) {
 361                 $dsn = $options['database'];
 362             }
 363         }
 364
 365         if (!$dsn) {
 366             throw new Exception("No database name / dsn found anywhere");
 367         }
 368
 369         return $dsn;
 370     }
 371 }