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)
