/**
* update
*
* @param mixed $identifier identifier to save
* @param string $amount the current amount
* @param string $timespan the timespan in seconds
*
* @return boolean
*/
public function update($identifier = null, $amount = null, $timespan = null)
{
if (!$identifier && !$amount && !$timespan) {
throw new \InvalidArgumentException('identifier, amount and timespan are required');
}
return $this->memcached->replace($this->fileName($identifier), $amount, $timespan);
}
/**
* 替换已经存在的key
* @param $key
* @param $val
* @param $expireTime
* @return bool
*/
public function update($key, $val, $expireTime)
{
$ret = $this->dbh->replace($key, $val, $expireTime);
if ($ret === false) {
$this->error('update', $key);
}
return true;
}
function replace($key, $value, $ttl = 0)
{
$key = str_replace('\\', '/', $key);
if (!$this->memcached->replace($key, $value, $ttl)) {
$message = sprintf('Memcache::replace() with key "%s" failed', $key);
\ManiaLib\Utils\Logger::error($message);
}
}
/**
* {@inheritdoc}
*/
public function put($key, $data, $ttl = 0)
{
if ($ttl !== 0) {
$ttl += time();
}
if ($this->memcached->replace($key, $data, $ttl) === false) {
return $this->memcached->set($key, $data, $ttl);
}
return true;
}
/**
* Unlock cached item - override parent for cacheid compatibility with lock
*
* @param string $id The cache data id
* @param string $group The cache data group
*
* @return boolean True on success, false otherwise.
*
* @since 12.1
*/
public function unlock($id, $group = null)
{
$cache_id = $this->_getCacheId($id, $group) . '_lock';
if (!$this->lockindex())
{
return false;
}
$index = self::$_db->get($this->_hash . '-index');
if ($index === false)
{
$index = array();
}
foreach ($index as $key => $value)
{
if ($value->name == $cache_id)
{
unset($index[$key]);
}
break;
}
self::$_db->replace($this->_hash . '-index', $index, 0);
$this->unlockindex();
return self::$_db->delete($cache_id);
}
/**
* Replaces a value in cache.
*
* This method is similar to "add"; however, is does not successfully set a value if
* the object's key is not already set in cache.
*
* @link http://www.php.net/manual/en/memcached.replace.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 replace($key, $value, $group = 'default', $expiration = 0, $server_key = '', $byKey = 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)) {
// Replace won't save unless the key already exists; mimic this behavior here
if (!isset($this->cache[$derived_key])) {
return false;
}
$this->cache[$derived_key] = $value;
return true;
}
// Save to Memcached
if (false !== $byKey) {
$result = $this->mc->replaceByKey($server_key, $derived_key, $value, $expiration);
} else {
$result = $this->mc->replace($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;
}
/**
* Get lock
*
* Acquires an (emulated) lock.
*
* @param string $session_id Session ID
* @return bool
*/
protected function _get_lock($session_id)
{
if (isset($this->_lock_key)) {
return $this->_memcached->replace($this->_lock_key, time(), 300);
}
// 30 attempts to obtain a lock, in case another request already has it
$lock_key = $this->_key_prefix . $session_id . ':lock';
$attempt = 0;
do {
if ($this->_memcached->get($lock_key)) {
sleep(1);
continue;
}
if (!$this->_memcached->set($lock_key, time(), 300)) {
return FALSE;
}
$this->_lock_key = $lock_key;
break;
} while (++$attempt < 30);
if ($attempt === 30) {
return FALSE;
}
$this->_lock = TRUE;
return TRUE;
}
/**
* Get lock
*
* Acquires an (emulated) lock.
*
* @param string $session_id Session ID
*
* @return bool
*/
protected function lockSession(string $session_id) : bool
{
if (isset($this->lockKey)) {
return $this->memcached->replace($this->lockKey, time(), 300);
}
// 30 attempts to obtain a lock, in case another request already has it
$lock_key = $this->keyPrefix . $session_id . ':lock';
$attempt = 0;
do {
if ($this->memcached->get($lock_key)) {
sleep(1);
continue;
}
if (!$this->memcached->set($lock_key, time(), 300)) {
$this->logger->error('Session: Error while trying to obtain lock for ' . $this->keyPrefix . $session_id);
return false;
}
$this->lockKey = $lock_key;
break;
} while (++$attempt < 30);
if ($attempt === 30) {
$this->logger->error('Session: Unable to obtain lock for ' . $this->keyPrefix . $session_id . ' after 30 attempts, aborting.');
return false;
}
$this->lock = true;
return true;
}
/**
* Replace an item.
*
* Options:
* - ttl <float> optional
* - The time-to-live (Default: ttl of object)
* - namespace <string> optional
* - The namespace to use (Default: namespace of object)
*
* @param string $key
* @param mixed $value
* @param array $options
* @return boolean
* @throws Exception
*
* @triggers replaceItem.pre(PreEvent)
* @triggers replaceItem.post(PostEvent)
* @triggers replaceItem.exception(ExceptionEvent)
*/
public function replaceItem($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']);
$expiration = $this->expirationTime($options['ttl']);
if (!$this->memcached->replace($key, $value, $expiration)) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
$result = true;
return $this->triggerPost(__FUNCTION__, $args, $result);
} catch (\Exception $e) {
return $this->triggerException(__FUNCTION__, $args, $e);
}
}
/**
* Get lock
*
* Acquires an (emulated) lock.
*
* @param string $session_id Session ID
* @return bool
*/
protected function _get_lock($session_id)
{
// PHP 7 reuses the SessionHandler object on regeneration,
// so we need to check here if the lock key is for the
// correct session ID.
if ($this->_lock_key === $this->_key_prefix . $session_id . ':lock') {
return $this->_memcached->replace($this->_lock_key, time(), 300) ? $this->_success : $this->_failure;
}
// 30 attempts to obtain a lock, in case another request already has it
$lock_key = $this->_key_prefix . $session_id . ':lock';
$attempt = 0;
do {
if ($this->_memcached->get($lock_key)) {
sleep(1);
continue;
}
if (!$this->_memcached->set($lock_key, time(), 300)) {
log_message('error', 'Session: Error while trying to obtain lock for ' . $this->_key_prefix . $session_id);
return $this->_failure;
}
$this->_lock_key = $lock_key;
break;
} while (++$attempt < 30);
if ($attempt === 30) {
log_message('error', 'Session: Unable to obtain lock for ' . $this->_key_prefix . $session_id . ' after 30 attempts, aborting.');
return $this->_failure;
}
$this->_lock = TRUE;
return $this->_success;
}
/**
* @Name replace
*
* @param string|array $key 要替换的key
* @param mixed $value 要替换的value
* @param int|null $expiration 到期时间
* @return bool add by cheng.yafei
*
*/
public function replace($key = NULL, $value = NULL, $expiration = NULL)
{
if (is_null($expiration)) {
$expiration = C(Config::MEMCACHE_EXPIRATION);
}
if (is_array($key)) {
foreach ($key as $multi) {
if (!isset($multi['expiration']) || $multi['expiration'] == '') {
$multi['expiration'] = $expiration;
}
$this->replace($multi['key'], $multi['value'], $multi['expiration']);
}
$replace_status = true;
} else {
$this->local_cache[$this->key_name($key)] = $value;
$replace_status = false;
switch ($this->client_type) {
case 'Memcache':
$replace_status = $this->m->replace($this->key_name($key), $value, C(Config::MEMCACHE_COMPRESSION), $expiration);
break;
case 'Memcached':
$replace_status = $this->m->replace($this->key_name($key), $value, $expiration);
break;
}
}
return $replace_status;
}
/**
* Get lock
*
* Acquires an (emulated) lock.
*
* @param string $session_id Session ID
* @return bool
*/
protected function _get_lock($session_id)
{
if (isset($this->_lock_key)) {
return $this->_memcached->replace($this->_lock_key, time(), 300);
}
// 30 attempts to obtain a lock, in case another request already has it
$lock_key = $this->_key_prefix . $session_id . ':lock';
$attempt = 0;
do {
if ($this->_memcached->get($lock_key)) {
sleep(1);
continue;
}
if (!$this->_memcached->set($lock_key, time(), 300)) {
log_message('error', 'Session: Error while trying to obtain lock for ' . $this->_key_prefix . $session_id);
return FALSE;
}
$this->_lock_key = $lock_key;
break;
} while (++$attempt < 30);
if ($attempt === 30) {
log_message('error', 'Session: Unable to obtain lock for ' . $this->_key_prefix . $session_id . ' after 30 attempts, aborting.');
return FALSE;
}
$this->_lock = TRUE;
return TRUE;
}
/**
* Write
*
* Writes (create / update) session data
*
* @param string $session_id Session ID
* @param string $session_data Serialized session data
* @return bool
*/
public function write($session_id, $session_data)
{
if (!isset($this->_memcached)) {
return $this->_fail();
} elseif ($session_id !== $this->_session_id) {
if (!$this->_release_lock() or !$this->_get_lock($session_id)) {
return $this->_fail();
}
$this->_fingerprint = md5('');
$this->_session_id = $session_id;
}
if (isset($this->_lock_key)) {
$key = $this->_key_prefix . $session_id;
$this->_memcached->replace($this->_lock_key, time(), 300);
if ($this->_fingerprint !== ($fingerprint = md5($session_data))) {
if ($this->_memcached->replace($key, $session_data, $this->_config['expiration']) or $this->_memcached->getResultCode() === Memcached::RES_NOTFOUND && $this->_memcached->set($key, $session_data, $this->_config['expiration'])) {
$this->_fingerprint = $fingerprint;
return $this->_success;
}
return $this->_fail();
}
if ($this->_memcached->touch($key, $this->_config['expiration']) or $this->_memcached->getResultCode() === Memcached::RES_NOTFOUND && $this->_memcached->set($key, $session_data, $this->_config['expiration'])) {
return $this->_success;
}
}
return $this->_fail();
}
/**
* Replace 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 replaceItem.pre(PreEvent)
* @triggers replaceItem.post(PostEvent)
* @triggers replaceItem.exception(ExceptionEvent)
*/
public function replaceItem($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->get($internalKey)) {
throw new Exception\ItemNotFoundException("Key '{$internalKey}' doesn't exist");
}
$result = $this->memcached->replace($internalKey, $value, $options['ttl']);
if ($result === false) {
$type = is_object($value) ? get_class($value) : gettype($value);
throw new Exception\RuntimeException("Memcached::replace('{$internalKey}', <{$type}>, {$options['ttl']}) failed");
}
return $this->triggerPost(__FUNCTION__, $args, $result);
} catch (\Exception $e) {
return $this->triggerException(__FUNCTION__, $args, $e);
}
}
/**
* Internal method to replace an existing item.
*
* Options:
* - ttl <float>
* - The time-to-life
* - namespace <string>
* - The namespace to use
*
* @param string $normalizedKey
* @param mixed $value
* @param array $normalizedOptions
* @return boolean
* @throws Exception\ExceptionInterface
*/
protected function internalReplaceItem(&$normalizedKey, &$value, array &$normalizedOptions)
{
$this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $normalizedOptions['namespace']);
$expiration = $this->expirationTime($normalizedOptions['ttl']);
if (!$this->memcached->replace($normalizedKey, $value, $expiration)) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
return true;
}
/**
* var olan bir cache'i değiştirir
*
* @param string $cache_id
* @param object $result
* @param integer $timeout
* @return boolean
*/
public function replace($cache_id, $result, $timeout = null)
{
if ($this->getCache($cache_id)) {
if (is_null($timeout)) {
return false;
}
return $this->memcache->replace($cache_id, $result, $timeout);
} else {
$this->setCache($cache_id, $result, $timeout);
}
}
/**
* Give (if possible) an extra lifetime to the given cache id
*
* @param string $id cache id
* @param int $extraLifetime
* @return boolean true if ok
*/
public function touch($id, $extraLifetime)
{
$tmp = $this->_memcached->get($id);
$tmp = $this->_unserialize($tmp);
if (isset($tmp[0])) {
$now = time();
$expiration = $now + $extraLifetime;
$data = $this->_serialize(array($tmp[0], $now, $ttl));
return $this->_memcached->replace($id, $data, $extraLifetime);
}
}
/**
* Internal method to replace an existing item.
*
* @param string $normalizedKey
* @param mixed $value
* @return boolean
* @throws Exception\ExceptionInterface
*/
protected function internalReplaceItem(&$normalizedKey, &$value)
{
$expiration = $this->expirationTime();
if (!$this->memcached->replace($normalizedKey, $value, $expiration)) {
if ($this->memcached->getResultCode() == MemcachedResource::RES_NOTSTORED) {
return false;
}
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
return true;
}
/**
* Write to the cache
*
* @param $str_id
* @param $str_session_data
*/
private function cache($str_id, $str_session_data)
{
// syslog(LOG_WARNING, __METHOD__ . "() Writing to Memcache");
try {
$str_memcache_key = $this->getMemcacheKey($str_id);
$bol_replaced = $this->obj_mc->replace($str_memcache_key, $str_session_data, $this->getTimeout());
if (false === $bol_replaced) {
$this->obj_mc->set($str_memcache_key, $str_session_data, $this->getTimeout());
}
} catch (\Exception $obj_ex) {
syslog(LOG_WARNING, __METHOD__ . "() Unable to write to Memcache: " . $obj_ex->getMessage());
}
}
/**
* Read from cache.
* @param string key
* @return mixed|NULL
*/
public function read($key)
{
$key = urlencode($this->prefix . $key);
$meta = $this->memcached->get($key);
if (!$meta) {
return NULL;
}
// meta structure:
// array(
// data => stored data
// delta => relative (sliding) expiration
// callbacks => array of callbacks (function, args)
// )
// verify dependencies
if (!empty($meta[self::META_CALLBACKS]) && !Cache::checkCallbacks($meta[self::META_CALLBACKS])) {
$this->memcached->delete($key, 0);
return NULL;
}
if (!empty($meta[self::META_DELTA])) {
$this->memcached->replace($key, $meta, $meta[self::META_DELTA] + time());
}
return $meta[self::META_DATA];
}
/**
* Save XML to cache
*
* @param int $userid
* @param string $apikey
* @param string $scope
* @param string $name
* @param array $args
* @param string $xml
* @return bool|void
*/
public function save($userid, $apikey, $scope, $name, $args, $xml)
{
$key = $this->getKey($userid, $apikey, $scope, $name, $args);
$ttl = $this->getTimeout($xml);
$time = time();
$timeout = $time + $ttl;
$replace = $this->memcached->replace($key, $xml, $timeout);
$set = $set_age = false;
if (!$replace) {
$set = $this->memcached->set($key, $xml, $timeout);
}
$replace_age = $this->memcached->replace($key . '_age', array('age' => $time, 'ttl' => $ttl), $timeout);
if (!$replace_age) {
$set_age = $this->memcached->set($key . '_age', array('age' => $time, 'ttl' => $ttl), $timeout);
}
return ($replace || $set) && ($replace_age || $set_age);
}
/**
* Alter the TTL for a given key. Essentially, renewing it in
* the cache.
*
* @param string $key
* @param integer $ttl
* @return boolean
*/
public function renew($key, $ttl = self::DEFAULT_TTL)
{
if (!$this->hasConnection()) {
// @codeCoverageIgnoreStart
return false;
// @codeCoverageIgnoreEnd
}
$value = $this->get($key);
if ($value !== false) {
try {
return $this->memcached->replace($this->getKeyString($key), $value, $ttl);
// @codeCoverageIgnoreStart
} catch (\Exception $e) {
}
}
// @codeCoverageIgnoreEnd
return false;
}
/**
* Reads from cache in bulk.
* @param string key
* @return array key => value pairs, missing items are omitted
*/
public function bulkRead(array $keys)
{
$prefixedKeys = array_map(function ($key) {
return urlencode($this->prefix . $key);
}, $keys);
$keys = array_combine($prefixedKeys, $keys);
$metas = $this->memcached->getMulti($prefixedKeys);
$result = [];
$deleteKeys = [];
foreach ($metas as $prefixedKey => $meta) {
if (!empty($meta[self::META_CALLBACKS]) && !Cache::checkCallbacks($meta[self::META_CALLBACKS])) {
$deleteKeys[] = $prefixedKey;
} else {
$result[$keys[$prefixedKey]] = $meta[self::META_DATA];
}
if (!empty($meta[self::META_DELTA])) {
$this->memcached->replace($prefixedKey, $meta, $meta[self::META_DELTA] + time());
}
}
if (!empty($deleteKeys)) {
$this->memcached->deleteMulti($deleteKeys, 0);
}
return $result;
}
/**
* Get lock
*
* Acquires an (emulated) lock.
*
* @param string $session_id Session ID
* @return bool
*/
protected function _get_lock($session_id)
{
if (isset($this->_lock_key)) {
return $this->_memcached->replace($this->_lock_key, time(), MEMCACHE_COMPRESSED, 5);
}
$lock_key = $this->_key_prefix . $session_id . ':lock';
if (!($ts = $this->_memcached->get($lock_key))) {
if (!$this->_memcached->set($lock_key, TRUE, MEMCACHE_COMPRESSED, 5)) {
log_message('error', 'Session: Error while trying to obtain lock for ' . $this->_key_prefix . $session_id);
return FALSE;
}
$this->_lock_key = $lock_key;
$this->_lock = TRUE;
return TRUE;
}
// Another process has the lock, we'll try to wait for it to free itself ...
$attempt = 0;
while ($attempt++ < 5) {
usleep((time() - $ts) * 1000000 - 20000);
if (($ts = $this->_memcached->get($lock_key)) < time()) {
continue;
}
if (!$this->_memcached->set($lock_key, time(), MEMCACHE_COMPRESSED, 5)) {
log_message('error', 'Session: Error while trying to obtain lock for ' . $this->_key_prefix . $session_id);
return FALSE;
}
$this->_lock_key = $lock_key;
break;
}
if ($attempt === 5) {
log_message('error', 'Session: Unable to obtain lock for ' . $this->_key_prefix . $session_id . ' after 5 attempts, aborting.');
return FALSE;
}
$this->_lock = TRUE;
return TRUE;
}
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));
}
/**
* 替换指定键名的数据（如不存在则失败）
*
* @param string $key
* @param mixed $value
* @param int $expiration
* @return bool
*/
public function replace($key, $value, $expiration = 0)
{
return $this->memcached ? $this->memcached->replace($key, $value, $expiration) : false;
}
echo 'PHP Memcached extension was not installed';
exit;
}
echo "Use PHP Memcached extension.<br />";
//连接
$mem = new Memcached();
$mem->addServer("127.0.0.1", 11211) or die("Could not connect");
//显示版本
$version = current($mem->getVersion());
echo "Memcached Server version: " . $version . "<br />";
//保存数据
$mem->set('key1', 'This is first value', 60);
$val = $mem->get('key1');
echo "Get key1 value: " . $val . "<br />";
//替换数据
$mem->replace('key1', 'This is replace value', 60);
$val = $mem->get('key1');
echo "Get key1 value: " . $val . "<br />";
//保存数组
$arr = array('aaa', 'bbb', 'ccc', 'ddd');
$mem->set('key2', $arr, 60);
$val2 = $mem->get('key2');
echo "Get key2 value: ";
print_r($val2);
echo "<br />";
//删除数据
$mem->delete('key1');
$val = $mem->get('key1');
echo "Get key1 value: " . $val . "<br />";
//清除所有数据
$mem->flush();
/**
* {@inheritdoc}
*/
public function replace($key, $value, $expire = 0)
{
$key = $this->encodeKey($key);
return $this->client->replace($key, $value, $expire);
}
/**
* Updates data in cache.
*
* @param string $key The dataset Id
* @param string $value The data to write to cache
* @param string $namespace The dataset namespace
* @param int $lifetime Date/Time on which the cache-entry expires
* @param string $userdata The custom userdata to add
*
* @return bool TRUE on success, otherwise FALSE
* @author Benjamin Carl <*****@*****.**>
* @access public
* @throws Doozr_Cache_Service_Exception
*/
public function update($key, $value, $namespace, $lifetime = null, $userdata = null)
{
// Get internal used key
$key = $this->calculateUuid($key . $namespace);
// Build dataset from input
$dataset = array($this->getExpiresAbsolute($lifetime), $userdata, $this->encode($value), $namespace);
if (true !== ($result = $this->connection->replace($key, $dataset, $this->getCompress() === true ? MEMCACHE_COMPRESSED : 0, $this->getExpiresAbsolute($lifetime)))) {
throw new Doozr_Cache_Service_Exception('Error while updating dataset!');
}
if ($result === true) {
// On create we need to purge the old entry from runtime cache ...
$this->addToRuntimeCache($key, $dataset, $namespace);
}
return true;
}
<?php
$cache = new Memcached();
$cache->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$cache->setOption(Memcached::OPT_COMPRESSION, false);
$cache->addServer('localhost', 3434);
$cache->add("add_key", "hello", 500);
$cache->append("append_key", "world");
$cache->prepend("prepend_key", "world");
$cache->increment("incr", 2, 1, 500);
$cache->decrement("decr", 2, 1, 500);
$cache->delete("delete_k");
$cache->flush(1);
var_dump($cache->get('get_this'));
$cache->set('set_key', 'value 1', 100);
$cache->replace('replace_key', 'value 2', 200);
$cache->getStats();
$cache->quit();
sleep(1);
