/**
* Get a value from cache
*
* @param string $p_sKey The Key
* @return mixed
*/
function get($p_sKey)
{
if ($this->_serverAdded === false) {
$this->addServer('localhost');
}
return $this->_handler->get($p_sKey);
}
public function afterQuery(Atomik_Model_Builder $builder, Atomik_Model_Modelset $modelSet)
{
$modelName = $builder->name;
$primaryKeyName = $builder->getPrimaryKeyField()->name;
$manager = $builder->getManager();
$db = $manager->getDbInstance();
$rows = array();
$dataQuery = $db->q()->select()
->from($builder->tableName)
->where(array($primaryKeyName => null));
foreach ($modelSet as $row) {
$primaryKey = $row[$primaryKeyName];
$key = $modelName . ':' . $primaryKey;
if (($cached = $this->_memcache->get($key)) !== false) {
// cache hit
$rows[] = $cached;
continue;
}
$data = $dataQuery->setParams(array($primaryKey))->execute()->fetch();
$this->_memcache->set($key, $data);
$rows[] = $data;
}
$modelSet->setData($rows);
}
/**
* @see Cache::_exists()
*/
protected function _exists($key)
{
if (!$this->is_connected) {
return false;
}
return $this->memcache->get($key) !== false;
}
public function get($key)
{
if (null === $this->memcache) {
$this->connect();
}
return $this->memcache->get($key);
}
/**
* get cache item with given key
*
* @param string $key
* @return string|array
*/
public function get($key)
{
if (empty($key)) {
throw new InvalidArgumentException("\$key is empty");
}
return $this->memcache->get($key);
}
/**
* Read from cache.
* @param string key
* @return mixed|NULL
*/
public function read($key)
{
$key = $this->prefix . $key;
$meta = $this->memcache->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]) && !NCache::checkCallbacks($meta[self::META_CALLBACKS])) {
$this->memcache->delete($key, 0);
return NULL;
}
if (!empty($meta[self::META_DELTA])) {
$this->memcache->replace($key, $meta, 0, $meta[self::META_DELTA] + time());
}
return $meta[self::META_DATA];
}
/**
* Write a line to the logfile.
* @param String $line
*/
protected function _updateValue($message, $keyPostfix = "")
{
$key = $this->_getKey($keyPostfix);
$value = $this->_memcache->get($key);
$value .= self::VALUE_SEPARATOR . $message;
$this->_memcache->set($key, $value, null, $this->_expiry);
}
function checkCache($check = 0, $in, $out, $set = 0)
{
$inOut = 'inOut_' . $in . '_' . $out;
$memcache_obj = new Memcache();
$memcache_obj->connect('127.0.0.1', 11211) or die("Could not connect");
if ($check === 1) {
$available = $memcache_obj->get($inOut);
if (!$available) {
$set = $this->superfastCheck(1, $in, $out);
$memcache_obj->set($inOut, $set, false, 324);
$available = $memcache_obj->get($inOut);
}
} elseif ($check === 2) {
$memcache_obj->flush();
} else {
$set = $this->superfastCheck($in, $out);
//var_dump($set);
$memcache_obj->set($inOut, $set, false, 324);
//echo $inOut;
$available = $memcache_obj->get($inOut);
//var_dump($memcache_obj->getStats());
}
//var_dump($available);
$memcache_obj->close();
return $available;
}
/**
* @param string $id - session id, must be valid hash
* @return string
*/
public static function read($id)
{
if (!self::isConnected() || !self::isValidId($id)) {
return "";
}
$sid = self::getPrefix();
if (!self::$isReadOnly) {
$lockTimeout = 55;
//TODO: add setting
$lockWait = 59000000;
//micro seconds = 60 seconds TODO: add setting
$waitStep = 100;
while (!self::$connection->add($sid . $id . ".lock", 1, 0, $lockTimeout)) {
usleep($waitStep);
$lockWait -= $waitStep;
if ($lockWait < 0) {
CSecuritySession::triggerFatalError('Unable to get session lock within 60 seconds.');
}
if ($waitStep < 1000000) {
$waitStep *= 2;
}
}
}
self::$sessionId = $id;
$res = self::$connection->get($sid . $id);
if ($res === false) {
$res = "";
}
return $res;
}
/**
* Creates a new MemcacheAdapter object.
*/
private function __construct()
{
if (!class_exists('Memcache')) {
throw new SystemException('memcache support is not enabled.');
}
// init memcache
$this->memcache = new Memcache();
// add servers
$servers = explode("\n", StringUtil::unifyNewlines(CACHE_SOURCE_MEMCACHE_HOST));
foreach ($servers as $server) {
$server = StringUtil::trim($server);
if (!empty($server)) {
$host = $server;
$port = 11211;
// default memcache port
// get port
if (strpos($host, ':')) {
$parsedHost = explode(':', $host);
$host = $parsedHost[0];
$port = $parsedHost[1];
}
$this->memcache->addServer($host, $port, CACHE_SOURCE_MEMCACHE_USE_PCONNECT);
}
}
// test connection
$this->memcache->get('testing');
}
public function get($id)
{
if (($value = $this->memcache->get($id)) === false) {
return null;
}
return $value;
}
public function get($key)
{
$status = $this->aerospike->get($this->getKey($key), $record);
if ($status == \Aerospike::OK) {
return $record['bins'];
}
}
/**
* Read values for a set of keys from cache
*
* @param array $keys list of keys to fetch
* @return array list of values with the given keys used as indexes
* @return boolean true on success, false on failure
*/
protected function read(array $keys)
{
$_res = array();
/*
$_keys = $lookup = array();
foreach ($keys as $k) {
$_k = sha1($k);
$_keys[] = $_k;
$lookup[$_k] = $k;
}
$res = $this->phpFastCache->get($_keys);
if(!$res){
return $res;
}
foreach ($res as $k => $v) {
$_res[$lookup[$k]] = $v;
} //*/
foreach ($keys as $k) {
$k = sha1($k);
$_res[$k] = $this->phpFastCache->get($k);
//$_res[$k]=unserialize($_res[$k]);
}
//dump($_res);
return $_res;
}
public function run($request)
{
if (!class_exists('Memcache')) {
$this->msg("Memcache class does not exist. Make sure that the Memcache extension is installed");
}
$host = defined('MEMCACHE_HOST') ? MEMCACHE_HOST : 'localhost';
$port = defined('MEMCACHE_PORT') ? MEMCACHE_PORT : 11211;
$memcache = new Memcache();
$connected = $memcache->connect($host, $port);
if ($connected) {
$this->msg("Server's version: " . $memcache->getVersion());
$result = $memcache->get("key");
if ($result) {
$this->msg("Data found in cache");
} else {
$this->msg("Data not found in cache");
$tmp_object = new stdClass();
$tmp_object->str_attr = "test";
$tmp_object->int_attr = 123;
$tmp_object->time = time();
$tmp_object->date = date('Y-m-d H:i:s');
$tmp_object->arr = array(1, 2, 3);
$memcache->set("key", $tmp_object, false, 10);
}
$this->msg("Store data in the cache (data will expire in 10 seconds)");
$this->msg("Data from the cache:");
echo '<pre>';
var_dump($memcache->get("key"));
echo '</pre>';
} else {
$this->msg("Failed to connect");
}
}
/**
* Pobranie wartości z cache
*
* @param string $module
* @param string $property
* @return mixed
*/
function get($module, $property)
{
$tKey = $this->getKey($module, $property);
if (!isset($this->internalCache[$tKey])) {
$this->internalCache[$tKey] = $this->memcached->get($tKey);
}
return $this->internalCache[$tKey];
}
/**
* {@inheritDoc}
*
* @return mixed
*/
public function get($key)
{
$data = $this->memcache->get($key);
if ($data === false) {
return null;
}
return $data;
}
/**
* Get cached value
*
* @param string $key
* @param mixed $default
* @return array|mixed|null|string
*/
public function get($key, $default = null)
{
$key = $this->prepareKey($key);
if ($data = $this->memcached->get($key)) {
return $data;
}
return $default;
}
/**
* {@inheritDoc}
*
* @see http://www.php.net/manual/en/memcache.get.php
*/
protected function _get($key)
{
$flags = null;
// Passed by reference
$filler = false;
// Passed by reference, undocumented complaint in PHP7 without
return $this->_memcache_get_requires_filler ? $this->_connection->get($key, $flags, $filler) : $this->_connection->get($key);
}
/**
* Retrieve an item from the cache by key.
*
* @param $key
* @param bool $strict
* @param null $default
*
* @return mixed|null
*
* @throws CacheMissException
*/
public function get($key, $strict = true, $default = null)
{
$value = $this->memcache->get($key);
if (false === $value && $strict) {
throw new CacheMissException($key);
}
return $default;
}
/**
* This function emulates the compare and swap functionality available in the other extension. This allows
* that functionality to be used when possible and emulated without too much issue, but for obvious reasons
* this shouldn't be counted on to be exact.
*
* @param string $key
* @param mixed $value
* @return mixed
*/
public function cas($key, $value)
{
if (($return = @$this->memcached->get($key)) !== false) {
return $return;
}
$this->memcached->set($key, $value);
return $value;
}
/**
* @param string $key
* @param \DateTime $time
*
* @return bool
*/
public function set($key, \DateTime $time)
{
$key = $this->prefix . $key;
if (!($old_time = $this->memcache->get($key)) || $old_time < $time->getTimestamp()) {
return $this->memcache->set($key, $time->getTimestamp());
}
return true;
}
/**
* {@inheritdoc}
*/
public function has($key)
{
$data = $this->server->get($this->getKey($key));
if (!$data) {
return false;
}
return true;
}
/**
* {@inheritdoc }
*/
public function has($key)
{
$tKey = $this->getKey($key);
if ($this->server->get($tKey)) {
return true;
}
return false;
}
/**
* {@inheritdoc}
*/
public function isExists()
{
if (false !== $this->memcacheInstance->get($this->keyName)) {
return true;
} else {
return false;
}
}
/**
* 从session中读取数据
*
* @param string $sessionId session的ID
*
* @return mixed 返回session中对应的数据
*/
public function read($sessionId)
{
$out = $this->handler->get($this->storageKey($sessionId));
if ($out === false || $out == null) {
return '';
} else {
return $out;
}
}
/**
* Verifica si la llave existe.
*
* @param string $llave
*
* @return bool
*/
public function existe($llave)
{
$temp = $this->gestor->get(array($llave));
if (isset($temp)) {
return true;
} else {
return false;
}
}
public function get($id)
{
$flags = null;
$result = @$this->memcache->get($id, $flags);
if (false === $result && (is_null($flags) || 1 !== $flags >> 16)) {
return null;
}
return $result;
}
/**
* Retrieve an item from the cache.
*
* @param string $name The name of the cache
* @param boolean $hard_refresh True if we should do a hard refresh
* @return mixed Cache data if successful, false if failure
*/
function fetch($name, $hard_refresh = false)
{
$data = $this->memcache->get($this->unique_id . "_" . $name);
if ($data === false) {
return false;
} else {
return $data;
}
}
public function testIncrementCacheWithDelete()
{
$key = 'test_test_mapper_customer_version';
$this->assertFalse($this->memcache->get($key));
$this->object->findAll();
$this->assertSame(0, $this->memcache->get($key));
$this->object->delete(array('id' => 2));
$this->assertSame(1, $this->memcache->get($key));
}
/**
* Retrieve an item from the cache by key.
*
* @param string $key
*
* @return mixed
*/
public function get($key)
{
$value = $this->memcache->get($this->prefix . $key);
if (sizeof($value) > 0 && $value !== false) {
return $value;
} else {
return;
}
return $value;
}
