/** * Tears down the fixture, for example, closes a network connection. * This method is called after a test is executed. */ protected function tearDown() { \Gacela\Gacela::reset(); if (is_object($this->memcache)) { $this->memcache->flush(); } }
/** * Invalidate all the objects in the cache * @return void */ public function DeleteAll() { $this->objMemcache->flush(); // needs to wait one second after flush. // See comment on http://www.php.net/manual/ru/memcache.flush.php#81420 sleep(1); }
function deleteAll() { if (null === $this->memcache) { $this->connect(); } $this->memcache->flush(); }
/** * @return PeclMemcache **/ public function clean() { try { $this->instance->flush(); } catch (BaseException $e) { $this->alive = false; } return parent::clean(); }
function checkCache($check = 0, $in, $out, $set = 0) { $inOut = 'inOut_' . $in . '_' . $out; $memcache_obj = new Memcache(); $memcache_obj->connect('127.0.0.1', 11211) or die("Could not connect"); if ($check === 1) { $available = $memcache_obj->get($inOut); if (!$available) { $set = $this->superfastCheck(1, $in, $out); $memcache_obj->set($inOut, $set, false, 324); $available = $memcache_obj->get($inOut); } } elseif ($check === 2) { $memcache_obj->flush(); } else { $set = $this->superfastCheck($in, $out); //var_dump($set); $memcache_obj->set($inOut, $set, false, 324); //echo $inOut; $available = $memcache_obj->get($inOut); //var_dump($memcache_obj->getStats()); } //var_dump($available); $memcache_obj->close(); return $available; }
* @param $key * @return array|bool|string */ public function get($key) { if (self::$mc == null || empty($key)) { return false;
protected function setUp() { parent::setUp(); if (\extension_loaded('memcache') && @fsockopen('localhost', 11211)) { $memcache = new \Memcache(); $memcache->addServer('localhost'); $memcache->flush(); $cacheDriver = new \Doctrine\Common\Cache\MemcacheCache(); $cacheDriver->setMemcache($memcache); $this->_em->getMetadataFactory()->setCacheDriver($cacheDriver); } else { if (\extension_loaded('apc')) { $this->_em->getMetadataFactory()->setCacheDriver(new \Doctrine\Common\Cache\ApcCache()); } else { $this->markTestSkipped('Test only works with a cache enabled.'); } } try { $this->_schemaTool->createSchema(array($this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC742User'), $this->_em->getClassMetadata(__NAMESPACE__ . '\\DDC742Comment'))); } catch (\Exception $e) { } // make sure classes will be deserialized from caches $this->_em->getMetadataFactory()->setMetadataFor(__NAMESPACE__ . '\\DDC742User', null); $this->_em->getMetadataFactory()->setMetadataFor(__NAMESPACE__ . '\\DDC742Comment', null); }
/** * Clears all cache records. * * @return boolean TRUE if cache is cleared FALSE otherwise */ public function clear() { if (false === $this->_cache->flush()) { return $this->_onError('clear'); } return true; }
public function run($request) { // Flush memcache if (defined('DEVTOOLKIT_USE_MEMCACHED') && DEVTOOLKIT_USE_MEMCACHED) { $host = defined('MEMCACHE_HOST') ? MEMCACHE_HOST : 'localhost'; $port = defined('MEMCACHE_PORT') ? MEMCACHE_PORT : 11211; $memcache = new Memcache(); $connected = $memcache->connect($host, $port); if ($connected) { echo "Flush memcache<br/>"; $memcache->flush(); } } // Clear file cache $folder = TEMP_FOLDER; $di = new RecursiveDirectoryIterator($folder, FilesystemIterator::SKIP_DOTS); $ri = new RecursiveIteratorIterator($di, RecursiveIteratorIterator::CHILD_FIRST); foreach ($ri as $file) { echo "Deleting " . $file . '<br/>'; if ($file->isFile()) { unlink($file); } } echo '<hr>Clear completed!'; }
/** * Clear/flush all cached data. * * @return bool */ public function clear() { if ($this->open()) { return $this->memcache->flush(); } return false; }
public function defaultAction() { $memcache = new Memcache(); $memcache->flush(); $usuario = new Usuario(); $daoUsuario = DAOFactory::getUsuarioDAO(); /** @var $user User */ $user = UserService::getCurrentUser(); if (isset($user)) { $usuarioBD = $daoUsuario->queryByGoogle($user->getUserId()); if (!$usuarioBD) { // No existe el usuario $usuario->google = $user->getUserId(); $usuario->correo = $user->getEmail(); $usuario->nombre = $user->getNickname(); $daoUsuario->insert($usuario); } else { $usuario = $usuarioBD; } $_SESSION['logoutUrl'] = UserService::createLogoutUrl('/index/closeSession'); $_SESSION['usuario'] = $usuario; include 'vod/index.php'; } else { $this->login(); } }
/** * @see Cache::flush() */ public function flush() { if (!$this->is_connected) { return false; } return $this->memcache->flush(); }
/** * Flush all existing items in storage. * * @return boolean * * @since __DEPLOY_VERSION__ */ public function flush() { if (!$this->lockindex()) { return false; } return static::$_db->flush(); }
/** * @param int $iTimeToClearInHours = 24 * * @return bool */ public function GC($iTimeToClearInHours = 24) { if (0 === $iTimeToClearInHours && $this->oMem) { return $this->oMem->flush(); } return false; }
public function flush() { if (!isset($this->memcache)) { $this->connect(); } return $this->memcache->flush(); }
/** * Removes items from the cache by conditions & garbage collector. * @param array conditions * @return void */ public function clean(array $conds) { if (!empty($conds[Cache::ALL])) { $this->memcache->flush(); } elseif (isset($conds[Cache::TAGS]) || isset($conds[Cache::PRIORITY])) { throw new NotSupportedException('Tags and priority is not supported by MemcachedStorage.'); } }
/** * Delete all cache entries * * @return boolean */ public function delete_all() { $result = $this->_memcache->flush(); // We must sleep after flushing, or overwriting will not work! // @see http://php.net/manual/en/function.memcache-flush.php#81420 sleep(1); return $result; }
function _remove_all() { if (!self::$memcache_operational) { return; } debug_add("Calling \\self::\$memcache->flush()"); $stat = @self::$memcache->flush(); debug_add("self::\$memcache->flush() returned " . (int) $stat); }
/** * Removes items from the cache by conditions & garbage collector. * @param array conditions * @return void */ public function clean(array $conds) { if (!empty($conds[Cache::ALL])) { $this->memcache->flush(); } elseif ($this->context) { foreach ($this->getJournal()->clean($conds) as $entry) { $this->memcache->delete($entry, 0); } } }
/** * {@inheritdoc} * * @return \Endeveit\Cache\Interfaces\Driver */ protected static function getDriver() { if (!class_exists('Memcache')) { return null; } $memcache = new \Memcache(); $memcache->addServer('127.0.0.1'); $memcache->flush(); return new Driver(array('client' => $memcache, 'prefix_id' => 'PHPUnit_')); }
public function testLoadResourceWithMemcache() { $memcache = new \Memcache(); $memcache->addServer('127.0.0.1', 11211); $memcache->flush(); \Gacela\Gacela::instance()->enableCache($memcache); $this->assertFalse($memcache->get('test_resource_test')); $test = $this->object->loadResource('test'); $this->assertEquals($test, $memcache->get('test_resource_test')); }
/** * Removes items from the cache by conditions & garbage collector. * @param array conditions * @return void */ public function clean(array $conditions) { if (!empty($conditions[Cache::ALL])) { $this->memcache->flush(); } elseif ($this->journal) { foreach ($this->journal->clean($conditions) as $entry) { $this->memcache->delete($entry, 0); } } }
/** * Записывает массив с данными временного аккаунта * @param $newData array('free'=>array('login'=>'test', 'pass'=>'testPass')) * @return bool */ public static function configSet($newData) { $memcache = new \Memcache(); $memcache->addServer('localhost', 11211); $memcache->flush(); try { return $memcache->set($newData, 'Login'); } catch (\Exception $e) { ExpectedException::throwException('2', 'Error write to memcache', ''); } }
/** * Flush all existing items on Memcache server. * Note : only \Hoa\Cache::CLEAN_ALL is supported by Memcache. * * @param int $lifetime Specific lifetime. * @return void * @throws \Hoa\Cache\Exception */ public function clean($lifetime = Cache::CLEAN_ALL) { $this->setMemcache(); if ($lifetime != Cache::CLEAN_ALL) { throw new Cache\Exception('Only \\Hoa\\Cache::CLEAN_ALL constant is supported by ' . 'Memcache backend.', 1); } if (false === @$this->_memcache->flush()) { throw new Cache\Exception('Flush all existing items on Memcache server %s failed.', 2, $this->_parameters->getParameter('memcache.database.host')); } return; }
public static function setUpBeforeClass() { if (!extension_loaded('memcache')) { static::$cache = null; return; } $memcache = new \Memcache(); $memcache->connect('unix:///usr/local/var/run/memcached.sock', 0); $memcache->flush(); static::$cache = new \Cachalot\MemcacheCache($memcache, 'cachalot-test:'); }
function clear() { // $ports = explode(',',MEMCACHED_PORT); foreach (explode(',', MEMCACHED_HOST) as $i => $h) { $clear_obj = new Memcache(); $clear_obj->connect($h, '11211') or die('Could not connect'); $clear_obj->flush(); unset($clear_obj); } return true; }
/** * Flush all existing items at the server * @param boolean $wait_on_flush Note that after flushing, you have to wait a certain amount of time (in many case < 1s) to be able to write to Memcached again. make if 0/1 to flag to wait on flush or not. * @link http://www.php.net/manual/en/memcache.flush.php */ public function flush($wait_on_flush = 1) { $this->connect(); $this->mem_cache_instace->flush(); $this->disconnect(); self::$_soft_cache = array(); $this->deinit_internal_cache(); if ($wait_on_flush) { \sleep(1); } }
/** * This method is intended only for unit testing. Do NOT use it in other context. * Clear all the cache class vars, useful to calculate every value again. */ public function clearValues() { if (!defined('VB_UNITTEST')) { throw new Exception('This method should be called only from unit tests'); } else { $this->memcache_set = true; $this->store_result = false; $this->memcache->flush(); parent::clearValues(); } }
public function tearDown() { if (extension_loaded('apc')) { \apc_clear_cache(); } if (extension_loaded('memcache')) { $memcache = new \Memcache(); if ($memcache->addServer('localhost', 11211)) { $memcache->flush(); } } }
/** * Removes all items from cache * * @return bool */ public function delete_all() { if ($flushed = $this->memcache->flush()) { // Memcached has one second granularity, which means it must wait // at least 1 sec after flushing, that is, flush() will expire all items // set within that second and new items will be invalidated immediately sleep(1); self::$tags = array(); $this->store_tags(); } return $flushed; }