/**
* constructor of the handler - initialises Memcached object
*
* @return bool
*
*/
function __construct()
{
#this ensures to write down and close the session when destroying the handler object
register_shutdown_function("session_write_close");
$this->memcache = new Memcache();
$this->memcache->connect('MEMCACHE_NODE_ADDRESS_HERE', 11211);
$this->lifeTime = intval(ini_get("session.cookie_lifetime"));
$this->initSessionData = null;
return true;
}
public function _before(TestCase $test)
{
if (class_exists('\\Memcache')) {
$this->memcache = new \Memcache();
$this->memcache->connect($this->config['host'], $this->config['port']);
} elseif (class_exists('\\Memcached')) {
$this->memcache = new \Memcached();
$this->memcache->addServer($this->config['host'], $this->config['port']);
} else {
throw new ModuleConfigException(__CLASS__, 'Memcache classes not loaded');
}
}
/**
* 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;
}
}
public function make($config = null)
{
if (!extension_loaded('memcached')) {
throw new \RuntimeException('Memcached extension was not loaded.');
}
$memcached = new \Memcached();
$memcached->connect($config['host'], $config['port']);
$cache = new MemcachedCache();
$cache->setMemcached($memcached);
return $cache;
}
/**
* Initializes usage of memcache or memcached
*/
private function __construct()
{
$ini = eZINI::instance('merck.ini');
if ( $ini->hasSection('MemcacheSettings') )
{
$this->_host = $ini->variable('MemcacheSettings', 'Host');
$this->_port = $ini->variable('MemcacheSettings', 'Port');
}
elseif( strpos(ini_get('session.save_handler'), 'memcache') === 0
&& preg_match('#^(?:tcp://)?(?P<memcacheHost>[^:]+):(?P<memcachePort>[^?]+)#', ini_get('session.save_path'), $m)
){
// No memcache settings set, we try to use the session handler one
$this->_host = $m['memcacheHost'];
$this->_port = $m['memcachePort'];
}
if ( $this->_host )
{
if ( extension_loaded('memcached') )
{
$this->_memcache = new Memcached();
$this->_type = self::TYPE_MEMCACHED;
$this->_isValid = $this->_memcache->addserver( $this->_host, $this->_port );
}
elseif( extension_loaded( 'memcache') )
{
$this->_memcache = new Memcache();
$this->_type = self::TYPE_MEMCACHE;
$this->_isValid = $this->_memcache->connect( $this->_host, $this->_port );
}
}
if ( !$this->isValid() )
{
eZDebug::writeError('Could not find any valid memcache configuration or memcache module', 'MemcacheTool');
// do not break. Any memcache w/r should be fault tolerant in case memcache clears its cache by itself.
}
}
public static function memcacheSetup()
{
// Memcache provider setup:
if (MEMCACHE_LIBRARY == 'memcache') {
$memcache = new \Memcache();
} else {
if (MEMCACHE_LIBRARY == 'memcached') {
$memcache = new \Memcached();
}
}
if (!$memcache->connect(MEMCACHE_HOST, MEMCACHE_PORT)) {
throw new exception('Unable to connect to Memcache');
}
return $memcache;
}
/**
* Connect to the cache server(s).
*
* @throws CacheException
* @access private
*/
private function connect()
{
$this->connected = false;
if ($this->isRedis === true) {
if ($this->socketFile === false) {
$servers = unserialize(nZEDb_CACHE_HOSTS);
foreach ($servers as $server) {
if ($this->server->connect($server['host'], $server['port'], (double) nZEDb_CACHE_TIMEOUT) === false) {
throw new CacheException('Error connecting to the Redis server!');
} else {
$this->connected = true;
}
}
} else {
if ($this->server->connect(nZEDb_CACHE_SOCKET_FILE) === false) {
throw new CacheException('Error connecting to the Redis server!');
} else {
$this->connected = true;
}
}
} else {
if ($this->socketFile === false) {
if ($this->server->addServers(unserialize(nZEDb_CACHE_HOSTS)) === false) {
throw new CacheException('Error connecting to the Memcached server!');
} else {
$this->connected = true;
}
} else {
if ($this->server->addServers(array(array(nZEDb_CACHE_SOCKET_FILE, 'port' => 0))) === false) {
throw new CacheException('Error connecting to the Memcached server!');
} else {
$this->connected = true;
}
}
}
}
public function import_vars($key = false)
{
if (Xcrud_config::$alt_session) {
if (class_exists('Memcache')) {
$mc = new Memcache();
$mc->connect(Xcrud_config::$mc_host, Xcrud_config::$mc_port);
$data = $mc->get($this->sess_id);
} elseif (class_exists('Memcached')) {
$mc = new Memcached();
$mc->connect(Xcrud_config::$mc_host, Xcrud_config::$mc_port);
$data = $mc->get($this->sess_id);
} else {
self::error('Can\'t use alternative session. Memcache(d) is not available');
}
if (!$data) {
self::error('Can\'t use alternative session. Data is not exist');
}
$_SESSION['xcrud_session'] = $this->decrypt($data[0], $data[1]);
unset($data);
if (!$_SESSION['xcrud_session']) {
self::error('Can\'t use alternative session. Data is invalid');
}
}
$inst_name = $this->instance_name;
foreach ($this->params2save() as $item) {
$this->{$item} = $_SESSION['xcrud_session'][$inst_name][$item];
}
if ($key) {
$this->key = $key;
}
}
/**
* Connects to a server.
*
* @param string $hostname The hostname to connect to
* @param string $port The port to connect to
*
* @author Benjamin Carl <*****@*****.**>
* @return Memcached The created instance of memcache
* @access protected
* @throws Doozr_Cache_Service_Exception
*/
protected function connect($hostname, $port)
{
$memcache = new Memcached();
// API requires to add server first
$memcache->addServer($hostname, $port);
// Finally we try to connect
try {
@$memcache->connect($hostname, $port);
} catch (Exception $e) {
throw new Doozr_Cache_Service_Exception(sprintf('Error while connecting to host: "%s" on Port: "%s". Connection failed.', $hostname, $port));
}
// return instance on success
return $memcache;
}
/**
* Automatically picks the cache mechanism to use. If you pick one manually it will use that
* If there is no config option for $driver in the config, or it's set to 'auto', it will
* pick the best option based on which cache extensions are installed.
*
* @return DoctrineCache\CacheProvider The cache driver to use
*/
public function getCacheDriver()
{
$setting = $this->driver_setting;
$driver_name = 'file';
if (!$setting || $setting == 'auto') {
if (extension_loaded('apcu')) {
$driver_name = 'apcu';
} elseif (extension_loaded('apc')) {
$driver_name = 'apc';
} elseif (extension_loaded('wincache')) {
$driver_name = 'wincache';
} elseif (extension_loaded('xcache')) {
$driver_name = 'xcache';
}
} else {
$driver_name = $setting;
}
$this->driver_name = $driver_name;
switch ($driver_name) {
case 'apc':
$driver = new DoctrineCache\ApcCache();
break;
case 'apcu':
$driver = new DoctrineCache\ApcuCache();
break;
case 'wincache':
$driver = new DoctrineCache\WinCacheCache();
break;
case 'xcache':
$driver = new DoctrineCache\XcacheCache();
break;
case 'memcache':
$memcache = new \Memcache();
$memcache->connect($this->config->get('system.cache.memcache.server', 'localhost'), $this->config->get('system.cache.memcache.port', 11211));
$driver = new DoctrineCache\MemcacheCache();
$driver->setMemcache($memcache);
break;
case 'memcached':
$memcached = new \Memcached();
$memcached->connect($this->config->get('system.cache.memcached.server', 'localhost'), $this->config->get('system.cache.memcached.port', 11211));
$driver = new DoctrineCache\MemcachedCache();
$driver->setMemcached($memcached);
break;
case 'redis':
$redis = new \Redis();
$redis->connect($this->config->get('system.cache.redis.server', 'localhost'), $this->config->get('system.cache.redis.port', 6379));
$driver = new DoctrineCache\RedisCache();
$driver->setRedis($redis);
break;
default:
$driver = new DoctrineCache\FilesystemCache($this->cache_dir);
break;
}
return $driver;
}
public function connect()
{
$conf = $this->conf;
if ($this->link) {
return $this->link;
}
if (extension_loaded('Memcache')) {
$memcache = new Memcache();
} elseif (extension_loaded('Memcached')) {
$memcache = new Memcached();
} else {
$this->error(2, 'Memcache 扩展不存在。');
return FALSE;
}
$r = $memcache->connect($conf['host'], $conf['port']);
if (!$r) {
$this->error(3, '连接 Memcached 服务器失败。');
return FALSE;
}
$this->link = $memcache;
return $this->link;
}
$modx->tpl = DLTemplate::getInstance($modx);
$modx->fs = \Helpers\FS::getInstance();
switch (true) {
case function_exists('apc_cache_info'):
$modx->cache = new \Doctrine\Common\Cache\ApcCache();
break;
case class_exists('Memcache'):
$modx->cache = new \Doctrine\Common\Cache\MemcacheCache();
$memcache = new Memcache();
$memcache->connect('localhost', 11211);
$modx->cache->setMemcache($memcache);
break;
case class_exists('Memcached'):
$modx->cache = new \Doctrine\Common\Cache\MemcachedCache();
$memcached = new Memcached();
$memcached->connect('localhost', 11211);
$modx->cache->setMemcache($memcached);
break;
case class_exists('SQLite3'):
$modx->cache = new \Doctrine\Common\Cache\SQLite3Cache(new SQLite3(MODX_BASE_PATH . 'assets/cache/sqlite.db'), 'cache');
break;
default:
$modx->cache = new Doctrine\Common\Cache\FilesystemCache(MODX_BASE_PATH . 'assets/cache/template/');
}
$modx->cache->setNamespace($modx->getConfig('site_name'));
$moduleDebug = false;
if (!is_ajax() && ($modx->isFrontend() && $modx->getLoginUserID('mgr')) || $modx->isBackend() && isset($_GET['a']) && $_GET['a'] == 112 && $moduleDebug) {
error_reporting(E_ALL);
ini_set('display_errors', true);
}
if ($modx->isFrontend() && $modx->getLoginUserID('web') && $modx->user instanceof \modUsers) {
<?php
//
// apt-get install php5-memcache
//
$memcache_enabled = extension_loaded("memcached");
if ($memcache_enabled) {
echo "extension loaded";
} else {
echo "extension not loaded";
}
$mc = new Memcached();
$mc->connect("localhost", 11211);
print_r($mc->getStats());
