/**
* Set/add something to the cache
*
* @param string $key Key for the value
* @param mixed $value Value
* @return boolean
*/
public function set($key, $value)
{
if ($this->cache->add($key, $value, $this->compression, $this->expire)) {
return true;
}
return $this->cache->replace($key, $value, $this->compression, $this->expire);
}
/**
* Save getting data to memory (RAM)
*/
public function save()
{
$this->storage_data['last_update'] = $this->last_update;
if ($this->memcache->replace('storage_data', $this->storage_data) === false) {
$this->memcache->add('storage_data', $this->storage_data);
}
}
/**
* @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;
}
function add($key, $value, $ttl = 0)
{
$key = str_replace('\\', '/', $key);
if (!$this->memcache->add($key, $value, false, $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->memcache->add($id, $value, 0, $ttl);
}
public function exists($id)
{
$success = $this->memcache->add($id, 0);
if (!$success) {
return true;
}
$this->memcache->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(), null, $expiry)) {
if (!$this->isLocked($mutexKey)) {
throw new LockFailedException();
}
}
}
public function store($key, $value, $overwrite, $ttl = 0)
{
// always store as an UNIX timestamp
// (see description of the expire parameter in the PHP manunal)
$expire = $ttl > 0 ? time() + $ttl : 0;
if ($overwrite) {
return $this->memcache->set($key, $value, 0, $expire);
} else {
return $this->memcache->add($key, $value, 0, $expire);
}
}
/**
* 设置缓存
*
* @param string $key 要设置的缓存项目名称
* @param mixed $value 要设置的缓存项目内容
* @param int $time 要设置的缓存项目的过期时长，默认保存时间为 -1，永久保存为 0
*
* @return bool 保存是成功为true ，失败为false
*/
public function store($key, $value, $time = -1)
{
if ($time == -1) {
$time = $this->expire;
}
$sValue = serialize($value);
if (!$this->connection->add($key, $sValue, $this->compressed, $time)) {
return $this->connection->set($key, $sValue, $this->compressed, $time);
}
return true;
}
function keyExists($key)
{
if (null === $this->memcache) {
$this->connect();
}
if ($this->memcache->add($key, null)) {
$this->memcache->delete($key);
return false;
} else {
return true;
}
}
/**
* @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;
if (defined('BX_SECURITY_SESSION_MEMCACHE_EXLOCK') && BX_SECURITY_SESSION_MEMCACHE_EXLOCK)
$lock = Bitrix\Main\Context::getCurrent()->getRequest()->getRequestedPage();
else
$lock = 1;
while(!self::$connection->add($sid.$id.".lock", $lock, 0, $lockTimeout))
{
usleep($waitStep);
$lockWait -= $waitStep;
if($lockWait < 0)
{
$errorText = 'Unable to get session lock within 60 seconds.';
if ($lock !== 1)
{
$lockedUri = self::$connection->get($sid.$id.".lock");
if ($lockedUri && $lockedUri != 1)
$errorText .= sprintf(' Locked by "%s".', self::$connection->get($sid.$id.".lock"));
}
CSecuritySession::triggerFatalError($errorText);
}
if($waitStep < 1000000)
$waitStep *= 2;
}
}
self::$sessionId = $id;
self::$isSessionReady = true;
$res = self::$connection->get($sid.$id);
if($res === false)
$res = "";
return $res;
}
/**
* Obtain lock on a key.
*
* @param string $key The key to lock.
*/
public function lock($key)
{
$i = 0;
while ($this->_memcache->add($this->_key($key . self::LOCK_SUFFIX), 1, 0, self::LOCK_TIMEOUT) === false) {
usleep(min(pow(2, $i++) * 10000, 100000));
}
/* Register a shutdown handler function here to catch cases where PHP
* suffers a fatal error. Must be done via shutdown function, since
* a destructor will not be called in this case.
* Only trigger on error, since we must assume that the code that
* locked will also handle unlocks (which may occur in the destruct
* phase, e.g. session handling).
* @todo: $this is not usable in closures until PHP 5.4+ */
if (empty($this->_locks)) {
$self = $this;
register_shutdown_function(function () use($self) {
$e = error_get_last();
if ($e['type'] & E_ERROR) {
/* Try to do cleanup at very end of shutdown methods. */
register_shutdown_function(array($self, 'shutdown'));
}
});
}
$this->_locks[$key] = true;
}
function cache($op, $key, $val = '', $expiry = 604800)
{
static $memcache = false;
if ($memcache === false) {
$memcache = new Memcache();
$memcache->connect('localhost', 11211) or die('Fatal error - could not connect to Memcache');
}
$retval = true;
// Prefix the key to avoid collisions with other apps
$key = 'twitapps_' . $key;
switch ($op) {
case 'set':
$memcache->set($key, $val, false, $expiry) or die('Fatal error - could not store ' . htmlentities($key) . ' in Memcache');
break;
case 'get':
$retval = $memcache->get($key);
break;
case 'inc':
$retval = $memcache->increment($key);
break;
case 'add':
$retval = $memcache->add($key, $val, false, $expiry);
break;
}
return $retval;
}
/**
* Lock cache index
*
* @return boolean True on success, false otherwise.
*
* @since 11.1
*/
protected function lockindex()
{
$looptime = 300;
$data_lock = self::$_db->add($this->_hash . '-index_lock', 1, false, 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, false, 30);
$lock_counter++;
}
}
return true;
}
/**
* 批量设置键值(当键名不存在时);<br>
* 只有当键值全部设置成功时,才返回true,否则返回false并尝试回滚
* @param array $sets 键值数组
* @return boolean 是否成功
*/
public function mSetNX($sets)
{
try {
$keys = [];
$status = true;
foreach ($sets as $key => $value) {
$value = self::setValue($value);
$status = $this->handler->add($key, $value, $this->compress($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;
}
/**
* Write data for key into cache if it doesn't exist already. When using memcached as your cache engine
* remember that the Memcached PECL extension does not support cache expiry times greater
* than 30 days in the future. Any duration greater than 30 days will be treated as never expiring.
* If it already exists, it fails and returns false.
*
* @param string $key Identifier for the data.
* @param mixed $value Data to be cached.
* @param int $duration How long to cache the data, in seconds.
* @return bool True if the data was successfully cached, false on failure.
* @link http://php.net/manual/en/memcache.add.php
*/
public function add($key, $value, $duration)
{
if ($duration > 30 * DAY) {
$duration = 0;
}
return $this->_Memcache->add($key, $value, $this->settings['compress'], $duration);
}
/**
* Write data for key into cache if it doesn't exist already. When using memcached as your cache engine
* remember that the Memcached pecl extension does not support cache expiry times greater
* than 30 days in the future. Any duration greater than 30 days will be treated as never expiring.
* If it already exists, it fails and returns false.
*
* @param string $key Identifier for the data.
* @param mixed $value Data to be cached.
* @param int $duration How long to cache the data, in seconds.
* @return bool True if the data was successfully cached, false on failure.
* @link http://php.net/manual/en/memcached.add.php
*/
public function add($key, $value, $duration)
{
if ($duration > 30 * DAY) {
$duration = 0;
}
return $this->_Memcached->add($key, $value, $duration);
}
/**
* Small wrapper around Memcache[d]#add().
*
* @param string $key The key to lock.
*/
protected function _lockAdd($key)
{
if ($this->_memcache instanceof Memcached) {
$this->_memcache->add($this->_key($key . self::LOCK_SUFFIX), 1, self::LOCK_TIMEOUT);
} else {
$this->_memcache->add($this->_key($key . self::LOCK_SUFFIX), 1, 0, self::LOCK_TIMEOUT);
}
}
/**
* Obtain lock on a key.
*
* @param string $key The key to lock.
*/
public function lock($key)
{
$i = 0;
while ($this->_memcache->add($this->_key($key . self::LOCK_SUFFIX), 1, 0, self::LOCK_TIMEOUT) === false) {
usleep(min(pow(2, $i++) * 10000, 100000));
}
$this->_locks[$key] = true;
}
public function add($key, $var, $flag = 1, $expire = 0)
{
if (!$this->is_open) {
return false;
}
$key = $this->format_key($key);
return parent::add($key, $var, $flag, $expire);
}
function addToCache($key, $content)
{
$ini = parse_ini_file('scielo.def', true);
$memcache = new Memcache();
$memcache->connect($ini['CACHE']['SERVER_CACHE'], $ini['CACHE']['SERVER_PORT_CACHE']);
$result = $memcache->add($key, $content);
$memcache->close();
return $result;
}
/**
* Store some data in session.
* Expects a session id and the data to write.
* @param string $sessionId
* @param mixed $data
* @return boolean
*/
public function write($sessionId = '', $data = '')
{
if ($sessionId !== '') {
if ($this->_memcache->replace($this->_key($sessionId), $data, null, $this->_lifetime) === false) {
// add the item if we couldn't have replaced it (i.e. if it doesn't already exists)
$this->_memcache->add($this->_key($sessionId), $data, null, $this->_lifetime);
}
}
return true;
}
/**
* This method will be called after a Datastore put.
*/
protected function onItemWrite()
{
$mc = new Memcache();
try {
$key = self::getCacheKey($this->subscriber_url);
$mc->add($key, $this, 0, 120);
} catch (Google_Cache_Exception $ex) {
syslog(LOG_WARNING, "in onItemWrite: memcache exception");
}
}
/**
* 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 add($key, $var, $flag = null, $expire = null)
{
if ($this->stopwatch) {
$e = $this->getStopwatchEvent('add');
}
$result = parent::add($key, $var, $flag, $expire);
if ($this->stopwatch) {
$e->stop();
}
return $result;
}
/**
* Check if a key exists.
*
* @param $key
* @return bool
*/
public function exists($key)
{
if ($this->open()) {
// if array check each key
if (is_array($key)) {
$out = array();
foreach ($key as $k) {
if ($this->exists($k)) {
$out[$k] = true;
}
}
return $out;
} elseif (empty($key)) {
return false;
}
// try adding if true it does not exists
if ($return = $this->memcache->add($key, 1)) {
$this->memcache->delete($key, 0);
}
return $return === false;
}
return false;
}
/**
* @param $keyword
* @param string $value
* @param int $time
* @param array $option
* @return array|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['skipExisting']) && $option['skipExisting'] == true) {
return $this->instant->add($keyword, $value, false, $time);
} else {
return $this->instant->set($keyword, $value, false, $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->memcache->add($this->getKeyString($key), $value, $this->getFlagFromValue($value), $ttl);
// @codeCoverageIgnoreStart
} catch (\Exception $e) {
}
return false;
// @codeCoverageIgnoreEnd
}
function add($key, $var, $flag = null, $expire = null, $mysql = false)
{
if (!$this->isConnected) {
$this->connect();
}
if ($this->debugMode && !$mysql) {
$s = get_microtime();
}
$return = parent::add($key, $var, $flag, $expire);
if ($this->debugMode && !$mysql) {
$e = get_microtime();
array_push($this->queryLog, array('query' => 'add ' . $key, 'time' => number_format(($e - $s) * 1000, 4)));
}
return $return;
}
