public function init() { parent::init(); if (!$this->isComponentActive()) { return; } try { $this->userInfo = call_user_func($this->userInfoCallable); $this->setUser($this->userInfo); $memcacheServerName = $this->cacheServer['host']; $memcacheServerPort = $this->cacheServer['port']; if ($memcacheServerName && $memcacheServerPort) { $memcached = new \Memcached(); $memcached->addServer($memcacheServerName, $memcacheServerPort); $cacheDriver = new \Doctrine\Common\Cache\MemcachedCache(); $cacheDriver->setMemcached($memcached); $cacheStorage = new \Kevinrob\GuzzleCache\Storage\DoctrineCacheStorage($cacheDriver); } else { $cacheStorage = new \Kevinrob\GuzzleCache\Storage\DoctrineCacheStorage(new \Doctrine\Common\Cache\FilesystemCache('/tmp/')); } $this->client = new \LaunchDarkly\LDClient($this->apiKey, array("cache" => $cacheStorage)); $this->featureToggleUser = (new \LaunchDarkly\LDUserBuilder($this->user->key))->secondary($this->user->secondary)->ip($this->user->ip)->country($this->user->country)->email($this->user->email)->name($this->user->name)->avatar($this->user->avatar)->firstName($this->user->firstName)->lastName($this->user->lastName)->anonymous($this->user->anonymous)->custom(array('type' => $this->user->type, 'parentCompanyId' => $this->user->parentId, 'referredAccountId' => $this->user->referredAccountId, 'channel' => $this->user->channel, 'payoutMethod' => isset($this->user->payoutMethod) ? $this->user->payoutMethod : null))->build(); } catch (\Exception $ex) { $this->componentActive = false; \Yii::log("Cannot initiate Feature Toggles: {$ex->getMessage()}", \CLogger::LEVEL_WARNING, 'system.featureToggle'); } }
/** * constructor */ public function __construct() { // load database configuration from CodeIgniter require APPPATH . 'config/database.php'; // Set up class loading. You could use different autoloaders, provided by your favorite framework, // if you want to. //require_once APPPATH.'third_party/Doctrine/Common/ClassLoader.php'; $doctrineClassLoader = new ClassLoader('Doctrine', APPPATH . '../vendor/doctrine'); $doctrineClassLoader->register(); $entitiesClassLoader = new ClassLoader('models', APPPATH . "models/Entities"); $entitiesClassLoader->register(); $proxiesClassLoader = new ClassLoader('proxies', APPPATH . 'models/proxies'); $proxiesClassLoader->register(); // Set up caches $config = new Configuration(); //TODO this approach won't work always, developers may habe memcached installed, but not interested //to use or server not running. Need to fix. if (class_exists('Memcached')) { $memcache = new \Memcached(); $memcache->addServer('127.0.0.1', 11211); $cacheDriver = new \Doctrine\Common\Cache\MemcachedCache(); $cacheDriver->setMemcached($memcache); } else { if (extension_loaded('apc') && ini_get('apc.enabled')) { $cacheDriver = new \Doctrine\Common\Cache\ApcCache(); } else { $cacheDriver = new \Doctrine\Common\Cache\ArrayCache(); } } $config->setMetadataCacheImpl($cacheDriver); $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models/Entities')); $config->setMetadataDriverImpl($driverImpl); $config->setQueryCacheImpl($cacheDriver); // Proxy configuration $config->setProxyDir(APPPATH . 'models/proxies'); $config->setProxyNamespace('Proxies'); // Set up logger //$logger = new Doctrine\DBAL\Logging\CIProfiler(); //$config->setSQLLogger($logger); $config->setAutoGenerateProxyClasses(TRUE); // Database connection information $connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']); // Create EntityManager $this->em = EntityManager::create($connectionOptions, $config); foreach ($driverImpl->getAllClassNames() as $class) { require_once $entitiesClassLoader->getIncludePath() . "/" . $class . ".php"; } //$this->generate_classes(); }
/** * Get cache driver according to config.yml entry. * * Logic from Doctrine setup method * https://github.com/doctrine/doctrine2/blob/master/lib/Doctrine/ORM/Tools/Setup.php#L122 * * @param array $cacheConfig * @param boolean $isDevMode * @param string|null $proxyDir * @return Cache */ protected function getManuallyDefinedCache(array $cacheConfig, $isDevMode = false, $proxyDir = null) { $proxyDir = $proxyDir ?: sys_get_temp_dir(); if ($isDevMode === false) { if (extension_loaded('apc') && !empty($cacheConfig['type']) && $cacheConfig['type'] == 'apc') { $cache = new \Doctrine\Common\Cache\ApcCache(); } elseif (extension_loaded('xcache') && !empty($cacheConfig['type']) && $cacheConfig['type'] == 'xcache') { $cache = new \Doctrine\Common\Cache\XcacheCache(); } elseif (extension_loaded('memcache') && !empty($cacheConfig['type']) && $cacheConfig['type'] == 'memcache') { $memcache = new \Memcache(); $host = !empty($cacheConfig['host']) ? $cacheConfig['host'] : '127.0.0.1'; if (!empty($cacheConfig['port'])) { $memcache->connect($host, $cacheConfig['port']); } else { $memcache->connect($host); } $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($memcache); } elseif (extension_loaded('memcached') && !empty($cacheConfig['type']) && $cacheConfig['type'] == 'memcached') { $memcached = new \Memcached(); $host = !empty($cacheConfig['host']) ? $cacheConfig['host'] : '127.0.0.1'; $port = !empty($cacheConfig['port']) ? $cacheConfig['port'] : 11211; $memcached->addServer($host, $port); $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcached($memcached); } elseif (extension_loaded('redis') && !empty($cacheConfig['type']) && $cacheConfig['type'] == 'redis') { $redis = new \Redis(); $host = !empty($cacheConfig['host']) ? $cacheConfig['host'] : '127.0.0.1'; if (!empty($cacheConfig['port'])) { $redis->connect($host, $cacheConfig['port']); } else { $redis->connect($host); } $cache = new \Doctrine\Common\Cache\RedisCache(); $cache->setRedis($redis); } else { $cache = new ArrayCache(); } } else { $cache = new ArrayCache(); } if ($cache instanceof CacheProvider) { $cache->setNamespace("dc2_" . md5($proxyDir) . "_"); // to avoid collisions } return $cache; }
/** * * 获取缓存信息 * @return \Doctrine\Common\Cache\MongoDBCache */ protected function getCache() { $namespace = 'PanGuKTD_ORM_'; $cacheConfig = config('doctrine'); $cacheName = $cacheConfig['name']; $cache = null; if ($cacheName == 'array') { $cache = new \Doctrine\Common\Cache\ArrayCache(); } elseif ($cacheName == 'xcache') { $cache = new \Doctrine\Common\Cache\XcacheCache(); } elseif ($cacheName == 'memcached') { $memcached = new \Memcached(); $memcached->addServers($cacheConfig['memcached']); $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcached($memcached); $cache->setNamespace($namespace); } elseif ($cacheName == 'memcache') { $memcache = new \Memcache(); foreach ($cacheConfig['memcache'] as $key => $value) { $memcache->addServer($value['host'], $value['port'], $value['persistent'], $value['weight']); } $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($memcache); $cache->setNamespace($namespace); } elseif ($cacheName == 'apc') { $cache = new \Doctrine\Common\Cache\ApcCache(); $cache->setNamespace($namespace); } elseif ($cacheName == 'mongo') { $host = $cacheConfig['mongo']['host']; $port = $cacheConfig['mongo']['port']; $opt = $cacheConfig['mongo']['options']; $mongo = new \MongoClient("mongodb://{$host}:{$port}", $opt); $mongo = new \MongoDB($mongo, 'doctrine_orm_cache'); $conn = new \MongoCollection($mongo, $namespace); $cache = new \Doctrine\Common\Cache\MongoDBCache($conn); $cache->setNamespace($namespace); } elseif ($cacheName == 'redis') { $host = $cacheConfig['redis']['host']; $port = $cacheConfig['redis']['port']; $redis = new \Redis(); $redis->connect($host, $port); $cache = new \Doctrine\Common\Cache\RedisCache(); $cache->setRedis($redis); } return $cache; }
public function __call($method, $args) { $driver = null; switch (config()->cache_driver()) { case 'memcached': $memcached = new \Memcached(); $memcached->addServer(config()->cache_host(), 11211); $driver = new \Doctrine\Common\Cache\MemcachedCache(); $driver->setMemcached($memcached); break; case 'apc': $driver = new \Doctrine\Common\Cache\ApcCache(); break; } switch ($method) { case 'set': // $driver->delete($args[0]); $driver->save($args[0], json_encode($args[1])); break; case 'get': return json_decode($driver->fetch($args[0])); break; } }
/** * Detects the correct doctrine cache driver for the user caching engine in use * @return \Doctrine\Common\Cache\AbstractCache The doctrine cache driver object */ public function getDoctrineCacheDriver() { if ($this->doctrineCacheEngine) { // return cache engine if already set return $this->doctrineCacheEngine; } $userCacheEngine = $this->getUserCacheEngine(); // check if user caching is active if (!$this->getUserCacheActive()) { $userCacheEngine = \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_OFF; } switch ($userCacheEngine) { case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_APC: $cache = new \Doctrine\Common\Cache\ApcCache(); $cache->setNamespace($this->getCachePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_MEMCACHE: $memcache = $this->getMemcache(); $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($memcache); $cache->setNamespace($this->getCachePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_MEMCACHED: $memcached = $this->getMemcached(); $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcached($memcached); $cache->setNamespace($this->getCachePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_XCACHE: $cache = new \Doctrine\Common\Cache\XcacheCache(); $cache->setNamespace($this->getCachePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_FILESYSTEM: $cache = new \Cx\Core_Modules\Cache\Controller\Doctrine\CacheDriver\FileSystemCache($this->strCachePath); break; default: $cache = new \Doctrine\Common\Cache\ArrayCache(); break; } // set the doctrine cache engine to avoid getting it a second time $this->doctrineCacheEngine = $cache; return $cache; }
$fileName = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR; } $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php'; require $fileName; }); use Ray\Di\Config; class Module extends \Ray\Di\AbstractModule { public function configure() { } } //Either use the injector directly, which works for the test but uses 19mb of RAM on this test and 203mb on Test 3 $injector = Ray\Di\Injector::create([new Module()]); //or use a compiled injector, which cannot be tested because it always returns the same instance. $cache = new \Doctrine\Common\Cache\MemcachedCache(); $m = new Memcached(); $m->addServer('localhost', 11211); $cache->setMemcached($m); $injector = \Ray\Di\DiCompiler::create($injector, $cache, 'ray', './tmp'); $a = $injector->getInstance('A'); $a1 = $injector->getInstance('A'); if ($a === $a1) { throw new Exception('Container returned the same instance'); } $t1 = microtime(true); for ($i = 0; $i < 10000; $i++) { $a = $injector->getInstance('A'); } $t2 = microtime(true); $results = ['time' => $t2 - $t1, 'files' => count(get_included_files()), 'memory' => memory_get_peak_usage() / 1024 / 1024];
/** * Returns the doctrine entity manager * @return \Doctrine\ORM\EntityManager */ public function getEntityManager() { if ($this->em) { return $this->em; } global $objCache; $config = new \Doctrine\ORM\Configuration(); $userCacheEngine = $objCache->getUserCacheEngine(); if (!$objCache->getUserCacheActive()) { $userCacheEngine = \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_OFF; } $arrayCache = new \Doctrine\Common\Cache\ArrayCache(); switch ($userCacheEngine) { case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_APC: $cache = new \Doctrine\Common\Cache\ApcCache(); $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_MEMCACHE: $memcache = $objCache->getMemcache(); if ($memcache instanceof \Memcache) { $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($memcache); } elseif ($memcache instanceof \Memcached) { $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcache($memcache); } $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_XCACHE: $cache = new \Doctrine\Common\Cache\XcacheCache(); $cache->setNamespace($this->db->getName() . '.' . $this->db->getTablePrefix()); break; case \Cx\Core_Modules\Cache\Controller\Cache::CACHE_ENGINE_FILESYSTEM: $cache = new \Cx\Core_Modules\Cache\Controller\Doctrine\CacheDriver\FileSystemCache(ASCMS_CACHE_PATH); break; default: $cache = $arrayCache; break; } \Env::set('cache', $cache); //$config->setResultCacheImpl($cache); $config->setMetadataCacheImpl($cache); $config->setQueryCacheImpl($cache); $config->setProxyDir(ASCMS_MODEL_PROXIES_PATH); $config->setProxyNamespace('Cx\\Model\\Proxies'); /** * This should be set to true if workbench is present and active. * Just checking for workbench.config is not really a good solution. * Since ConfigurationFactory used by EM caches auto generation * config value, there's no possibility to set this later. */ $config->setAutoGenerateProxyClasses(file_exists(ASCMS_DOCUMENT_ROOT . '/workbench.config')); $connectionOptions = array('pdo' => $this->getPdoConnection(), 'dbname' => $this->db->getName()); $evm = new \Doctrine\Common\EventManager(); $chainDriverImpl = new \Doctrine\ORM\Mapping\Driver\DriverChain(); $driverImpl = new \Cx\Core\Model\Controller\YamlDriver(array(ASCMS_CORE_PATH . '/Core' . '/Model/Yaml')); $chainDriverImpl->addDriver($driverImpl, 'Cx'); //loggable stuff $loggableDriverImpl = $config->newDefaultAnnotationDriver(ASCMS_LIBRARY_PATH . '/doctrine/Gedmo/Loggable/Entity'); $chainDriverImpl->addDriver($loggableDriverImpl, 'Gedmo\\Loggable'); $this->loggableListener = new \Cx\Core\Model\Model\Event\LoggableListener(); $this->loggableListener->setUsername('currently_loggedin_user'); // in real world app the username should be loaded from session, example: // Session::getInstance()->read('user')->getUsername(); $evm->addEventSubscriber($this->loggableListener); //tree stuff $treeListener = new \Gedmo\Tree\TreeListener(); $evm->addEventSubscriber($treeListener); $config->setMetadataDriverImpl($chainDriverImpl); //table prefix $prefixListener = new \DoctrineExtension\TablePrefixListener($this->db->getTablePrefix()); $evm->addEventListener(\Doctrine\ORM\Events::loadClassMetadata, $prefixListener); $config->setSqlLogger(new \Cx\Lib\DBG\DoctrineSQLLogger()); $em = \Cx\Core\Model\Controller\EntityManager::create($connectionOptions, $config, $evm); //resolve enum, set errors $conn = $em->getConnection(); $conn->setCharset($this->db->getCharset()); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('enum', 'string'); $conn->getDatabasePlatform()->registerDoctrineTypeMapping('set', 'string'); $this->em = $em; return $this->em; }
<?php require_once '../testclasses.php'; function __autoload($className) { $className = ltrim($className, '\\'); $fileName = ''; $namespace = ''; if ($lastNsPos = strrpos($className, '\\')) { $namespace = substr($className, 0, $lastNsPos); $className = substr($className, $lastNsPos + 1); $fileName = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR; } $fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php'; require $fileName; } require_once 'DI/functions.php'; $builder = new \DI\ContainerBuilder(); $builder->addDefinitions('config-test3.php'); $cache = new \Doctrine\Common\Cache\MemcachedCache(); $m = new Memcached(); $m->addServer('localhost', 11211); $cache->setMemcached($m); $builder->setDefinitionCache($cache); $container = $builder->build(); for ($i = 0; $i < $argv[1]; $i++) { $j = $container->get('J'); } $results = ['time' => 0, 'files' => count(get_included_files()), 'memory' => memory_get_peak_usage() / 1024 / 1024]; echo json_encode($results);
protected function initCache() { $cacheConfiguration = $this['config']->getCacheConfiguration(); switch ($cacheConfiguration['driver']['type']) { case 'apc': $cacheDriver = new \Doctrine\Common\Cache\ApcCache(); break; case 'memcached': $memcached = new \Memcached(); $memcached->addServer($cacheConfiguration['driver']['host'], $cacheConfiguration['driver']['port']); $cacheDriver = new \Doctrine\Common\Cache\MemcachedCache(); $cacheDriver->setMemcached($memcached); break; case 'memcache': $memcache = new \Memcache(); $memcache->connect($cacheConfiguration['driver']['host'], $cacheConfiguration['driver']['port']); $cacheDriver = new \Doctrine\Common\Cache\MemcacheCache(); $cacheDriver->setMemcache($memcache); break; case 'file': $cacheDriver = new PhPFileCache(APPLICATION_PATH . '/doctrine-cache', 'txt'); $this->setCacheDriver($cacheDriver); break; default: $cacheDriver = new \Doctrine\Common\Cache\ArrayCache(); break; } if (isset($cacheConfiguration['driver']['prefix'])) { $cacheDriver->setNamespace($cacheConfiguration['driver']['prefix'] . '_'); } $this->setCacheDriver($cacheDriver); }
private static function getMemcachedObject() { if (!defined('__CA_MEMCACHED_HOST__')) { define('__CA_MEMCACHED_HOST__', 'localhost'); } if (!defined('__CA_MEMCACHED_PORT__')) { define('__CA_MEMCACHED_PORT__', 11211); } $o_memcached = new Memcached(); $o_memcached->addServer(__CA_MEMCACHED_HOST__, __CA_MEMCACHED_PORT__); $o_cache = new \Doctrine\Common\Cache\MemcachedCache(); $o_cache->setMemcached($o_memcached); return $o_cache; }
/** * Creates an instance of a doctrine cache provider and assigns it an ID. * * @param string $id - Instance ID. * @param string|CacheProvider $typeOrInstance - Instance type. * @param array $config - Instance config. * @param bool $refresh - Re-create the instance even if it's already created. * * @throws InvalidTypeException * @throws InvalidConfigException * @throws MissingExtensionException * * @return CacheProvider */ public function create($id, $typeOrInstance, array $config = [], $refresh = false) { if (!is_string($id)) { throw new \InvalidArgumentException('Argument $id must be a string.'); } if (!is_string($id) && (!is_object($typeOrInstance) || !$typeOrInstance instanceof CacheProvider)) { throw new \InvalidArgumentException('Argument $typeOrInstance must be a string or an instance of \\Doctrine\\Common\\Cache\\CacheProvider.'); } if (!isset($this->_instances[$id]) || $refresh) { if (is_object($typeOrInstance)) { $this->_instances[$id] = $typeOrInstance; } else { $cache = null; switch ($typeOrInstance) { case self::TYPE_APCU: if (!function_exists('apcu_fetch')) { throw MissingExtensionException::create('apcu', 'ApcuCache'); } $cache = new \Doctrine\Common\Cache\ApcuCache(); break; case self::TYPE_ARRAY: $cache = new \Doctrine\Common\Cache\ArrayCache(); break; case self::TYPE_COUCHBASE: if (!class_exists('\\Couchbase')) { throw MissingExtensionException::create('couchbase', 'CouchbaseCache'); } $config = array_merge(['couchbase' => null], $config); if (!is_object($config['couchbase']) || !$config['couchbase'] instanceof \Couchbase) { throw InvalidConfigException::create('couchbase', 'an instance of \\Couchbase.'); } $cache = new \Doctrine\Common\Cache\CouchbaseCache(); $cache->setCouchbase($config['couchbase']); break; case self::TYPE_FILESYSTEM: $config = array_merge(['directory' => null, 'extension' => FilesystemCache::EXTENSION, 'umask' => 02], $config); $cache = new FilesystemCache($config['directory'], $config['extension'], $config['umask']); break; case self::TYPE_MEMCACHE: if (!class_exists('\\Memcache')) { throw MissingExtensionException::create('memcache', 'MemcacheCache'); } $config = array_merge(['memcache' => null], $config); if (!is_object($config['memcache']) || !$config['memcache'] instanceof \Memcache) { throw InvalidConfigException::create('memcache', 'an instance of \\Memcache.'); } $cache = new \Doctrine\Common\Cache\MemcacheCache(); $cache->setMemcache($config['memcache']); break; case self::TYPE_MEMCACHED: if (!class_exists('\\Memcached')) { throw MissingExtensionException::create('memcached', 'MemcachedCache'); } $config = array_merge(['memcached' => null], $config); if (!is_object($config['memcached']) || !$config['memcached'] instanceof \Memcached) { throw InvalidConfigException::create('memcached', 'an instance of \\Memcached.'); } $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcached($config['memcached']); break; case self::TYPE_MONGODB: if (!class_exists('\\MongoCollection')) { throw MissingExtensionException::create('mongo', 'MongoDBCache'); } $config = array_merge(['mongoCollection' => null], $config); if (!is_object($config['mongoCollection']) || !$config['mongoCollection'] instanceof \MongoCollection) { throw InvalidConfigException::create('mongoCollection', 'an instance of \\MongoCollection.'); } $cache = new \Doctrine\Common\Cache\MongoDBCache($config['mongoCollection']); break; case self::TYPE_PHP_FILE: $config = array_merge(['directory' => null, 'extension' => PhpFileCache::EXTENSION, 'umask' => 02], $config); $cache = new PhpFileCache($config['directory'], $config['extension'], $config['umask']); break; case self::TYPE_PREDIS: if (!class_exists('\\Predis\\ClientInterface')) { throw MissingExtensionException::create('predis', 'PredisCache'); } $config = array_merge(['predisClient' => null], $config); if (!is_object($config['predisClient']) || !$config['predisClient'] instanceof \Predis\ClientInterface) { throw InvalidConfigException::create('predisClient', 'an instance of \\Predis\\ClientInterface.'); } $cache = new \Doctrine\Common\Cache\PredisCache($config['predisClient']); break; case self::TYPE_REDIS: if (!class_exists('\\Redis')) { throw MissingExtensionException::create('redis', 'RedisCache'); } $config = array_merge(['redis' => null], $config); if (!is_object($config['redis']) || !$config['redis'] instanceof \Redis) { throw InvalidConfigException::create('redis', 'an instance of \\Redis.'); } $cache = new \Doctrine\Common\Cache\RedisCache(); $cache->setRedis($config['redis']); break; case self::TYPE_RIAK: if (!class_exists('\\Riak\\Bucket')) { throw MissingExtensionException::create('riak', 'RiakCache'); } $config = array_merge(['riakBucket' => null], $config); if (!is_object($config['riakBucket']) || !$config['riakBucket'] instanceof \Riak\Bucket) { throw InvalidConfigException::create('riakBucket', 'an instance of \\Riak\\Bucket.'); } $cache = new \Doctrine\Common\Cache\RiakCache($config['riakBucket']); break; case self::TYPE_SQLITE3: if (!class_exists('\\SQLite3')) { throw MissingExtensionException::create('sqlite3', 'SQLite3Cache'); } $config = array_merge(['sqlite3' => null, 'sqlite3Table' => null], $config); if (!is_object($config['sqlite3']) || !$config['sqlite3'] instanceof \SQLite3) { throw InvalidConfigException::create('sqlite3', 'an instance of \\SQLite3.'); } if (!is_string($config['sqlite3Table']) || $config['sqlite3Table'] === '') { throw InvalidConfigException::create('sqlite3Table', 'a non-empty string.'); } $cache = new \Doctrine\Common\Cache\SQLite3Cache($config['sqlite3'], $config['sqlite3Table']); break; case self::TYPE_VOID: $cache = new VoidCache(); break; case self::TYPE_WINCACHE: if (!function_exists('wincache_ucache_get')) { throw MissingExtensionException::create('wincache', 'WinCacheCache'); } $cache = new \Doctrine\Common\Cache\WinCacheCache(); break; case self::TYPE_XCACHE: if (!function_exists('xcache_isset')) { throw MissingExtensionException::create('xcache', 'XcacheCache'); } $cache = new \Doctrine\Common\Cache\XcacheCache(); break; case self::TYPE_ZEND_DATA: if (!function_exists('zend_shm_cache_fetch')) { throw new \RuntimeException('Zend Data component must be installed and available before using this Cache Driver.'); } $cache = new \Doctrine\Common\Cache\ZendDataCache(); break; default: throw InvalidTypeException::create($typeOrInstance); } $this->_instances[$id] = $cache; } } return $this->_instances[$id]; }
public function initModules() { $this->register(new ConsoleServiceProvider(), array('console.name' => 'AnyContent CMCK Console', 'console.version' => '1.0.0', 'console.project_directory' => APPLICATION_PATH)); foreach ($this->modules as $module) { $class = $module['class'] . '\\Module'; $o = new $class(); $o->init($this, $module['options']); $module['module'] = $o; $this->modules[$module['class']] = $module; } $this->register(new \Silex\Provider\TwigServiceProvider(), array('twig.path' => array_reverse($this->templatesFolder))); $this['twig']->setCache(APPLICATION_PATH . '/twig-cache'); // Init Cache $cacheConfiguration = $this['config']->getCacheConfiguration(); switch ($cacheConfiguration['driver']['type']) { case 'none': $cacheDriver = new ArrayCache(); break; case 'apc': $cacheDriver = new \Doctrine\Common\Cache\ApcCache(); $this->setCacheDriver($cacheDriver); break; case 'memcached': $memcached = new \Memcached(); $memcached->addServer($cacheConfiguration['driver']['host'], $cacheConfiguration['driver']['port']); $memcached->setOption(\Memcached::OPT_BINARY_PROTOCOL, 1); if (array_key_exists('username', $cacheConfiguration['driver'])) { $memcached->setSaslAuthData($cacheConfiguration['driver']['username'], $cacheConfiguration['driver']['password']); } $cacheDriver = new \Doctrine\Common\Cache\MemcachedCache(); $cacheDriver->setMemcached($memcached); $this->setCacheDriver($cacheDriver); break; case 'file': $cacheDriver = new PhPFileCache(APPLICATION_PATH . '/doctrine-cache', 'txt'); $this->setCacheDriver($cacheDriver); break; case 'mysql': $cacheDriver = new MySQLCache($cacheConfiguration['driver']['host'], $cacheConfiguration['driver']['dbname'], $cacheConfiguration['driver']['tablename'], $cacheConfiguration['driver']['user'], $cacheConfiguration['driver']['password'], $cacheConfiguration['driver']['port']); $this->setCacheDriver($cacheDriver); break; default: throw new \Exception('Unknown authentication adapter type ' . $cacheConfiguration['driver']['type'] . '.'); break; } $client = $this->getClient(); $client->setCacheProvider($cacheDriver); // Now add the repositories $this->getRepositoryManager()->init(); // Then run all modules foreach ($this->modules as $module) { $module['module']->run($this); } $this['repos']->setUserInfo($this['user']->getClientUserInfo()); }
/** * @return \Doctrine\Common\Cache\CacheProvider */ protected function getCacheDriver() { if ($this->getParameter('app.devmode')) { return new \Doctrine\Common\Cache\ArrayCache(); } if (!$this->hasParameter('cache.host')) { return new \Doctrine\Common\Cache\ApcCache(); } $memcached = new \Memcached(); $memcached->addServer($this->getParameter('cache.host'), $this->getParameter('cache.port')); $cache = new \Doctrine\Common\Cache\MemcachedCache(); $cache->setMemcached($memcached); return $cache; }
private function buildCacheFromConfig($config) { $caches = []; if ($config['array']['enabled']) { $caches[] = new ArrayCache(); } if ($config['memcached']['enabled']) { $memcached = new \Memcached(); if (!$memcached->addServer($config['memcached']['host'], $config['memcached']['port'])) { throw new RuntimeException('Fail to connect to Memcached'); } $memcachedCache = new \Doctrine\Common\Cache\MemcachedCache(); $memcachedCache->setMemcached($memcached); $caches[] = $memcachedCache; } switch (count($caches)) { case 0: return null; case 1: return reset($caches); default: return new ChainCache($caches); } }