/** * Class constructor * * @param $memcache_host, $memcache_port */ public function __construct($memcache_host = '127.0.0.1', $memcache_port = 11211) { if (is_null($this->memcache) || !is_object($this->memcache)) { $this->memcache = new Memcache(); if (!$this->memcache->pconnect($memcache_host, $memcache_port)) { throw new Exception("Error in object initialization", 2); } } }
/** * Open up the backend * * @param string $savePath * @param string $sessionName * @return boolean */ public function open($savePath, $sessionName) { $this->_backend = new Memcache(); // Open a persistent or regular connection if ($this->_config['persistent']) { $this->_backend->pconnect($this->_config['hostname'], $this->_config['port'], $this->_config['timeout_connect']); } else { $this->_backend->connect($this->_config['hostname'], $this->_config['port'], $this->_config['timeout_connect']); } }
public function __construct($config) { $this->handler = new Memcache(); if (isset($config['keep-alive']) && $config['keep-alive']) { $fd = $this->handler->pconnect($config['host'], $config['port'], TXConst::minute); } else { $fd = $this->handler->connect($config['host'], $config['port']); } if (!$fd) { throw new TXException(4004, array($config['host'], $config['port'])); } }
public function __construct($host = self::DEFAULT_HOST, $port = self::DEFAULT_PORT) { $this->instance = new \Memcache(); try { try { $this->instance->pconnect($host, $port); } catch (BaseException $e) { $this->instance->connect($host, $port); } $this->alive = true; } catch (BaseException $e) { // bad luck. } }
/** * Конструктор * * @param array $servers * @param boolean $persistent */ public function __construct($host, $port, $persistent = false) { if (!extension_loaded('memcache') || !class_exists('Memcache')) { throw new _Core_Cache_Exception('Extension "memcache" is not loaded or not up to date !'); } $this->server = new Memcache(); if ($persistent) { $connected = $this->server->pconnect($host, $port); } else { $connected = $this->server->connect($host, $port); } if (!$connected) { throw new _Core_Cache_Exception('Could not connect to memcached server on ' . $host . ':' . $port . ' !'); } }
public function __construct($exp = 3600) { $this->expire = $exp; if (defined('CACHE_DRIVER')) { $this->cachedriver = CACHE_DRIVER; } if ($this->cachedriver == 'memcached') { $mc = new Memcache(); if ($mc->pconnect(MEMCACHE_HOSTNAME, MEMCACHE_PORT)) { $this->memcache = $mc; $this->ismemcache = true; } } if (!$this->ismemcache) { $files = glob(DIR_CACHE . 'cache.*'); if ($files) { foreach ($files as $file) { $time = substr(strrchr($file, '.'), 1); if ($time < time()) { if (file_exists($file)) { @touch($file); @unlink($file); } } } } } }
/** * This handler completes the configuration. */ public function _on_initialize() { if (array_key_exists('host', $this->_config)) { $this->_host = $this->_config['host']; } if (array_key_exists('port', $this->_config)) { $this->_port = $this->_config['port']; } // memcache does serialization automatically. no need for manual serialization $this->_auto_serialize = false; // Open the persistant connection. if (is_null(self::$memcache)) { self::$memcache = new Memcache(); try { self::$memcache_operational = @self::$memcache->pconnect($this->_host, $this->_port); } catch (Exception $e) { // Memcache connection failed if ($this->_abort_on_fail) { debug_add("Failed to connect to {$this->_host}:{$this->_port}. " . $e->getMessage(), MIDCOM_LOG_ERROR); // Abort the request throw new midcom_error("Failed to connect to {$this->_host}:{$this->_port}."); } // Otherwise we just skip caching debug_add("memcache handler: Failed to connect to {$this->_host}:{$this->_port}. " . $e->getMessage() . ". Serving this request without cache.", MIDCOM_LOG_ERROR); self::$memcache_operational = false; } } }
function _init_connection() { if (!class_exists('Memcache')) { return false; } $memcache_connection = new Memcache(); $server_list = explode(',', AMP_SYSTEM_MEMCACHE_SERVER); $primary_server = array_shift($server_list); $result = $memcache_connection->pconnect($primary_server, AMP_SYSTEM_MEMCACHE_PORT); if (count($server_list)) { foreach ($server_list as $additional_server) { $result = $memcache_connection->addServer($additional_server, AMP_SYSTEM_MEMCACHE_PORT) || $result; } } if ($result) { $this->set_connection($memcache_connection); } else { trigger_error(sprintf(AMP_TEXT_ERROR_CACHE_REQUEST_FAILED, 'Memcache', 'connect', 'Request: ' . $_SERVER['REQUEST_URI'])); $result = $this->_restart_memcached(); //try again if ($result) { $this->set_connection($memcache_connection); } } return $result; }
function elggcache_cacheinit() { global $CFG, $messages; //memcache_debug(true); if (!empty($CFG->elggcache_enabled)) { static $memcacheconn; //var_dump($memcacheconn); if (!isset($memcacheconn)) { if (!empty($CFG->elggcache_debug)) { $messages[] = 'connecting to memcache<br />'; } $memcacheconn = new Memcache(); $memcacheconn->pconnect($CFG->elggcache_memcache_host, $CFG->elggcache_memcache_port); } //var_dump($memcacheconn); if (empty($memcacheconn) || !is_resource($memcacheconn->connection)) { $CFG->elggcache_enabled = false; if (!empty($CFG->elggcache_debug)) { $messages[] = 'failed connect to memcache<br />'; } } } else { $memcacheconn = false; } //$stats = $memcacheconn->getExtendedStats(); //var_dump($stats); //var_dump($memcacheconn); return $memcacheconn; }
public function __construct() { $host = '127.0.0.1'; $port = 11211; $memcache = new \Memcache(); $memcache->pconnect($host, $port); $this->memcache = $memcache; }
/** * {@inheritDoc} */ public function __construct($name) { $this->prefix = $name; if (!self::$memcache) { self::$memcache = new Memcache(); $host = Config::get('cache_host'); $port = Config::get('cache_port'); if (Config::get('cache_memcache_pconnect')) { if (!@self::$memcache->pconnect($host, $port)) { throw new CacheException("Couldn't connect to memcache server"); } } else { if (!@self::$memcache->connect($host, $port)) { throw new CacheException("Couldn't connect to memcache server"); } } } }
/** * Detect if backend is available * @return bool */ public static function isAvailable() { if (!extension_loaded('memcache')) { return false; } if (self::$memcache) { return true; } $serverList = [['unix:///tmp/memcache', 0], ['127.0.0.1', 11211]]; self::$memcache = new \MemCache(); foreach ($serverList as $serv) { if (@self::$memcache->pconnect($serv[0], $serv[1])) { self::$server = $serv[0]; self::$port = $serv[1]; return true; } } return false; }
public function enableMemcache() { $this->memcacheConfig = ConfigManager::getConfig("Db", "Memcache")->AuxConfig; if ($this->memcacheConfig->enabled) { $memcache = new Memcache(); if ($memcache->pconnect($this->memcacheConfig->host, $this->memcacheConfig->port)) { Minify::setCache(new Minify_Cache_Memcache($memcache)); } } }
/** * Create the Memcache connection * * @return void * * @since 11.1 * @throws RuntimeException */ protected function getConnection() { if (!static::isSupported()) { throw new RuntimeException('Memcache Extension is not available'); } $config = JFactory::getConfig(); $host = $config->get('memcache_server_host', 'localhost'); $port = $config->get('memcache_server_port', 11211); // Create the memcache connection static::$_db = new Memcache(); if ($config->get('memcache_persist', true)) { $result = @static::$_db->pconnect($host, $port); } else { $result = @static::$_db->connect($host, $port); } 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 memcache server'); } }
function cache_memcache() { global $_W; static $memcacheobj; if (!extension_loaded('memcache')) { return error(1, 'Class Memcache is not found'); } if (empty($memcacheobj)) { $config = $_W['config']['setting']['memcache']; $memcacheobj = new Memcache(); if ($config['pconnect']) { $connect = $memcacheobj->pconnect($config['server'], $config['port']); } else { $connect = $memcacheobj->connect($config['server'], $config['port']); } } return $memcacheobj; }
function initMemcache() { //Connect to memcache /** @var Memcache $memCache */ global $memCache; global $timer; global $configArray; // Set defaults if nothing set in config file. $host = isset($configArray['Caching']['memcache_host']) ? $configArray['Caching']['memcache_host'] : 'localhost'; $port = isset($configArray['Caching']['memcache_port']) ? $configArray['Caching']['memcache_port'] : 11211; $timeout = isset($configArray['Caching']['memcache_connection_timeout']) ? $configArray['Caching']['memcache_connection_timeout'] : 1; // Connect to Memcache: $memCache = new Memcache(); if (!@$memCache->pconnect($host, $port, $timeout)) { //Try again with a non-persistent connection if (!$memCache->connect($host, $port, $timeout)) { PEAR_Singleton::raiseError(new PEAR_Error("Could not connect to Memcache (host = {$host}, port = {$port}).")); } } $timer->logTime("Initialize Memcache"); }
/** * memcahcedへの接続オープン * @param string $name * @return unknown_type */ public function memOpen($name) { $this->dsn_name = $name; if (!isset(self::$connection[$name])) { $dsn = $this->dsn_name; $memcache = new Memcache(); // ADD START 2010/10/04 hhasegawa $connectFlg = self::OFF_FLG; // 接続処理 if ($memcache->pconnect($dsn)) { $connectFlg = self::ON_FLG; } if ($connectFlg === self::ON_FLG) { $this->memcache = $memcache; self::$connection[$name] = $memcache; } else { return false; } } else { $this->memcache = self::$connection[$name]; } }
function flushmemcache($key = false, $host, $port, $debug = false) { if (!function_exists('memcache_pconnect')) { if ($debug) { ADOConnection::outp(" Memcache module PECL extension not found!<br>\n"); } return; } $memcache = new Memcache(); if (!@$memcache->pconnect($host, $port)) { if ($debug) { ADOConnection::outp(" Can't connect to memcache server on: {$host}:{$port}<br>\n"); } return; } if ($key) { if (!$memcache->delete($key)) { if ($debug) { ADOConnection::outp("CacheFlush: {$key} entery doesn't exist on memcached server!<br>\n"); } } else { if ($debug) { ADOConnection::outp("CacheFlush: {$key} entery flushed from memcached server!<br>\n"); } } } else { if (!$memcache->flush()) { if ($debug) { ADOConnection::outp("CacheFlush: Failure flushing all enteries from memcached server!<br>\n"); } } else { if ($debug) { ADOConnection::outp("CacheFlush: All enteries flushed from memcached server!<br>\n"); } } } return; }
function mc_pconnect() { static $memcache = null; if ($this->get_hostname() == 'http://twetest.com') { return null; } if (!$memcache) { $memcache = new Memcache(); //open a persistent connection if (!$memcache->pconnect('localhost', 11211)) { $memcache = null; //................................. //send system maintenance message $to = '*****@*****.**'; $subject = 'memcached not running'; $message = 'start memcached daemon'; $headers = 'From: contact@twextra.com' . "\r\n" . 'Reply-To: contact@twextra.com' . "\r\n" . 'X-Mailer: PHP/' . phpversion(); //mail($to, $subject, $message, $headers); //.................................... } } return $memcache; }
/** * Constructs this backend * * @param mixed $options Configuration options - depends on the actual backend * @author Robert Lemke <*****@*****.**> */ public function __construct($options = array()) { if (!extension_loaded('memcache')) { throw new t3lib_cache_Exception('The PHP extension "memcached" must be installed and loaded in ' . 'order to use the Memcached backend.', 1213987706); } parent::__construct($options); $this->memcache = new Memcache(); $defaultPort = ini_get('memcache.default_port'); if (!count($this->servers)) { throw new t3lib_cache_Exception('No servers were given to Memcache', 1213115903); } foreach ($this->servers as $serverConfiguration) { if (substr($serverConfiguration, 0, 7) == 'unix://') { $host = $serverConfiguration; $port = 0; } else { if (substr($serverConfiguration, 0, 6) === 'tcp://') { $serverConfiguration = substr($serverConfiguration, 6); } if (strstr($serverConfiguration, ':') !== FALSE) { list($host, $port) = explode(':', $serverConfiguration, 2); } else { $host = $serverConfiguration; $port = $defaultPort; } } if ($this->serverConnected) { $this->memcache->addserver($host, $port); } else { // pconnect throws PHP warnings when it cannot connect! $this->serverConnected = @$this->memcache->pconnect($host, $port); } } if (!$this->serverConnected) { t3lib_div::sysLog('Unable to connect to any Memcached server', 'core', 3); } }
/** * @return bool false on error */ protected function reconnect() { $this->memcache = null; if ($this->connectAttempts >= self::MAX_CONNECT_ATTEMPTS) { return false; } $connectResult = false; $connStart = microtime(true); while ($this->connectAttempts < self::MAX_CONNECT_ATTEMPTS) { $this->connectAttempts++; $memcache = new Memcache(); //$memcache->setOption(Memcached::OPT_BINARY_PROTOCOL, true); // TODO: enable when moving to memcached v1.3 $curConnStart = microtime(true); if ($this->persistent) { $connectResult = @$memcache->pconnect($this->hostName, $this->port); } else { $connectResult = @$memcache->connect($this->hostName, $this->port); } if ($connectResult || microtime(true) - $curConnStart < 0.5) { // retry only if there's an error and it's a timeout error break; } self::safeLog("got timeout error while connecting to memcache..."); } $connTook = microtime(true) - $connStart; self::safeLog("connect took - {$connTook} seconds to {$this->hostName}:{$this->port} attempts {$this->connectAttempts}"); if (class_exists("KalturaMonitorClient")) { KalturaMonitorClient::monitorConnTook($this->hostName, $connTook); } if (!$connectResult) { self::safeLog("failed to connect to memcache"); return false; } $this->memcache = $memcache; return true; }
error_reporting(0); ini_set('display_errors', '0'); session_start(); ob_start("mb_output_handler"); header("Content-Type: text/html; charset=UTF-8"); header("Cache-Control: no-cache"); header("Pragma: no-cache"); date_default_timezone_set("Asia/Tokyo"); // storage api include_once "../config.inc"; // setting mbstring mb_internal_encoding("UTF-8"); // browser flag $g_isIE = strstr($_SERVER['HTTP_USER_AGENT'], "MSIE") ? true : false; $memcached = new Memcache(); if (!$memcached->pconnect(MEMCACHED_IP, MEMCACHED_PORT)) { $memcached = null; } include_once 'log4php/Logger.php'; Logger::configure(__DIR__ . '/../log4php.properties'); ////////////////////////////////////////////////////////////////// // 共通関数 ////////////////////////////////////////////////////////////////// // ************************ 常数の定義 *************************** // ************************ 共通関数の定義 *********************** //------------------------- // 1. チE�Eタベ�Eス管琁E��連 //------------------------- $g_transaction = false; // チE�Eタベ�Eスに接綁E function connectDB()
public static function init() { if (self::disabled() || !class_exists("Memcache")) { return null; } self::$memcache = new Memcache(); $host = defined("HL_MEMCACHE_HOST") ? HL_MEMCACHE_HOST : '127.0.0.1'; self::$memcache->pconnect($host); }
private static function getMemcache() { $memcache = new Memcache(); $memcache->pconnect('localhost', 11211); return $memcache; }
protected function getMemcache() { $memcache = new Memcache(); $memcache->pconnect('localhost', 11211); return $memcache; }
private function initMemcache() { global $memCache; // Set defaults if nothing set in config file. $host = isset($configArray['Caching']['memcache_host']) ? $configArray['Caching']['memcache_host'] : 'localhost'; $port = isset($configArray['Caching']['memcache_port']) ? $configArray['Caching']['memcache_port'] : 11211; $timeout = isset($configArray['Caching']['memcache_connection_timeout']) ? $configArray['Caching']['memcache_connection_timeout'] : 1; // Connect to Memcache: $memCache = new Memcache(); if (!$memCache->pconnect($host, $port, $timeout)) { PEAR_Singleton::raiseError(new PEAR_Error("Could not connect to Memcache (host = {$host}, port = {$port}).")); } $this->logTime("Initialize Memcache"); }
function flushmemcache($key = false, &$host, $port, $debug = false) { if (is_object($host)) { $memcache =& $host; } else { $memcache = new Memcache(); if (!@$memcache->pconnect($host, $port)) { if ($debug) { ADOConnection::outp(" Can't connect to memcache server on: {$host}:{$port}<br>\n"); } return; } } if ($key) { if (!$memcache->delete($key)) { if ($debug) { ADOConnection::outp("CacheFlush: {$key} entery doesn't exist on memcached server!<br>\n"); } } else { if ($debug) { ADOConnection::outp("CacheFlush: {$key} entery flushed from memcached server!<br>\n"); } } } else { if (!$memcache->flush()) { if ($debug) { ADOConnection::outp("CacheFlush: Failure flushing all enteries from memcached server!<br>\n"); } } else { if ($debug) { ADOConnection::outp("CacheFlush: All enteries flushed from memcached server!<br>\n"); } } } return; }
/** * Opens the memcache connection * * @return \r8\Cache\Memcache Returns a self reference */ public function connect() { // If we are already connected if ($this->isConnected()) { return $this; } $link = new \Memcache(); // Connect with persistence, if they requested it if ($this->persistent) { $result = @$link->pconnect($this->host, $this->port, $this->timeout); } else { $result = @$link->connect($this->host, $this->port, $this->timeout); } // If an error occured while connect, translate it to an exception if (!$result) { $error = \error_get_last(); throw new \r8\Exception\Cache\Connection($error['message'], $error['type']); } // Now that we have verified the connection, save it $this->link = $link; return $this; }
require dirname(__FILE__) . "/includes/PDO.class.php"; $DB = new Db(DBHost, DBName, DBUser, DBPassword); //Initialize MemCache(d) / Redis $MCache = false; if (EnableMemcache) { if (extension_loaded('memcached')) { //MemCached $MCache = new Memcached(MemCachePrefix . 'Cache'); //Using persistent memcached connection if (!count($MCache->getServerList())) { $MCache->addServer(MemCacheHost, MemCachePort); } } elseif (extension_loaded('memcache')) { //MemCache $MCache = new Memcache(); $MCache->pconnect(MemCacheHost, MemCachePort); } elseif (extension_loaded('redis')) { //Redis //https://github.com/phpredis/phpredis $MCache = new Redis(); $MCache->pconnect(MemCacheHost, MemCachePort); } } //Load configuration $Config = array(); if ($MCache) { $Config = $MCache->get(MemCachePrefix . 'Config'); } if (!$Config) { foreach ($DB->query('SELECT ConfigName,ConfigValue FROM ' . $Prefix . 'config') as $ConfigArray) { $Config[$ConfigArray['ConfigName']] = $ConfigArray['ConfigValue'];
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <head> <link href="style.css" rel="stylesheet"> </head> <div class="productList"> <?php include 'my_memcache.php'; $link = mysql_connect('localhost', 'nfuogibo', 'T6iT0i0a1j') or die('Не удалось соединиться: ' . mysql_error()); mysql_select_db('nfuogibo_goods') or die('Не удалось выбрать базу данных nfuogibo_goods'); $memcache_host = 'localhost'; $memcache_port = 11211; $memcache = new Memcache(); if (!$memcache->pconnect($memcache_host, $memcache_port)) { die("Memcached не доступен: {$memcache_host}:{$memcache_port}"); } echo '<div class = "header">'; echo '<table class = "menu"><tr>'; echo '<td class = "menu">'; echo '<a href="index.php">Вернуться к списку товаров</a>'; echo '</td>'; echo '</tr></table>'; echo '</div>'; echo '<div class = "product">'; if (isset($_POST['delete'])) { $aDoor = $_POST['delete']; $N = count($aDoor); for ($i = 0; $i < $N; $i++) { $ath = sqlSet("DELETE FROM goods WHERE id = " . $aDoor[$i] . ";", $aDoor[$i]); echo 'Товар с id ' . $aDoor[$i] . ' уcпешно удален.<br>'; }