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
