/**
* Create the Memcached connection
*
* @return void
*
* @since 12.1
* @throws RuntimeException
*/
protected function getConnection()
{
if (!static::isSupported()) {
throw new RuntimeException('Memcached Extension is not available');
}
$config = JFactory::getConfig();
$host = $config->get('memcached_server_host', 'localhost');
$port = $config->get('memcached_server_port', 11211);
// Create the memcached connection
if ($config->get('memcached_persist', true)) {
static::$_db = new Memcached($this->_hash);
$servers = static::$_db->getServerList();
if ($servers && ($servers[0]['host'] != $host || $servers[0]['port'] != $port)) {
static::$_db->resetServerList();
$servers = array();
}
if (!$servers) {
static::$_db->addServer($host, $port);
}
} else {
static::$_db = new Memcached();
static::$_db->addServer($host, $port);
}
static::$_db->setOption(Memcached::OPT_COMPRESSION, $this->_compress);
$stats = static::$_db->getStats();
$result = !empty($stats["{$host}:{$port}"]) && $stats["{$host}:{$port}"]['pid'] > 0;
if (!$result) {
// Null out the connection to inform the constructor it will need to attempt to connect if this class is instantiated again
static::$_db = null;
throw new JCacheExceptionConnecting('Could not connect to memcached server');
}
}
/**
* @param array $servers List of servers
* @param int $expire Expiration time, defaults to 3600 seconds
* @throws \Exception
*/
public function __construct($servers = [], $expire = 3600)
{
// Set expiration time
$this->expire = $expire;
// Create memcached object
$this->cache = new \Memcached();
// Check if there already are servers added, according to the manual
// http://php.net/manual/en/memcached.addservers.php no duplication checks
// are made. Since we have at least one connection we don't need to add
// more servers and maybe add duplicates.
if (count($this->cache->getServerList()) === 0) {
// Add servers
$this->cache->addServers($servers);
}
// Get server stats
$stats = $this->cache->getStats();
// Loop through servers
foreach ($stats as $stat) {
// Check if pid is more than 0, if pid is -1 connection isn't working
if ($stat['pid'] > 0) {
// Return true to avoid the exception below
return true;
}
}
// If we end up here we don't have a working connection. Throw an exception that
// will be handled by the method calling this connect method. A working cache is
// NOT a requirement for the application to run so it's important to handle the
// exception and let the application run. Suggestion: if the exception below is
// thrown a new NullCache should be created
throw new \Exception('Unable to connect to Memcache(d) backend');
}
/**
* @return bool
*/
protected function checkConnection()
{
$stats = $this->cache->getStats();
$result = isset($stats[$this->configuration->getHost() . ":" . $this->configuration->getPort()]);
if (!$result) {
throw new CacheException('Connection error!');
}
return true;
}
/**
* @inheritdoc
*/
public function status()
{
$status_arr = $this->memcached->getStats();
$server_arr = $this->memcached->getServerList();
if (isset($server_arr[0]['host']) and isset($server_arr[0]['port']) and isset($status_arr["{$server_arr[0]['host']}:{$server_arr[0]['port']}"])) {
$info = $status_arr["{$server_arr[0]['host']}:{$server_arr[0]['port']}"];
} else {
$info = [];
}
$status[self::HITS] = isset($info['get_hits']) ? $info['get_hits'] : 0;
$status[self::MISSES] = isset($info['get_misses']) ? $info['get_misses'] : 0;
$status[self::START_TIME] = isset($info['uptime']) ? $info['uptime'] : 0;
$status[self::MEMORY_USED] = isset($info['bytes']) ? $info['bytes'] : 0;
$status[self::MEMORY_LEFT] = isset($info['limit_maxbytes']) ? $info['limit_maxbytes'] : 0;
return $status;
}
private function skipIfMemcacheIsNotRunning(\Memcached $client)
{
$memcacheAddress = self::MEMCACHED_HOST . ':' . self::MEMCACHED_PORT;
if (!isset($client->getStats()[$memcacheAddress])) {
$this->markTestSkipped('You need a running memcached to run the integration tests!');
}
}
/**
* Get available space in bytes
*
* @return int|float
*/
public function getAvailableSpace()
{
$stats = $this->memcached->getStats();
if ($stats === false) {
throw new Exception\RuntimeException($this->memcached->getResultMessage());
}
$mem = array_pop($stats);
return $mem['limit_maxbytes'] - $mem['bytes'];
}
/**
* Internal method to get storage capacity.
*
* @param array $normalizedOptions
* @return array|boolean Capacity as array or false on failure
* @throws Exception\ExceptionInterface
*/
protected function internalGetCapacity(array &$normalizedOptions)
{
$stats = $this->memcached->getStats();
if ($stats === false) {
throw $this->getExceptionByResultCode($this->memcached->getResultCode());
}
$mem = array_pop($stats);
return array('free' => $mem['limit_maxbytes'] - $mem['bytes'], 'total' => $mem['limit_maxbytes']);
}
/**
* Get cache server statistics.
*
* @return array|string
* @access public
*/
public function serverStatistics()
{
if ($this->connected === true && $this->ping() === true) {
if ($this->isRedis === true) {
return $this->server->info();
} else {
return $this->server->getStats();
}
}
return array();
}
public function getStats($config)
{
if (!$config) {
return array();
}
$memcached = new \Memcached();
$memcached->setOption($memcached::OPT_PREFIX_KEY, $config['options']['namespace']);
$memcached->addServers($config['options']['servers']);
$stats = $memcached->getStats();
return $stats;
}
/**
* Get cache status
*
* @return array
*/
public function status()
{
if (!$this->isEnabled()) {
return array("provider" => "memcached", "enabled" => false, "objects" => null, "options" => array());
}
$stats = $this->instance->getStats();
$objects = 0;
foreach ($stats as $key => $value) {
$objects = max($objects, $value['curr_items']);
}
return array("provider" => "memcached", "enabled" => $this->isEnabled(), "objects" => intval($objects), "options" => $stats);
}
/**
* 获取服务器池的统计信息
* @param string $type
* @return array|bool
*/
public function getStats($type = "items")
{
switch ($this->client_type) {
case 'Memcache':
$stats = $this->m->getStats($type);
break;
default:
case 'Memcached':
$stats = $this->m->getStats();
break;
}
return $stats;
}
public function setUp()
{
if (!extension_loaded('memcached')) {
$this->markTestSkipped("Memcached extension not loaded");
}
// Ensure the proper configuration exists
$config = new \r8\Test\Config("MEMCACHE", array("HOST", "PORT"));
$config->test();
$cache = new \Memcached();
$cache->addServer(MEMCACHE_HOST, MEMCACHE_PORT);
if ($cache->getStats() === FALSE) {
$this->markTestSkipped("Unable to connect to Memcached server");
}
}
/**
* Get cache server statistics.
*
* @return array
* @access public
*/
public function serverStatistics()
{
if ($this->ping()) {
switch (NN_CACHE_TYPE) {
case self::TYPE_REDIS:
return $this->server->info();
case self::TYPE_MEMCACHED:
return $this->server->getStats();
case self::TYPE_APC:
return apc_cache_info();
}
}
return array();
}
public function getMemcached()
{
try {
$m = new \Memcached();
$m->addServer(self::HOST, self::PORT);
$stats = $m->getStats();
$host = self::HOST . ':' . self::PORT;
if ($stats[$host]['pid'] == -1) {
throw new \Exception(sprintf('Unable to reach a memcached server on %s', $host));
}
} catch (\Exception $e) {
$this->markTestSkipped($e->getMessage());
}
return $m;
}
/**
* Get storage capacity.
*
* @param array $options
* @return array|boolean Capacity as array or false on failure
*
* @triggers getCapacity.pre(PreEvent)
* @triggers getCapacity.post(PostEvent)
* @triggers getCapacity.exception(ExceptionEvent)
*/
public function getCapacity(array $options = array())
{
$args = new ArrayObject(array('options' => &$options));
try {
$eventRs = $this->triggerPre(__FUNCTION__, $args);
if ($eventRs->stopped()) {
return $eventRs->last();
}
$mem = array_pop($this->memcached->getStats());
$result = array('free' => $mem['limit_maxbytes'] - $mem['bytes'], 'total' => $mem['limit_maxbytes']);
return $this->triggerPost(__FUNCTION__, $args, $result);
} catch (\Exception $e) {
return $this->triggerException(__FUNCTION__, $args, $e);
}
}
/**
* 检查连接状态
* @return boolean
*/
public function checkDriver()
{
if (!$this->isConnected && $this->reConnected < $this->maxReConnected) {
if ($this->handler->getStats() !== false) {
$this->isConnected = true;
} else {
$this->handler->initServers();
}
if (!$this->isConnected) {
$this->reConnected++;
} else {
$this->reConnected = 0;
}
}
return $this->isConnected;
}
public function getStats()
{
$stats = $this->handler->getStats();
$servers = $this->servers;
foreach ($stats as $key => $stat) {
if ($stat['pid'] === -1) {
//移除不可用的server
unset($servers[$key]);
}
}
//没有可用的server
if (empty($servers)) {
$this->isConnected = false;
return false;
} else {
$this->handler->resetServerList();
$status = $this->handler->addServers(array_values($servers));
if ($status) {
$this->isConnected = true;
}
return $status;
}
}
/**
* @inheritdoc
*/
public function info()
{
return $this->driver->getStats();
}
private function fetchStatus()
{
if ($this->isAvailable() && null !== self::$Server && empty($this->Status)) {
$this->Status = self::$Server->getStats();
}
}
$config['dp_autocreate'] = $config['cdp_autocreate'];
}
if (!isset($config['mibdir'])) {
$config['mibdir'] = $config['install_dir'] . '/mibs';
}
$config['mib_dir'] = $config['mibdir'];
// If we're on SSL, let's properly detect it
if (isset($_SERVER['HTTPS'])) {
$config['base_url'] = preg_replace('/^http:/', 'https:', $config['base_url']);
}
if ($config['memcached']['enable'] === true) {
if (class_exists('Memcached')) {
$memcache = new Memcached();
$memcache->addServer($config['memcached']['host'], $config['memcached']['port']);
if ($debug) {
print_r($memcache->getStats());
}
} else {
echo "WARNING: You have enabled memcached but have not installed the PHP bindings. Disabling memcached support.\n";
echo "Try 'apt-get install php5-memcached' or 'pecl install memcached'. You will need the php5-dev and libmemcached-dev packages to use pecl.\n\n";
$config['memcached']['enable'] = 0;
}
}
// Set some times needed by loads of scripts (it's dynamic, so we do it here!)
$config['time']['now'] = time();
$config['time']['now'] -= $config['time']['now'] % 300;
$config['time']['fourhour'] = $config['time']['now'] - 14400;
// time() - (4 * 60 * 60);
$config['time']['sixhour'] = $config['time']['now'] - 21600;
// time() - (6 * 60 * 60);
$config['time']['twelvehour'] = $config['time']['now'] - 43200;
/**
* 获取服务器统计信息
*
* @return array
*/
public function stat()
{
return $this->memcached ? $this->memcached->getStats() : null;
}
if ($is_admin) {
$redis = new Redis();
$redis->connect(CMW_REDIS_HOST);
$info = $redis->info('default');
$response['redis_version'] = $info['redis_version'];
$response['redis_uptime'] = time_offset() + intval($info['uptime_in_seconds']);
$redis->close();
}
}
// Memcached //
if (defined('CMW_USING_MEMCACHED') && $show_memcached) {
$response['memcached_api_version'] = phpversion('memcached');
if ($is_admin) {
$m = new Memcached();
$m->addServer(CMW_MEMCACHED_HOST, CMW_MEMCACHED_PORT);
$m_data = $m->getStats();
//$response['memcached'] = []; // If multiple servers
foreach ($m_data as $key => $value) {
//$response['memcached'][$key] = $value['uptime']; // If multiple servers
$response['memcached_version'] = $value['version'];
$response['memcached_uptime'] = time_offset() + $value['uptime'];
}
$m->quit();
}
}
// Command Line Tools //
if (defined('CMW_USING_IMAGEMAGICK') && !$show_specific && $is_admin) {
unset($out);
unset($ret);
exec("convert -version", $out, $ret);
$response['imagemagick_version'] = $ret ? "ERROR" : preg_split('/\\s+/', $out[0])[2];
/**
* @param \Memcached $memcached
* @throws \Exception
*/
private function validate(\Memcached $memcached)
{
$stats = $memcached->getStats();
foreach ($this->servers as $server) {
$host = $server[MemcacheConfigConstants::SERVER_HOST] . ':' . $server[MemcacheConfigConstants::SERVER_PORT];
if ($stats[$host]['pid'] == -1) {
throw new \Exception("Error establishing memcache connection to {$host}");
}
}
}
<?php
$mc = new Memcached();
$mc->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$mc->addServers(array_map(function ($server) {
return explode(':', $server, 2);
}, explode(',', $_ENV['MEMCACHEDCLOUD_SERVERS'])));
$mc->setSaslAuthData($_ENV['MEMCACHEDCLOUD_USERNAME'], $_ENV['MEMCACHEDCLOUD_PASSWORD']);
switch ($_GET['a']) {
case 'set':
echo $mc->set('welcome_msg', 'Hello from Redis!');
break;
case 'get':
echo $mc->get('welcome_msg');
break;
case 'stats':
foreach ($mc->getStats() as $key => $value) {
foreach ($value as $k => $v) {
echo "{$k}: {$v} <br />\n";
}
}
break;
case 'delete':
echo $mc->delete('welcome_msg');
break;
default:
echo '';
break;
}
/**
* Get server pool statistics.
*
* @link http://www.php.net/manual/en/memcached.getstats.php
*
* @return array Array of server statistics, one entry per server.
*/
public function getStats()
{
return $this->m->getStats();
}
/**
* Returns a Memcached connection.
*
* @param array $options Available options are 'host' and 'port'
*
* @return \Memcached
*
* @throws RuntimeException
*/
public function getMemcachedConnection(array $options = [])
{
$options = array_replace(['host' => 'localhost', 'port' => 11211], $options);
if (null !== ($cache = $this->getConnection('memcached', $options))) {
return $cache;
}
if (!extension_loaded('memcached')) {
throw new RuntimeException('The Memcached cache requires the Memcached extension.');
}
$memcached = new \Memcached();
$memcached->addServer($options['host'], $options['port']);
$memcached->getStats();
if (\Memcached::RES_SUCCESS !== $memcached->getResultCode()) {
throw new RuntimeException(sprintf("Memcached instance with host '%s' and port '%s' is not reachable.", $options['host'], $options['port']));
}
return $this->setConnection('memcached', $options, $memcached);
}
if (isset($config['cdp_autocreate'])) {
$config['dp_autocreate'] = $config['cdp_autocreate'];
}
if (!isset($config['mibdir'])) {
$config['mibdir'] = $config['install_dir'] . '/mibs';
}
$config['mib_dir'] = $config['mibdir'];
// If we're on SSL, let's properly detect it
if (isset($_SERVER['HTTPS'])) {
$config['base_url'] = preg_replace('/^http:/', 'https:', $config['base_url']);
}
if ($config['memcached']['enable'] === true) {
if (class_exists('Memcached')) {
$memcache = new Memcached();
$memcache->addServer($config['memcached']['host'], $config['memcached']['port']);
$memcache->getStats();
} else {
echo "WARNING: You have enabled memcached but have not installed the PHP bindings. Disabling memcached support.\n";
echo "Try 'apt-get install php5-memcached' or 'pecl install memcached'. You will need the php5-dev and libmemcached-dev packages to use pecl.\n\n";
$config['memcached']['enable'] = 0;
}
}
// Set some times needed by loads of scripts (it's dynamic, so we do it here!)
$config['time']['now'] = time();
$config['time']['now'] -= $config['time']['now'] % 300;
$config['time']['fourhour'] = $config['time']['now'] - 14400;
// time() - (4 * 60 * 60);
$config['time']['sixhour'] = $config['time']['now'] - 21600;
// time() - (6 * 60 * 60);
$config['time']['twelvehour'] = $config['time']['now'] - 43200;
// time() - (12 * 60 * 60);
public function getStats()
{
return $this->memcached->getStats();
}
/**
* returns the current status
*/
public function getStatus() : array
{
return ['status' => parent::getStats(), 'version' => parent::getVersion(), 'server_list' => parent::getServerList()];
}
<?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);
