public function __construct($prefix = '')
{
parent::__construct($prefix);
if (is_null(self::$cache)) {
self::$cache = new \Memcached();
$servers = \OC::$server->getSystemConfig()->getValue('memcached_servers');
if (!$servers) {
$server = \OC::$server->getSystemConfig()->getValue('memcached_server');
if ($server) {
$servers = array($server);
} else {
$servers = array(array('localhost', 11211));
}
}
self::$cache->addServers($servers);
$defaultOptions = [\Memcached::OPT_CONNECT_TIMEOUT => 50, \Memcached::OPT_RETRY_TIMEOUT => 50, \Memcached::OPT_SEND_TIMEOUT => 50, \Memcached::OPT_RECV_TIMEOUT => 50, \Memcached::OPT_POLL_TIMEOUT => 50, \Memcached::OPT_COMPRESSION => true, \Memcached::OPT_LIBKETAMA_COMPATIBLE => true, \Memcached::OPT_BINARY_PROTOCOL => true];
// by default enable igbinary serializer if available
if (\Memcached::HAVE_IGBINARY) {
$defaultOptions[\Memcached::OPT_SERIALIZER] = \Memcached::SERIALIZER_IGBINARY;
}
$options = \OC::$server->getConfig()->getSystemValue('memcached_options', []);
if (is_array($options)) {
$options = $options + $defaultOptions;
self::$cache->setOptions($options);
} else {
throw new HintException("Expected 'memcached_options' config to be an array, got {$options}");
}
}
}
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)));
}
}
/**
* Configure options
*
* @return void
*/
protected function setOptions()
{
$options = $this->defaultOptions;
if (array_key_exists('options', $this->config)) {
$options = array_merge($options, $this->config['options']);
}
$this->connection->setOptions($options);
}
/**
* Constructor
*
* @param null|array|Traversable|MemcachedOptions $options
* @throws Exception\ExceptionInterface
* @return void
*/
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);
}
}
$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->events()->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);
}
}
}
// TODO: update on change/add server(s)
});
}
/**
* 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;
}
public function open($savePath, $sessID)
{
$options = [\Memcached::OPT_CONNECT_TIMEOUT => $this->timeout, \Memcached::OPT_DISTRIBUTION, \Memcached::DISTRIBUTION_CONSISTENT];
$this->handle = new \Memcached();
$this->handle->setOptions($options);
if (isset($this->servers['host'])) {
$this->handle->addServer($this->servers['host'], $this->servers['port'], isset($this->servers['weight']) ? $this->servers['weight'] : null);
} else {
foreach ($this->servers as $server) {
$this->handle->addServer($server['host'], $server['port'], isset($server['weight']) ? $server['weight'] : null);
}
}
return true;
}
/**
* @param float $requestTimeout time in seconds
*
* @return PeclMemcached
*/
public function setTimeout($requestTimeout)
{
$this->ensureTriedToConnect();
$this->requestTimeout = $requestTimeout;
$this->instance->setOptions([\Memcached::OPT_SEND_TIMEOUT => $requestTimeout * 1000, \Memcached::OPT_RECV_TIMEOUT => $requestTimeout * 1000]);
return $this;
}
/**
* @param \Memcached $memcached
* @return $this
*/
private function addOptions(\Memcached $memcached)
{
if (is_array($this->options) && !empty($this->options)) {
foreach ($this->options as $option) {
$memcached->setOption(constant('\\Memcached::' . $option[MemcacheConfigConstants::OPTION_NAME]), $option[MemcacheConfigConstants::OPTION_VALUE]);
}
$memcached->setOptions($this->options);
}
return $this;
}
/**
* 初始化servers
*/
private function initServers()
{
if (empty($this->config['servers'])) {
$servers = [['host' => '127.0.0.1', 'port' => 11211, 'weight' => 1]];
} else {
$servers = $this->config['servers'];
}
foreach ($servers as $server) {
$host = isset($server['host']) ? $server['host'] : '127.0.0.1';
$port = isset($server['port']) ? $server['port'] : 11211;
$weight = isset($server['weight']) ? $server['weight'] : 0;
$this->servers["{$host}:{$port}"] = [$host, $port, $weight];
$this->handler->addserver($host, $port, $weight);
}
if (!empty($this->config['options'])) {
$this->handler->setOptions($this->config['options']);
}
$this->handler->getStats();
}
/**
* @return \Memcached
* @throws InvalidConfigException
*/
public function getMemcached()
{
if (null === $this->instance) {
if (!extension_loaded('memcached')) {
throw new InvalidConfigException(__CLASS__ . ' requires PHP `memcached` extension to be loaded.');
}
$this->instance = new \Memcached($this->persistentId);
// SASL authentication
// @see http://php.net/manual/en/memcached.setsaslauthdata.php
if (ini_get('memcached.use_sasl') && (null !== $this->username || null !== $this->password)) {
if (method_exists($this->instance, 'setSaslAuthData')) {
$this->instance->setSaslAuthData($this->username, $this->password);
}
}
if (!empty($this->options)) {
$this->instance->setOptions($this->options);
}
}
return $this->instance;
}
protected function getConfiguredDriver(array $config)
{
$memcached = new \Memcached();
foreach ($config[Config::INDEX_SERVERS] as $server) {
$memcached->addServer($server[Config::INDEX_HOST], $server[Config::INDEX_PORT]);
}
if (!empty($config[Config::INDEX_OPTIONS])) {
$memcached->setOptions($config[Config::INDEX_OPTIONS]);
}
return $memcached;
}
/**
* @param FrontendInterface $frontend
* @param array $options
*/
public function __construct($frontend, $options = array())
{
$this->_backend = new MemcachedDriver(self::DRIVER_PERSISTENCE_ID);
if (!isset($options['servers'])) {
$options['servers'] = array(array('host' => self::DEFAULT_HOST));
}
foreach ($options['servers'] as $server) {
if (!array_key_exists('port', $server)) {
$server['port'] = self::DEFAULT_PORT;
}
if (!array_key_exists('weight', $server)) {
$server['weight'] = self::DEFAULT_WEIGHT;
}
$this->_backend->addServer($server['host'], $server['port'], $server['weight']);
}
if (isset($options['client']) && is_array($options['client'])) {
$this->_backend->setOptions($options['client']);
}
unset($options['servers'], $options['client']);
parent::__construct($frontend, $options);
}
/**
* @param ContainerInterface $container
* @return MemcachedSnapshotAdapter
*/
public function __invoke(ContainerInterface $container)
{
$config = $container->get('config');
$config = $this->options($config)['snapshot_adapter']['options'];
if (isset($config['memcached_connection_alias'])) {
$memcached = $container->get($config['memcached_connection_alias']);
} else {
$memcached = new \Memcached($config['persistent_id']);
$memcached->addServers($config['servers']);
$memcached->setOptions($config['memcached_options']);
}
return new MemcachedSnapshotAdapter($memcached);
}
/**
* 初始化servers
*/
private function initServers()
{
if (empty($this->config['servers'])) {
$servers = [['host' => '127.0.0.1', 'port' => 11211, 'weight' => 1]];
} else {
$servers = $this->config['servers'];
}
foreach ($servers as $server) {
$host = isset($server['host']) ? $server['host'] : '127.0.0.1';
$port = isset($server['port']) ? $server['port'] : 11211;
$weight = isset($server['weight']) ? $server['weight'] : 0;
$this->handler->addserver($host, $port, $weight);
}
if (!empty($this->config['options'])) {
$this->handler->setOptions($this->config['options']);
}
//如果获取服务器池的统计信息返回false,说明服务器池中有不可用服务器
if ($this->handler->getStats() === false) {
$this->isConnected = false;
} else {
$this->isConnected = true;
}
}
/**
* 连接memcached
*
* @return \Memcached
*/
public function connect()
{
if ($this->handler) {
return $this->handler;
}
$servers = isset($this->config['servers']) ? $this->config['servers'] : array(array('127.0.0.1', 11211));
$handler = new \Memcached();
if (!$handler->addServers($servers)) {
throw new \Lysine\Service\ConnectionException('Cannot connect memcached');
}
if (isset($config['options'])) {
$handler->setOptions($config['options']);
}
return $this->handler = $handler;
}
/**
* @param array $options
*/
public function __construct(array $options = [])
{
$memcached = new \Memcached($options["persistent_id"]);
$memcached->addServers($options["servers"]);
//过期时间
if (isset($options["lifetime"])) {
$this->_lifetime = $options["lifetime"];
}
$options = [Memcached::OPT_LIBKETAMA_COMPATIBLE => true, Memcached::OPT_COMPRESSION => true];
$options = array_merge($options, (array) $options["options"]);
$memcached->setOptions($options);
$this->_mem = $memcached;
session_set_save_handler([$this, "open"], [$this, "close"], [$this, "read"], [$this, "write"], [$this, "destroy"], [$this, "gc"]);
parent::__construct($options);
}
public function connect()
{
if ($this->memcached) {
return $this->memcached;
}
$memcached = new \Memcached($this->getConfig('persistent_id'));
$servers = $this->getConfig('servers') ?: [['127.0.0.1', 11211]];
if (!$memcached->addServers($servers)) {
throw new \Owl\Service\Exception('Memcached connect failed!');
}
if ($options = $this->getConfig('options')) {
$memcached->setOptions($options);
}
return $this->memcached = $memcached;
}
private static function getInstance()
{
if (!empty(self::$instance)) {
return self::$instance;
}
$config = Config::loadConfig('cache');
$driver = $config['driver'];
if (!extension_loaded($driver)) {
throw new Exception("error driver [{$driver}]");
}
$servers = $config['servers'] ?: [];
$options = $config['options'] ?: [];
$mc = new Memcached();
$mc->setOptions($options);
$mc->addServers($servers);
return self::$instance = $mc;
}
/**
* @return \Memcached
* @throws \Exception
*/
public function getCache()
{
if ($this->cache == null) {
if (!extension_loaded('memcached')) {
throw new \Exception('Requires PHP memcached extension to be loaded');
}
$this->cache = $this->persistentId !== null ? new \Memcached($this->persistentId) : new \Memcached();
if ($this->username !== null || $this->password !== null) {
$this->cache->setOption(\Memcached::OPT_BINARY_PROTOCOL, true);
$this->cache->setSaslAuthData($this->username, $this->password);
}
if (!empty($this->options)) {
$this->cache->setOptions($this->options);
}
}
return $this->cache;
}
/**
* @param string $namespace
* @return \Memcached
* @throws \Exception
*/
public static function connection($namespace = "default")
{
if (!isset(static::$instance[$namespace]) || !static::$instance[$namespace]) {
$config = Config::get("cache.memcache");
if (!isset($config[$namespace])) {
throw new \Exception("cache config has not key {$namespace}", 1);
}
$config = $config[$namespace];
$memcached = new \Memcached($config["persistent_id"]);
$memcached->addServers($config["servers"]);
$options = [\Memcached::OPT_LIBKETAMA_COMPATIBLE => true, \Memcached::OPT_COMPRESSION => true];
$options = array_merge($options, (array) $config["options"]);
$memcached->setOptions($options);
static::$instance[$namespace] = $memcached;
}
return static::$instance[$namespace];
}
public function connect()
{
if ($this->_connected) {
//throw new MemcacheException('Do not connect twice');
return;
}
$m = new \Memcached($this->getHandlerKey());
$ss = $m->getServerList();
if (isset($this->_options[ICacher::OPT_PREFIX_KEY])) {
$this->setOption(\Memcached::OPT_PREFIX_KEY, $this->_options[ICacher::OPT_PREFIX_KEY]);
}
if (empty($ss)) {
$options = $this->getOptions();
unset($options[ICacher::OPT_PREFIX_KEY]);
$m->setOptions($options);
$m->addServers(array_values($this->_servers));
}
$this->_connected = true;
$this->_handler = $m;
}
/**
* Create internal connection to memcached
*/
public function _connect()
{
$options = $this->_options;
if (!isset($options['servers'])) {
throw new Exception('Servers must be an array');
}
if (!is_array($options['servers'])) {
throw new Exception('Servers must be an array');
}
$memcache = new \Memcached();
if (!$memcache->addServers($servers)) {
throw new Exception('Cannot connect to Memcached server');
}
if (isset($options['client'])) {
if (!is_array($options['client'])) {
throw new Exception('Client options must be instance of array');
}
$memcache->setOptions($client);
}
$this->_memcache = $memcache;
}
/**
* Tests that memcached cache store flushes entire cache when it is using a dedicated cache.
*/
public function test_dedicated_cache()
{
if (!cachestore_memcached::are_requirements_met() || !defined('TEST_CACHESTORE_MEMCACHED_TESTSERVERS')) {
$this->markTestSkipped('Could not test cachestore_memcached. Requirements are not met.');
}
$definition = cache_definition::load_adhoc(cache_store::MODE_APPLICATION, 'cachestore_memcached', 'phpunit_test');
$cachestore = $this->create_test_cache_with_config($definition, array('isshared' => false));
$connection = new Memcached(crc32(__METHOD__));
$connection->addServers($this->get_servers(TEST_CACHESTORE_MEMCACHED_TESTSERVERS));
$connection->setOptions(array(Memcached::OPT_COMPRESSION => true, Memcached::OPT_SERIALIZER => Memcached::SERIALIZER_PHP, Memcached::OPT_PREFIX_KEY => 'phpunit_', Memcached::OPT_BUFFER_WRITES => false));
// We must flush first to make sure nothing is there.
$connection->flush();
// Test the cachestore.
$this->assertFalse($cachestore->get('test'));
$this->assertTrue($cachestore->set('test', 'cachestore'));
$this->assertSame('cachestore', $cachestore->get('test'));
// Test the connection.
$this->assertFalse($connection->get('test'));
$this->assertEquals(Memcached::RES_NOTFOUND, $connection->getResultCode());
$this->assertTrue($connection->set('test', 'connection'));
$this->assertSame('connection', $connection->get('test'));
// Test both again and make sure the values are correct.
$this->assertSame('cachestore', $cachestore->get('test'));
$this->assertSame('connection', $connection->get('test'));
// Purge the cachestore and check the connection was also purged.
$this->assertTrue($cachestore->purge());
$this->assertFalse($cachestore->get('test'));
$this->assertFalse($connection->get('test'));
}
