[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Wrapper for object caching in different caches.
   4   *
   5   * This program is free software; you can redistribute it and/or modify
   6   * it under the terms of the GNU General Public License as published by
   7   * the Free Software Foundation; either version 2 of the License, or
   8   * (at your option) any later version.
   9   *
  10   * This program is distributed in the hope that it will be useful,
  11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13   * GNU General Public License for more details.
  14   *
  15   * You should have received a copy of the GNU General Public License along
  16   * with this program; if not, write to the Free Software Foundation, Inc.,
  17   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18   * http://www.gnu.org/copyleft/gpl.html
  19   *
  20   * @file
  21   * @ingroup Cache
  22   */
  23  
  24  /**
  25   * A cache class that replicates all writes to multiple child caches. Reads
  26   * are implemented by reading from the caches in the order they are given in
  27   * the configuration until a cache gives a positive result.
  28   *
  29   * @ingroup Cache
  30   */
  31  class MultiWriteBagOStuff extends BagOStuff {
  32      /** @var array BagOStuff[] */
  33      protected $caches;
  34  
  35      /**
  36       * Constructor. Parameters are:
  37       *
  38       *   - caches:   This should have a numbered array of cache parameter
  39       *               structures, in the style required by $wgObjectCaches. See
  40       *               the documentation of $wgObjectCaches for more detail.
  41       *
  42       * @param array $params
  43       * @throws MWException
  44       */
  45  	public function __construct( $params ) {
  46          if ( !isset( $params['caches'] ) ) {
  47              throw new MWException( __METHOD__ . ': the caches parameter is required' );
  48          }
  49  
  50          $this->caches = array();
  51          foreach ( $params['caches'] as $cacheInfo ) {
  52              $this->caches[] = ObjectCache::newFromParams( $cacheInfo );
  53          }
  54      }
  55  
  56      /**
  57       * @param bool $debug
  58       */
  59  	public function setDebug( $debug ) {
  60          $this->doWrite( 'setDebug', $debug );
  61      }
  62  
  63      /**
  64       * @param string $key
  65       * @param mixed $casToken [optional]
  66       * @return bool|mixed
  67       */
  68  	public function get( $key, &$casToken = null ) {
  69          foreach ( $this->caches as $cache ) {
  70              $value = $cache->get( $key );
  71              if ( $value !== false ) {
  72                  return $value;
  73              }
  74          }
  75          return false;
  76      }
  77  
  78      /**
  79       * @param mixed $casToken
  80       * @param string $key
  81       * @param mixed $value
  82       * @param mixed $exptime
  83       * @return bool
  84       */
  85  	public function cas( $casToken, $key, $value, $exptime = 0 ) {
  86          throw new MWException( "CAS is not implemented in " . __CLASS__ );
  87      }
  88  
  89      /**
  90       * @param string $key
  91       * @param mixed $value
  92       * @param int $exptime
  93       * @return bool
  94       */
  95  	public function set( $key, $value, $exptime = 0 ) {
  96          return $this->doWrite( 'set', $key, $value, $exptime );
  97      }
  98  
  99      /**
 100       * @param string $key
 101       * @param int $time
 102       * @return bool
 103       */
 104  	public function delete( $key, $time = 0 ) {
 105          return $this->doWrite( 'delete', $key, $time );
 106      }
 107  
 108      /**
 109       * @param string $key
 110       * @param mixed $value
 111       * @param int $exptime
 112       * @return bool
 113       */
 114  	public function add( $key, $value, $exptime = 0 ) {
 115          return $this->doWrite( 'add', $key, $value, $exptime );
 116      }
 117  
 118      /**
 119       * @param string $key
 120       * @param int $value
 121       * @return bool|null
 122       */
 123  	public function incr( $key, $value = 1 ) {
 124          return $this->doWrite( 'incr', $key, $value );
 125      }
 126  
 127      /**
 128       * @param string $key
 129       * @param int $value
 130       * @return bool
 131       */
 132  	public function decr( $key, $value = 1 ) {
 133          return $this->doWrite( 'decr', $key, $value );
 134      }
 135  
 136      /**
 137       * @param string $key
 138       * @param int $timeout
 139       * @return bool
 140       */
 141  	public function lock( $key, $timeout = 0 ) {
 142          // Lock only the first cache, to avoid deadlocks
 143          if ( isset( $this->caches[0] ) ) {
 144              return $this->caches[0]->lock( $key, $timeout );
 145          } else {
 146              return true;
 147          }
 148      }
 149  
 150      /**
 151       * @param string $key
 152       * @return bool
 153       */
 154  	public function unlock( $key ) {
 155          if ( isset( $this->caches[0] ) ) {
 156              return $this->caches[0]->unlock( $key );
 157          } else {
 158              return true;
 159          }
 160      }
 161  
 162      /**
 163       * @param string $key
 164       * @param Closure $callback Callback method to be executed
 165       * @param int $exptime Either an interval in seconds or a unix timestamp for expiry
 166       * @param int $attempts The amount of times to attempt a merge in case of failure
 167       * @return bool Success
 168       */
 169  	public function merge( $key, Closure $callback, $exptime = 0, $attempts = 10 ) {
 170          return $this->doWrite( 'merge', $key, $callback, $exptime );
 171      }
 172  
 173  	public function getLastError() {
 174          return isset( $this->caches[0] ) ? $this->caches[0]->getLastError() : self::ERR_NONE;
 175      }
 176  
 177  	public function clearLastError() {
 178          if ( isset( $this->caches[0] ) ) {
 179              $this->caches[0]->clearLastError();
 180          }
 181      }
 182  
 183      /**
 184       * @param string $method
 185       * @return bool
 186       */
 187  	protected function doWrite( $method /*, ... */ ) {
 188          $ret = true;
 189          $args = func_get_args();
 190          array_shift( $args );
 191  
 192          foreach ( $this->caches as $cache ) {
 193              if ( !call_user_func_array( array( $cache, $method ), $args ) ) {
 194                  $ret = false;
 195              }
 196          }
 197          return $ret;
 198      }
 199  
 200      /**
 201       * Delete objects expiring before a certain date.
 202       *
 203       * Succeed if any of the child caches succeed.
 204       * @param string $date
 205       * @param bool|callable $progressCallback
 206       * @return bool
 207       */
 208  	public function deleteObjectsExpiringBefore( $date, $progressCallback = false ) {
 209          $ret = false;
 210          foreach ( $this->caches as $cache ) {
 211              if ( $cache->deleteObjectsExpiringBefore( $date, $progressCallback ) ) {
 212                  $ret = true;
 213              }
 214          }
 215          return $ret;
 216      }
 217  }