def add_route(self, action): """ Utility to add routes to actions contained in our controller """ plugin.run_hook("on_add_route", "*", "%s%s" % (self.path, action), "gyro.builtins.account.account.Account.%s" % (action, ))
def on_loaded(self): """ Attach our routes and templates """ plugin.run_hook("on_add_template_prefix", self.template_prefix, self.template_location) self.add_route("login") self.add_route("logout") self.add_route("forgot") self.add_route("reset")
def on_first_request(self, request): self.had_first_request = True if config.development: if self.smart_reload: plugin.load_second_plugins() self.start_monitoring() self.template_prefix = "gyro.development" self.template_location = os.path.join(self.location, "templates") j = plugin.find_plugin_instance("jinja.JinjaEngine") plugin.run_hook("on_add_template_prefix", self.template_prefix, self.template_location)
def on_route_not_found(self, request): routes = yield plugin.run_hook("on_list_routes") ctx = { "path" : request.path, "routes" : routes, } t = yield plugin.run_hook("on_render_jinja2_template", request, "gyro.development/404.html", ctx) request.set_response_code(404) request.set_header("content-type", "text/html") request.write(t.encode("utf-8")) request.finish() defer.returnValue(request)
def on_before_render(self, request): """ Load our session before rendering a request """ cookie_name = request.get_action_parameter("session_cookie_name", "gyro-session-uuid") uuid = request.get_cookie(cookie_name) session = None if uuid: session = self.storage.get_session(uuid) else: uuid = generate_uuid() request.session_uuid = uuid if session is not None: request.session = session else: def set_session(r): if not r: r = {} request.session = r return plugin.run_hook("on_new_session", request).add_callback( set_session)
def on_error_rendering(self, request, f): frames = f.stack[-5:] + f.frames traceback = [] for fn, filename, line_no, loc, glob in frames: traceback.append({ "fn" : fn, "filename" : filename, "line_no" : line_no, "preview" : get_code_preview(filename, line_no) }) ctx = { "failure" : f, "traceback" : traceback, "error" : "%s.%s : %s" % (f.type.__module__, f.type.__name__, f.value) } t = yield plugin.run_hook("on_render_jinja2_template", request, "gyro.development/500.html", ctx) if not t: #Our 500 page didn't get rendered log.msg("Error rendering 500 template") t = "<html><body><pre>%s</pre></body></html>" % (f.getTraceback(), ) request.set_response_code(500) request.set_header("content-type", "text/html") request.write(t.encode("utf-8")) request.finish() defer.returnValue(request)
def test_temporary_hook(self): def temp(p, arg): return 'temp' + arg plugin.add_hook("on_temp", temp) r = yield plugin.run_hook("on_temp", "result") self.assertEquals(r, "tempresult")
def cb_action(result): request.set_header('content-length', str(len(result))) def _write(r): request.write(result) return True return plugin.run_hook("on_after_render", request ).add_callback(_write)
def test_deferred_hooks(self): """ Test that our plugins can return deferreds as part of their hooks and that we run the plugin chain correctly based on the result of these deferreds """ core.load("gyro.impl.twisted.core.TwistedCore") class FirstPlugin(plugin.Plugin): priority = 0 def on_first(self, arg): return core.defer_later(0.01, lambda: "first" + arg) def on_second(self, arg): return core.defer_later(0.01, lambda: None) class SecondPlugin(plugin.Plugin): priority = 0 def on_first(self, arg): raise AssertionError("Should not be called") def on_second(self, arg): return core.defer_later(0.01, lambda: "second" + arg) plugin.enable_plugin("FirstPlugin") plugin.enable_plugin("SecondPlugin") self.assertEquals(len(plugin.get_active_plugins()), 2) r = yield plugin.run_hook("on_first", "result") self.assertEquals(r, "firstresult") r = yield plugin.run_hook("on_second", "result") self.assertEquals(r, "secondresult")
def serve(self, request): print 'serve static', request.kw attempts = [ os.path.join(config.app_path, request.kw["directory"], request.kw["filename"]), os.path.join(request.kw["directory"], request.kw["filename"]), os.path.join(os.path.dirname(gyro.__file__), "builtins", request.kw["directory"], request.kw["filename"]), ] for attempt in attempts: if os.path.exists(attempt): return core.server.serve_static(request, attempt) return plugin.run_hook("on_route_not_found", request)
def render(self, request, context, template=None): """ Render a page using the default templating engine given the context and template """ cls = request.action.im_class if not template: template = "%s.html" % (request.action.im_func.func_name) prefix = getattr(self, "template_prefix", None) if prefix: template = "%s/%s" % (prefix, template) r = getattr(self, "template_hook", "on_render_template") return plugin.run_hook(r, request, template, context)
def _eb_process(f): print f try: return plugin.run_hook("on_error_rendering", request, f).add_callback(_finish) except: log.err(f)
def authenticate(username, password, remember=False): """ Authenticate/log in a user based on the given information """ return plugin.run_hook("on_authenticate", username, password, remember)
def test_run_hooks(self): """ Check that we execute hooks correctly according to priority and that the execution chain is correct based on return result. Note that this only tests synchronous hooks """ core.load("gyro.impl.twisted.core.TwistedCore") class HighPriorityPlugin(plugin.Plugin): priority = 0 def on_high(self, arg): return "high" + arg def on_medium(self, arg): return None def on_low(self, arg): return None class MediumPriorityPlugin(plugin.Plugin): priority = 50 def on_high(self, arg): return "medium" + arg def on_medium(self, arg): return "medium" + arg def on_low(self, arg): return None class LowerPriorityPlugin(plugin.Plugin): priority = 100 def on_high(self, arg): return "low" + arg def on_medium(self, arg): return "low" + arg def on_low(self, arg): return "low" + arg self.failUnless(HighPriorityPlugin in plugin.Plugin.get_plugins()) self.failUnless(MediumPriorityPlugin in plugin.Plugin.get_plugins()) self.failUnless(LowerPriorityPlugin in plugin.Plugin.get_plugins()) plugin.enable_plugin("HighPriorityPlugin") plugin.enable_plugin("MediumPriorityPlugin") plugin.enable_plugin("LowerPriorityPlugin") self.assertEquals(len(plugin.get_active_plugins()), 3) r = yield plugin.run_hook("on_high", "result") self.assertEquals(r, "highresult") r = yield plugin.run_hook("on_medium", "result") self.assertEquals(r, "mediumresult") r = yield plugin.run_hook("on_low", "result") self.assertEquals(r, "lowresult") plugin.disable_plugin("HighPriorityPlugin") r = yield plugin.run_hook("on_high", "result") self.assertEquals(r, "mediumresult")
def _process(): if self.first_request: self.first_request = False return plugin.run_hook("on_first_request", request).add_callback(_new) return _new()
def _new(result=None): return plugin.run_hook("on_new_request", request).add_callback(_route)
def _route(result): return plugin.run_hook("on_route_request", request).add_callback(_routed)
def _routed(action): if not action: return plugin.run_hook("on_route_not_found", request) request.action = action return plugin.run_hook("on_before_render", request).add_callback(_render)
def _render(result): renderer = getattr(request.action.im_class, "renderer", "on_render_request") return plugin.run_hook(renderer, request).add_callback(_after)
def on_loaded(self): plugin.run_hook("on_add_route", "*", self.path, self.get_action("index")) plugin.run_hook("on_add_template_prefix", self.template_prefix, self.template_location)
def _after(result): return plugin.run_hook("on_finished_request", request).add_callback(_finish)