/** * @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'); }
/** * 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; }
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}"); } } }
/** * 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'); } }
/** * @return \Memcached */ public function getMemcached() { if (!$this->Memcached) { $this->Memcached = new \Memcached(); $this->Memcached->addServers($this->options['servers']); } return $this->Memcached; }
/** * {@inheritDoc} */ public function addServers(array $servers) { $configs = []; foreach ($servers as $server) { $configs[] = [$server['host'], $server['port']]; } $this->_connection->addServers($configs); }
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))); } }
/** * 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()); } }
/** * 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']); }
/** * Creates a new instance of memcached. */ public function __construct() { if (!class_exists('Memcached')) { throw new SystemException('memcached support is not enabled.'); } // init memcached $this->memcached = new \Memcached(); // add servers $tmp = explode("\n", StringUtil::unifyNewlines(CACHE_SOURCE_MEMCACHED_HOST)); $servers = array(); $defaultWeight = floor(100 / count($tmp)); $regex = new Regex('^\[([a-z0-9\:\.]+)\](?::([0-9]{1,5}))?(?::([0-9]{1,3}))?$', Regex::CASE_INSENSITIVE); foreach ($tmp as $server) { $server = StringUtil::trim($server); if (!empty($server)) { $host = $server; $port = 11211; // default memcached port $weight = $defaultWeight; // check for IPv6 if ($regex->match($host)) { $matches = $regex->getMatches(); $host = $matches[1]; if (isset($matches[2])) { $port = $matches[2]; } if (isset($matches[3])) { $weight = $matches[3]; } } else { // IPv4, try to get port and weight if (strpos($host, ':')) { $parsedHost = explode(':', $host); $host = $parsedHost[0]; $port = $parsedHost[1]; if (isset($parsedHost[2])) { $weight = $parsedHost[2]; } } } $servers[] = array($host, $port, $weight); } } $this->memcached->addServers($servers); // test connection $this->memcached->get('testing'); // set variable prefix to prevent collision $this->prefix = substr(sha1(WCF_DIR), 0, 8) . '_'; }
/** * @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); }
/** * Constructor * * @param array[] $servers server array */ public function __construct($servers) { if (!class_exists('Memcached')) { throw new Exception('Memcached extension not found'); } if (!$servers || !is_array($servers) || count($servers) < 1) { throw new GitPHP_MessageException('No Memcache servers defined', true, 500); } $this->memcache = new Memcached(); $this->memcache->addServers($servers); }
/** * Configure servers * * @return void * * @throws \InvalidArgumentException */ public function configureServers() { if (!array_key_exists('server', $this->config)) { throw new \InvalidArgumentException('Configuration key "server" must be set'); } $servers = $this->config['server']; // Single server if (array_key_exists('host', $servers)) { $servers = array($servers); } $this->connection->addServers($servers); }
/** * 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; }
/** * 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) }); }
/** * Connect to the cache server(s). * * @throws CacheException * @access private */ private function connect() { $this->connected = false; switch (NN_CACHE_TYPE) { case self::TYPE_REDIS: if ($this->socketFile === false) { $servers = unserialize(NN_CACHE_HOSTS); foreach ($servers as $server) { if ($this->server->connect($server['host'], $server['port'], (double) NN_CACHE_TIMEOUT) === false) { throw new CacheException('Error connecting to the Redis server!'); } else { $this->connected = true; } } } else { if ($this->server->connect(NN_CACHE_SOCKET_FILE) === false) { throw new CacheException('Error connecting to the Redis server!'); } else { $this->connected = true; } } break; case self::TYPE_MEMCACHED: $params = $this->socketFile === false ? unserialize(NN_CACHE_HOSTS) : [[NN_CACHE_SOCKET_FILE, 'port' => 0]]; if ($this->server->addServers($params) === false) { throw new CacheException('Error connecting to the Memcached server!'); } else { $this->connected = true; } break; case self::TYPE_APC: $this->connected = true; break; } }
/** * * @param array $servers Each entry in servers is supposed to be an array * containing hostname, port, and, optionally, weight of the server. * $servers = array( * array('mem1.domain.com', 11211, 33), * array('mem2.domain.com', 11211, 67) * ); * @return boolean * @codeCoverageIgnore */ public function addServers($servers) { if (!self::hasMemcachedExt()) { return false; } return $this->memcached->addServers($servers); }
/** * Adds an array of servers to the pool. * * Each individual server in the array must include a domain and port, with an optional * weight value: $servers = array( array( '127.0.0.1', 11211, 0 ) ); * * @link http://www.php.net/manual/en/memcached.addservers.php * * @param array $servers Array of server to register. * @return bool True on success; false on failure. */ public function addServers($servers) { if (!is_object($this->mc)) { return false; } return $this->mc->addServers($servers); }
/** * @return \Memcached */ protected function getMemcached() { $Memcached = new \Memcached(); $Memcached->addServers($this->getTestServers()); $Memcached->flush(); return $Memcached; }
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; }
/** * 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; }
public function __construct(array $config) { if (!extension_loaded('memcached')) { throw Error::require_extension('memcached'); } $memcached = new \Memcached(); if (isset($config['servers'])) { $memcached->addServers($config['servers']); } else { list($host, $port) = \Lysine\array_get($config, 'server') ?: $this->default_server; $memcached->addServer($host, $port); } if (isset($config['life_time'])) { $this->life_time = $config['life_time']; } if (isset($config['prefix'])) { $this->setPrefix($config['prefix']); } if (isset($config['options'])) { foreach ($config['options'] as $key => $val) { $memcache->setOption($key, $val); } } $this->memcached = $memcached; }
/** * 生成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; }
/** * * @param integer $size * @param string|array $hosts Single host, many hosts with commas, or array * of hosts -- which Memcached server(s) to connect to; default localhost */ public function __construct($size = 1000000, $hosts = 'localhost') { $this->size = $size; $this->memcached = new \Memcached(); if (!is_array($hosts)) { $hosts = explode(',', $hosts); } $servers = array(); foreach ($hosts as $host) { $servers[] = array($host, 11211, 100); } $this->memcached->addServers($servers); $this->memcached->setOption(\Memcached::OPT_CONNECT_TIMEOUT, 100); $this->memcached->setOption(\Memcached::OPT_SEND_TIMEOUT, 50); $this->memcached->setOption(\Memcached::OPT_RECV_TIMEOUT, 50); $this->memcached->setOption(\Memcached::OPT_POLL_TIMEOUT, 250); }
public function __construct($prefix = '') { parent::__construct($prefix); if (is_null(self::$cache)) { self::$cache = new \Memcached(); $servers = \OC_Config::getValue('memcached_servers'); if (!$servers) { $server = \OC_Config::getValue('memcached_server'); if ($server) { $servers = array($server); } else { $servers = array(array('localhost', 11211)); } } self::$cache->addServers($servers); } }
/** * memcache 链接池 * */ public static function cache() { static $cache; if (!isset($cache)) { $cache = new Memcached(); $cache->addServers(config::$memcacheServers); } return $cache; }
/** * @param array $servers Array of servers, where each server entry is in format array(SERVER_IP, SERVER_PORT, SERVER_WEIGHT), where SERVER_WEIGHT is optional (the bigger value, the bigger there is chance to be connected to that server). * @param string $prefix Prefix for all the keys stored in memcached using this adapter. */ public function __construct(array $servers, $prefix) { $driver = new MemcachedCache(); $memcached = new \Memcached(); $memcached->addServers($servers); $memcached->setOption(\Memcached::OPT_PREFIX_KEY, $prefix); $driver->setMemcached($memcached); $this->driver = $driver; parent::__construct($driver); }
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; }
/** * Maybe add server connections. * * @since 151216 Memcached utilities. */ protected function maybeAddServerConnections() { if (!$this->Pool) { return; // Not possible. } if ($this->serversDiffer()) { $this->Pool->quit(); $this->Pool->resetServerList(); $this->Pool->addServers($this->servers); } }
/** * Constructor * * @param null|array|Traversable|MemcachedOptions $options * @throws Exception * @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'); } $this->memcached = new MemcachedResource(); parent::__construct($options); // It's ok to add server as soon as possible because // ext/memcached auto-connects to the server on first use $options = $this->getOptions(); $servers = $options->getServers(); if (!$servers) { $options->addServer('localhost', 11211); $servers = $options->getServers(); } $this->memcached->addServers($servers); }