public function __construct()
{
$this->mem = new Memcached(static::$servers_id);
if (count($this->mem->getServerList()) == 0) {
$this->mem->addServer("", 11211);
}
}
/**
* @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');
}
public function __construct($persistent = true)
{
/*
* Caching can be disabled in the config file if you aren't able to run
* a memcached instance. In that case this class will still get used,
* but we will pretend that we have a perpetually empty cache.
*/
if (defined("USE_MEMCACHED") && USE_MEMCACHED != false) {
$servers = null;
if ($persistent === true) {
/*
* Since prefix should be unique across RTK installations, we can
* use the server hostname + port + prefix as a persistent ID.
* Hostname + port are included because otherwise changing the
* memcached server would NOT change the persistent connection,
* and you'd end up using the old server.
*/
$persistentID = MEMCACHED_HOST . ":" . MEMCACHED_PORT . "_" . MEMCACHED_PREFIX;
$this->cache = new Memcached($persistentID);
$serverList = $this->cache->getServerList();
foreach ($serverList as $entry) {
$servers[] = $entry['host'] . ":" . $entry['port'];
}
} else {
//Not running Memcached in persistent mode.
$this->cache = new Memcached();
}
if ($persistent !== true || !is_array($servers) || !in_array(MEMCACHED_HOST . ":" . MEMCACHED_PORT, $servers)) {
$this->cache->addServer(MEMCACHED_HOST, MEMCACHED_PORT);
}
}
}
/**
* 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');
}
}
/**
* Construct the driver instance.
*
* @param Config $config The instance config
*/
public function __construct(Config $config, Instance $instance)
{
$this->instance = $instance;
$this->client = new \Memcached($config->name);
if (count($this->client->getServerList()) === 0) {
$this->client->addServers($config->servers->toArray());
}
}
/**
* @return array
*/
protected function getMemcacheKeys()
{
$keys = [];
foreach ($this->memcache->getServerList() as $server) {
$keys = array_merge($keys, $this->getMemcacheKeysForHost($server[MemcacheConfigConstants::SERVER_HOST], $server[MemcacheConfigConstants::SERVER_PORT]));
}
return $keys;
}
public static function setUpBeforeClass()
{
self::$memcached = new \Memcached();
self::$memcached->setOptions(array(\Memcached::OPT_TCP_NODELAY => true, \Memcached::OPT_NO_BLOCK => true, \Memcached::OPT_CONNECT_TIMEOUT => 1000));
if (count(self::$memcached->getServerList()) == 0) {
self::$memcached->addServers(array(array(MEMCACHED_HOST, MEMCACHED_PORT)));
}
}
/**
* Set connection
*
* @param \Memcached $memcached
*
* @return $this
*
*/
public function setConnection(\Memcached $memcached)
{
$this->connection = $memcached;
if (!count($this->connection->getServerList())) {
$this->configureServers();
}
$this->setOptions();
return $this;
}
protected function _addServer($server, $port, $persist, $weight, $timeout)
{
$list = $this->_connection->getServerList();
foreach ($list as $srv) {
if ($srv['host'] === $server && (int) $srv['port'] === (int) $port && (!isset($srv['weight']) || (int) $srv['weight'] === (int) $weight)) {
return;
}
}
$this->_connection->addServer($server, $port, $weight);
}
/**
* @param $server
* @param $port
* @param $userName
* @param $password
* @param $bucket
*/
public function __construct($server, $port, $userName, $password, $bucket)
{
$this->_instance = new \Memcached();
$this->_instance->setOption(\Memcached::SERIALIZER_JSON, TRUE);
$this->_instance->setOption(\Memcached::OPT_COMPRESSION, FALSE);
$this->_instance->setOption(\Memcached::OPT_CONNECT_TIMEOUT, 500);
$this->_instance->setOption(\Memcached::OPT_POLL_TIMEOUT, 500);
$this->_instance->setOption(\Memcached::OPT_TCP_NODELAY, TRUE);
$this->_instance->setOption(\Memcached::OPT_NO_BLOCK, TRUE);
if (!count($this->_instance->getServerList())) {
$this->_instance->addServer($server, $port);
}
}
/**
* @param ConfigurationInterface $configuration
*/
protected function __construct(ConfigurationInterface $configuration)
{
$this->configuration = $configuration;
$this->cache = new \Memcached();
$serverList = $this->cache->getServerList();
if (empty($serverList)) {
$this->cache->addServer($this->configuration->getHost(), $this->configuration->getPort());
}
$this->cache->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
if ($this->configuration->shouldCheckConnection()) {
$this->checkConnection();
}
}
/**
* Get Mamcached Handler
*
* @return \Memcached
*/
public function getHandler()
{
if (!$this->handler) {
$persistentId = isset($this->settings['persistent']) ? $this->settings['persistent'] : null;
$this->handler = new \Memcached($persistentId);
if (!$this->handler->getServerList()) {
$this->handler->addServers($this->settings['servers']);
}
if (isset($this->settings['options'])) {
$this->handler->setOptions($this->settings['options']);
}
}
return $this->handler;
}
/**
* Initialize the Cache Engine
*
* Called automatically by the cache frontend
*
* @param array $config array of setting for the engine
* @return bool True if the engine has been successfully initialized, false if not
* @throws \InvalidArgumentException When you try use authentication without
* Memcached compiled with SASL support
*/
public function init(array $config = [])
{
if (!extension_loaded('memcached')) {
return false;
}
$this->_serializers = ['igbinary' => Memcached::SERIALIZER_IGBINARY, 'json' => Memcached::SERIALIZER_JSON, 'php' => Memcached::SERIALIZER_PHP];
if (defined('Memcached::HAVE_MSGPACK') && Memcached::HAVE_MSGPACK) {
$this->_serializers['msgpack'] = Memcached::SERIALIZER_MSGPACK;
}
parent::init($config);
if (!empty($config['host'])) {
if (empty($config['port'])) {
$config['servers'] = [$config['host']];
} else {
$config['servers'] = [sprintf('%s:%d', $config['host'], $config['port'])];
}
}
if (isset($config['servers'])) {
$this->config('servers', $config['servers'], false);
}
if (!is_array($this->_config['servers'])) {
$this->_config['servers'] = [$this->_config['servers']];
}
if (isset($this->_Memcached)) {
return true;
}
if ($this->_config['persistent']) {
$this->_Memcached = new Memcached((string) $this->_config['persistent']);
} else {
$this->_Memcached = new Memcached();
}
$this->_setOptions();
if (count($this->_Memcached->getServerList())) {
return true;
}
$servers = [];
foreach ($this->_config['servers'] as $server) {
$servers[] = $this->_parseServerString($server);
}
if (!$this->_Memcached->addServers($servers)) {
return false;
}
if (is_array($this->_config['options'])) {
foreach ($this->_config['options'] as $opt => $value) {
$this->_Memcached->setOption($opt, $value);
}
}
if (empty($this->_config['username']) && !empty($this->_config['login'])) {
throw new InvalidArgumentException('Please pass "username" instead of "login" for connecting to Memcached');
}
if ($this->_config['username'] !== null && $this->_config['password'] !== null) {
$sasl = method_exists($this->_Memcached, 'setSaslAuthData') && ini_get('memcached.use_sasl');
if (!$sasl) {
throw new InvalidArgumentException('Memcached extension is not build with SASL support');
}
$this->_Memcached->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$this->_Memcached->setSaslAuthData($this->_config['username'], $this->_config['password']);
}
return true;
}
private function __construct()
{
if (defined('MEMCACHE_SERVERS')) {
try {
// create a new persistent client
$m = new Memcached("memcached_pool");
$m->setOption(Memcached::OPT_BINARY_PROTOCOL, TRUE);
// some nicer default options
$m->setOption(Memcached::OPT_NO_BLOCK, TRUE);
$m->setOption(Memcached::OPT_AUTO_EJECT_HOSTS, TRUE);
$m->setOption(Memcached::OPT_CONNECT_TIMEOUT, 2000);
$m->setOption(Memcached::OPT_POLL_TIMEOUT, 2000);
$m->setOption(Memcached::OPT_RETRY_TIMEOUT, 2);
// setup authentication
if (defined('MEMCACHE_USERNAME') && defined('MEMCACHE_PASSWORD')) {
$m->setSaslAuthData(MEMCACHE_USERNAME, MEMCACHE_PASSWORD);
}
// We use a consistent connection to memcached, so only add in the
// servers first time through otherwise we end up duplicating our
// connections to the server.
if (!$m->getServerList()) {
// parse server config
$servers = explode(",", MEMCACHE_SERVERS);
foreach ($servers as $s) {
$parts = explode(":", $s);
$m->addServer($parts[0], $parts[1]);
}
}
} catch (Exception $e) {
$this->objCache = false;
}
} else {
$this->objCache = false;
}
}
/**
* Servers differ? i.e., current vs. active.
*
* @since 151216 Memcached utilities.
*
* @return bool True if servers differ.
*/
protected function serversDiffer() : bool
{
if (!$this->Pool) {
return false;
// Not possible.
}
$active_servers = [];
// Initialize array.
foreach ($this->Pool->getServerList() as $_server) {
$active_servers[$_server['host'] . ':' . $_server['port']] = $_server;
}
// unset($_server); // Housekeeping.
if (count($this->servers) !== count($active_servers)) {
return true;
// They definitely differ.
}
foreach ($this->servers as $_key => $_server) {
if (!isset($active_servers[$_key])) {
return true;
}
// unset($_key, $_server);
}
foreach ($active_servers as $_key => $_server) {
if (!isset($this->servers[$_key])) {
return true;
}
// unset($_key, $_server);
}
return false;
}
function check_login()
{
global $db, $mem;
if (defined('MEM') && MEM == True) {
$mem = new Memcached('moyoj');
$mem->setOption(Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
if (!count($mem->getServerList())) {
$mem->addServer(MEM_HOST, MEM_PORT);
}
}
$db = new DB();
$db->init(DB_HOST, DB_USER, DB_PASS, DB_NAME);
$db->connect();
$admin_info = mo_read_cache('mo-admin-' . $_SESSION['aid']);
if (!$admin_info) {
$sql = 'SELECT `id`, `username`, `password`, `nickname`, `role` FROM `mo_admin` WHERE `id` = ? AND `role` > 0';
$db->prepare($sql);
$db->bind('i', $_SESSION['aid']);
$result = $db->execute();
if (!$result || $result[0]['password'] != $_SESSION['admin_password']) {
unset($_SESSION['aid']);
header("Location: login.php");
exit(0);
}
mo_write_cache('mo-admin-' . $_SESSION['aid'], $result[0]);
}
$mo_settings = array();
mo_load_settings();
if (!isset($active)) {
$active = '';
}
}
/**
* @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;
}
protected function __construct()
{
if (class_exists('\\Memcached')) {
$m = new \Memcached("memcached_pool");
$m->setOption(\Memcached::OPT_BINARY_PROTOCOL, TRUE);
// some nicer default options
$m->setOption(\Memcached::OPT_NO_BLOCK, TRUE);
$m->setOption(\Memcached::OPT_AUTO_EJECT_HOSTS, TRUE);
// We use a consistent connection to memcached, so only add in the
// servers first time through otherwise we end up duplicating our
// connections to the server.
if (!$m->getServerList()) {
// parse server config
$servers = explode(",", MEMCACHE_SERVERS);
foreach ($servers as $s) {
$parts = explode(":", $s);
$m->addServer($parts[0], $parts[1]);
}
}
// setup authentication
if (defined('MEMCACHE_USERNAME') && defined('MEMCACHE_PASSWORD')) {
$m->setSaslAuthData(MEMCACHE_USERNAME, MEMCACHE_PASSWORD);
}
$this->memcache = $m;
}
}
protected function __construct($config)
{
if (empty($config)) {
throw new \exception('invalid!');
}
$c = new \Memcached('sk_cache');
//$c->resetserverlist();
$config_servers = $config['servers'];
//easier to keep the code straight this way.
$used_servers = $c->getServerList();
$count_servers_used = count($used_servers);
$count_servers_config = count($config_servers);
if (!$count_servers_used) {
//we have no servers stored. store the entire array.
$c->addServers($config_servers);
} else {
//we need to check to see if a new server was added to the config.
if ($count_servers_used < $count_servers_config) {
$used = array_column($used_servers, 0);
//0 index is ip, 1 index is port...
$config = array_column($config_servers, 0);
usort($used, ['self', 'sortServers']);
usort($config, ['self', 'sortServers']);
$diff = $count_servers_config - $count_servers_used;
$new = array_slice($config, $count_servers_used - 1);
foreach ($new as $server) {
$c->addServer($server, 11211);
//to do: find a way to retrieve the port of the server when adding it, in case of people with custom ports for memcache.
}
}
}
$this->driver = $c;
self::$instance =& $this;
}
/**
* Open
*
* Sanitizes save_path and initializes connections.
*
* @param string $save_path Server path(s)
* @param string $name Session cookie name, unused
* @return bool
*/
public function open($save_path, $name)
{
$this->_memcached = new Memcached();
$this->_memcached->setOption(Memcached::OPT_BINARY_PROTOCOL, TRUE);
// required for touch() usage
$server_list = array();
foreach ($this->_memcached->getServerList() as $server) {
$server_list[] = $server['host'] . ':' . $server['port'];
}
if (!preg_match_all('#,?([^,:]+)\\:(\\d{1,5})(?:\\:(\\d+))?#', $this->_config['save_path'], $matches, PREG_SET_ORDER)) {
$this->_memcached = NULL;
log_message('error', 'Session: Invalid Memcached save path format: ' . $this->_config['save_path']);
return FALSE;
}
foreach ($matches as $match) {
// If Memcached already has this server (or if the port is invalid), skip it
if (in_array($match[1] . ':' . $match[2], $server_list, TRUE)) {
log_message('debug', 'Session: Memcached server pool already has ' . $match[1] . ':' . $match[2]);
continue;
}
if (!$this->_memcached->addServer($match[1], $match[2], isset($match[3]) ? $match[3] : 0)) {
log_message('error', 'Could not add ' . $match[1] . ':' . $match[2] . ' to Memcached server pool.');
} else {
$server_list[] = $match[1] . ':' . $match[2];
}
}
if (empty($server_list)) {
log_message('error', 'Session: Memcached server pool is empty.');
return FALSE;
}
return TRUE;
}
/**
* Open
*
* Sanitizes save_path and initializes connections.
*
* @param string $save_path Server path(s)
* @param string $name Session cookie name, unused
*
* @return bool
*/
public function open($save_path, $name)
{
$this->memcached = new \Memcached();
$this->memcached->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
// required for touch() usage
$server_list = [];
foreach ($this->memcached->getServerList() as $server) {
$server_list[] = $server['host'] . ':' . $server['port'];
}
if (!preg_match_all('#,?([^,:]+)\\:(\\d{1,5})(?:\\:(\\d+))?#', $this->savePath, $matches, PREG_SET_ORDER)) {
$this->memcached = null;
$this->logger->error('Session: Invalid Memcached save path format: ' . $this->savePath);
return false;
}
foreach ($matches as $match) {
// If Memcached already has this server (or if the port is invalid), skip it
if (in_array($match[1] . ':' . $match[2], $server_list, true)) {
$this->logger->debug('Session: Memcached server pool already has ' . $match[1] . ':' . $match[2]);
continue;
}
if (!$this->memcached->addServer($match[1], $match[2], isset($match[3]) ? $match[3] : 0)) {
$this->logger->error('Could not add ' . $match[1] . ':' . $match[2] . ' to Memcached server pool.');
} else {
$server_list[] = $match[1] . ':' . $match[2];
}
}
if (empty($server_list)) {
$this->logger->error('Session: Memcached server pool is empty.');
return false;
}
return true;
}
/**
* 生成Memcached实例
*
* @param array $serverList
* @param string $persistentId 持久连接的名称
* @return \Memcached
*/
public static function memcached(array $serverList, $persistentId = '')
{
$saver = new \Memcached($persistentId);
if (!count($saver->getServerList())) {
$saver->addServers($serverList);
}
return $saver;
}
/**
* @Name: add_server
*
* @param
* :none
* @todu 连接memcache server
* @return : TRUE or FALSE
* add by cheng.yafei
*
*/
public function add_server($server)
{
if (count($this->m->getServerList()) == 0) {
extract($server);
return $this->m->addServer($host, $port, $weight);
}
return true;
}
/**
* This method cannot be overridden because you need to override \Hoard\AbstractPool::getAdapterOptions().
*
* @return \Memcached
* @throws \Exception
*/
protected final function getConnection()
{
$defaultPersistentId = 'hoard-persist';
// first time connect
if (null == $this->connection) {
if (!class_exists('\\Memcached')) {
throw new \Exception('Memcached extension is not installed.');
}
$this->connection = new \Memcached($defaultPersistentId);
if (!count($this->connection->getServerList())) {
// setup memcached options
if (isset($this->adapterOptions['client']) && is_array($this->adapterOptions['client'])) {
foreach ($this->adapterOptions['client'] as $name => $value) {
$optId = null;
if (is_int($name)) {
$optId = $name;
} else {
$optConst = 'Memcached::OPT_' . strtoupper($name);
if (defined($optConst)) {
$optId = constant($optConst);
} else {
throw new \Exception("Unknown memcached client option '{$name}' ({$optConst})");
}
}
if (null !== $optId) {
if (!$this->connection->setOption($optId, $value)) {
throw new \Exception("Setting memcached client option '{$optId}' failed");
}
}
}
}
// if no servers are provided try to bind to default configuration
if (!array_key_exists('servers', $this->adapterOptions)) {
$this->adapterOptions['servers'] = array('localhost:11211');
}
// add servers
foreach ($this->adapterOptions['servers'] as $server) {
list($host, $port) = explode(':', $server, 2);
$this->connection->addServer($host, $port);
}
}
}
return $this->connection;
}
/**
* @param array $servers
* @param string $persistentId
* @return \Memcached
*/
public static function get(array $servers, $persistentId = null)
{
$memcached = new \Memcached($persistentId);
if (!count($memcached->getServerList())) {
foreach ($servers as $server) {
$memcached->addServer($server['host'], $server['port']);
}
}
return $memcached;
}
/**
* Detect if backend is available
* @return bool
*/
public static function isAvailable()
{
try {
if (!extension_loaded('memcached')) {
return false;
}
if (self::$memcache) {
return true;
}
self::$memcache = new \MemCached();
$currentServers = self::$memcache->getServerList();
if (empty($currentServers)) {
return false;
}
return true;
} catch (Exception $ex) {
return false;
}
}
protected function init()
{
if (!self::$memcached) {
if (!empty($this->options['persistent'])) {
self::$memcached = new Memcached($this->options['persistent']);
// if servers already exists
if (self::$memcached->getServerList()) {
return;
}
} else {
self::$memcached = new Memcached();
}
if (empty($this->options['servers'])) {
self::$memcached->addServer('127.0.0.1', 11211);
} else {
foreach ($this->options['servers'] as $s) {
self::$memcached->addServer($s['host'], isset($s['port']) ? $s['port'] : 11211, isset($s['weight']) ? $s['weight'] : 0);
}
}
}
}
/**
* Add a Memcached server to stack
*
* @param string $server Server address (or IP)
* @param string $port Server port
* @param string $weight Server weight
*/
private function addServer($server, $port, $weight)
{
$status = $this->instance->addServer($server, $port, $weight);
if ($status === false) {
$this->raiseError("Error communicating with server", array("RESULTCODE" => $this->instance->getResultCode(), "RESULTMESSAGE" => $this->instance->getResultMessage()));
}
if (sizeof($this->instance->getServerList()) == 0) {
$this->raiseError("No available server, disabling cache administratively");
$this->disable();
} else {
$this->enable();
}
}
public function addMemcachedServers(\Memcached $cache, $servers)
{
$existingServers = array();
if ($this->persistentId !== null) {
foreach ($cache->getServerList() as $s) {
$existingServers[$s['host'] . ':' . $s['port']] = true;
}
}
foreach ($servers as $server) {
if (empty($existingServers) || !isset($existingServers[$server->host . ':' . $server->port])) {
$cache->addServer($server->host, $server->port, $server->weight);
}
}
}
/**
* Initialises the cache.
*
* Once this has been done the cache is all set to be used.
*
* @param cache_definition $definition
*/
public function initialise(cache_definition $definition)
{
if ($this->is_initialised()) {
throw new coding_exception('This memcached instance has already been initialised.');
}
$this->definition = $definition;
$this->connection = new Memcached(crc32($this->name));
$servers = $this->connection->getServerList();
if (empty($servers)) {
foreach ($this->options as $key => $value) {
$this->connection->setOption($key, $value);
}
$this->connection->addServers($this->servers);
}
}
