/**
* 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;
}
/**
* Construct the adapter, giving an array of servers.
* @example
* array(
* 'prefix' => '',
* 'persistent_id' => '',
* 'servers' => array(
* array (
* 'host' => 'cache1.example.com',
* 'port' => 11211,
* 'weight' => 1
* ),
* array(
* 'host' => 'cache2.example.com',
* 'port' => 11211,
* 'weight' => 2
* )
* )
* )
* @param array $config
*/
public function __construct(array $config = array())
{
try {
if (array_key_exists('prefix', $config)) {
$this->prefix = $config['prefix'];
}
if (array_key_exists('persistent_id', $config) && !empty($config['persistent_id'])) {
// @codeCoverageIgnoreStart
$this->memcached = new \Memcached($config['persistent_id']);
} else {
// @codeCoverageIgnoreEnd
$this->memcached = new \Memcached();
}
foreach ($config['servers'] as $server) {
$this->memcached->addserver($server['host'], $server['port'], $server['weight']);
}
if (array_key_exists('options', $config)) {
foreach ($config['options'] as $optionKey => $optionValue) {
$this->memcached->setOption($optionKey, $optionValue);
}
}
} catch (\Exception $e) {
// @codeCoverageIgnoreStart
$this->memcached = null;
// @codeCoverageIgnoreEnd
}
}
private function __construct()
{
$fristclassname = 'Memcached';
$secondclassname = 'Memcache';
$this->client_type = class_exists($fristclassname) ? $fristclassname : (class_exists($secondclassname) ? $secondclassname : FALSE);
if ($this->client_type) {
// 判断引入类型
switch ($this->client_type) {
case 'Memcached':
$this->m = new \Memcached('hella_connect');
if (count($this->m->getServerList()) == 0) {
$this->m->setOption(\Memcached::OPT_COMPRESSION, false);
// 关闭压缩功能
$this->m->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
// 使用binary二进制协议
} else {
// functionsDump ( $this->m->getServerList () );
}
break;
case 'Memcache':
$this->m = new \Memcache();
// if (auto_compress_tresh){
// $this->setcompressthreshold(auto_compress_tresh, auto_compress_savings);
// }
break;
}
$this->auto_connect();
} else {
echo 'ERROR: Failed to load Memcached or Memcache Class (∩_∩)';
exit;
}
}
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;
}
}
/**
* 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');
}
}
public function init($config)
{
global $_G;
if (!$config) {
if (TAE) {
$config["host"] = "127.0.0.1";
$config["port"] = 11211;
} else {
$config = $_G['_config']['cache_config'];
}
}
$this->config = $config;
$connect = new Memcached();
//声明一个新的memcached链接
$connect->setOption(Memcached::OPT_COMPRESSION, false);
//关闭压缩功能
$connect->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
//使用binary二进制协议
$connect->addServer($config['host'], $config['port']);
//添加OCS实例地址及端口号
if ($config['username'] && $config['password']) {
//设置OCS帐号密码进行鉴权，如已开启免密码功能，则无需此步骤
$connect->setSaslAuthData($config['username'], $config['password']);
}
$this->enable = true;
$this->obj = $connect;
return $this->enable;
}
/**
* Return memcached connection object
*
* @return object memcached connection object
*
* @since 12.1
*/
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) {
return JError::raiseError(404, "Could not connect to memcached server");
}
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;
}
/**
* {@inheritdoc}
*/
public function write($key, $data, $expires = 60, $compressed = false)
{
$cmp = $this->driver->getOption(Memcached::OPT_COMPRESSION);
$this->driver->setOption(Memcached::OPT_COMPRESSION, $compressed);
$cached = $this->driver->set($key, $data, $expires);
$this->driver->setOption(Memcached::OPT_COMPRESSION, $cmp);
return $cached;
}
protected function getBackend()
{
$memcached = new Memcached();
$memcached->addServer('localhost', 11211);
$memcached->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
$memcached->setOption(Memcached::OPT_TCP_NODELAY, true);
return Matryoshka\Memcached::create($memcached);
}
/**
* Constructor
* @param array $options cache store storage option
*/
public function __construct($options = array())
{
$this->connect = new \Memcached();
$this->prefix = $options['prefix'];
$this->default_ttl = $options['default_ttl'];
$this->connect->setOption(\Memcached::OPT_PREFIX_KEY, $this->prefix);
$this->connect->addServers($options['servers']);
}
/**
* {@inheritdoc}
*/
public function connect()
{
foreach ($this->options['options'] as $option => $value) {
$this->service->setOption($option, $value);
}
foreach ($this->options['servers'] as $server) {
$server = $server + $this->options['defaultServer'];
$this->service->addServer($server['host'], $server['port'], $server['weight']);
}
}
/**
* @param $persistentId
* @param array $connections
*/
public function __construct($persistentId, array $connections)
{
$this->isMemcachedExtensionAvailable();
$this->memcached = new MemcachedDriver($persistentId);
$this->memcached->addServers($connections);
$this->memcached->setOption(MemcachedDriver::OPT_SERIALIZER, \defined(MemcachedDriver::HAVE_IGBINARY) && MemcachedDriver::HAVE_IGBINARY ? MemcachedDriver::SERIALIZER_IGBINARY : MemcachedDriver::SERIALIZER_PHP);
$this->memcached->setOption(MemcachedDriver::OPT_DISTRIBUTION, MemcachedDriver::DISTRIBUTION_CONSISTENT);
$this->memcached->setOption(MemcachedDriver::OPT_LIBKETAMA_COMPATIBLE, true);
$this->memcached->setOption(MemcachedDriver::OPT_BINARY_PROTOCOL, true);
}
public function __construct()
{
$this->connect();
if ($this->is_connected) {
$this->memcached->setOption(Memcached::OPT_PREFIX_KEY, _DB_PREFIX_);
if ($this->memcached->getOption(Memcached::HAVE_IGBINARY)) {
$this->memcached->setOption(Memcached::OPT_SERIALIZER, Memcached::SERIALIZER_IGBINARY);
}
}
}
/**
* Constructor.
*
* @param \Memcached $memcached A \Memcached instance
* @param array $memcachedOptions An associative array of Memcached options
* @param array $options Session configuration options.
*/
public function __construct(\Memcached $memcached, array $memcachedOptions = array(), array $options = array())
{
$this->memcached = $memcached;
// defaults
if (!isset($memcachedOptions['serverpool'])) {
$memcachedOptions['serverpool'][] = array('host' => '127.0.0.1', 'port' => 11211, 'weight' => 1);
}
$memcachedOptions['expiretime'] = isset($memcachedOptions['expiretime']) ? (int) $memcachedOptions['expiretime'] : 86400;
$this->memcached->setOption(\Memcached::OPT_PREFIX_KEY, isset($memcachedOptions['prefix']) ? $memcachedOptions['prefix'] : 'sf2s');
$this->memcachedOptions = $memcachedOptions;
}
public function init()
{
$this->parentInit();
if (!$this->storage instanceof \Memcached) {
$this->storage = new \Memcached();
$this->normalizeServers($this->servers, $this->storage);
$this->storage->setOption(\Memcached::OPT_COMPRESSION, true);
}
if ($this->serializer !== self::SERIALIZE_JSON) {
$this->storage->setOption(\Memcached::OPT_SERIALIZER, \Memcached::SERIALIZER_PHP);
}
}
/**
* Constructor.
*/
protected function __construct()
{
$this->memcached = new \Memcached();
$this->memcached->addServer(Config::getCacheHost(), Config::getCachePort());
$this->memcached->setOption(\Memcached::OPT_PREFIX_KEY, Config::getCachePrefix());
//determine if deleteMulti() is supported
if (defined('HHVM_VERSION')) {
$this->hasMultiDelete = false;
} else {
$ext = new \ReflectionExtension('memcached');
$this->hasMultiDelete = version_compare($ext->getVersion(), '2.0.0', '>=');
}
}
/**
* @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();
}
}
/**
* return memcached instance
*/
protected function memcached()
{
$arrConfig = $this->_arrConfig;
if (!extension_loaded('memcached')) {
throw_exception(__CLASS__ . '/' . __FUNCTION__ . "Memcached EXTENSION NOT INSTALLED!");
return false;
}
$m = new Memcached();
$m->setOption(Memcached::OPT_HASH, Memcached::HASH_MD5);
$m->setOption(Memcached::OPT_DISTRIBUTION, Memcached::DISTRIBUTION_CONSISTENT);
$m->addServers($arrConfig['machines']);
return $m;
}
function GetMemCachedObj()
{
static $MemCachedObj;
if (!$MemCachedObj) {
$MemCachedObj = new Memcached();
if (!$MemCachedObj->addServer(MEMCACHED_HOST, MEMCACHED_PORT)) {
throw new Exception('No se pudo conectar al Memcached: ' . $MemCachedObj->getResultMessage() . '.');
}
$MemCachedObj->setOption(Memcached::OPT_COMPRESSION, false);
$MemCachedObj->setOption(Memcached::OPT_BINARY_PROTOCOL, false);
$MemCachedObj->setOption(Memcached::OPT_CONNECT_TIMEOUT, 10000);
}
return $MemCachedObj;
}
/**
* Constructor
*
* @param null|array|Traversable|MemcachedOptions $options
* @throws Exception\ExceptionInterface
*/
public function __construct($options = null)
{
if (static::$extMemcachedMajorVersion === null) {
$v = (string) phpversion('memcached');
static::$extMemcachedMajorVersion = $v !== '' ? (int) $v[0] : 0;
}
if (static::$extMemcachedMajorVersion < 1) {
throw new Exception\ExtensionNotLoadedException('Need ext/memcached version >= 1.0.0');
}
parent::__construct($options);
// It's ok to init the memcached instance as soon as possible because
// ext/memcached auto-connects to the server on first use
$this->memcached = new MemcachedResource();
$options = $this->getOptions();
// set lib options
if (static::$extMemcachedMajorVersion > 1) {
$this->memcached->setOptions($options->getLibOptions());
} else {
foreach ($options->getLibOptions() as $k => $v) {
$this->memcached->setOption($k, $v);
}
}
$this->memcached->setOption(MemcachedResource::OPT_PREFIX_KEY, $options->getNamespace());
$servers = $options->getServers();
if (!$servers) {
$options->addServer('127.0.0.1', 11211);
$servers = $options->getServers();
}
$this->memcached->addServers($servers);
// get notified on change options
$memc = $this->memcached;
$memcMV = static::$extMemcachedMajorVersion;
$this->getEventManager()->attach('option', function ($event) use($memc, $memcMV) {
$params = $event->getParams();
if (isset($params['lib_options'])) {
if ($memcMV > 1) {
$memc->setOptions($params['lib_options']);
} else {
foreach ($params['lib_options'] as $k => $v) {
$memc->setOption($k, $v);
}
}
}
if (isset($params['namespace'])) {
$memc->setOption(MemcachedResource::OPT_PREFIX_KEY, $params['namespace']);
}
// TODO: update on change/add server(s)
});
}
private function connect($configServerArray)
{
$obj = new Memcached();
$obj->addServer($configServerArray['host'], $configServerArray['port'], $configServerArray['height']);
if (!empty($configServerArray['auth'])) {
$obj->setOption(Memcached::OPT_COMPRESSION, false);
//关闭压缩功能
$obj->setOption(Memcached::OPT_BINARY_PROTOCOL, true);
//使用binary二进制协议
$auth = $configServerArray['auth'];
$obj->setSaslAuthData($auth['user'], $auth['password']);
//设置OCS帐号密码进行鉴权，如已开启免密码功能，则无需此步骤
}
return $obj;
}
/**
* Constructor.
*
* @access public
* @param array $servers Memcache servers
* @param int $timeout Timeout in seconds
* @param boolean $compressData Compress data?
*/
public function __construct(array $servers, $timeout = 1, $compressData = false)
{
$this->memcached = new PHPMemcached();
if ($timtout !== 1) {
$this->memcached->setOption(PHPMemcached::OPT_CONNECT_TIMEOUT, $timeout * 1000);
// Multiply by 1000 to convert to ms
}
if ($compressData === false) {
$this->memcached->setOption(PHPMemcached::OPT_COMPRESSION, false);
}
// Add servers to the connection pool
foreach ($servers as $server) {
$this->memcached->addServer($server['server'], $server['port'], $server['weight']);
}
}
/**
* MemcachedProvider constructor
* @param string $cache_id
* @param string $options
* @throws \RuntimeException
*/
public function __construct($cache_id = null, $options = null)
{
//check installed library
if (!class_exists('\\Memcached')) {
throw new \RuntimeException("Memcached extension was not found on this server");
}
//create a new memcached instance with the given id
$this->memcached = is_null($cache_id) ? new \Memcached() : new \Memcached($cache_id);
if (is_array($options) && !empty($options)) {
// set instance options
foreach ($options as $option => $value) {
$this->memcached->setOption($option, $value);
}
}
}
public function register(Application $app)
{
$app['memcached'] = $app->share(function () use($app) {
$memcached = new \Memcached($app['memcached.identifier']);
$memcached->setOption(\Memcached::OPT_COMPRESSION, false);
$memcached->setOption(\Memcached::OPT_PREFIX_KEY, $app['memcached.prefix']);
$serversToAdd = array_udiff($app['memcached.servers'], $memcached->getServerList(), function ($a, $b) {
return $a['host'] == $b['host'] && $a['port'] == $b['port'] ? 0 : 1;
});
if (count($serversToAdd)) {
$memcached->addServers($serversToAdd);
}
return $memcached;
});
}
function cdash_memcache_connect($server, $port)
{
if (class_exists('Memcached')) {
$memcached = new Memcached();
$memcached->setOption(Memcached::OPT_COMPRESSION, true);
global $CDASH_USE_ELASTICACHE_AUTO_DISCOVERY;
if ($CDASH_USE_ELASTICACHE_AUTO_DISCOVERY) {
$memcached->setOption(Memcached::OPT_CLIENT_MODE, Memcached::DYNAMIC_CLIENT_MODE);
}
if ($memcached->addServer($server, $port) !== false) {
return $memcached;
}
}
return false;
}
/**
* @param string $namespace
* @param string $identifier
* @param array $options
* @throws \InvalidArgumentException
* @throws \Leapt\CacheBundle\Exception\CacheException
*/
public function __construct($namespace, $identifier, array $options)
{
parent::__construct($namespace, $identifier, $options);
$this->driver = new \Memcached();
$this->driver->setOption(\Memcached::OPT_PREFIX_KEY, $namespace . '.' . $identifier . '.');
if (!isset($options['server']) || !isset($options['port'])) {
throw new \InvalidArgumentException(sprintf('Memcached is expecting a "server" and "port" options'));
}
if (!$this->driver->addServer($options['server'], $options['port'])) {
throw new CacheException('The memcached server could not be added');
}
if (isset($options['ttl'])) {
$this->ttl = $options['ttl'];
}
}
/**
* 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;
}
/**
* Class constructor.
*
* @since 151216 Memcached utilities.
*
* @param Classes\App $App Instance of App.
*/
public function __construct(Classes\App $App)
{
parent::__construct($App);
$this->enabled = $this->App->Config->©memcache['©enabled'];
$this->namespace = $this->App->Config->©memcache['©namespace'];
$this->servers = $active_servers = [];
// Initialize.
foreach ($this->App->Config->©memcache['©servers'] as $_server) {
$_host = $_server['©host'];
$_port = $_server['©port'] ?? 11211;
$_weight = $_server['©weight'] ?? 0;
$this->servers[$_host . ':' . $_port] = [$_host, $_port, $_weight];
}
// unset($_server, $_host, $_port, $_weight);
if (!class_exists('Memcached')) {
return;
// Not possible.
} elseif (!$this->enabled || !$this->namespace || !$this->servers) {
return;
// Disabled or lacking config values.
}
$this->Pool = new \Memcached($this->App->namespace_sha1);
$this->Pool->setOption(\Memcached::OPT_NO_BLOCK, true);
$this->Pool->setOption(\Memcached::OPT_SEND_TIMEOUT, 5);
$this->Pool->setOption(\Memcached::OPT_RECV_TIMEOUT, 5);
$this->Pool->setOption(\Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
if (\Memcached::HAVE_IGBINARY) {
// Size and speed gains.
$this->Pool->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
$this->Pool->setOption(\Memcached::OPT_SERIALIZER, \Memcached::SERIALIZER_IGBINARY);
}
$this->maybeAddServerConnections();
}
public function getTestLink()
{
$cache = new \Memcached();
$cache->addServer(MEMCACHE_HOST, MEMCACHE_PORT);
$cache->setOption(Memcached::OPT_COMPRESSION, FALSE);
return new \r8\Cache\Memcached($cache);
}
/**
* 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;
}
