def __call__(self, environ, start_response):
"""
Accept ``environ`` and ``start_response``; create a
:term:`request` and route the request to a :app:`Pyramid`
view based on introspection of :term:`view configuration`
within the application registry; call ``start_response`` and
return an iterable.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
request = self.request_factory(environ)
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
try:
try:
response = self.handle_request(request)
has_listeners and notify(NewResponse(request, response))
if request.response_callbacks:
request._process_response_callbacks(response)
return response(request.environ, start_response)
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def invoke_request(self, request,
_use_tweens=True, _apply_extensions=False):
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
if _use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if _apply_extensions and extensions is not None:
apply_request_extensions(request, extensions=extensions)
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def __call__(self, environ, start_response):
"""
Accept ``environ`` and ``start_response``; create a
:term:`request` and route the request to a :app:`Pyramid`
view based on introspection of :term:`view configuration`
within the application registry; call ``start_response`` and
return an iterable.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
request = self.request_factory(environ)
threadlocals = {"registry": registry, "request": request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
try:
try:
response = self.handle_request(request)
has_listeners and notify(NewResponse(request, response))
if request.response_callbacks:
request._process_response_callbacks(response)
return response(request.environ, start_response)
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def invoke_request(self, request,
_use_tweens=True, _apply_extensions=False):
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
if _use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if _apply_extensions and extensions is not None:
apply_request_extensions(request, extensions=extensions)
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def clear_snapshot(signum=None, frame=None):
global current_xmin_snapshot_id
if current_xmin_snapshot_id is None:
return
transaction.abort()
manager.pop()
current_xmin_snapshot_id = None
def __call__(self, environ, start_response):
"""
Accept ``environ`` and ``start_response``; create a
:term:`request` and route the request to a :app:`Pyramid`
view based on introspection of :term:`view configuration`
within the application registry; call ``start_response`` and
return an iterable.
"""
registry = self.registry
manager = self.threadlocal_manager
request = None
threadlocals = {'registry':registry, 'request':request}
manager.push(threadlocals)
try:
try:
request = self.request_factory(environ)
threadlocals['request'] = request
request.registry = registry
response = self.handle_request(request)
finally:
if request is not None and request.finished_callbacks:
request._process_finished_callbacks()
return response(request.environ, start_response)
finally:
manager.pop()
def test_it(self):
from pyramid.threadlocal import manager
try:
manager.push({'registry':123})
self.assertEqual(self._callFUT(), 123)
finally:
manager.pop()
def clear_snapshot(signum=None, frame=None):
global current_xmin_snapshot_id
if current_xmin_snapshot_id is None:
return
transaction.abort()
manager.pop()
current_xmin_snapshot_id = None
def test_it(self):
from pyramid.threadlocal import manager
request = object()
try:
manager.push({'request':request})
self.assertEqual(self._callFUT(), request)
finally:
manager.pop()
self.assertEqual(self._callFUT(), None)
def init_application(event):
app = event.object
registry = app.registry
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
# Set up sms service backend
registry.registerAdapter(factory=OvhService,
required=(IRequest, ),
provided=ISMSService)
root = app.root_factory(request)
# A transaction.commit() just happened here if this is the first time we
# start. This is just after all RootAdded subscribers are executed.
request.root = root
# other init functions
if getattr(root, 'locale', None) is None:
try:
# This code is actually an evolve step for old novaideo instances.
# The root.locale is set in the RootAdded subscriber above
# for new instances.
root.locale = registry.settings.get('pyramid.default_locale_name')
transaction.commit()
except ConflictError:
# We have a conflict error in case of serveral workers, just abort
transaction.abort()
init_contents(registry) # there is no changes in ZODB here
# invite initial user if first deployment
if getattr(root, 'first_invitation_to_add', False):
# LOGO_FILENAME='marianne.svg' for example
logo = os.getenv('LOGO_FILENAME', '')
if logo:
logo_path = os.path.join(os.path.dirname(__file__), 'static',
'images', logo)
if os.path.exists(logo_path):
buf = open(logo_path, mode='rb')
log_file = File(fp=buf,
filename=logo,
mimetype='image/svg+xml')
root.setproperty('picture', log_file)
title = os.getenv('INITIAL_USER_TITLE', '')
first_name = os.getenv('INITIAL_USER_FIRSTNAME', '')
last_name = os.getenv('INITIAL_USER_LASTNAME', '')
email = os.getenv('INITIAL_USER_EMAIL', '')
phone = os.getenv('INITIAL_USER_PHONE', '')
if first_name and last_name and (phone or email):
_invite_first_user(root, request, title, first_name, last_name,
email, phone)
del root.first_invitation_to_add
# This is a change in ZODB, but it's ok, it is executed only the first
# time when we only have one worker.
transaction.commit()
manager.pop()
def execute_callback(app, callback, login):
# set site and interaction that will be memorized in job
request = DummyRequest()
request.root = app
registry = get_current_registry()
manager.push({'registry': registry, 'request': request})
user = get_user_by_login(login, request)
request.user = user
callback()
manager.pop()
def execute_callback(app, callback, login):
# set site and interaction that will be memorized in job
request = DummyRequest()
request.root = app
registry = get_current_registry()
manager.push({'registry': registry, 'request': request})
user = get_user_by_login(login, request)
request.user = user
callback()
manager.pop()
def test_add_translation_dirs_registers_chameleon_translate(self):
from pyramid.interfaces import IChameleonTranslate
from pyramid.threadlocal import manager
request = DummyRequest()
config = self._makeOne(autocommit=True)
manager.push({'request':request, 'registry':config.registry})
try:
config.add_translation_dirs('pyramid.tests.pkgs.localeapp:locale')
translate = config.registry.getUtility(IChameleonTranslate)
self.assertEqual(translate('Approve'), u'Approve')
finally:
manager.pop()
def _threadContext(self):
# IMPORTANT: this assumes that APScheduler invokes jobs in a separate
# thread per job (as documented)...
# TODO: this needs confirmation!
if self.appreg is None:
yield
else:
from pyramid.threadlocal import manager
reg = dict(manager.get())
reg['registry'] = self.appreg
manager.push(reg)
try:
yield
finally:
manager.pop()
def _threadContext(self):
# IMPORTANT: this assumes that APScheduler invokes jobs in a separate
# thread per job (as documented)...
# TODO: this needs confirmation!
if self.appreg is None:
yield
else:
from pyramid.threadlocal import manager
reg = dict(manager.get())
reg['registry'] = self.appreg
manager.push(reg)
try:
yield
finally:
manager.pop()
def test_it_raises_if_no_registry(self):
request = self._makeOne()
del request.registry
from pyramid.threadlocal import manager
manager.push({'registry': None, 'request': request})
try:
raise RuntimeError
except RuntimeError:
try:
request.invoke_exception_view()
except RuntimeError as e:
self.assertEqual(e.args[0], "Unable to retrieve registry")
else: # pragma: no cover
self.fail()
finally:
manager.pop()
def tearDown(unhook_zca=True):
"""Undo the effects of :func:`pyramid.testing.setUp`. Use this
function in the ``tearDown`` method of a unit test that uses
:func:`pyramid.testing.setUp` in its ``setUp`` method.
If the ``unhook_zca`` argument is ``True`` (the default), call
:func:`zope.component.getSiteManager.reset`. This undoes the
action of :func:`pyramid.testing.setUp` when called with the
argument ``hook_zca=True``. If :mod:`zope.component` cannot be
imported, ``unhook_zca`` is set to ``False``.
"""
global have_zca
if unhook_zca and have_zca:
try:
from zope.component import getSiteManager
getSiteManager.reset()
except ImportError: # pragma: no cover
have_zca = False
info = manager.pop()
manager.clear()
if info is not None:
registry = info['registry']
if hasattr(registry, '__init__') and hasattr(registry, '__name__'):
try:
registry.__init__(registry.__name__)
except TypeError:
# calling __init__ is largely for the benefit of
# people who want to use the global ZCA registry;
# however maybe somebody's using a registry we don't
# understand, let's not blow up
pass
def test_it_raises_if_no_registry(self):
request = self._makeOne()
del request.registry
from pyramid.threadlocal import manager
manager.push({'registry': None, 'request': request})
try:
raise RuntimeError
except RuntimeError:
try:
request.invoke_exception_view()
except RuntimeError as e:
self.assertEqual(e.args[0], "Unable to retrieve registry")
else: # pragma: no cover
self.fail()
finally:
manager.pop()
def tearDown(unhook_zca=True):
"""Undo the effects :func:`pyramid.testing.setUp`. Use this
function in the ``tearDown`` method of a unit test that uses
:func:`pyramid.testing.setUp` in its ``setUp`` method.
If the ``unhook_zca`` argument is ``True`` (the default), call
:func:`zope.component.getSiteManager.reset`. This undoes the
action of :func:`pyramid.testing.setUp` called with the
argument ``hook_zca=True``. If :mod:`zope.component` cannot be
imported, ignore the argument.
"""
global have_zca
if unhook_zca and have_zca:
try:
from zope.component import getSiteManager
getSiteManager.reset()
except ImportError: # pragma: no cover
have_zca = False
info = manager.pop()
manager.clear()
if info is not None:
registry = info['registry']
if hasattr(registry, '__init__') and hasattr(registry, '__name__'):
try:
registry.__init__(registry.__name__)
except TypeError:
# calling __init__ is largely for the benefit of
# people who want to use the global ZCA registry;
# however maybe somebody's using a registry we don't
# understand, let's not blow up
pass
def add_process_definitions(event):
app = event.object
registry = app.registry
settings = getattr(registry, 'settings', {})
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
root = app.root_factory(request)
request.root = root
# use same env variable as substanced catalog to determine
# if we want to recreate process definitions
autosync = asbool(
os.environ.get(
'SUBSTANCED_CATALOGS_AUTOSYNC',
settings.get(
'substanced.catalogs.autosync',
settings.get('substanced.autosync_catalogs', False) # bc
)))
def_container = root['process_definition_container']
if autosync:
for definition in def_container.definitions:
if hasattr(definition, '_broken_object'):
name = definition.__name__
def_container.remove(name, send_events=False)
def_container._definitions_value.remove(name)
for definition in processdef_container.DEFINITIONS.values():
old_def = def_container.get(definition.id, None)
if old_def is None:
def_container.add_definition(definition)
else:
if autosync:
def_container.delfromproperty('definitions', old_def)
def_container.add_definition(definition)
for definition in def_container.definitions:
for node in definition.nodes:
for context in getattr(node, 'contexts', []):
context.node_definition = node
if autosync:
processdef_container.DEFINITIONS.clear()
transaction.commit()
registry.notify(DatabaseOpenedWithRoot(root._p_jar.db()))
manager.pop()
def invoke_subrequest(self, request, use_tweens=False):
"""Obtain a response object from the Pyramid application based on
information in the ``request`` object provided. The ``request``
object must be an object that implements the Pyramid request
interface (such as a :class:`pyramid.request.Request` instance). If
``use_tweens`` is ``True``, the request will be sent to the
:term:`tween` in the tween stack closest to the request ingress. If
``use_tweens`` is ``False``, the request will be sent to the main
router handler, and no tweens will be invoked.
See the API for pyramid.request for complete documentation.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry':registry, 'request':request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
request.invoke_subrequest = self.invoke_subrequest
if use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if extensions is not None:
apply_request_extensions(request, extensions=extensions)
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def invoke_subrequest(self, request, use_tweens=False):
"""Obtain a response object from the Pyramid application based on
information in the ``request`` object provided. The ``request``
object must be an object that implements the Pyramid request
interface (such as a :class:`pyramid.request.Request` instance). If
``use_tweens`` is ``True``, the request will be sent to the
:term:`tween` in the tween stack closest to the request ingress. If
``use_tweens`` is ``False``, the request will be sent to the main
router handler, and no tweens will be invoked.
See the API for pyramid.request for complete documentation.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
request.invoke_subrequest = self.invoke_subrequest
if use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if extensions is not None:
request._set_extensions(extensions)
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def test_request_make_body_seekable_cleans_up_threadmanger_on_exception(config):
from pyramid.threadlocal import manager
# Clear defaults.
manager.pop()
assert len(manager.stack) == 0
app = config.make_wsgi_app()
app = webtest.TestApp(app)
with pytest.raises(Exception):
# Content-length=1 and empty body causes
# webob.request.DisconnectionError:
# The client disconnected while sending the body
# (1 more bytes were expected) when you call
# request.make_body_seekable().
app.get('/', headers={'Content-Length': '1'})
# len(manager.stack) == 1 when you don't catch exception
# from request.make_body_seekable() and clean up.
assert len(manager.stack) == 0
def test_activate_hook_cleans_up_threadmanager_on_generator_exit(config):
from pyramid.threadlocal import manager
# Clear defaults.
manager.pop()
assert len(manager.stack) == 0
def activate_hook(request):
raise GeneratorExit
config.add_settings({
'retry.attempts': 3,
'retry.activate_hook': activate_hook,
})
app = config.make_wsgi_app()
app = webtest.TestApp(app)
with pytest.raises(GeneratorExit):
app.get('/')
# len(manager.stack) == 1 when you don't catch GeneratorExit
# from activate_hook and clean up.
assert len(manager.stack) == 0
def execute(self, p_steps=None, request=None):
registry = self.registry
if request is None:
request_factory = registry.queryUtility(IRequestFactory,
default=Request)
request = request_factory.blank('/')
request.registry = registry
threadlocals = {'registry': registry, 'request': request}
threadlocal_manager.push(threadlocals)
steps = self.list_steps(p_steps)
log = logging.getLogger('ptah')
for step in steps:
log.info('Executing populate step: %s', step['name'])
step['factory'](registry)
transaction.commit()
threadlocal_manager.pop()
def execute(self, p_steps=None, request=None):
registry = self.registry
if request is None:
request_factory = registry.queryUtility(
IRequestFactory, default=Request)
request = request_factory.blank('/')
request.registry = registry
threadlocals = {'registry':registry, 'request':request}
threadlocal_manager.push(threadlocals)
steps = self.list_steps(p_steps)
log = logging.getLogger('ptah')
for step in steps:
log.info('Executing populate step: %s', step['name'])
step['factory'](registry)
transaction.commit()
threadlocal_manager.pop()
def add_services_definitions(event):
app = event.object
registry = app.registry
settings = getattr(registry, 'settings', {})
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
root = app.root_factory(request)
request.root = root
# use same env variable as substanced catalog to determine
# if we want to upgrade definitions
autosync = asbool(
os.environ.get(
'SUBSTANCED_CATALOGS_AUTOSYNC',
settings.get(
'substanced.catalogs.autosync',
settings.get('substanced.autosync_catalogs', False) # bc
)))
existing_definitions = root.get_services_definition()
if autosync:
for definition in existing_definitions.values():
if hasattr(definition, '_broken_object'):
root.delfromproperty('services_definition', definition)
for definition in core.SERVICES_DEFINITION.values():
old_def = existing_definitions.get(definition.service_id, None)
if old_def is None:
root.addtoproperty('services_definition', definition)
core.SERVICES_DEFINITION.clear()
# other init functions
init_site_folders(root)
init_contents(registry)
init_sites_social_login(root)
transaction.commit()
manager.pop()
def add_services_definitions(event):
app = event.object
registry = app.registry
settings = getattr(registry, 'settings', {})
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
root = app.root_factory(request)
request.root = root
# use same env variable as substanced catalog to determine
# if we want to upgrade definitions
autosync = asbool(
os.environ.get(
'SUBSTANCED_CATALOGS_AUTOSYNC',
settings.get(
'substanced.catalogs.autosync',
settings.get('substanced.autosync_catalogs', False) # bc
)))
existing_definitions = root.get_services_definition()
if autosync:
for definition in existing_definitions.values():
if hasattr(definition, '_broken_object'):
root.delfromproperty('services_definition', definition)
for definition in core.SERVICES_DEFINITION.values():
old_def = existing_definitions.get(definition.service_id, None)
if old_def is None:
root.addtoproperty('services_definition', definition)
core.SERVICES_DEFINITION.clear()
# other init functions
init_site_folders(root)
init_contents(registry)
init_sites_social_login(root)
transaction.commit()
manager.pop()
def invoke_request(self, request, _use_tweens=True):
"""
Execute a request through the request processing pipeline and
return the generated response.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
if _use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def tearDown(unhook_zca=True):
"""Undo the effects :func:`pyramid.testing.setUp`. Use this
function in the ``tearDown`` method of a unit test that uses
:func:`pyramid.testing.setUp` in its ``setUp`` method.
If the ``unhook_zca`` argument is ``True`` (the default), call
:func:`zope.component.getSiteManager.reset`. This undoes the
action of :func:`pyramid.testing.setUp` called with the
argument ``hook_zca=True``. If :mod:`zope.component` cannot be
imported, ignore the argument.
.. warning:: Although this method of tearing a test setup down
will never disappear, after :app:`Pyramid` 1.0,
using the ``begin`` and ``end`` methods of a
``Configurator`` are preferred to using
``pyramid.testing.setUp`` and
``pyramid.testing.tearDown``. See
:ref:`unittesting_chapter` for more information.
"""
if unhook_zca:
try:
from zope.component import getSiteManager
getSiteManager.reset()
except ImportError: # pragma: no cover
pass
info = manager.pop()
manager.clear()
if info is not None:
registry = info["registry"]
if hasattr(registry, "__init__") and hasattr(registry, "__name__"):
try:
registry.__init__(registry.__name__)
except TypeError:
# calling __init__ is largely for the benefit of
# people who want to use the global ZCA registry;
# however maybe somebody's using a registry we don't
# understand, let's not blow up
pass
_clearContext() # XXX why?
def invoke_exception_view(
self,
exc_info=None,
request=None,
secure=True,
reraise=False,
):
""" Executes an exception view related to the request it's called upon.
The arguments it takes are these:
``exc_info``
If provided, should be a 3-tuple in the form provided by
``sys.exc_info()``. If not provided,
``sys.exc_info()`` will be called to obtain the current
interpreter exception information. Default: ``None``.
``request``
If the request to be used is not the same one as the instance that
this method is called upon, it may be passed here. Default:
``None``.
``secure``
If the exception view should not be rendered if the current user
does not have the appropriate permission, this should be ``True``.
Default: ``True``.
``reraise``
A boolean indicating whether the original error should be reraised
if a :term:`response` object could not be created. If ``False``
then an :class:`pyramid.httpexceptions.HTTPNotFound`` exception
will be raised. Default: ``False``.
If a response is generated then ``request.exception`` and
``request.exc_info`` will be left at the values used to render the
response. Otherwise the previous values for ``request.exception`` and
``request.exc_info`` will be restored.
.. versionadded:: 1.7
.. versionchanged:: 1.9
The ``request.exception`` and ``request.exc_info`` properties will
reflect the exception used to render the response where previously
they were reset to the values prior to invoking the method.
Also added the ``reraise`` argument.
"""
if request is None:
request = self
registry = getattr(request, 'registry', None)
if registry is None:
registry = get_current_registry()
if registry is None:
raise RuntimeError("Unable to retrieve registry")
if exc_info is None:
exc_info = sys.exc_info()
exc = exc_info[1]
attrs = request.__dict__
context_iface = providedBy(exc)
# clear old generated request.response, if any; it may
# have been mutated by the view, and its state is not
# sane (e.g. caching headers)
with hide_attrs(request, 'response', 'exc_info', 'exception'):
attrs['exception'] = exc
attrs['exc_info'] = exc_info
# we use .get instead of .__getitem__ below due to
# https://github.com/Pylons/pyramid/issues/700
request_iface = attrs.get('request_iface', IRequest)
manager.push({'request': request, 'registry': registry})
try:
response = _call_view(
registry,
request,
exc,
context_iface,
'',
view_types=None,
view_classifier=IExceptionViewClassifier,
secure=secure,
request_iface=request_iface.combined,
)
except:
if reraise:
reraise_(*exc_info)
raise
finally:
manager.pop()
if response is None:
if reraise:
reraise_(*exc_info)
raise HTTPNotFound
# successful response, overwrite exception/exc_info
attrs['exception'] = exc
attrs['exc_info'] = exc_info
return response
def fin():
# The request was not called
manager.pop()
def add_process_definitions(event):
app = event.object
registry = app.registry
settings = getattr(registry, 'settings', {})
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
root = app.root_factory(request)
request.root = root
# use same env variable as substanced catalog to determine
# if we want to recreate process definitions.
# autosync is True only in development mode.
autosync = asbool(
os.environ.get(
'SUBSTANCED_CATALOGS_AUTOSYNC',
settings.get(
'substanced.catalogs.autosync',
settings.get('substanced.autosync_catalogs', False) # bc
)))
try:
# This code block must be in sync with what we do in
# process_definitions_evolve minus the autosync conditions
def_container = root['process_definition_container']
if autosync:
for definition in def_container.definitions:
if hasattr(definition, '_broken_object'):
name = definition.__name__
def_container.remove(name, send_events=False)
def_container._definitions_value.remove(name)
for definition in processdef_container.DEFINITIONS.values():
old_def = def_container.get(definition.id, None)
if old_def is None:
# We add the definition at startup when creating the application
# the first time where we normally have one worker.
# If we have more that one worker, the other workers will do
# a ConflictError here.
if getattr(def_container, '_initializing', False) or autosync:
def_container.add_definition(definition)
else:
if autosync:
def_container.delfromproperty('definitions', old_def)
def_container.add_definition(definition)
if autosync:
# if not autosync, we still need this global constant for the
# process_definitions_evolve step
processdef_container.DEFINITIONS.clear()
if getattr(def_container, '_initializing', False):
del def_container._initializing
transaction.commit()
except ConflictError:
# The first worker did the changes, simply abort to get the changes.
transaction.abort()
# After the restart of the application, we always need to resync
# the node_definition attributes to be the node definition instances
# currently in ZODB.
for definition in def_container.definitions:
for node in definition.nodes:
for context in getattr(node, 'contexts', []):
# context here is a class, we set the class attribute
# node_definition to the current node definition in ZODB
context.node_definition = node
registry.notify(DatabaseOpenedWithRoot(root._p_jar.db()))
manager.pop()
def closer():
threadlocal_manager.pop()
def fin():
# The request was not called
manager.pop()
def get_response(self, app, catch_exc_info=True):
try:
super(PyramidWebTestRequest,
app).get_response(catch_exc_info=catch_exc_info)
finally:
manager.pop()
def add_process_definitions(event):
app = event.object
registry = app.registry
settings = getattr(registry, 'settings', {})
request = Request.blank('/application_created') # path is meaningless
request.registry = registry
manager.push({'registry': registry, 'request': request})
root = app.root_factory(request)
request.root = root
# use same env variable as substanced catalog to determine
# if we want to recreate process definitions.
# autosync is True only in development mode.
autosync = asbool(
os.environ.get(
'SUBSTANCED_CATALOGS_AUTOSYNC',
settings.get(
'substanced.catalogs.autosync',
settings.get('substanced.autosync_catalogs', False) # bc
)))
try:
# This code block must be in sync with what we do in
# process_definitions_evolve minus the autosync conditions
def_container = root['process_definition_container']
if autosync:
for definition in def_container.definitions:
if hasattr(definition, '_broken_object'):
name = definition.__name__
def_container.remove(name, send_events=False)
def_container._definitions_value.remove(name)
for definition in processdef_container.DEFINITIONS.values():
old_def = def_container.get(definition.id, None)
if old_def is None:
# We add the definition at startup when creating the application
# the first time where we normally have one worker.
# If we have more that one worker, the other workers will do
# a ConflictError here.
if getattr(def_container, '_initializing', False) or autosync:
def_container.add_definition(definition)
else:
if autosync:
def_container.delfromproperty('definitions', old_def)
def_container.add_definition(definition)
if autosync:
# if not autosync, we still need this global constant for the
# process_definitions_evolve step
processdef_container.DEFINITIONS.clear()
if getattr(def_container, '_initializing', False):
del def_container._initializing
transaction.commit()
except ConflictError:
# The first worker did the changes, simply abort to get the changes.
transaction.abort()
# After the restart of the application, we always need to resync
# the node_definition attributes to be the node definition instances
# currently in ZODB.
for definition in def_container.definitions:
for node in definition.nodes:
for context in getattr(node, 'contexts', []):
# context here is a class, we set the class attribute
# node_definition to the current node definition in ZODB
context.node_definition = node
registry.notify(DatabaseOpenedWithRoot(root._p_jar.db()))
manager.pop()
def tearDown(self, app):
manager.pop()
app._p_jar.close()
def invoke_exception_view(
self, exc_info=None, request=None, secure=True, reraise=False
):
""" Executes an exception view related to the request it's called upon.
The arguments it takes are these:
``exc_info``
If provided, should be a 3-tuple in the form provided by
``sys.exc_info()``. If not provided,
``sys.exc_info()`` will be called to obtain the current
interpreter exception information. Default: ``None``.
``request``
If the request to be used is not the same one as the instance that
this method is called upon, it may be passed here. Default:
``None``.
``secure``
If the exception view should not be rendered if the current user
does not have the appropriate permission, this should be ``True``.
Default: ``True``.
``reraise``
A boolean indicating whether the original error should be reraised
if a :term:`response` object could not be created. If ``False``
then an :class:`pyramid.httpexceptions.HTTPNotFound`` exception
will be raised. Default: ``False``.
If a response is generated then ``request.exception`` and
``request.exc_info`` will be left at the values used to render the
response. Otherwise the previous values for ``request.exception`` and
``request.exc_info`` will be restored.
.. versionadded:: 1.7
.. versionchanged:: 1.9
The ``request.exception`` and ``request.exc_info`` properties will
reflect the exception used to render the response where previously
they were reset to the values prior to invoking the method.
Also added the ``reraise`` argument.
"""
if request is None:
request = self
registry = getattr(request, 'registry', None)
if registry is None:
registry = get_current_registry()
if registry is None:
raise RuntimeError("Unable to retrieve registry")
if exc_info is None:
exc_info = sys.exc_info()
exc = exc_info[1]
attrs = request.__dict__
context_iface = providedBy(exc)
# clear old generated request.response, if any; it may
# have been mutated by the view, and its state is not
# sane (e.g. caching headers)
with hide_attrs(request, 'response', 'exc_info', 'exception'):
attrs['exception'] = exc
attrs['exc_info'] = exc_info
# we use .get instead of .__getitem__ below due to
# https://github.com/Pylons/pyramid/issues/700
request_iface = attrs.get('request_iface', IRequest)
manager.push({'request': request, 'registry': registry})
try:
response = _call_view(
registry,
request,
exc,
context_iface,
'',
view_types=None,
view_classifier=IExceptionViewClassifier,
secure=secure,
request_iface=request_iface.combined,
)
except Exception:
if reraise:
reraise_(*exc_info)
raise
finally:
manager.pop()
if response is None:
if reraise:
reraise_(*exc_info)
raise HTTPNotFound
# successful response, overwrite exception/exc_info
attrs['exception'] = exc
attrs['exc_info'] = exc_info
return response
def invoke_subrequest(self, request, use_tweens=False):
"""
Obtain a response object from the Pyramid application based on
information in the ``request`` object provided. The ``request``
object must be an object that implements the Pyramid request
interface (such as a :class:`pyramid.request.Request` instance). If
``use_tweens`` is ``True``, the request will be sent to the
:term:`tween` in the tween stack closest to the request ingress. If
``use_tweens`` is ``False``, the request will be sent to the main
router handler, and no tweens will be invoked. This function also:
- manages the threadlocal stack (so that
:func:`~pyramid.threadlocal.get_current_request` and
:func:`~pyramid.threadlocal.get_current_registry` work during a
request)
- Adds a ``registry`` attribute and a ``invoke_subrequest`` attribute
(a callable) to the request object it's handed.
- sets request extensions (such as those added via
:meth:`~pyramid.config.Configurator.add_request_method` or
:meth:`~pyramid.config.Configurator.set_request_property`) on the
request it's passed.
- causes a :class:`~pyramid.event.NewRequest` event to be sent at the
beginning of request processing.
- causes a :class:`~pyramid.event.ContextFound` event to be sent
when a context resource is found.
- causes a :class:`~pyramid.event.NewResponse` event to be sent when
the Pyramid application returns a response.
- Calls any :term:`response callback` functions defined within the
request's lifetime if a response is obtained from the Pyramid
application.
- Calls any :term:`finished callback` functions defined within the
request's lifetime.
See also :ref:`subrequest_chapter`.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry':registry, 'request':request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
request.invoke_subrequest = self.invoke_subrequest
if use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if extensions is not None:
request._set_extensions(extensions)
response = handle_request(request)
has_listeners and notify(NewResponse(request, response))
if request.response_callbacks:
request._process_response_callbacks(response)
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def threadlocals(request, dummy_request, registry):
from pyramid.threadlocal import manager
manager.push({'request': dummy_request, 'registry': registry})
yield dummy_request
manager.pop()
def clear_manager(signum=None, frame=None):
manager.pop()
msg = why[0]
except:
msg = ''
# repoze.bfg.message docs-deprecated in Pyramid 1.0
environ['repoze.bfg.message'] = msg
result = view_callable(why, request)
# process the response
response = registry.queryAdapterOrSelf(result, IResponse)
if response is None:
raise ValueError(
'Could not convert view return value "%s" into a '
'response object' % (result,))
has_listeners and registry.notify(NewResponse(request,response))
if request.response_callbacks:
request._process_response_callbacks(response)
finally:
if request is not None and request.finished_callbacks:
request._process_finished_callbacks()
return response(request.environ, start_response)
finally:
manager.pop()
def fin():
print "finalizer test_webrequest"
# The request was not called
manager.pop()
def fin():
print("finalizer test_webrequest")
# The request was not called
manager.pop()
def tearDown(self, app):
manager.pop()
app._p_jar.close()
def invoke_subrequest(self, request, use_tweens=False):
"""
Obtain a response object from the Pyramid application based on
information in the ``request`` object provided. The ``request``
object must be an object that implements the Pyramid request
interface (such as a :class:`pyramid.request.Request` instance). If
``use_tweens`` is ``True``, the request will be sent to the
:term:`tween` in the tween stack closest to the request ingress. If
``use_tweens`` is ``False``, the request will be sent to the main
router handler, and no tweens will be invoked. This function also:
- manages the threadlocal stack (so that
:func:`~pyramid.threadlocal.get_current_request` and
:func:`~pyramid.threadlocal.get_current_registry` work during a
request)
- Adds a ``registry`` attribute and a ``invoke_subrequest`` attribute
(a callable) to the request object it's handed.
- sets request extensions (such as those added via
:meth:`~pyramid.config.Configurator.add_request_method` or
:meth:`~pyramid.config.Configurator.set_request_property`) on the
request it's passed.
- causes a :class:`~pyramid.event.NewRequest` event to be sent at the
beginning of request processing.
- causes a :class:`~pyramid.event.ContextFound` event to be sent
when a context resource is found.
- Calls any :term:`response callback` functions defined within the
request's lifetime if a response is obtained from the Pyramid
application.
- causes a :class:`~pyramid.event.NewResponse` event to be sent if a
response is obtained.
- Calls any :term:`finished callback` functions defined within the
request's lifetime.
See also :ref:`subrequest_chapter`.
"""
registry = self.registry
has_listeners = self.registry.has_listeners
notify = self.registry.notify
threadlocals = {'registry': registry, 'request': request}
manager = self.threadlocal_manager
manager.push(threadlocals)
request.registry = registry
request.invoke_subrequest = self.invoke_subrequest
if use_tweens:
handle_request = self.handle_request
else:
handle_request = self.orig_handle_request
try:
try:
extensions = self.request_extensions
if extensions is not None:
request._set_extensions(extensions)
response = handle_request(request)
if request.response_callbacks:
request._process_response_callbacks(response)
has_listeners and notify(NewResponse(request, response))
return response
finally:
if request.finished_callbacks:
request._process_finished_callbacks()
finally:
manager.pop()
def closer():
threadlocal_manager.pop()
environ['repoze.bfg.message'] = msg
response = view_callable(why, request)
# process the response
has_listeners and registry.notify(
NewResponse(request, response))
if request.response_callbacks:
request._process_response_callbacks(response)
try:
headers = response.headerlist
app_iter = response.app_iter
status = response.status
except AttributeError:
raise ValueError(
'Non-response object returned from view named %s '
'(and no renderer): %r' % (view_name, response))
finally:
if request is not None and request.finished_callbacks:
request._process_finished_callbacks()
start_response(status, headers)
return app_iter
finally:
manager.pop()
def get_response(self, app, catch_exc_info=True):
try:
super(PyramidWebTestRequest, app).get_response(
catch_exc_info=catch_exc_info)
finally:
manager.pop()
def postrun_end_request(sender, task, kwargs={}, **kw):
logger.debug('signal postrun for %r' % task)
request = kwargs.get('request', None)
if request and request.finished_callbacks:
request._process_finished_callbacks()
threadlocal_manager.pop()
def get_exported_file_by_func(func,
discussion,
lang='fr',
anon='false',
social_columns=True,
start=None,
end=None,
interval=None):
"""
Helper function to get a specific export a file to be downloaded. Downloaded into the S3 bucket.
To be used within a shell environment
"""
import boto3
from datetime import datetime
from pyramid.threadlocal import manager
from assembl.lib.config import get
class FakeContext(object):
def __init__(self, discussion):
self._instance = discussion
class FakeLocalizer(object):
def translate(self, message):
return message
class FakeRequest(object):
authenticated_userid = None
def __init__(self, discussion, lang='fr'):
self.discussion = discussion
self.GET = {}
self.context = FakeContext(discussion)
self.localizer = FakeLocalizer()
self.locale_name = lang
self.matchdict = {'discussion_id': discussion.id}
r = FakeRequest(discussion, lang=lang)
manager.push({'request': r})
r.GET['as_buffer'] = 'true'
r.GET['lang'] = lang
r.GET['anon'] = anon
if not social_columns:
r.GET['no_extra_columns'] = 'true'
if start:
r.GET['start'] = start
if end:
r.GET['end'] = end
if interval:
r.GET['interval'] = interval
try:
output, mime_type = func(r)
finally:
manager.pop()
account_number = get('aws_client', None)
_now = datetime.utcnow()
func_name = func.__name__
name = "%s-%s" % (func_name, _now.isoformat())
def write(o):
with open(name, mode='w') as f:
f.write(o)
if account_number:
try:
s3 = boto3.resource('s3')
bucket = s3.Bucket('assembl-data-%s' % account_number.strip())
bucket.put_object(Body=output, ContentType=mime_type, Key=name)
print("The file was uploaded as %s" % name)
except Exception:
write(output)
print("Failed to upload, creating file locally with name %s" %
name)
else:
write(output)
print(
"The account number could not be found. Saving the file to disk as %s"
% name)
def threadlocals(request, dummy_request, registry):
from pyramid.threadlocal import manager
manager.push({'request': dummy_request, 'registry': registry})
yield dummy_request
manager.pop()
def run(self):
logger.debug("Started thread worker.")
tasks = GetQueue("tasks")
results = GetQueue("results", query=True)
manager_pop = 0
while True:
self.waiting = True
self.task = None
# logger.debug("waiting for a task.")
wrk = getUtility(IWorker, name="queue")
if logger.isEnabledFor(logging.DEBUG):
logger.debug(
"Queue %s has %d tasks. Workers occupied: %d; free:%d"
% (tasks, tasks.qsize(), wrk.processing(), wrk.waiting())
)
logger.debug("Singleton tasks: {}".format(tasks.singletons))
logger.debug("Active Tasks:{}".format(wrk.tasks()))
del wrk
self.task = task = tasks.get()
task.locks = []
# Setup a context (request and registry)
for _ in range(manager_pop):
manager.pop()
manager_pop = 0
print(
"""
1: {}
""".format(
task.context_thread_data
)
)
if task.context_thread_data:
print(
"""
2: {}
""".format(
task.context_thread_data
)
)
manager.push(task.context_thread_data)
manager_pop += 1
self.waiting = False
logger.info("got a task %s" % task)
if ITerminationTask.providedBy(task):
task_done()
logger.info("finished task %s" % task)
return
task.phase = "prepare"
try:
task.prepare()
except BaseException as e:
# traceback.print_exception(type, value, err.__traceback__)
f = io.StringIO()
traceback.print_exc(file=f)
logger.error(f.getvalue())
logger.error("{!r}; cancelling main task run.".format(e))
task.task_done()
logger.info("finished task %s (exception)" % task)
self.release_locks(task)
continue
task.phase = "run"
try:
rc = task.run()
except BaseException as e:
f = io.StringIO()
traceback.print_exc(file=f)
logger.error(f.getvalue())
logger.error("{!r}; some code did not run correctly, proceed with finalization.".format(e))
rc = None
self.release_locks(task)
if rc != None and results != None:
task.result = rc
results.put(task)
task.phase = "finalize"
try:
task.finalize()
except BaseException as e:
f = io.StringIO()
traceback.print_exc(file=f)
logger.error(f.getvalue())
logger.error("{!r}; finalization failde try next task.".format(e))
self.release_locks(task)
task.phase = None
tasks.task_done()
logger.info("finished task %s (complete)" % task)