/**
* Initialize the Cache Engine
*
* Called automatically by the cache frontend
* To reinitialize the settings call Cache::engine('EngineName', [optional] settings = array());
*
* @param array $settings array of setting for the engine
* @return boolean True if the engine has been successfully initialized, false if not
*/
public function init($settings = array())
{
if (!class_exists('Memcache')) {
return false;
}
if (!isset($settings['prefix'])) {
$settings['prefix'] = Inflector::slug(APP_DIR) . '_';
}
$settings += array('engine' => 'Memcache', 'servers' => array('127.0.0.1'), 'compress' => false, 'persistent' => true);
parent::init($settings);
if ($this->settings['compress']) {
$this->settings['compress'] = MEMCACHE_COMPRESSED;
}
if (is_string($this->settings['servers'])) {
$this->settings['servers'] = array($this->settings['servers']);
}
if (!isset($this->_Memcache)) {
$return = false;
$this->_Memcache = new Memcache();
foreach ($this->settings['servers'] as $server) {
list($host, $port) = $this->_parseServerString($server);
if ($this->_Memcache->addServer($host, $port, $this->settings['persistent'])) {
$return = true;
}
}
return $return;
}
return true;
}
/**
* Creates a new MemcacheAdapter object.
*/
private function __construct()
{
if (!class_exists('Memcache')) {
throw new SystemException('memcache support is not enabled.');
}
// init memcache
$this->memcache = new Memcache();
// add servers
$servers = explode("\n", StringUtil::unifyNewlines(CACHE_SOURCE_MEMCACHE_HOST));
foreach ($servers as $server) {
$server = StringUtil::trim($server);
if (!empty($server)) {
$host = $server;
$port = 11211;
// default memcache port
// get port
if (strpos($host, ':')) {
$parsedHost = explode(':', $host);
$host = $parsedHost[0];
$port = $parsedHost[1];
}
$this->memcache->addServer($host, $port, CACHE_SOURCE_MEMCACHE_USE_PCONNECT);
}
}
// test connection
$this->memcache->get('testing');
}
/**
* Construct
*
* @param array $options Cache options
*
* @return void
*/
public function __construct(array $options)
{
$this->cache = new Memcache();
foreach ($options['servers'] as $server) {
$this->cache->addServer($server['host'], $server['port'], $server['timeout']);
}
}
/**
* Check for existence of the memcache extension and
* constructs the memcache Cache object
*
* @param array configuration
* @throws Cache_Exception
*/
function CI_Cache_Memcache($config)
{
// Check for the memcache extention
if (!extension_loaded('memcache')) {
show_error('Memcache PHP extention not loaded.');
}
$this->conf = $config;
// Setup Memcache
$this->memcache = new Memcache();
// Load servers from configuration
$servers = $config['servers'];
if (!$servers) {
// Throw an exception if no server found
show_error('No Memcache servers defined in configuration');
}
// Setup default server configuration
$config = array('host' => 'localhost', 'port' => 11211, 'persistent' => FALSE, 'weight' => 1, 'timeout' => 1, 'retry_interval' => 15, 'status' => TRUE, 'failure_callback' => array($this, '_failed_request'));
// Add the memcache servers to the pool
foreach ($servers as $server) {
// Merge the defined config with defaults
$server += $config;
if (!$this->memcache->addServer($server['host'], $server['port'], $server['persistent'], $server['weight'], $server['timeout'], $server['retry_interval'], $server['status'], $server['failure_callback'])) {
show_error('Memcache could not connect to host ' . $server['host'] . ' using port ' . $server['port']);
}
}
// Setup the flags
$this->flags = $this->conf['compression'] !== FALSE ? MEMCACHE_COMPRESSED : FALSE;
}
/**
* Crea una instancia del Adaptador y pasa configuraciones.
*
* @param array $config Configuraciones
*/
public function __construct(array $config)
{
$this->gestor = new \Memcache();
foreach ($config['servidores'] as $servidor) {
$this->gestor->addServer($servidor[0], $servidor[1], true, $servidor[2]);
}
}
public function addServer($host = 'localhost', $port = 11211, $timeout = 1)
{
if ($this->memcache->addServer($host, $port, TRUE, 1, $timeout) === FALSE) {
$error = error_get_last();
throw new Nette\InvalidStateException("Memcache::addServer(): {$error['message']}.");
}
}
/**
* 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;
}
/**
* Initialize the Cache Engine
*
* Called automatically by the cache frontend
* To reinitialize the settings call Cache::engine('EngineName', [optional] settings = array());
*
* @param array $setting array of setting for the engine
* @return boolean True if the engine has been successfully initialized, false if not
* @access public
*/
function init($settings = array())
{
if (!class_exists('Memcache')) {
return false;
}
parent::init(array_merge(array('engine' => 'Memcache', 'prefix' => Inflector::slug(APP_DIR) . '_', 'servers' => array('127.0.0.1'), 'compress' => false), $settings));
if ($this->settings['compress']) {
$this->settings['compress'] = MEMCACHE_COMPRESSED;
}
if (!is_array($this->settings['servers'])) {
$this->settings['servers'] = array($this->settings['servers']);
}
if (!isset($this->__Memcache)) {
$return = false;
$this->__Memcache =& new Memcache();
foreach ($this->settings['servers'] as $server) {
$parts = explode(':', $server);
$host = $parts[0];
$port = 11211;
if (isset($parts[1])) {
$port = $parts[1];
}
if ($this->__Memcache->addServer($host, $port)) {
$return = true;
}
}
return $return;
}
return true;
}
/**
* Return memcache connection object
*
* @return object memcache connection object
*
* @since 11.1
* @throws RuntimeException
*/
protected function getConnection()
{
if ((extension_loaded('memcache') && class_exists('Memcache')) != true) {
return false;
}
$config = JFactory::getConfig();
$this->_persistent = $config->get('memcache_persist', true);
$this->_compress = $config->get('memcache_compress', false) == false ? 0 : MEMCACHE_COMPRESSED;
/*
* 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
self::$_db = new Memcache();
self::$_db->addServer($server['host'], $server['port'], $this->_persistent);
$memcachetest = @self::$_db->connect($server['host'], $server['port']);
if ($memcachetest == false) {
throw new RuntimeException('Could not connect to memcache server', 404);
}
// Memcahed 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, $this->_compress, 0);
}
return;
}
/**
* 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');
}
}
/**
* opening of the session - mandatory arguments won't be needed
*
* @param string $savePath
* @param string $sessionName
* @return bool
*/
public function open($savePath, $sessionName)
{
if (!isset($this->_lifeTime)) {
$this->_lifeTime = intval(ini_get("session.gc_maxlifetime"));
}
if (!isset($this->_refreshTime)) {
$this->_refreshTime = ceil($this->_lifeTime / 3);
}
$this->_initSessionData = null;
$this->_memcache = new Memcache();
if (Kwf_Config::getValue('aws.simpleCacheCluster')) {
$servers = Kwf_Util_Aws_ElastiCache_CacheClusterEndpoints::getCached(Kwf_Config::getValue('aws.simpleCacheCluster'));
} else {
if (Kwf_Cache_Simple::$memcacheHost) {
$servers = array(array('host' => Kwf_Cache_Simple::$memcacheHost, 'port' => Kwf_Cache_Simple::$memcachePort));
} else {
throw new Kwf_Exception("no memcache configured");
}
}
foreach ($servers as $s) {
if (version_compare(phpversion('memcache'), '2.1.0') == -1 || phpversion('memcache') == '2.2.4') {
// < 2.1.0
$this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1);
} else {
if (version_compare(phpversion('memcache'), '3.0.0') == -1) {
// < 3.0.0
$this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1, true, null, 10000);
} else {
$this->_memcache->addServer($s['host'], $s['port'], true, 1, 1, 1);
}
}
}
return true;
}
/**
* {@inheritdoc}
*/
public function connect()
{
foreach ($this->options['servers'] as $server) {
$server = $server + $this->options['defaultServer'];
$this->service->addServer($server['host'], $server['port'], $server['persistent'], $server['weight']);
}
}
/**
* Connect and initialize this handler.
*
* @return boolean True if successful, false on failure
*/
function connect()
{
global $mybb, $error_handler;
$this->memcache = new Memcache();
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 $memcache) {
if (!$memcache['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($memcache['port'])) {
$memcache['port'] = "11211";
}
$this->memcache->addServer($memcache['host'], $memcache['port']);
if (!$this->memcache) {
$message = "Unable to connect to the memcache server on {$memcache['memcache_host']}:{$memcache['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;
}
/**
* constructor
*
* @param array $options associative array of cache driver options
*/
public function __construct($options = array())
{
if (!extension_loaded('memcache')) {
throw new Doctrine_Cache_Exception('In order to use Memcache driver, the memcache extension must be loaded.');
}
parent::__construct($options);
if (isset($options['servers'])) {
$value = $options['servers'];
if (isset($value['host'])) {
// in this case, $value seems to be a simple associative array (one server only)
$value = array(0 => $value);
// let's transform it into a classical array of associative arrays
}
$this->setOption('servers', $value);
}
$this->_memcache = new Memcache();
foreach ($this->_options['servers'] as $server) {
if (!array_key_exists('persistent', $server)) {
$server['persistent'] = true;
}
if (!array_key_exists('port', $server)) {
$server['port'] = 11211;
}
$this->_memcache->addServer($server['host'], $server['port'], $server['persistent']);
}
}
/**
* {@inheritdoc}
*/
public function connect()
{
foreach ($this->servers as $server) {
$server = $server + $this->defaultServer;
$this->driver->addServer($server['host'], $server['port'], $server['persistent'], $server['weight']);
}
}
/**
* {@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']);
}
}
public function addServer($host = 'localhost', $port = 11211, $timeout = 1)
{
Nette\Diagnostics\Debugger::tryError();
$this->memcache->addServer($host, $port, TRUE, 1, $timeout);
if (Nette\Diagnostics\Debugger::catchError($e)) {
throw new Nette\InvalidStateException('Memcache::addServer(): ' . $e->getMessage(), 0, $e);
}
}
protected function registerServer($host, $port)
{
$result = $this->memcache->addServer($host, $port);
if (!$result) {
LogHelper::log_error(t('[@cacheType] Could not add server (@host:@port)', array('@cacheType' => self::$CACHE__TYPE, '@host' => $host, '@port' => $port)));
}
return $result;
}
/**
* 添加memcache服务器
* @param string $host
* @param int $port
* @return XF_Cache_Memcache
*/
public function addServer($host, $port)
{
if ($this->_memcache == null) {
$this->_memcache = new Memcache();
}
$this->_memcache->addServer($host, $port);
return $this;
}
public function addServer($host = 'localhost', $port = 11211, $timeout = 1)
{
set_error_handler(function ($severity, $message) {
restore_error_handler();
throw new Nette\InvalidStateException("Memcache::addServer(): {$message}");
});
$this->memcache->addServer($host, $port, TRUE, 1, $timeout);
restore_error_handler();
}
/**
* 构造函数
* @param string $host Memcached 服务器的主机名或IP地址或者为服务器组相关信息
* @param int $port 端口号
* @param int $timeout 超时时间
*/
function __construct($host = 'localhost', $port = 11211, $timeout = 60)
{
$this->memcache = new Memcache();
$host = is_array($host) ? $host : array(array('host' => $host, 'port' => $port));
//如果是服务器分组则添加所有的服务器分组
foreach ($host as $m) {
$this->memcache->addServer($m['host'], $m['port']);
}
}
public function setUp()
{
// fix permission denied warnings by setting to a path we should have
// write access to
$this->originalSessionSavePath = session_save_path();
session_save_path('/tmp');
$this->memcached = new \Memcached();
$this->memcached->addServer(TESTS_MEMCACHE_HOST, TESTS_MEMCACHE_PORT);
}
/**
* @param array[] $servers
*/
public function __construct(array $servers)
{
$this->_memcache = new Memcache();
foreach ($servers as $server) {
$this->_memcache->addServer($server['host'], $server['port'], true, 1, 1, 1, true, function ($host, $port) {
$this->getServiceManager()->getLogger()->error('Cannot connect to memcached server', (new CM_Log_Context())->setExtra(['host' => $host, 'port' => $port]));
});
}
}
public function setUp()
{
parent::setUp();
$this->object = \Gacela\Gacela::instance()->loadMapper('Customer');
$this->memcache = new Memcache();
$this->memcache->addServer('127.0.0.1', 11211);
$this->memcache->flush();
\Gacela\Gacela::instance()->enableCache($this->memcache);
}
public function __construct()
{
if (class_exists('Memcached')) {
$this->memcache = new Memcached();
} else {
$this->memcache = new Memcache();
}
$this->memcache->addServer('127.0.0.1', 11211);
}
/**
* @param BaseMemCache|null $server
*/
public function __construct(BaseMemcache $server = null)
{
if ($server) {
$this->server = $server;
return;
}
$this->server = new BaseMemcache();
$this->server->addServer('localhost', 11211);
}
protected function __construct(MemcacheConnectionParams $params)
{
if (!class_exists('Memcache')) {
throw new Exception('PECL\\Memcache extension not found');
}
$this->memcache = new \Memcache();
foreach ($params->hosts as $host) {
$this->memcache->addServer($host);
}
}
/**
* @param array[] $servers
*/
public function __construct(array $servers)
{
$this->_memcache = new Memcache();
foreach ($servers as $server) {
$this->_memcache->addServer($server['host'], $server['port'], true, 1, 1, 15, true, function ($host, $port) {
$warning = new CM_Exception('Cannot connect to memcached host `' . $host . '` on port `' . $port . '`', CM_Exception::WARN);
CM_Bootloader::getInstance()->getExceptionHandler()->handleException($warning);
});
}
}
/**
* 构造函数
* @param string $host Redis 服务器的主机名或IP地址或者为服务器组相关信息
* @param int $port 端口号
* @param int $timeout 超时时间
*/
private function __construct($host = 'localhost', $port = 11211, $timeout = 60)
{
$this->redis = new redis();
exit('sdfsdf');
$host = is_array($host) ? $host : array(array('host' => $host, 'port' => $port));
//如果是服务器分组则添加所有的服务器分组
foreach ($host as $m) {
$this->redis->addServer($m['host'], $m['port']);
}
}
/**
* 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->memcache = new PHPMemcache();
if ($compressData === true) {
$this->compressionLevel = MEMCACHE_COMPRESSED;
}
// Add servers to the connection pool
foreach ($servers as $server) {
$this->memcache->addServer($server['server'], $server['port'], $server['persistent_connection'], $server['weight'], $timeout);
}
}
