/** * Store data on the cache server. * * @param string $key Key we can use to retrieve the data. * @param string|array $data Data to store on the cache server. * @param int $expiration Time before the data expires on the cache server. * * @return bool Success/Failure. * @access public */ public function set($key, $data, $expiration) { if ($this->connected === true && $this->ping() === true) { return $this->server->set($key, $this->isRedis ? $this->IgBinarySupport ? igbinary_serialize($data) : serialize($data) : $data, $expiration); } return false; }
/** * {@inheritdoc} */ public function set($key, $value, $ttl = null) { if (!$ttl) { $ttl = $this->ttl; } $this->server->set($this->getKey($key), $this->pack($value), time() + $ttl); }
/** * save * * @param mixed $identifier identifier to save * @param string $amount the current amount * @param string $timespan the timespan in seconds * * @return boolean */ public function save($identifier = null, $amount = null, $timespan = null) { if (!$identifier && !$amount && !$timespan) { throw new \InvalidArgumentException('identifier, amount and timespan are required'); } return $this->memcached->set($this->fileName($identifier), $amount, $timespan); }
/** * @see Cache::_set() */ protected function _set($key, $value, $ttl = 0) { if (!$this->is_connected) { return false; } return $this->memcached->set($key, $value, $ttl); }
/** * @param string $key * @param mixed $var * @param int $expiration * @return bool True on success, false on failure */ public function set($key, $var, $expiration = null) { if (!$this->memcached) { throw new CacheException('No memcached defined.'); } return $this->memcached->set($key, $var, $expiration === null ? 0 : $expiration); }
/** * Set a value against a key in the cache. * * @param string $key The key to store against * @param string $value A json_encoded value * @param int $expires Optional expiry time in seconds from now */ public function set($key, $value = null, $expires = 0) { if ($value === null) { return $this->clear($key); } return $this->client->set($key, $value, $expires); }
/** * @param $key * @param $data * @return bool */ public function set($key, $data) { if (!is_null($this->memcache)) { $this->memcache->set($key, $data, $this->expire); } return false; }
/** * Set a value in the cache * * @param string $p_sKey The Key * @param mixed $p_mData The Data * @param integer $p_mTTL The Time To Live * @return boolean */ function set($p_sKey, $p_mData, $p_mTTL = 0) { if ($this->_serverAdded === false) { $this->addServer('localhost'); } return $this->_handler->set($p_sKey, $p_mData, is_numeric($p_mTTL) ? $p_mTTL : strtotime($p_mTTL)); }
/** * set cache-item by key => value + ttl * * @param string $key * @param mixed $value * @param int $ttl * * @return boolean */ public function setExpired($key, $value, $ttl) { if ($ttl > 2592000) { $ttl = 2592000; } return $this->memcached->set($key, $value, $ttl); }
/** * @inheritdoc */ public function put($key, $value, $ttl = 0) { if ($ttl > 30 * 24 * 3600) { $ttl = time() + $ttl; } return $this->memcached->set($key, $value, 0, (int) $ttl); }
/** * Store an item in the cache for a given number of minutes. * * @param string $key * @param mixed $value * @param int $seconds * @param bool $strict * * @throws CacheSetException * * @return bool */ public function set($key, $value, $seconds, $strict = true) { $set = $this->memcached->set($key, $value, $seconds); if (!$set && $strict) { throw new CacheSetException($key); } }
/** * Sets an item into the cache * * @param string $key cache key * @param mixed $value object to cache * @param int $lifetime cached object lifetime */ public function Set($key, $value, $lifetime) { if (empty($key) || empty($value)) { return; } $this->memcache->set($key, $value, false, time() + $lifetime); }
public function set($id, $value, $ttl = null) { $ttl = $ttl ?: 0; if ($ttl > 0) { $ttl = time() + $ttl; } return $this->memcached->set($id, $value, $ttl); }
public function set($key, $value, $ttl = 0) { if ($ttl > 0) { return self::$cache->set($this->getNamespace() . $key, $value, $ttl); } else { return self::$cache->set($this->getNamespace() . $key, $value); } }
public function setUp() { self::$memcached->flush(); self::$memcached->quit(); self::$memcached->set('found', array('count' => 5, 'time' => strtotime('2015-01-01 00:00:00'))); self::$memcached->set('oldkey', 'old story'); $this->storage = new MemcachedStorage(self::$memcached); }
/** * Stores data in the cache. * * @param string $key The key under which to save the data. * @param mixed $data Any object or value that can be serialized. * @param int $duration How long to cache the data in seconds, or 0 for indefinite. * @return boolean Indicates whether the value was cached successfully. */ public function save($key, $data, $duration) { if (isset($this->cache)) { $hashedKey = hash("sha1", MEMCACHED_PREFIX . $key); return $this->cache->set($hashedKey, $data, $duration); } return true; }
/** * {@inheritdoc} */ public function write($key, $data, $expires = 60, $compressed = false) { $cmp = $this->driver->getOption(Memcached::OPT_COMPRESSION); $this->driver->setOption(Memcached::OPT_COMPRESSION, $compressed); $cached = $this->driver->set($key, $data, $expires); $this->driver->setOption(Memcached::OPT_COMPRESSION, $cmp); return $cached; }
/** * Store a Gameserver object in the cache * * @param \SQ\Gameserver $server */ public function put(Gameserver $server) { if ($this->memcached != null) { $this->memcached->set(self::getKey($server), $server->toJSON()); } else { file_put_contents(self::getFileName($server), $server->toJSON()); } }
/** * Save values for a set of keys to cache * * @param array $keys list of values to save * @param int $expire expiration time * * @return boolean true on success, false on failure */ protected function write(array $keys, $expire = null) { foreach ($keys as $k => $v) { $k = sha1($k); $this->memcached->set($k, $v, $expire); } return true; }
public function cas($key, $value) { if (($return = @$this->memcached->get($key)) !== false) { return $return; } $this->memcached->set($key, $value); return $value; }
/** * Save item in the cache. * * @param string $key * @param string $value * @param int $ttl * @return void * * @throws Ejsmont\CircuitBreaker\Storage\StorageException if storage error occurs, handler can not be used */ protected function save($key, $value, $ttl) { try { $this->memcached->set($key, $value, $ttl); } catch (\Exception $e) { throw new StorageException("Failed to save memcached key: {$key}", 1, $e); } }
/** * Write an item to the cache for a given number of minutes. * * <code> * // Put an item in the cache for 15 minutes * Cache::put('name', 'Taylor', 15); * </code> * * @param string $key * @param mixed $value * @param int $minutes * @return void */ public function put($key, $value, $minutes) { if ($this->sectionable($key)) { list($section, $key) = $this->parse($key); return $this->put_in_section($section, $key, $value, $minutes); } else { $this->memcache->set($this->key . $key, $value, $minutes * 60); } }
public function createRate($key, $limit, $period) { $info = array(); $info['limit'] = $limit; $info['calls'] = 1; $info['reset'] = time() + $period; $this->client->set($key, $info, $period); return $this->getRateInfo($key); }
/** * Save value * @param string * @param string * @throws RunTimeException */ public function store($key, $val) { $val = gzcompress(json_encode($val)); if ($this->Memcached->set($this->table . '_' . $key, $val, 600) === false) { $msg = $this->Memcached->getResultMessage(); $code = $this->Memcached->getResultCode(); throw new \RunTimeException("Memcached Error (store): " . $msg . "(" . $code . ")"); } }
/** * {@inheritdoc} */ protected function doSet($key, $value, $expiration, array $options = array()) { $this->client->set($this->getKey($key, $options), $value, $expiration); /* Success should never fail, so anything other than success is also a server (connection) error. */ if ($this->isSuccess()) { return new CacheResponse(true, true, true); } return new CacheResponse(false, false, false, CacheResponse::CONNECTION_ERROR); }
protected final function setCache($data) { list($name, $key) = $this->configCache(); if (self::$memcache) { self::$memcache->set($name . ':' . $data->{$key}, $data, self::$memcache_expire); } else { self::$cache[$name][$data->{$key}] = $data; } }
/** * {@inheritdoc} */ public function add(string $alias, FeatureInterface $feature) : StorageInterface { $key = $this->key($alias); $this->memcached->set($key, $this->feature($feature)); if (!$this->memcached->append($this->prefix, "|{$key}")) { $this->memcached->set($this->prefix, $key); } return $this; }
/** * @param string $name * @param string $value * @param integer $lifeTime * @throws \InvalidArgumentException */ public function write($name, $value, $lifeTime) { if (!is_int($lifeTime) || $lifeTime < 0) { throw new \InvalidArgumentException('Lifetime must be integer greater than or equal to 0. Get "' . $lifeTime . '"'); } if (!$this->memcached instanceof \Memcached) { $this->connect(); } $this->memcached->set($name, $value, $lifeTime); }
public function setUp() { parent::setUp(); $this->memcache = new \Memcached(); $this->memcache->addServer(self::TEST_MEMCACHE_SERVER, self::TEST_MEMCACHE_PORT); $this->memcache->flush(); if (!$this->memcache->set('test', 1, time() + 100)) { throw new \RuntimeException('Cannot save item to memcache. ' . $this->memcache->getResultMessage()); } }
public function set($key, $value, $ttl = 0) { if ($ttl > 0) { $result = self::$cache->set($this->getNamespace() . $key, $value, $ttl); } else { $result = self::$cache->set($this->getNamespace() . $key, $value); } $this->verifyReturnCode(); return $result; }