def __init__(self, application, request, **kwargs): super().__init__(application, request, **kwargs) cache_manager = CacheManager( **parse_cache_config_options(CACHE_SETTINGS) ) self._search_pages_cache = cache_manager.get_cache_region('default', 'search_pages') self._audio_info_cache = cache_manager.get_cache_region('default', 'audio_info')
class TestBeakerBackend(unittest.TestCase): def setUp(self): reg = {} reg['cache.expire'] = 10 reg['cache.regions'] = 'session' reg['cache.type'] = 'memory' reg['batch.user.session.timeout'] = 1 self.cachemgr = CacheManager(**parse_cache_config_options(reg)) self.backend = BeakerBackend(reg) def __get_region(self, key): return self.cachemgr.get_cache_region('edware_session_' + key, 'session') def test_create_new_session(self): session = Session() session.set_session_id('123') self.backend.create_new_session(session) self.assertIsNotNone(self.__get_region('123').get('123')) def test_get_session_from_persistence_with_existing_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) lookup = self.backend.get_session('456') self.assertEqual(lookup.get_uid(), 'abc') def test_get_session_invalid_session(self): lookup = self.backend.get_session('idontexist') self.assertIsNone(lookup) def test_delete_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) self.backend.delete_session('456') self.assertFalse('456' in self.__get_region('456')) def test_update_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) session.set_uid('def') self.backend.update_session(session) lookup = self.__get_region('456').get('456') self.assertEquals(lookup.get_uid(), 'def') def test_overwrite_timeout(self): session = Session() session.set_session_id('1456') session.set_uid('abc') self.backend.create_new_session(session, overwrite_timeout=True) time.sleep(1) self.assertIsNone(self.backend.get_session('1456'))
class TestBeakerBackend(unittest.TestCase): def setUp(self): reg = {} reg['cache.expire'] = 10 reg['cache.regions'] = 'session' reg['cache.type'] = 'memory' reg['batch.user.session.timeout'] = 1 self.cachemgr = CacheManager(**parse_cache_config_options(reg)) self.backend = BeakerBackend(reg) def __get_region(self, key): return self.cachemgr.get_cache_region('edware_session_' + key, 'session') def test_create_new_session(self): session = Session() session.set_session_id('123') self.backend.create_new_session(session) self.assertIsNotNone(self.__get_region('123').get('123')) def test_get_session_from_persistence_with_existing_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) lookup = self.backend.get_session('456') self.assertEqual(lookup.get_uid(), 'abc') def test_get_session_invalid_session(self): lookup = self.backend.get_session('idontexist') self.assertIsNone(lookup) def test_delete_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) self.backend.delete_session('456') self.assertFalse('456' in self.__get_region('456')) def test_update_session(self): session = Session() session.set_session_id('456') session.set_uid('abc') self.backend.create_new_session(session) session.set_uid('def') self.backend.update_session(session) lookup = self.__get_region('456').get('456') self.assertEquals(lookup.get_uid(), 'def') def test_overwrite_timeout(self): session = Session() session.set_session_id('1456') session.set_uid('abc') self.backend.create_new_session(session, overwrite_timeout=True) time.sleep(1) self.assertIsNone(self.backend.get_session('1456'))
class BeakerBackend(Backend): ''' Manipulates session that resides in persistent storage (memory, memcached) ''' def __init__(self, settings): self.cache_mgr = CacheManager(**parse_cache_config_options(settings)) self.batch_timeout = int(settings.get('batch.user.session.timeout')) def create_new_session(self, session, overwrite_timeout=False): ''' Creates a new session ''' self.update_session(session, overwrite_timeout=overwrite_timeout) def update_session(self, session, overwrite_timeout=False): ''' Given a session, persist it ''' _id = session.get_session_id() region = self.__get_cache_region(_id) # Overwrite the timeout for batch user sessions if overwrite_timeout: region.expiretime = self.batch_timeout region.put(_id, session) def get_session(self, session_id): ''' Return session from persistent storage ''' region = self.__get_cache_region(session_id) if session_id not in region: logger.info( 'Session is not found in cache. It may have expired or connection to memcached is down' ) return None return region.get(session_id) def delete_session(self, session_id): ''' Delete session from persistent storage ''' # delete from db doesn't work region = self.__get_cache_region(session_id) if session_id in region: # works for memcached region.remove_value(session_id) def __get_cache_region(self, key): return self.cache_mgr.get_cache_region('edware_session_' + key, 'session') def clear(self): ''' clear cache ''' self.cache_region.clear()
class BeakerBackend(Backend): ''' Manipulates session that resides in persistent storage (memory, memcached) ''' def __init__(self, settings): self.cache_mgr = CacheManager(**parse_cache_config_options(settings)) self.batch_timeout = int(settings.get('batch.user.session.timeout')) def create_new_session(self, session, overwrite_timeout=False): ''' Creates a new session ''' self.update_session(session, overwrite_timeout=overwrite_timeout) def update_session(self, session, overwrite_timeout=False): ''' Given a session, persist it ''' _id = session.get_session_id() region = self.__get_cache_region(_id) # Overwrite the timeout for batch user sessions if overwrite_timeout: region.expiretime = self.batch_timeout region.put(_id, session) def get_session(self, session_id): ''' Return session from persistent storage ''' region = self.__get_cache_region(session_id) if session_id not in region: logger.info('Session is not found in cache. It may have expired or connection to memcached is down') return None return region.get(session_id) def delete_session(self, session_id): ''' Delete session from persistent storage ''' # delete from db doesn't work region = self.__get_cache_region(session_id) if session_id in region: # works for memcached region.remove_value(session_id) def __get_cache_region(self, key): return self.cache_mgr.get_cache_region('edware_session_' + key, 'session') def clear(self): ''' clear cache ''' self.cache_region.clear()
class CacheManager(grok.GlobalUtility): """ a cache manager that wraps beaker """ grok.implements(ICacheManager) grok.provides(ICacheManager) default_region_options = { 'lock_dir': '/tmp/beaker', 'type': 'memorylru', 'max_items': '1000', } def __init__(self): self._parse_config() self.bcm = BCM(**self._parse_config()) self.regions = self.bcm.regions def get_cache_from_region(self, namespace, region): try: return self.bcm.get_cache_region(namespace, region) except BeakerException as e: logger.warn('no specific configuration for region %s' ' using defaults (%s) : %s', region, repr(self.default_region_options), e) self._create_region_from_default(region) return self.bcm.get_cache_region(namespace, region) def get_cache(self, namespace, **options): # Doesn't rely on region for configuration. return self.bcm.get_cache(namespace, **options) def _parse_config(self): zconf = getattr(getConfiguration(), 'product_config', {}) cache_config = zconf.get('silva.core.cache', {}) regions = {} for key, value in cache_config.iteritems(): if '.' in key: try: region, param = key.split('.', 1) except ValueError: continue if region not in regions: regions[region] = {} regions[region][param] = value if regions.has_key('default'): self.default_region_options = regions['default'] del regions['default'] options = self.default_region_options.copy() options['cache_regions'] = regions return options def _create_region_from_default(self, region): """ Create the region with default """ options = self.default_region_options.copy() self.regions[region] = options self.bcm.regions.update({region: options}) beaker.cache.cache_regions.update({region: options})
class Application(object): """ Represents the vcs server application. This object is responsible to initialize the application and all needed libraries. After that it hooks together the different objects and provides them a way to access things like configuration. """ def __init__( self, host, port=None, locale='', threadpool_size=None, timeout=None, cache_config=None, remote_wsgi_=None): self.host = host self.port = int(port) or settings.PYRO_PORT self.threadpool_size = ( int(threadpool_size) if threadpool_size else None) self.locale = locale self.timeout = timeout self.cache_config = cache_config self.remote_wsgi = remote_wsgi_ or remote_wsgi def init(self): """ Configure and hook together all relevant objects. """ self._configure_locale() self._configure_pyro() self._initialize_cache() self._create_daemon_and_remote_objects(host=self.host, port=self.port) def run(self): """ Start the main loop of the application. """ if hasattr(os, 'getpid'): log.info('Starting %s in PID %i.', __name__, os.getpid()) else: log.info('Starting %s.', __name__) if SERVER_RUNNING_FILE: log.info('PID file written as %s', SERVER_RUNNING_FILE) else: log.info('No PID file written by default.') when_ready(self) try: self._pyrodaemon.requestLoop( loopCondition=lambda: not self._vcsserver._shutdown) finally: self._pyrodaemon.shutdown() def _configure_locale(self): if self.locale: log.info('Settings locale: `LC_ALL` to %s' % self.locale) else: log.info( 'Configuring locale subsystem based on environment variables') try: # If self.locale is the empty string, then the locale # module will use the environment variables. See the # documentation of the package `locale`. locale.setlocale(locale.LC_ALL, self.locale) language_code, encoding = locale.getlocale() log.info( 'Locale set to language code "%s" with encoding "%s".', language_code, encoding) except locale.Error: log.exception( 'Cannot set locale, not configuring the locale system') def _configure_pyro(self): if self.threadpool_size is not None: log.info("Threadpool size set to %s", self.threadpool_size) Pyro4.config.THREADPOOL_SIZE = self.threadpool_size if self.timeout not in (None, 0, 0.0, '0'): log.info("Timeout for RPC calls set to %s seconds", self.timeout) Pyro4.config.COMMTIMEOUT = float(self.timeout) Pyro4.config.SERIALIZER = 'pickle' Pyro4.config.SERIALIZERS_ACCEPTED.add('pickle') Pyro4.config.SOCK_REUSE = True # Uncomment the next line when you need to debug remote errors # Pyro4.config.DETAILED_TRACEBACK = True def _initialize_cache(self): cache_config = parse_cache_config_options(self.cache_config) log.info('Initializing beaker cache: %s' % cache_config) self.cache = CacheManager(**cache_config) def _create_daemon_and_remote_objects(self, host='localhost', port=settings.PYRO_PORT): daemon = Pyro4.Daemon(host=host, port=port) self._vcsserver = VcsServer() uri = daemon.register( self._vcsserver, objectId=settings.PYRO_VCSSERVER) log.info("Object registered = %s", uri) if GitFactory and GitRemote: git_repo_cache = self.cache.get_cache_region('git', region='repo_object') git_factory = GitFactory(git_repo_cache) self._git_remote = GitRemote(git_factory) uri = daemon.register(self._git_remote, objectId=settings.PYRO_GIT) log.info("Object registered = %s", uri) else: log.info("Git client import failed") if MercurialFactory and HgRemote: hg_repo_cache = self.cache.get_cache_region('hg', region='repo_object') hg_factory = MercurialFactory(hg_repo_cache) self._hg_remote = HgRemote(hg_factory) uri = daemon.register(self._hg_remote, objectId=settings.PYRO_HG) log.info("Object registered = %s", uri) else: log.info("Mercurial client import failed") if SubversionFactory and SvnRemote: svn_repo_cache = self.cache.get_cache_region('svn', region='repo_object') svn_factory = SubversionFactory(svn_repo_cache) self._svn_remote = SvnRemote(svn_factory, hg_factory=hg_factory) uri = daemon.register(self._svn_remote, objectId=settings.PYRO_SVN) log.info("Object registered = %s", uri) else: log.info("Subversion client import failed") self._git_remote_wsgi = self.remote_wsgi.GitRemoteWsgi() uri = daemon.register(self._git_remote_wsgi, objectId=settings.PYRO_GIT_REMOTE_WSGI) log.info("Object registered = %s", uri) self._hg_remote_wsgi = self.remote_wsgi.HgRemoteWsgi() uri = daemon.register(self._hg_remote_wsgi, objectId=settings.PYRO_HG_REMOTE_WSGI) log.info("Object registered = %s", uri) self._pyrodaemon = daemon