def begin(self): # Add test apps to import path sys.path.append( os.path.join(os.path.dirname(os.path.dirname(__file__)), 'tests', 'apps')) if self.val_disable: return # import here so we can avoid test coverage issues from blazeweb.events import signal from blazeweb.globals import ag, settings from blazeweb.hierarchy import findobj from blazeweb.scripting import load_current_app, UsageError try: _, _, _, wsgiapp = load_current_app(self.val_app_name, self.val_app_profile) # make the app available to the tests ag.wsgi_test_app = wsgiapp # an application can define functions to be called after the app # is initialized but before any test inspection is done or tests # are ran. We call those functions here: for callstring in tolist(settings.testing.init_callables): tocall = findobj(callstring) tocall() # we also support events for pre-test setup signal('blazeweb.pre_test_init').send() except UsageError: if self.val_debug: raise self.val_disable = True
def wsgi_app(self, environ, start_response): log.debug('request received for URL: %s', environ['PATH_INFO']) with self.request_manager(environ): signal('blazeweb.request.started').send() try: try: endpoint, args = rg.urladapter.match() except HTTPException as e: log.debug('routing HTTP exception %s from %s', e, rg.request.url) raise log.debug('wsgi_app processing %s (%s)', endpoint, args) response = self.response_cycle(endpoint, args) except _Redirect as e: response = e.response except HTTPException as e: if not self.settings.http_exception_handling: raise response = self.handle_http_exception(e) except Exception as e: response = self.handle_exception(e) # todo: I wonder if this signal send should be called even in the # case of an exception by putting in a finally block signal('blazeweb.request.ended').send(response=response) return response(environ, start_response)
def begin(self): # Add test apps to import path sys.path.append(os.path.join(os.path.dirname(os.path.dirname(__file__)), 'tests', 'apps')) if self.val_disable: return # import here so we can avoid test coverage issues from blazeweb.events import signal from blazeweb.globals import ag, settings from blazeweb.hierarchy import findobj from blazeweb.scripting import load_current_app, UsageError try: _, _, _, wsgiapp = load_current_app(self.val_app_name, self.val_app_profile) # make the app available to the tests ag.wsgi_test_app = wsgiapp # an application can define functions to be called after the app # is initialized but before any test inspection is done or tests # are ran. We call those functions here: for callstring in tolist(settings.testing.init_callables): tocall = findobj(callstring) tocall() # we also support events for pre-test setup signal('blazeweb.pre_test_init').send() except UsageError: if self.val_debug: raise self.val_disable = True
def response_cycle(self, endpoint, args, error_doc_code=None): rg.forward_queue = [(endpoint, args)] while True: with self.response_context(error_doc_code): endpoint, args = rg.forward_queue[-1] signal('blazeweb.response_cycle.started').send(endpoint=endpoint, urlargs=args) response = self.dispatch_to_endpoint(endpoint, args) signal('blazeweb.response_cycle.ended').send(response=response) return response
def response_cycle(self, endpoint, args, error_doc_code=None): rg.forward_queue = [(endpoint, args)] while True: with self.response_context(error_doc_code): endpoint, args = rg.forward_queue[-1] signal('blazeweb.response_cycle.started').send( endpoint=endpoint, urlargs=args) response = self.dispatch_to_endpoint(endpoint, args) signal('blazeweb.response_cycle.ended').send(response=response) return response
def init_auto_actions(self): # create the writeable directories if they don't exist already if self.settings.auto_create_writeable_dirs: mkdirs(self.settings.dirs.data) mkdirs(self.settings.dirs.logs) mkdirs(self.settings.dirs.tmp) # copy static files if requested if self.settings.auto_copy_static.enabled: copy_static_files(self.settings.auto_copy_static.delete_existing) if self.settings.auto_abort_as_builtin is True: six.moves.builtins.dabort = abort signal('blazeweb.auto_actions.initialized').connect(clear_old_beaker_sessions) signal('blazeweb.auto_actions.initialized').send(self.init_auto_actions)
def init_auto_actions(self): # create the writeable directories if they don't exist already if self.settings.auto_create_writeable_dirs: mkdirs(self.settings.dirs.data) mkdirs(self.settings.dirs.logs) mkdirs(self.settings.dirs.tmp) # copy static files if requested if self.settings.auto_copy_static.enabled: copy_static_files(self.settings.auto_copy_static.delete_existing) if self.settings.auto_abort_as_builtin is True: six.moves.builtins.dabort = abort signal('blazeweb.auto_actions.initialized').connect( clear_old_beaker_sessions) signal('blazeweb.auto_actions.initialized').send( self.init_auto_actions)
def pytest_configure(config): from blazeutils import tolist from blazeweb.events import signal from blazeweb.globals import ag, settings from blazeweb.hierarchy import findobj from blazeweb.scripting import load_current_app _, _, _, wsgiapp = load_current_app(config.getoption('blazeweb_package'), config.getoption('blazeweb_profile')) # make the app available to the tests ag.wsgi_test_app = wsgiapp # an application can define functions to be called after the app # is initialized but before any test inspection is done or tests # are ran. We call those functions here: for callstring in tolist(settings.testing.init_callables): tocall = findobj(callstring) tocall() # we also support events for pre-test setup signal('blazeweb.pre_test_init').send()
def setup_class(cls): # these lines necessary because we are sharing test space with a Flask # app built with FlaskSQLAlchemy. That lib places listeners on the # session class but expects its own code will run to set up a session SASession._model_changes = mock.Mock() SASession.app = mock.Mock() _, _, _, wsgiapp = load_current_app('webgrid_blazeweb_ta', 'Test') # make the app available to the tests ag.wsgi_test_app = wsgiapp # an application can define functions to be called after the app # is initialized but before any test inspection is done or tests # are ran. We call those functions here: for callstring in tolist(settings.testing.init_callables): tocall = findobj(callstring) tocall() # we also support events for pre-test setup signal('blazeweb.pre_test_init').send() cls.ta = TestApp(ag.wsgi_test_app)
from blazeweb.events import signal from blazeweb.globals import user from blazeweb.views import forward def check_reset_required(sender, endpoint, urlargs): skip_endpoints = ['auth:ChangePassword', 'auth:Logout'] if user.is_authenticated and user.reset_required and endpoint not in skip_endpoints: forward('auth:ChangePassword') signal('blazeweb.response_cycle.started').connect(check_reset_required)
def init_signals(self): # signals are weakly referenced, so we need to keep a reference as long # as this application is instantiated self.signals = ( signal('blazeweb.pre_test_init'), signal('blazeweb.events.initialized'), signal('blazeweb.settings.initialized'), signal('blazeweb.auto_actions.initialized'), signal('blazeweb.logging.initialized'), signal('blazeweb.routing.initialized'), signal('blazeweb.templating.initialized'), signal('blazeweb.request.started'), signal('blazeweb.response_cycle.started'), signal('blazeweb.response_cycle.ended'), signal('blazeweb.request.ended'), )
def init_logging(self): create_handlers_from_settings(self.settings) signal('blazeweb.logging.initialized').send(self.init_logging)
def init_events(self): visitmods('events') signal('blazeweb.events.initialized').send(self.init_events)
def init_events(self): global called visitmods('events') called = signal('blazeweb.events.initialized').send(self.init_events)
from blazeweb.events import signal from blazeweb.globals import settings from blazeweb.tasks import run_tasks def setup_db_structure(sender): if settings.components.sqlalchemy.pre_test_init_tasks: run_tasks(settings.components.sqlalchemy.pre_test_init_tasks) signal('blazeweb.pre_test_init').connect(setup_db_structure) def clear_old_beaker_sessions(sender): # clear up old beaker sessions, if needed if ( settings.beaker.enabled and settings.beaker.auto_clear_sessions and settings.beaker.type == 'ext:database' ): import datetime as dt import sqlalchemy as sa table_name = getattr(settings.beaker, 'table_name', 'beaker_cache') try: sessions_table = sa.Table( table_name, sa.MetaData(settings.beaker.url), autoload=True ) sessions_table.delete( sessions_table.c.accessed < (
from blazeweb.globals import rg from blazeweb.events import signal from blazeweb.utils import redirect from blazeweb.views import forward def fire_after_event_init(sender): return 'newlayout' signal('blazeweb.events.initialized').connect(fire_after_event_init) def modify_response(sender, response=None): if 'eventtest' in rg.request.url: response.data = response.data + b'newlayout' signal('blazeweb.response_cycle.ended').connect(modify_response) def send_to_index(sender, endpoint, urlargs): """ simulating hijacking the request and forcing it to go to another view. This minicks what you would want to do if a user need to change a password, was locked out, or any number of things that might cause you to want to send them to a different location than the one they are requesting. """ if 'request-hijack/forward' in rg.request.url: # we have to have a flag that says we have already forwarded, otherwise # we will get a forward loop since the request isn't modified # when we forward if getattr(rg, 'newlayout_events_send_to_index', None): return rg.newlayout_events_send_to_index = True