Namespaces

  • Latte
    • Loaders
    • Macros
    • Runtime
  • Nette
    • Application
      • Responses
      • Routers
      • UI
    • Bridges
      • ApplicationDI
      • ApplicationLatte
      • ApplicationTracy
      • CacheDI
      • CacheLatte
      • DatabaseDI
      • DatabaseTracy
      • DITracy
      • FormsDI
      • FormsLatte
      • Framework
      • HttpDI
      • HttpTracy
      • MailDI
      • ReflectionDI
      • SecurityDI
      • SecurityTracy
    • Caching
      • Storages
    • ComponentModel
    • Database
      • Conventions
      • Drivers
      • Table
    • DI
      • Config
        • Adapters
      • Extensions
    • Forms
      • Controls
      • Rendering
    • Http
    • Iterators
    • Loaders
    • Localization
    • Mail
    • Neon
    • PhpGenerator
    • Reflection
    • Security
    • Tokenizer
    • Utils
  • Tracy
    • Bridges
      • Nette
  • none

Classes

  • DevNullStorage
  • FileStorage
  • MemcachedStorage
  • MemoryStorage
  • NewMemcachedStorage
  • SQLiteJournal
  • SQLiteStorage

Interfaces

  • IJournal
  • Overview
  • Namespace
  • Class
  • Tree
  • Deprecated
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (https://nette.org)
  5:  * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
  6:  */
  7: 
  8: namespace Nette\Caching\Storages;
  9: 
 10: use Nette;
 11: use Nette\Caching\Cache;
 12: 
 13: 
 14: /**
 15:  * Memcached storage.
 16:  */
 17: class MemcachedStorage implements Nette\Caching\IStorage
 18: {
 19:     use Nette\SmartObject;
 20: 
 21:     /** @internal cache structure */
 22:     const META_CALLBACKS = 'callbacks',
 23:         META_DATA = 'data',
 24:         META_DELTA = 'delta';
 25: 
 26:     /** @var \Memcache */
 27:     private $memcache;
 28: 
 29:     /** @var string */
 30:     private $prefix;
 31: 
 32:     /** @var IJournal */
 33:     private $journal;
 34: 
 35: 
 36:     /**
 37:      * Checks if Memcached extension is available.
 38:      * @return bool
 39:      */
 40:     public static function isAvailable()
 41:     {
 42:         return extension_loaded('memcache');
 43:     }
 44: 
 45: 
 46:     public function __construct($host = 'localhost', $port = 11211, $prefix = '', IJournal $journal = null)
 47:     {
 48:         if (!static::isAvailable()) {
 49:             throw new Nette\NotSupportedException("PHP extension 'memcache' is not loaded.");
 50:         }
 51: 
 52:         $this->prefix = $prefix;
 53:         $this->journal = $journal;
 54:         $this->memcache = new \Memcache;
 55:         if ($host) {
 56:             $this->addServer($host, $port);
 57:         }
 58:     }
 59: 
 60: 
 61:     public function addServer($host = 'localhost', $port = 11211, $timeout = 1)
 62:     {
 63:         if ($this->memcache->addServer($host, $port, true, 1, $timeout) === false) {
 64:             $error = error_get_last();
 65:             throw new Nette\InvalidStateException("Memcache::addServer(): $error[message].");
 66:         }
 67:     }
 68: 
 69: 
 70:     /**
 71:      * @return \Memcache
 72:      */
 73:     public function getConnection()
 74:     {
 75:         return $this->memcache;
 76:     }
 77: 
 78: 
 79:     /**
 80:      * Read from cache.
 81:      * @param  string
 82:      * @return mixed
 83:      */
 84:     public function read($key)
 85:     {
 86:         $key = urlencode($this->prefix . $key);
 87:         $meta = $this->memcache->get($key);
 88:         if (!$meta) {
 89:             return null;
 90:         }
 91: 
 92:         // meta structure:
 93:         // array(
 94:         //     data => stored data
 95:         //     delta => relative (sliding) expiration
 96:         //     callbacks => array of callbacks (function, args)
 97:         // )
 98: 
 99:         // verify dependencies
100:         if (!empty($meta[self::META_CALLBACKS]) && !Cache::checkCallbacks($meta[self::META_CALLBACKS])) {
101:             $this->memcache->delete($key, 0);
102:             return null;
103:         }
104: 
105:         if (!empty($meta[self::META_DELTA])) {
106:             $this->memcache->replace($key, $meta, 0, $meta[self::META_DELTA] + time());
107:         }
108: 
109:         return $meta[self::META_DATA];
110:     }
111: 
112: 
113:     /**
114:      * Prevents item reading and writing. Lock is released by write() or remove().
115:      * @param  string
116:      * @return void
117:      */
118:     public function lock($key)
119:     {
120:     }
121: 
122: 
123:     /**
124:      * Writes item into the cache.
125:      * @param  string
126:      * @param  mixed
127:      * @return void
128:      */
129:     public function write($key, $data, array $dp)
130:     {
131:         if (isset($dp[Cache::ITEMS])) {
132:             throw new Nette\NotSupportedException('Dependent items are not supported by MemcachedStorage.');
133:         }
134: 
135:         $key = urlencode($this->prefix . $key);
136:         $meta = [
137:             self::META_DATA => $data,
138:         ];
139: 
140:         $expire = 0;
141:         if (isset($dp[Cache::EXPIRATION])) {
142:             $expire = (int) $dp[Cache::EXPIRATION];
143:             if (!empty($dp[Cache::SLIDING])) {
144:                 $meta[self::META_DELTA] = $expire; // sliding time
145:             }
146:         }
147: 
148:         if (isset($dp[Cache::CALLBACKS])) {
149:             $meta[self::META_CALLBACKS] = $dp[Cache::CALLBACKS];
150:         }
151: 
152:         if (isset($dp[Cache::TAGS]) || isset($dp[Cache::PRIORITY])) {
153:             if (!$this->journal) {
154:                 throw new Nette\InvalidStateException('CacheJournal has not been provided.');
155:             }
156:             $this->journal->write($key, $dp);
157:         }
158: 
159:         $this->memcache->set($key, $meta, 0, $expire);
160:     }
161: 
162: 
163:     /**
164:      * Removes item from the cache.
165:      * @param  string
166:      * @return void
167:      */
168:     public function remove($key)
169:     {
170:         $this->memcache->delete(urlencode($this->prefix . $key), 0);
171:     }
172: 
173: 
174:     /**
175:      * Removes items from the cache by conditions & garbage collector.
176:      * @param  array  conditions
177:      * @return void
178:      */
179:     public function clean(array $conditions)
180:     {
181:         if (!empty($conditions[Cache::ALL])) {
182:             $this->memcache->flush();
183: 
184:         } elseif ($this->journal) {
185:             foreach ($this->journal->clean($conditions) as $entry) {
186:                 $this->memcache->delete($entry, 0);
187:             }
188:         }
189:     }
190: }
191: 
Nette 2.4-20170829 API API documentation generated by ApiGen 2.8.0