/**
* Initialise memcached storage cache.
*
* @param array $options optional config array, valid keys are: host, port
*/
public function __construct(array $options = array())
{
$this->options = $options + $this->options;
$this->memcached = new \Memcached();
$this->memcached->addServer($this->options['host'], $this->options['port'], 0);
$this->flags = $this->options['compressed'] ? MEMCACHED_COMPRESSED : 0;
}
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);
}
}
}
public static function setUpBeforeClass()
{
static::$Memcached = new \Memcached();
// MEMCACHED_TEST_SERVER defined in phpunit.xml
$server = explode(':', MEMCACHED_TEST_SERVER);
static::$Memcached->addServer($server[0], $server[1]);
}
/**
* Constructor
*
* @access public
*
* @param array $config config array
*
* @result void
* @throws Exception
*/
public function __construct(array $config = [])
{
parent::__construct($config);
if (empty($config['type']) || !$this->check()) {
throw new Exception('Memcache(d) not installed or not select type');
}
switch (strtolower($config['type'])) {
case 'memcached':
$this->driver = new \Memcached();
break;
case 'memcache':
$this->driver = new \Memcache();
break;
default:
throw new Exception('Selected type not valid in the driver');
}
if (!empty($config['servers'])) {
$this->driver->addServers($config['servers']);
} elseif ($config['server']) {
$conf = $config['server'];
$server = ['hostname' => !empty($conf['hostname']) ? $conf['hostname'] : '127.0.0.1', 'port' => !empty($conf['port']) ? $conf['port'] : 11211, 'weight' => !empty($conf['weight']) ? $conf['weight'] : 1];
if (get_class($this->driver) === 'Memcached') {
$this->driver->addServer($server['hostname'], $server['port'], $server['weight']);
} else {
$this->driver->addServer($server['hostname'], $server['port'], true, $server['weight']);
}
} else {
throw new Exception('Server(s) not configured');
}
}
public function __construct(array $aConfig = [])
{
// Parent construct
parent::__construct($aConfig);
// Extend config
$aConfig = ExtendedArray::extendWithDefaultValues($aConfig, ['connection_timeout' => 10, 'server_failure_limit' => 5, 'remove_failed_servers' => true, 'retry_timeout' => 1]);
// Check Memcached is loaded
if (!extension_loaded('memcached')) {
throw new RuntimeException('Memcached extension is not loaded');
}
// Create client
$this->oClient = new Memcached();
$this->oClient->setOption(Memcached::OPT_CONNECT_TIMEOUT, $aConfig['connection_timeout']);
$this->oClient->setOption(Memcached::OPT_DISTRIBUTION, Memcached::DISTRIBUTION_CONSISTENT);
$this->oClient->setOption(Memcached::OPT_SERVER_FAILURE_LIMIT, $aConfig['server_failure_limit']);
$this->oClient->setOption(Memcached::OPT_REMOVE_FAILED_SERVERS, $aConfig['remove_failed_servers']);
$this->oClient->setOption(Memcached::OPT_RETRY_TIMEOUT, $aConfig['retry_timeout']);
// Add servers
if (array_key_exists('servers', $aConfig)) {
$aServers = array_filter(explode(',', $aConfig['servers']));
foreach ($aServers as $sAddress) {
// Parse address
list($sHost, $sPort) = array_pad(explode(':', $sAddress), 2, '');
// Add server
$this->oClient->addServer($sHost, intval($sPort));
}
}
}
public function __construct()
{
$this->mem = new Memcached(static::$servers_id);
if (count($this->mem->getServerList()) == 0) {
$this->mem->addServer("", 11211);
}
}
private function setupMemcache()
{
if (is_null($this->memcache) && class_exists('Memcached', false)) {
$this->memcache = new \Memcached();
$this->memcache->addServer($this->host, $this->port);
}
}
public function addServer($host = 'localhost', $port = 11211)
{
if ($this->memcached->addServer($host, $port, 1) === FALSE) {
$error = error_get_last();
throw new Nette\InvalidStateException("Memcached::addServer(): {$error['message']}.");
}
}
/**
* Constructor
*
* @param string $uniqId to be used to separate objects in addition to their key identifiers, for instance in a
* multi-user scenario.
*
* @return \iveeCrest\MemcachedWrapper
*/
public function __construct($uniqId)
{
$this->memcached = new \Memcached();
$this->memcached->addServer(Config::getCacheHost(), Config::getCachePort());
$this->memcached->setOption(\Memcached::OPT_PREFIX_KEY, Config::getCachePrefix());
$this->uniqId = $uniqId;
}
/**
* Creamos y configuramos el driver para la cache.
* @param string $hostname Nombre del host para conectar al servidor memcached.
* @param int $port Puerto para conectar al servidor de memcached.
* @param int $weight Importancia del servidor frente al resto.
*/
public function __construct($hostname = '127.0.0.1', $port = 11211, $weight = 1)
{
// Instanciamos memcached.
$this->_memcached = new Memcached();
// Configuramos el servidor.
$this->_memcached->addServer($hostname, $port, $weight);
}
protected function init()
{
$this->config['host'] = $this->config['host'] ?: 'localhost';
$this->config['port'] = $this->config['port'] ?: 11211;
$this->store = new Memcached();
$this->store->addServer($this->config['host'], $this->config['port'], 100);
}
/**
* @return bool
*/
public function connectServer()
{
if ($this->checkdriver() == false) {
return false;
}
$s = $this->config['memcache'];
if (count($s) < 1) {
$s = array(array('127.0.0.1', 11211, 100));
}
foreach ($s as $server) {
$name = isset($server[0]) ? $server[0] : '127.0.0.1';
$port = isset($server[1]) ? $server[1] : 11211;
$sharing = isset($server[2]) ? $server[2] : 0;
$checked = $name . '_' . $port;
if (!isset($this->checked[$checked])) {
try {
if ($sharing > 0) {
if (!$this->instant->addServer($name, $port, $sharing)) {
$this->fallback = true;
}
} else {
if (!$this->instant->addServer($name, $port)) {
$this->fallback = true;
}
}
$this->checked[$checked] = 1;
} catch (\Exception $e) {
$this->fallback = true;
}
}
}
}
/**
* Connect and initialize this handler.
*
* @return boolean True if successful, false on failure
*/
function connect()
{
global $mybb, $error_handler;
$this->memcached = new Memcached();
if ($mybb->config['memcache']['host']) {
$mybb->config['memcache'][0] = $mybb->config['memcache'];
unset($mybb->config['memcache']['host']);
unset($mybb->config['memcache']['port']);
}
foreach ($mybb->config['memcache'] as $memcached) {
if (!$memcached['host']) {
$message = "Please configure the memcache settings in inc/config.php before attempting to use this cache handler";
$error_handler->trigger($message, MYBB_CACHEHANDLER_LOAD_ERROR);
die;
}
if (!isset($memcached['port'])) {
$memcached['port'] = "11211";
}
$this->memcached->addServer($memcached['host'], $memcached['port']);
if (!$this->memcached) {
$message = "Unable to connect to the memcached server on {$memcached['memcache_host']}:{$memcached['memcache_port']}. Are you sure it is running?";
$error_handler->trigger($message, MYBB_CACHEHANDLER_LOAD_ERROR);
die;
}
}
// Set a unique identifier for all queries in case other forums are using the same memcache server
$this->unique_id = md5(MYBB_ROOT);
return true;
}
/**
* Only connect at the last possible moment. This enables you to get the cache provider, but not connect
* until you have business with the cache.
*/
private function connect()
{
if ($this->isConnected) {
return;
}
$this->memcache->addServer($this->configuration->getHost(), $this->configuration->getPort());
}
/**
* Constructor
*
* @param array[] $servers server array
*/
public function __construct($servers)
{
if (!$servers || !is_array($servers) || count($servers) < 1) {
throw new GitPHP_MessageException('No Memcache servers defined', true, 500);
}
if (class_exists('Memcached')) {
$this->memcacheObj = new Memcached();
$this->memcacheType = GitPHP_CacheResource_Memcache::Memcached;
$this->memcacheObj->addServers($servers);
} else {
if (class_exists('Memcache')) {
$this->memcacheObj = new Memcache();
$this->memcacheType = GitPHP_CacheResource_Memcache::Memcache;
foreach ($servers as $server) {
if (is_array($server)) {
$host = $server[0];
$port = 11211;
if (isset($server[1])) {
$port = $server[1];
}
$weight = 1;
if (isset($server[2])) {
$weight = $server[2];
}
$this->memcacheObj->addServer($host, $port, true, $weight);
}
}
} else {
throw new GitPHP_MissingMemcacheException();
}
}
$this->servers = $servers;
}
/**
* 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');
}
}
/**
* Return memcached connection object
*
* @return object memcached connection object
*
* @since 12.1
* @throws RuntimeException
*/
protected function getConnection()
{
if ((extension_loaded('memcached') && class_exists('Memcached')) != true) {
return false;
}
$config = JFactory::getConfig();
$this->_persistent = $config->get('memcache_persist', true);
$this->_compress = $config->get('memcache_compress', false) == false ? 0 : Memcached::OPT_COMPRESSION;
/*
* This will be an array of loveliness
* @todo: multiple servers
* $servers = (isset($params['servers'])) ? $params['servers'] : array();
*/
$server = array();
$server['host'] = $config->get('memcache_server_host', 'localhost');
$server['port'] = $config->get('memcache_server_port', 11211);
// Create the memcache connection
if ($this->_persistent) {
$session = JFactory::getSession();
self::$_db = new Memcached($session->getId());
} else {
self::$_db = new Memcached();
}
$memcachedtest = self::$_db->addServer($server['host'], $server['port']);
if ($memcachedtest == false) {
throw new RuntimeException('Could not connect to memcached server', 404);
}
self::$_db->setOption(Memcached::OPT_COMPRESSION, $this->_compress);
// Memcached has no list keys, we do our own accounting, initialise key index
if (self::$_db->get($this->_hash . '-index') === false) {
$empty = array();
self::$_db->set($this->_hash . '-index', $empty, 0);
}
return;
}
public static function getMemcache()
{
if (!isset(self::$mc)) {
self::$mc = new Memcached();
self::$mc->addServer("localhost", 11211);
}
return self::$mc;
}
/**
* {@inheritdoc}
*/
public function connect()
{
foreach ($this->servers as $server) {
//Merging default options
$server = $server + $this->defaultServer;
$this->driver->addServer($server['host'], $server['port'], $server['weight']);
}
}
/**
* Get Memcached instance.
*
* @return Memcached
*/
public function getMemcached()
{
if (!isset($this->memcached)) {
$this->memcached = new Memcached();
$this->memcached->addServer($this->options['host'], $this->options['port']);
}
return $this->memcached;
}
/**
* @return \Memcached
*/
public function getInstance()
{
if (is_null($this->instance)) {
$this->instance = new \Memcached();
$this->instance->addServer("localhost", 11211);
return $this->instance;
}
return $this->instance;
}
/**
* @param BaseMemcached|null $server
*/
public function __construct(BaseMemcached $server = null)
{
if ($server) {
$this->server = $server;
return;
}
$this->server = new BaseMemcached();
$this->server->addServer('localhost', 11211);
}
public function setConfig(array $config)
{
$default = ['host' => '127.0.0.1', 'port' => 11211];
$config = array_merge($default, $config);
$this->connected = $this->handler->addServer($config['host'], $config['port']);
if (!$this->connected) {
throw new \RuntimeException('Connect Memcache Server Failed!');
}
}
/**
* Construct a new DocumentIndex
* @param String $host Host setting for Memcached service
* @param Integer $port Port setting for Memcached service
*/
public function __construct($host = 'localhost', $port = 11211)
{
$this->index = new \Memcached();
$this->index->addServer($host, $port);
$this->size = $this->index->get('index_size');
if ($this->size === false) {
$this->size = 0;
}
}
/**
* Constructs the memcached object
*
* @param array configuration
* @throws Kohana_Cache_Exception
*/
public function __construct(array $config)
{
// Check that memcached is loaded
if (!extension_loaded('memcached')) {
throw new Kohana_Cache_Exception('Memcached extension is not loaded');
}
parent::__construct($config);
// Check whether this is a persistent connection
if ($config['persistent'] == FALSE) {
// Setup a non-persistent memcached connection
$this->_memcached = new Memcached();
} else {
// Setup a persistent memcached connection
$this->_memcached = new Memcached($this->_config['persistent_id']);
}
// Load servers from configuration
$servers = Arr::get($this->_config, 'servers', NULL);
if (!$servers) {
// Throw exception if no servers found in configuration
throw new Kohana_Cache_Exception('No Memcache servers defined in configuration');
}
// Add memcache servers
foreach ($servers as $server) {
if (!$this->_memcached->addServer($server['host'], $server['port'], $server['weight'])) {
throw new Kohana_Cache_Exception('Could not connect to memcache host at \':host\' using port \':port\'', array(':host' => $server['host'], ':port' => $server['port']));
}
}
// Load memcached options from configuration
$options = Arr::get($this->_config, 'options', NULL);
// Make sure there are options to set
if ($options != NULL) {
// Set the options
foreach ($options as $key => $value) {
// Special cases for a few options
switch ($key) {
case 'serializer':
$value = $this->_serializer_map[$value];
break;
case 'hash':
$value = $this->_hash_map[$value];
break;
case 'distribution':
$value = $this->_distribution_map[$value];
break;
case 'prefix_key':
// Throw exception is key prefix is greater than 128 characters
if (strlen($value) > 128) {
throw new Kohana_Cache_Exception('Memcached prefix key cannot exceed 128 characters');
}
break;
default:
break;
}
$this->_memcached->setOption($this->_options_map[$key], $value);
}
}
}
public function __construct($prefix = '')
{
parent::__construct($prefix);
if (is_null(self::$cache)) {
self::$cache = new \Memcached();
list($host, $port) = \OC_Config::getValue('memcached_server', array('localhost', 11211));
self::$cache->addServer($host, $port);
}
}
/**
* @throws \RuntimeException
*/
private function connect()
{
if (empty($this->servers)) {
throw new \RuntimeException('Missing memcached server/s configuration');
}
$this->memcached = new \Memcached();
foreach ($this->servers as $serverConfiguration) {
$this->memcached->addServer($serverConfiguration->getHost(), $serverConfiguration->getPort(), $serverConfiguration->getWeight());
}
}
/**
* (non-PHPdoc)
* @see \parallely\AbstractTransport::_prepare()
*/
protected function _prepare()
{
if (empty($this->_oMemcache) === true) {
$this->_oMemcache = new \Memcached();
if ($this->_oMemcache->addServer($this->_aOptions['host'], $this->_aOptions['port']) !== true) {
throw new \parallely\Exception(\parallely\Exception::SETUP_ERROR);
}
}
return $this;
}
public function setUp()
{
parent::setUp();
$this->memcache = new \Memcached();
$this->memcache->addServer(self::TEST_MEMCACHE_SERVER, self::TEST_MEMCACHE_PORT);
$this->memcache->flush();
if (!$this->memcache->set('test', 1, time() + 100)) {
throw new \RuntimeException('Cannot save item to memcache. ' . $this->memcache->getResultMessage());
}
}
/**
* @param \Memcached|null $memcached
*/
public function setMemcached($memcached = null)
{
if ($memcached) {
$this->memcached = $memcached;
}
if ($this->memcached) {
$this->memcached->resetServerList();
$this->memcached->addServer($this->server, $this->port);
}
}
