/** * 新增key * @param $key * @param $val * @param $expireTime * @return bool */ public function add($key, $val, $expireTime) { $ret = $this->dbh->add($key, $val, $expireTime); if ($ret === false) { $this->error('add', $key); } return true; }
function add($key, $value, $ttl = 0) { $key = str_replace('\\', '/', $key); if (!$this->memcached->add($key, $value, $ttl)) { $message = sprintf('Memcache::set() with key "%s" failed', $key); \ManiaLib\Utils\Logger::error($message); } }
public function add($id, $value, $ttl = null) { $ttl = $ttl ?: 0; if ($ttl > 0) { $ttl = time() + $ttl; } return $this->memcached->add($id, $value, $ttl); }
public function exists($id) { $success = $this->memcached->add($id, 0); if (!$success) { return true; } $this->memcached->delete($id); return false; }
/** * Lock the mutex * * @param string $mutexKey Identifier of the mutex. * @param int $expiry How long in seconds to keep the mutex locked just in * case the script dies. 0 = never expires. * * @throws LockFailedException */ public function lock($mutexKey, $expiry) { // Try and set the value. If it fails check to see if // it already contains our ID if (!$this->_memcache->add($mutexKey, $this->_getLockId(), $expiry)) { if (!$this->isLocked($mutexKey)) { throw new LockFailedException(); } } }
/** * 上锁 * * @param string $key * @return boolean */ public function acquire($key) { $key = $this->prefix . $key; $time = time(); while (time() - $time < $this->max_timeout) { if ($this->memcached->add($key, $this->Identifier, $this->timeout)) { return true; } usleep($this->retry_wait_usec); } return false; }
/** * Internal method to decrement an item. * * Options: * - ttl <float> * - The time-to-life * - namespace <string> * - The namespace to use * * @param string $normalizedKey * @param int $value * @param array $normalizedOptions * @return int|boolean The new value on success, false on failure * @throws Exception\ExceptionInterface */ protected function internalDecrementItem(& $normalizedKey, & $value, array & $normalizedOptions) { $this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $normalizedOptions['namespace']); $value = (int)$value; $newValue = $this->memcached->decrement($normalizedKey, $value); if ($newValue === false) { $rsCode = $this->memcached->getResultCode(); // initial value if ($rsCode == MemcachedResource::RES_NOTFOUND) { $newValue = -$value; $expiration = $this->expirationTime($normalizedOptions['ttl']); $this->memcached->add($normalizedKey, $newValue, $expiration); $rsCode = $this->memcached->getResultCode(); } if ($rsCode) { throw $this->getExceptionByResultCode($rsCode); } } return $newValue; }
/** * {@inheritdoc} */ public function doIncrement($key, $increment = 1, $initialValue = 0, $expiration = null, array $options = array()) { $key = $this->getKey($key, $options); /* Only the binary protocol supports initial value, in which case the implementation is simpler. */ if ($this->isBinaryProtocolActive()) { $result = $this->client->increment($key, $increment, $initialValue, $expiration); return new CacheResponse($result, $this->isSuccess(), $this->isSuccess() || $this->isNotFound()); } /* If the binary protocol is disable we must implement the initial value logic. */ $result = $this->client->increment($key, $increment); /* In case or success or any error aside "not found" there's nothing more to do. */ if ($this->isSuccess() || !$this->isNotFound()) { return new CacheResponse($result, true, true); } /** * Try to add the key; notice that "add" is used instead of "set", to ensure we do not override * the value in case another process already set it. */ $result = $this->client->add($key, $increment + $initialValue, $expiration); /* Created the key successfully. */ if ($this->isSuccess()) { return new CacheResponse($increment + $initialValue, true, true); } /* The key was not stored because is already existed, try to increment a last time. */ if ($this->isNotStored()) { $result = $this->client->increment($key, $increment); return new CacheResponse($result, $this->isSuccess(), $this->isSuccess() || $this->isNotFound()); } return new CacheResponse($result, false, false); }
/** * 批量设置键值(当键名不存在时);<br> * 只有当键值全部设置成功时,才返回true,否则返回false并尝试回滚 * @param array $sets 键值数组 * @return boolean 是否成功 */ public function mSetNX($sets) { try { $keys = []; $status = true; foreach ($sets as $key => $value) { $status = $this->handler->add($key, self::setValue($value)); if ($status) { $keys[] = $key; } else { break; } } //如果失败,尝试回滚,但不保证成功 if (!$status) { foreach ($keys as $key) { $this->handler->delete($key); } } return $status; } catch (Exception $ex) { self::exception($ex); //连接状态置为false $this->isConnected = false; } return false; }
/** * Lock cache index * * @return boolean True on success, false otherwise. * * @since 12.1 */ protected function lockindex() { $looptime = 300; $data_lock = self::$_db->add($this->_hash . '-index_lock', 1, 30); if ($data_lock === false) { $lock_counter = 0; // Loop until you find that the lock has been released. that implies that data get from other thread has finished while ($data_lock === false) { if ($lock_counter > $looptime) { return false; break; } usleep(100); $data_lock = self::$_db->add($this->_hash . '-index_lock', 1, 30); $lock_counter++; } } return true; }
/** * Add an item. * * Options: * - namespace <string> optional * - The namespace to use (Default: namespace of object) * - tags <array> optional * - An array of tags * * @param string $key * @param mixed $value * @param array $options * @return boolean * @throws Exception * * @triggers addItem.pre(PreEvent) * @triggers addItem.post(PostEvent) * @triggers addItem.exception(ExceptionEvent) */ public function addItem($key, $value, array $options = array()) { $baseOptions = $this->getOptions(); if (!$baseOptions->getWritable()) { return false; } $this->normalizeOptions($options); $this->normalizeKey($key); $args = new ArrayObject(array('key' => &$key, 'value' => &$value, 'options' => &$options)); try { $eventRs = $this->triggerPre(__FUNCTION__, $args); if ($eventRs->stopped()) { return $eventRs->last(); } $internalKey = $options['namespace'] . $baseOptions->getNamespaceSeparator() . $key; if (!$this->memcached->add($internalKey, $value, $options['ttl'])) { if ($this->memcached->get($internalKey) !== false) { throw new Exception\RuntimeException("Key '{$internalKey}' already exists"); } $type = is_object($value) ? get_class($value) : gettype($value); throw new Exception\RuntimeException("Memcached::add('{$internalKey}', <{$type}>, {$options['ttl']}) failed"); } $result = true; return $this->triggerPost(__FUNCTION__, $args, $result); } catch (\Exception $e) { return $this->triggerException(__FUNCTION__, $args, $e); } }
/** * Decrement an item. * * Options: * - namespace <string> optional * - The namespace to use (Default: namespace of object) * - ignore_missing_items <boolean> optional * - Throw exception on missing item or return false * * @param string $key * @param int $value * @param array $options * @return int|boolean The new value or false or failure * @throws Exception * * @triggers decrementItem.pre(PreEvent) * @triggers decrementItem.post(PostEvent) * @triggers decrementItem.exception(ExceptionEvent) */ public function decrementItem($key, $value, array $options = array()) { $baseOptions = $this->getOptions(); if (!$baseOptions->getWritable()) { return false; } $this->normalizeOptions($options); $this->normalizeKey($key); $args = new ArrayObject(array('key' => &$key, 'value' => &$value, 'options' => &$options)); try { $eventRs = $this->triggerPre(__FUNCTION__, $args); if ($eventRs->stopped()) { return $eventRs->last(); } $this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $options['namespace']); $value = (int) $value; $newValue = $this->memcached->decrement($key, $value); if ($newValue === false) { if (($rsCode = $this->memcached->getResultCode()) != 0 && ($rsCode != MemcachedResource::RES_NOTFOUND || !$options['ignore_missing_items'])) { throw $this->getExceptionByResultCode($rsCode); } $expiration = $this->expirationTime($options['ttl']); if (!$this->memcached->add($key, -$value, $expiration)) { throw $this->getExceptionByResultCode($this->memcached->getResultCode()); } $newValue = -$value; } return $this->triggerPost(__FUNCTION__, $args, $newValue); } catch (\Exception $e) { return $this->triggerException(__FUNCTION__, $args, $e); } }
/** * 添加数据 * @param string|array $key * @param mixed $value * @param int $expiration * @return array|bool */ public function add($key = NULL, $value = NULL, $expiration = 0) { if (is_null($expiration)) { $expiration = C(Config::MEMCACHE_EXPIRATION); } $expiration = intval($expiration); if (is_array($key)) { foreach ($key as $multi) { if (!isset($multi['expiration']) || $multi['expiration'] == '') { $multi['expiration'] = $expiration; } $this->add($this->key_name($multi['key']), $multi['value'], $multi['expiration']); } $add_status = true; } else { $keyName = $this->key_name($key); $this->local_cache[$keyName] = $value; switch ($this->client_type) { case 'Memcache': $add_status = $this->m->add($keyName, $value, C(Config::MEMCACHE_COMPRESSION), $expiration); break; default: case 'Memcached': $add_status = $this->m->add($keyName, $value, $expiration); break; } } return $add_status; }
/** * Adds a value to cache. * * If the specified key already exists, the value is not stored and the function * returns false. * * @link http://www.php.net/manual/en/memcached.add.php * * @param string $key The key under which to store the value. * @param mixed $value The value to store. * @param string $group The group value appended to the $key. * @param int $expiration The expiration time, defaults to 0. * @param string $server_key The key identifying the server to store the value on. * @param bool $byKey True to store in internal cache by key; false to not store by key * @return bool Returns TRUE on success or FALSE on failure. */ public function add($key, $value, $group = 'default', $expiration = 0, $server_key = '', $byKey = false) { /** * Ensuring that wp_suspend_cache_addition is defined before calling, because sometimes an advanced-cache.php * file will load object-cache.php before wp-includes/functions.php is loaded. In those cases, if wp_cache_add * is called in advanced-cache.php before any more of WordPress is loaded, we get a fatal error because * wp_suspend_cache_addition will not be defined until wp-includes/functions.php is loaded. */ if (function_exists('wp_suspend_cache_addition') && wp_suspend_cache_addition()) { return false; } $derived_key = $this->buildKey($key, $group); $expiration = $this->sanitize_expiration($expiration); // If group is a non-Memcached group, save to runtime cache, not Memcached if (in_array($group, $this->no_mc_groups)) { // Add does not set the value if the key exists; mimic that here if (isset($this->cache[$derived_key])) { return false; } $this->add_to_internal_cache($derived_key, $value); return true; } // Save to Memcached if (false !== $byKey) { $result = $this->mc->addByKey($server_key, $derived_key, $value, $expiration); } else { $result = $this->mc->add($derived_key, $value, $expiration); } // Store in runtime cache if add was successful if (Memcached::RES_SUCCESS === $this->getResultCode()) { $this->add_to_internal_cache($derived_key, $value); } return $result; }
/** * Set a value in the cache if it's not already stored * * @param string $key * @param mixed $value * @param int $ttl Time To Live in seconds. Defaults to 60*60*24 * @return bool * @throws \Exception */ public function add($key, $value, $ttl = 0) { $result = self::$cache->add($this->getPrefix() . $key, $value, $ttl); if (self::$cache->getResultCode() !== \Memcached::RES_NOTSTORED) { $this->verifyReturnCode(); } return $result; }
public function set($key, $value) { $this->get($key); if (!$value) { throw new StorageException('[STORAGE] Given value for "' . $this->getStorageName() . '::set" not valid! Key: ' . $key); } if ($this->memcachedObj->getResultCode() == \Memcached::RES_NOTFOUND) { $this->memcachedObj->add($key, $value); unset($this->casArray[$key]); } else { $this->memcachedObj->cas($this->casArray[$key], $key, $value); } $resultCode = $this->memcachedObj->getResultCode(); if ($resultCode != \Memcached::RES_SUCCESS) { throw new StorageException('[STORAGE] "' . $this->getStorageName() . '::set" failed!' . ' StorageRespCode: ' . $resultCode . ', Key: ' . $key . ', Cas: ' . (isset($this->casArray[$key]) ? $this->casArray[$key] : 'null')); } return $resultCode; }
/** * Add a key to the cache if it does not already exist. * * @param string $key Identifier for the data. * @param mixed $value Data to be cached. * @return bool True if the data was successfully cached, false on failure. */ public function add($key, $value) { $duration = $this->_config['duration']; if ($duration > 30 * DAY) { $duration = 0; } $key = $this->_key($key); return $this->_Memcached->add($key, $value, $duration); }
/** * Save data into a memory area shared by all users, all sessions on server * * @param string $memoryid Memory id of shared area * @param string $data Data to save * @return int <0 if KO, Nb of bytes written if OK */ function dol_setcache($memoryid, $data) { global $conf; $result = 0; // Using a memcached server if (!empty($conf->memcached->enabled) && class_exists('Memcached')) { global $dolmemcache; if (empty($dolmemcache) || !is_object($dolmemcache)) { $dolmemcache = new Memcached(); $tmparray = explode(':', $conf->global->MEMCACHED_SERVER); $result = $dolmemcache->addServer($tmparray[0], $tmparray[1] ? $tmparray[1] : 11211); if (!$result) { return -1; } } $memoryid = session_name() . '_' . $memoryid; //$dolmemcache->setOption(Memcached::OPT_COMPRESSION, false); //print "Add memoryid=".$memoryid; $dolmemcache->add($memoryid, $data); // This fails if key already exists $rescode = $dolmemcache->getResultCode(); if ($rescode == 0) { return count($data); } else { return -$rescode; } } else { if (!empty($conf->memcached->enabled) && class_exists('Memcache')) { global $dolmemcache; if (empty($dolmemcache) || !is_object($dolmemcache)) { $dolmemcache = new Memcache(); $tmparray = explode(':', $conf->global->MEMCACHED_SERVER); $result = $dolmemcache->addServer($tmparray[0], $tmparray[1] ? $tmparray[1] : 11211); if (!$result) { return -1; } } $memoryid = session_name() . '_' . $memoryid; //$dolmemcache->setOption(Memcached::OPT_COMPRESSION, false); $result = $dolmemcache->add($memoryid, $data); // This fails if key already exists if ($result) { return count($data); } else { return -1; } } else { if (isset($conf->global->MAIN_OPTIMIZE_SPEED) && $conf->global->MAIN_OPTIMIZE_SPEED & 0x2) { $result = dol_setshmop($memoryid, $data); } } } return $result; }
public function cas($key, $value) { if (($rValue = $this->memcached->get($key, null, $token)) !== false) { return $rValue; } if ($this->memcached->getResultCode() === Memcached::RES_NOTFOUND) { $this->memcached->add($key, $value); } else { $this->memcached->cas($token, $key, $value); } return $value; }
/** * (non-PHPdoc) * * @see Memcached::addServer() * * @abstract indicator of a positive connection should be returned */ public function addServer($host, $port, $weight = null) { $this->is_connected = parent::addServer($host, $port, $weight); // Get the Cache Listing $this->cache_listing = parent::get('cache_listing'); if ($this->cache_listing === FALSE) { parent::add('cache_listing', array()); $this->cache_listing = array(); } // check sum for the saving process $this->_md5_sum = md5(serialize($this->cache_listing)); }
function handle($pKey, $userKey) { $this->privateKey = $pKey; $this->userKey = $userKey; $memcache = new Memcached(); if ($this->rateUsed = $memcache->get($this->memcacheKey())) { $memcache->increment($this->memcacheKey(), 1); $this->rateUsed += 1; } else { $memcache->add($this->memcacheKey(), 1, $this->getNextResetTime()); $this->rateUsed = 1; } return $this->isValid(); }
/** * @param $keyword * @param string $value * @param int $time * @param array $option * @return bool */ public function driver_set($keyword, $value = '', $time = 300, $option = array()) { $this->connectServer(); // Memcache will only allow a expiration timer less than 2592000 seconds, // otherwise, it will assume you're giving it a UNIX timestamp. if ($time > 2592000) { $time = time() + $time; } if (isset($option['isExisting']) && $option['isExisting'] == true) { return $this->instant->add($keyword, $value, $time); } else { return $this->instant->set($keyword, $value, $time); } }
/** * \brief Save data into a memory area shared by all users, all sessions on server * \param $memoryid Memory id of shared area * \param $data Data to save * \return int <0 if KO, Nb of bytes written if OK */ function dol_setcache($memoryid,$data) { global $conf; $result=0; // Using a memcached server if (! empty($conf->memcached->enabled) && class_exists('Memcached')) { $memoryid=session_name().'_'.$memoryid; $m=new Memcached(); $tmparray=explode(':',$conf->global->MEMCACHED_SERVER); $result=$m->addServer($tmparray[0], $tmparray[1]?$tmparray[1]:11211); //$m->setOption(Memcached::OPT_COMPRESSION, false); $m->add($memoryid,$data); $rescode=$m->getResultCode(); if ($rescode == 0) { return sizeof($data); } else { return -$rescode; } } else if (! empty($conf->memcached->enabled) && class_exists('Memcache')) { $memoryid=session_name().'_'.$memoryid; $m=new Memcache(); $tmparray=explode(':',$conf->global->MEMCACHED_SERVER); $result=$m->addServer($tmparray[0], $tmparray[1]?$tmparray[1]:11211); //$m->setOption(Memcached::OPT_COMPRESSION, false); $result=$m->add($memoryid,$data); if ($result) { return sizeof($data); } else { return -1; } } // Using shmop else if (isset($conf->global->MAIN_OPTIMIZE_SPEED) && ($conf->global->MAIN_OPTIMIZE_SPEED & 0x02)) { $result=dol_setshmop($memoryid,$data); } return $result; }
/** * Set a value in cache if it doesn't already exist. Internally, this uses * Memcache::add * * @param string $key * @param mixed $value * @param integer $ttl * @return boolean */ public function setIfNotExists($key, $value, $ttl = self::DEFAULT_TTL) { if (!$this->hasConnection()) { // @codeCoverageIgnoreStart return false; // @codeCoverageIgnoreEnd } try { return $this->memcached->add($this->getKeyString($key), $value, $ttl); // @codeCoverageIgnoreStart } catch (\Exception $e) { } return false; // @codeCoverageIgnoreEnd }
/** * Namespace a key. * * @since 151216 Memcached utilities. * * @param string $primary_key Primary key. * @param string|int $sub_key Sub-key. * * @return string Full namespaced cache key. */ protected function key(string $primary_key, $sub_key) : string { if (!$this->Pool) { return ''; // Not possible. } if (!($namespaced_primary_key = $this->nspKey($primary_key))) { return ''; // Not possible; e.g., empty key. } $namespaced_primary_key_uuid = ''; // Initialize. do { // Avoid race issues with a loop. $attempts = $attempts ?? 0; ++$attempts; // Counter. if ($existing_namespaced_primary_key_uuid = (string) $this->Pool->get($namespaced_primary_key)) { $namespaced_primary_key_uuid = $existing_namespaced_primary_key_uuid; break; // All good; stop here. } if (!isset($new_namespaced_primary_key_uuid)) { $new_namespaced_primary_key_uuid = $this->c::uuidV4(); } if ($this->Pool->add($namespaced_primary_key, $new_namespaced_primary_key_uuid)) { $namespaced_primary_key_uuid = $new_namespaced_primary_key_uuid; break; // All good; stop here. } $result_code = $this->Pool->getResultCode(); // } while ($attempts < $this::MAX_WRITE_ATTEMPTS && $result_code === \Memcached::RES_NOTSTORED); if (!$namespaced_primary_key_uuid) { return ''; // Failure; e.g., race condition. } $sub_key = (string) $sub_key; $namespaced_primary_key_uuid_prefix = $namespaced_primary_key_uuid . '\\'; $namespaced_key = $namespaced_primary_key_uuid_prefix . $sub_key; if (isset($namespaced_key[251])) { throw $this->c::issue(sprintf('Sub key too long; %1$s bytes max.', 250 - strlen($namespaced_primary_key_uuid_prefix))); } return $namespaced_key; }
/** * * * @param string $key * @param mixed $value * @param array $options * @return bool */ public function add($key, $value, $options = array()) { if (!$this->online()) { return Gdn_Cache::CACHEOP_FAILURE; } $finalOptions = array_merge($this->StoreDefaults, $options); $expiry = val(Gdn_Cache::FEATURE_EXPIRY, $finalOptions, 0); $useLocal = (bool) $finalOptions[Gdn_Cache::FEATURE_LOCAL]; $realKey = $this->makeKey($key, $finalOptions); // Sharding, write real keys if (array_key_exists(Gdn_Cache::FEATURE_SHARD, $finalOptions) && ($shards = $finalOptions[Gdn_Cache::FEATURE_SHARD])) { $manifest = $this->shard($realKey, $value, $shards); $shards = $manifest->shards; unset($manifest->shards); // Attempt to write manifest $added = $this->memcache->add($realKey, $manifest, $expiry); // Check if things went ok $ok = $this->lastAction($realKey); if (!$ok || !$added) { return Gdn_Cache::CACHEOP_FAILURE; } // Write real keys foreach ($shards as $shard) { $this->memcache->setByKey($shard['server'], $shard['key'], $shard['data'], $expiry); } unset($shards); if ($useLocal) { $this->localSet($realKey, $value); } return Gdn_Cache::CACHEOP_SUCCESS; } $stored = $this->memcache->add($realKey, $value, $expiry); // Check if things went ok $ok = $this->lastAction($realKey); if (!$ok) { return Gdn_Cache::CACHEOP_FAILURE; } if ($stored) { if ($useLocal) { $this->localSet($realKey, $value); } return Gdn_Cache::CACHEOP_SUCCESS; } return Gdn_Cache::CACHEOP_FAILURE; }
/** * Internal method to decrement an item. * * @param string $normalizedKey * @param int $value * @return int|boolean The new value on success, false on failure * @throws Exception\ExceptionInterface */ protected function internalDecrementItem(&$normalizedKey, &$value) { $value = (int) $value; $newValue = $this->memcached->decrement($normalizedKey, $value); if ($newValue === false) { $rsCode = $this->memcached->getResultCode(); // initial value if ($rsCode == MemcachedResource::RES_NOTFOUND) { $newValue = -$value; $this->memcached->add($normalizedKey, $newValue, $this->expirationTime()); $rsCode = $this->memcached->getResultCode(); } if ($rsCode) { throw $this->getExceptionByResultCode($rsCode); } } return $newValue; }
/** * construct wrapper * * @param \stdClass $param * * @return \chilimatic\lib\Cache\Engine\Memcached */ public function __construct($param = null) { parent::__construct(isset($param->persistent_id) ? $param->persistent_id : null, isset($param->callback) ? $param->callback : null); if (isset($param->server_list)) { $server = $param->server_list; if (count($server) === 1) { $server = array_pop($server); $this->setConnected(parent::addServer($server->host, $server->port ?? self::DEFAULT_PORT, isset($server->weight) ? $server->weight : null)); } else { $this->setConnected(parent::addServers($server)); } } // Get the Cache Listing $this->cacheListing = parent::get('cacheListing'); if ($this->cacheListing === false) { parent::add('cacheListing', array()); $this->cacheListing = array(); } // check sum for the saving process $this->md5Sum = md5(json_encode($this->cacheListing)); }
/** * Returns the name for the given cache name in respect to flush count. * * @param string $cacheName * @return string */ protected function getCacheName($cacheName) { $parts = explode('-', $cacheName, 2); $flush = $this->memcached->get('_flush'); // create flush counter if it does not exist if ($flush === false) { $this->memcached->add('_flush', TIME_NOW); $flush = $this->memcached->get('_flush'); } // the cache specific flush counter only is of interest if the cache name contains parameters // the version without parameters is deleted explicitly when calling flush // this saves us a memcached query in most cases (caches without any parameters) if (isset($parts[1])) { $flushByCache = $this->memcached->get('_flush_' . $parts[0]); // create flush counter if it does not exist if ($flushByCache === false) { $this->memcached->add('_flush_' . $parts[0], TIME_NOW); $flushByCache = $this->memcached->get('_flush_' . $parts[0]); } $flush .= '_' . $flushByCache; } return $flush . '_' . $cacheName; }
public function testPassingNullKey() { $memcached = new Memcached(); $this->assertFalse($memcached->add(null, 1)); $this->assertFalse($memcached->replace(null, 1)); $this->assertFalse($memcached->set(null, 1)); $this->assertFalse($memcached->increment(null)); $this->assertFalse($memcached->decrement(null)); }