interface/modules/zend_modules/library/Zend/Cache/Storage/Adapter/WinCache.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Cache\Storage\Adapter;
  11
  12 use stdClass;
  13 use Traversable;
  14 use Zend\Cache\Exception;
  15 use Zend\Cache\Storage\AvailableSpaceCapableInterface;
  16 use Zend\Cache\Storage\Capabilities;
  17 use Zend\Cache\Storage\FlushableInterface;
  18 use Zend\Cache\Storage\TotalSpaceCapableInterface;
  19
  20 class WinCache extends AbstractAdapter implements
  21     AvailableSpaceCapableInterface,
  22     FlushableInterface,
  23     TotalSpaceCapableInterface
  24 {
  25     /**
  26      * Constructor
  27      *
  28      * @param  array|Traversable|WinCacheOptions $options
  29      * @throws Exception\ExceptionInterface
  30      */
  31     public function __construct($options = null)
  32     {
  33         if (!extension_loaded('wincache')) {
  34             throw new Exception\ExtensionNotLoadedException("WinCache extension is not loaded");
  35         }
  36
  37         $enabled = ini_get('wincache.ucenabled');
  38         if (PHP_SAPI == 'cli') {
  39             $enabled = $enabled && (bool) ini_get('wincache.enablecli');
  40         }
  41
  42         if (!$enabled) {
  43             throw new Exception\ExtensionNotLoadedException(
  44                 "WinCache is disabled - see 'wincache.ucenabled' and 'wincache.enablecli'"
  45             );
  46         }
  47
  48         parent::__construct($options);
  49     }
  50
  51     /* options */
  52
  53     /**
  54      * Set options.
  55      *
  56      * @param  array|Traversable|WinCacheOptions $options
  57      * @return WinCache
  58      * @see    getOptions()
  59      */
  60     public function setOptions($options)
  61     {
  62         if (!$options instanceof WinCacheOptions) {
  63             $options = new WinCacheOptions($options);
  64         }
  65
  66         return parent::setOptions($options);
  67     }
  68
  69     /**
  70      * Get options.
  71      *
  72      * @return WinCacheOptions
  73      * @see setOptions()
  74      */
  75     public function getOptions()
  76     {
  77         if (!$this->options) {
  78             $this->setOptions(new WinCacheOptions());
  79         }
  80         return $this->options;
  81     }
  82
  83     /* TotalSpaceCapableInterface */
  84
  85     /**
  86      * Get total space in bytes
  87      *
  88      * @return int|float
  89      */
  90     public function getTotalSpace()
  91     {
  92         $mem = wincache_ucache_meminfo();
  93         return $mem['memory_total'];
  94     }
  95
  96     /* AvailableSpaceCapableInterface */
  97
  98     /**
  99      * Get available space in bytes
 100      *
 101      * @return int|float
 102      */
 103     public function getAvailableSpace()
 104     {
 105         $mem = wincache_ucache_meminfo();
 106         return $mem['memory_free'];
 107     }
 108
 109     /* FlushableInterface */
 110
 111     /**
 112      * Flush the whole storage
 113      *
 114      * @return bool
 115      */
 116     public function flush()
 117     {
 118         return wincache_ucache_clear();
 119     }
 120
 121     /* reading */
 122
 123     /**
 124      * Internal method to get an item.
 125      *
 126      * @param  string  $normalizedKey
 127      * @param  bool $success
 128      * @param  mixed   $casToken
 129      * @return mixed Data on success, null on failure
 130      * @throws Exception\ExceptionInterface
 131      */
 132     protected function internalGetItem(& $normalizedKey, & $success = null, & $casToken = null)
 133     {
 134         $options     = $this->getOptions();
 135         $namespace   = $options->getNamespace();
 136         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 137         $internalKey = $prefix . $normalizedKey;
 138         $result      = wincache_ucache_get($internalKey, $success);
 139
 140         if ($success) {
 141             $casToken = $result;
 142         } else {
 143             $result = null;
 144         }
 145
 146         return $result;
 147     }
 148
 149     /**
 150      * Internal method to get multiple items.
 151      *
 152      * @param  array $normalizedKeys
 153      * @return array Associative array of keys and values
 154      * @throws Exception\ExceptionInterface
 155      */
 156     protected function internalGetItems(array & $normalizedKeys)
 157     {
 158         $options   = $this->getOptions();
 159         $namespace = $options->getNamespace();
 160         if ($namespace === '') {
 161             return wincache_ucache_get($normalizedKeys);
 162         }
 163
 164         $prefix       = $namespace . $options->getNamespaceSeparator();
 165         $internalKeys = array();
 166         foreach ($normalizedKeys as $normalizedKey) {
 167             $internalKeys[] = $prefix . $normalizedKey;
 168         }
 169
 170         $fetch = wincache_ucache_get($internalKeys);
 171
 172         // remove namespace prefix
 173         $prefixL = strlen($prefix);
 174         $result  = array();
 175         foreach ($fetch as $internalKey => & $value) {
 176             $result[substr($internalKey, $prefixL)] = & $value;
 177         }
 178
 179         return $result;
 180     }
 181
 182     /**
 183      * Internal method to test if an item exists.
 184      *
 185      * @param  string $normalizedKey
 186      * @return bool
 187      * @throws Exception\ExceptionInterface
 188      */
 189     protected function internalHasItem(& $normalizedKey)
 190     {
 191         $options   = $this->getOptions();
 192         $namespace = $options->getNamespace();
 193         $prefix    = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 194         return wincache_ucache_exists($prefix . $normalizedKey);
 195     }
 196
 197     /**
 198      * Get metadata of an item.
 199      *
 200      * @param  string $normalizedKey
 201      * @return array|bool Metadata on success, false on failure
 202      * @throws Exception\ExceptionInterface
 203      */
 204     protected function internalGetMetadata(& $normalizedKey)
 205     {
 206         $options     = $this->getOptions();
 207         $namespace   = $options->getNamespace();
 208         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 209         $internalKey = $prefix . $normalizedKey;
 210
 211         $info = wincache_ucache_info(true, $internalKey);
 212         if (isset($info['ucache_entries'][1])) {
 213             $metadata = $info['ucache_entries'][1];
 214             $this->normalizeMetadata($metadata);
 215             return $metadata;
 216         }
 217
 218         return false;
 219     }
 220
 221     /* writing */
 222
 223     /**
 224      * Internal method to store an item.
 225      *
 226      * @param  string $normalizedKey
 227      * @param  mixed  $value
 228      * @return bool
 229      * @throws Exception\ExceptionInterface
 230      */
 231     protected function internalSetItem(& $normalizedKey, & $value)
 232     {
 233         $options     = $this->getOptions();
 234         $namespace   = $options->getNamespace();
 235         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 236         $internalKey = $prefix . $normalizedKey;
 237         $ttl         = $options->getTtl();
 238
 239         if (!wincache_ucache_set($internalKey, $value, $ttl)) {
 240             $type = is_object($value) ? get_class($value) : gettype($value);
 241             throw new Exception\RuntimeException(
 242                 "wincache_ucache_set('{$internalKey}', <{$type}>, {$ttl}) failed"
 243             );
 244         }
 245
 246         return true;
 247     }
 248
 249     /**
 250      * Internal method to store multiple items.
 251      *
 252      * @param  array $normalizedKeyValuePairs
 253      * @return array Array of not stored keys
 254      * @throws Exception\ExceptionInterface
 255      */
 256     protected function internalSetItems(array & $normalizedKeyValuePairs)
 257     {
 258         $options   = $this->getOptions();
 259         $namespace = $options->getNamespace();
 260         if ($namespace === '') {
 261             return wincache_ucache_set($normalizedKeyValuePairs, null, $options->getTtl());
 262         }
 263
 264         $prefix                = $namespace . $options->getNamespaceSeparator();
 265         $internalKeyValuePairs = array();
 266         foreach ($normalizedKeyValuePairs as $normalizedKey => & $value) {
 267             $internalKey = $prefix . $normalizedKey;
 268             $internalKeyValuePairs[$internalKey] = & $value;
 269         }
 270
 271         $result = wincache_ucache_set($internalKeyValuePairs, null, $options->getTtl());
 272
 273         // remove key prefic
 274         $prefixL = strlen($prefix);
 275         foreach ($result as & $key) {
 276             $key = substr($key, $prefixL);
 277         }
 278
 279         return $result;
 280     }
 281
 282     /**
 283      * Add an item.
 284      *
 285      * @param  string $normalizedKey
 286      * @param  mixed  $value
 287      * @return bool
 288      * @throws Exception\ExceptionInterface
 289      */
 290     protected function internalAddItem(& $normalizedKey, & $value)
 291     {
 292         $options     = $this->getOptions();
 293         $namespace   = $options->getNamespace();
 294         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 295         $internalKey = $prefix . $normalizedKey;
 296         $ttl         = $options->getTtl();
 297
 298         if (!wincache_ucache_add($internalKey, $value, $ttl)) {
 299             $type = is_object($value) ? get_class($value) : gettype($value);
 300             throw new Exception\RuntimeException(
 301                 "wincache_ucache_add('{$internalKey}', <{$type}>, {$ttl}) failed"
 302             );
 303         }
 304
 305         return true;
 306     }
 307
 308     /**
 309      * Internal method to add multiple items.
 310      *
 311      * @param  array $normalizedKeyValuePairs
 312      * @return array Array of not stored keys
 313      * @throws Exception\ExceptionInterface
 314      */
 315     protected function internalAddItems(array & $normalizedKeyValuePairs)
 316     {
 317         $options   = $this->getOptions();
 318         $namespace = $options->getNamespace();
 319         if ($namespace === '') {
 320             return wincache_ucache_add($normalizedKeyValuePairs, null, $options->getTtl());
 321         }
 322
 323         $prefix                = $namespace . $options->getNamespaceSeparator();
 324         $internalKeyValuePairs = array();
 325         foreach ($normalizedKeyValuePairs as $normalizedKey => $value) {
 326             $internalKey = $prefix . $normalizedKey;
 327             $internalKeyValuePairs[$internalKey] = $value;
 328         }
 329
 330         $result = wincache_ucache_add($internalKeyValuePairs, null, $options->getTtl());
 331
 332         // remove key prefic
 333         $prefixL = strlen($prefix);
 334         foreach ($result as & $key) {
 335             $key = substr($key, $prefixL);
 336         }
 337
 338         return $result;
 339     }
 340
 341     /**
 342      * Internal method to replace an existing item.
 343      *
 344      * @param  string $normalizedKey
 345      * @param  mixed  $value
 346      * @return bool
 347      * @throws Exception\ExceptionInterface
 348      */
 349     protected function internalReplaceItem(& $normalizedKey, & $value)
 350     {
 351         $options     = $this->getOptions();
 352         $namespace   = $options->getNamespace();
 353         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 354         $internalKey = $prefix . $normalizedKey;
 355         if (!wincache_ucache_exists($internalKey)) {
 356             return false;
 357         }
 358
 359         $ttl = $options->getTtl();
 360         if (!wincache_ucache_set($internalKey, $value, $ttl)) {
 361             $type = is_object($value) ? get_class($value) : gettype($value);
 362             throw new Exception\RuntimeException(
 363                 "wincache_ucache_set('{$internalKey}', <{$type}>, {$ttl}) failed"
 364             );
 365         }
 366
 367         return true;
 368     }
 369
 370     /**
 371      * Internal method to remove an item.
 372      *
 373      * @param  string $normalizedKey
 374      * @return bool
 375      * @throws Exception\ExceptionInterface
 376      */
 377     protected function internalRemoveItem(& $normalizedKey)
 378     {
 379         $options     = $this->getOptions();
 380         $namespace   = $options->getNamespace();
 381         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 382         $internalKey = $prefix . $normalizedKey;
 383         return wincache_ucache_delete($internalKey);
 384     }
 385
 386     /**
 387      * Internal method to remove multiple items.
 388      *
 389      * @param  array $normalizedKeys
 390      * @return array Array of not removed keys
 391      * @throws Exception\ExceptionInterface
 392      */
 393     protected function internalRemoveItems(array & $normalizedKeys)
 394     {
 395         $options   = $this->getOptions();
 396         $namespace = $options->getNamespace();
 397         if ($namespace === '') {
 398             $result = wincache_ucache_delete($normalizedKeys);
 399             return ($result === false) ? $normalizedKeys : $result;
 400         }
 401
 402         $prefix       = $namespace . $options->getNamespaceSeparator();
 403         $internalKeys = array();
 404         foreach ($normalizedKeys as $normalizedKey) {
 405             $internalKeys[] = $prefix . $normalizedKey;
 406         }
 407
 408         $result = wincache_ucache_delete($internalKeys);
 409         if ($result === false) {
 410             return $normalizedKeys;
 411         } elseif ($result) {
 412             // remove key prefix
 413             $prefixL = strlen($prefix);
 414             foreach ($result as & $key) {
 415                 $key = substr($key, $prefixL);
 416             }
 417         }
 418
 419         return $result;
 420     }
 421
 422     /**
 423      * Internal method to increment an item.
 424      *
 425      * @param  string $normalizedKey
 426      * @param  int    $value
 427      * @return int|bool The new value on success, false on failure
 428      * @throws Exception\ExceptionInterface
 429      */
 430     protected function internalIncrementItem(& $normalizedKey, & $value)
 431     {
 432         $options     = $this->getOptions();
 433         $namespace   = $options->getNamespace();
 434         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 435         $internalKey = $prefix . $normalizedKey;
 436         return wincache_ucache_inc($internalKey, (int) $value);
 437     }
 438
 439     /**
 440      * Internal method to decrement an item.
 441      *
 442      * @param  string $normalizedKey
 443      * @param  int    $value
 444      * @return int|bool The new value on success, false on failure
 445      * @throws Exception\ExceptionInterface
 446      */
 447     protected function internalDecrementItem(& $normalizedKey, & $value)
 448     {
 449         $options     = $this->getOptions();
 450         $namespace   = $options->getNamespace();
 451         $prefix      = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator();
 452         $internalKey = $prefix . $normalizedKey;
 453         return wincache_ucache_dec($internalKey, (int) $value);
 454     }
 455
 456     /* status */
 457
 458     /**
 459      * Internal method to get capabilities of this adapter
 460      *
 461      * @return Capabilities
 462      */
 463     protected function internalGetCapabilities()
 464     {
 465         if ($this->capabilities === null) {
 466             $marker       = new stdClass();
 467             $capabilities = new Capabilities(
 468                 $this,
 469                 $marker,
 470                 array(
 471                     'supportedDatatypes' => array(
 472                         'NULL'     => true,
 473                         'boolean'  => true,
 474                         'integer'  => true,
 475                         'double'   => true,
 476                         'string'   => true,
 477                         'array'    => true,
 478                         'object'   => 'object',
 479                         'resource' => false,
 480                     ),
 481                     'supportedMetadata' => array(
 482                         'internal_key', 'ttl', 'hits', 'size'
 483                     ),
 484                     'minTtl'             => 1,
 485                     'maxTtl'             => 0,
 486                     'staticTtl'          => true,
 487                     'ttlPrecision'       => 1,
 488                     'useRequestTime'     => false,
 489                     'expiredRead'        => false,
 490                     'namespaceIsPrefix'  => true,
 491                     'namespaceSeparator' => $this->getOptions()->getNamespaceSeparator(),
 492                 )
 493             );
 494
 495             // update namespace separator on change option
 496             $this->getEventManager()->attach('option', function ($event) use ($capabilities, $marker) {
 497                 $params = $event->getParams();
 498
 499                 if (isset($params['namespace_separator'])) {
 500                     $capabilities->setNamespaceSeparator($marker, $params['namespace_separator']);
 501                 }
 502             });
 503
 504             $this->capabilities     = $capabilities;
 505             $this->capabilityMarker = $marker;
 506         }
 507
 508         return $this->capabilities;
 509     }
 510
 511     /* internal */
 512
 513     /**
 514      * Normalize metadata to work with WinCache
 515      *
 516      * @param  array $metadata
 517      * @return void
 518      */
 519     protected function normalizeMetadata(array & $metadata)
 520     {
 521         $metadata['internal_key'] = $metadata['key_name'];
 522         $metadata['hits']         = $metadata['hitcount'];
 523         $metadata['ttl']          = $metadata['ttl_seconds'];
 524         $metadata['size']         = $metadata['value_size'];
 525
 526         unset(
 527             $metadata['key_name'],
 528             $metadata['hitcount'],
 529             $metadata['ttl_seconds'],
 530             $metadata['value_size']
 531         );
 532     }
 533 }