Current File : /home/vacivi36/ava/lib/adodb/adodb-memcache.lib.inc.php
<?php
/**
* Memory caching.
*
* This file is part of ADOdb, a Database Abstraction Layer library for PHP.
*
* @package ADOdb
* @link https://adodb.org Project's web site and documentation
* @link https://github.com/ADOdb/ADOdb Source code and issue tracker
*
* The ADOdb Library is dual-licensed, released under both the BSD 3-Clause
* and the GNU Lesser General Public Licence (LGPL) v2.1 or, at your option,
* any later version. This means you can use it in proprietary products.
* See the LICENSE.md file distributed with this source code for details.
* @license BSD-3-Clause
* @license LGPL-2.1-or-later
*
* @copyright 2000-2013 John Lim
* @copyright 2014 Damien Regad, Mark Newnham and the ADOdb community
*
* @noinspection PhpUnused
*/
// security - hide paths
if (!defined('ADODB_DIR')) die();
global $ADODB_INCLUDED_MEMCACHE;
$ADODB_INCLUDED_MEMCACHE = 1;
global $ADODB_INCLUDED_CSV;
if (empty($ADODB_INCLUDED_CSV)) {
include_once(ADODB_DIR . '/adodb-csvlib.inc.php');
}
class ADODB_Cache_MemCache
{
/**
* @var bool Prevents parent class calling non-existant function
*/
public $createdir = false;
/**
* @var array of hosts
*/
private $hosts;
/**
* @var int Connection Port, uses default
*/
private $port;
/**
* @var bool memcache compression with zlib
*/
private $compress;
/**
* @var array of options for memcached only
*/
private $options;
/**
* @var bool Internal flag indicating successful connection
*/
private $isConnected = false;
/**
* @var Memcache|Memcached Handle for the Memcache library
*
* Populated with the proper library on connect, used later when
* there are differences in specific calls between memcache and memcached
*/
private $memcacheLibrary = false;
/**
* @var array New server feature controller lists available servers
*/
private $serverControllers = array();
/**
* @var array New server feature template uses granular server controller
*/
private $serverControllerTemplate = array(
'host' => '',
'port' => 11211,
'weight' => 0,
);
/**
* An integer index into the libraries
* @see $libraries
*/
const MCLIB = 1;
const MCLIBD = 2;
/**
* @var array Xrefs the library flag to the actual class name
*/
private $libraries = array(
self::MCLIB => 'Memcache',
self::MCLIBD => 'Memcached'
);
/**
* @var int An indicator of which library we are using
*/
private $libraryFlag;
/**
* Class Constructor.
*
* @param ADOConnection $db
*/
public function __construct($db)
{
$this->hosts = $db->memCacheHost;
$this->port = $this->serverControllerTemplate['port'] = $db->memCachePort;
$this->compress = $db->memCacheCompress;
$this->options = $db->memCacheOptions;
}
/**
* Return true if the current library is Memcached.
* @return bool
*/
public function isLibMemcached(): bool
{
return $this->libraryFlag == self::MCLIBD;
}
/**
* Lazy connection.
*
* The connection only occurs on CacheExecute call.
*
* @param string $err
*
* @return bool success of connecting to a server
*/
public function connect(&$err)
{
// do we have memcache or memcached? see the note at adodb.org on memcache
if (class_exists('Memcache')) {
$this->libraryFlag = self::MCLIB;
} elseif (class_exists('Memcached')) {
$this->libraryFlag = self::MCLIBD;
} else {
$err = 'Neither the Memcache nor Memcached PECL extensions were found!';
return false;
}
$usedLibrary = $this->libraries[$this->libraryFlag];
/** @var Memcache|Memcached $memCache */
$memCache = new $usedLibrary;
if (!$memCache) {
$err = 'Memcache library failed to initialize';
return false;
}
// Convert simple compression flag for memcached
if ($this->isLibMemcached()) {
$this->options[Memcached::OPT_COMPRESSION] = $this->compress;
}
// Are there any options available for memcached
if ($this->isLibMemcached() && count($this->options) > 0) {
$optionSuccess = $memCache->setOptions($this->options);
if (!$optionSuccess) {
$err = 'Invalid option parameters passed to Memcached';
return false;
}
}
// Have we passed a controller array
if (!is_array($this->hosts)) {
$this->hosts = array($this->hosts);
}
if (!is_array($this->hosts[0])) {
// Old way, convert to controller
foreach ($this->hosts as $ipAddress) {
$connector = $this->serverControllerTemplate;
$connector['host'] = $ipAddress;
$connector['port'] = $this->port;
$this->serverControllers[] = $connector;
}
} else {
// New way, must validate port, etc
foreach ($this->hosts as $controller) {
$connector = array_merge($this->serverControllerTemplate, $controller);
if ($this->isLibMemcached()) {
$connector['weight'] = (int)$connector['weight'];
} else {
// Cannot use weight in memcache, simply discard
$connector['weight'] = 0;
}
$this->serverControllers[] = $connector;
}
}
// Checks for existing connections ( but only for memcached )
if ($this->isLibMemcached() && !empty($memCache->getServerList())) {
// Use the existing configuration
$this->isConnected = true;
$this->memcacheLibrary = $memCache;
return true;
}
$failcnt = 0;
foreach ($this->serverControllers as $controller) {
if ($this->isLibMemcached()) {
if (!@$memCache->addServer($controller['host'], $controller['port'], $controller['weight'])) {
$failcnt++;
}
} else {
if (!@$memCache->addServer($controller['host'], $controller['port'])) {
$failcnt++;
}
}
}
if ($failcnt == sizeof($this->serverControllers)) {
$err = 'Can\'t connect to any memcache server';
return false;
}
$this->memcacheLibrary = $memCache;
// A valid memcache connection is available
$this->isConnected = true;
return true;
}
/**
* Writes a cached query to the server
*
* @param string $filename The MD5 of the query to cache
* @param string $contents The query results
* @param bool $debug
* @param int $secs2cache
*
* @return bool true or false. true if successful save
*/
public function writeCache($filename, $contents, $debug, $secs2cache)
{
$err = '';
if (!$this->isConnected && $debug) {
// Call to writeCache() before connect(), try to connect
if (!$this->connect($err)) {
ADOConnection::outp($err);
}
} else {
if (!$this->isConnected) {
$this->connect($err);
}
}
if (!$this->memcacheLibrary) {
return false;
}
$failed = false;
switch ($this->libraryFlag) {
case self::MCLIB:
if (!$this->memcacheLibrary->set($filename, $contents, $this->compress ? MEMCACHE_COMPRESSED : 0,
$secs2cache)) {
$failed = true;
}
break;
case self::MCLIBD:
if (!$this->memcacheLibrary->set($filename, $contents, $secs2cache)) {
$failed = true;
}
break;
default:
$failed = true;
break;
}
if ($failed) {
if ($debug) {
ADOConnection::outp(" Failed to save data at the memcache server!<br>\n");
}
return false;
}
return true;
}
/**
* Reads a cached query from the server.
*
* @param string $filename The MD5 of the query to read
* @param string $err The query results
* @param int $secs2cache
* @param object $rsClass **UNUSED**
*
* @return object|bool record or false.
*
* @noinspection PhpUnusedParameterInspection
*/
public function readCache($filename, &$err, $secs2cache, $rsClass)
{
if (!$this->isConnected) {
$this->connect($err);
}
if (!$this->memcacheLibrary) {
return false;
}
$rs = $this->memcacheLibrary->get($filename);
if (!$rs) {
$err = 'Item with such key doesn\'t exist on the memcache server.';
return false;
}
// hack, should actually use _csv2rs
$rs = explode("\n", $rs);
unset($rs[0]);
$rs = join("\n", $rs);
$rs = unserialize($rs);
if (!is_object($rs)) {
$err = 'Unable to unserialize $rs';
return false;
}
if ($rs->timeCreated == 0) {
return $rs;
} // apparently have been reports that timeCreated was set to 0 somewhere
$tdiff = intval($rs->timeCreated + $secs2cache - time());
if ($tdiff <= 2) {
switch ($tdiff) {
case 2:
if ((rand() & 15) == 0) {
$err = "Timeout 2";
return false;
}
break;
case 1:
if ((rand() & 3) == 0) {
$err = "Timeout 1";
return false;
}
break;
default:
$err = "Timeout 0";
return false;
}
}
return $rs;
}
/**
* Flushes all of the stored memcache data
*
* @param bool $debug
*
* @return bool The response from the memcache server
*/
public function flushAll($debug = false)
{
if (!$this->isConnected) {
$err = '';
if (!$this->connect($err) && $debug) {
ADOConnection::outp($err);
}
}
if (!$this->memcacheLibrary) {
return false;
}
$del = $this->memcacheLibrary->flush();
if ($debug) {
if (!$del) {
ADOConnection::outp("flushall: failed!<br>\n");
} else {
ADOConnection::outp("flushall: succeeded!<br>\n");
}
}
return $del;
}
/**
* Flushes the contents of a specified query
*
* @param string $filename The MD5 of the query to flush
* @param bool $debug
*
* @return bool The response from the memcache server
*/
public function flushCache($filename, $debug = false)
{
if (!$this->isConnected) {
$err = '';
if (!$this->connect($err) && $debug) {
ADOConnection::outp($err);
}
}
if (!$this->memcacheLibrary) {
return false;
}
$del = $this->memcacheLibrary->delete($filename);
if ($debug) {
if (!$del) {
ADOConnection::outp("flushcache: $filename entry doesn't exist on memcache server!<br>\n");
} else {
ADOConnection::outp("flushcache: $filename entry flushed from memcache server!<br>\n");
}
}
return $del;
}
}
Mini Shell