def get_view(self, request, endpoint, values):
emit_event("view-dispatch", endpoint, values)
view = self._find_view(endpoint)
if view:
return view(request, **values)
else:
raise NotFound()
def _get_controller_view(self, controller, target):
"""Get the view function from the controller instance specified by the
full target string."""
if hasattr(controller, target):
emit_event('controller-match', controller, target)
view = getattr(controller, target)
return self._get_controller_before_wrapper(controller, view)
def find_view(self, endpoint):
"""Finds a view, not a controller based on the endpoint."""
view = self.views.get(endpoint, None)
if hasattr(view, '__call__'):
emit_event('view-match', view)
return view
return None
def _handle_request_fatal(self, request, error):
"""Called on the request-fatal event, indicating a fatal error occured
while processing the current view."""
self._log_fatal(request, error)
view = self._find_view_for_code(500)
# In debug mode, we always prefer the original traceback.
if view and not self.app.cfg['general/debug']:
emit_event('error-match', error, view)
error['response'] = view(request)
def _handle_request_error(self, request, error):
"""Called by the request-error event."""
self._log_error(request, error)
view = self._find_view_for_code(error.code)
if view:
emit_event('error-match', error, view)
data = view(request).data
# FIXME: This way sucks hard!
error.get_body = lambda environ: data
def cursor_execute(self, execute, cursor, statement, parameters,
context, executemany):
emit_event('before-cursor-executed', cursor=self, statement=statement,
parameters=parameters)
start = _timer()
try:
return execute(cursor, statement, parameters, context)
finally:
emit_event('after-cursor-executed',
cursor=self,
statement=statement,
parameters=parameters,
time=_timer() - start)
def setup_repozecatalog(app, default_dbpath='repozecatalog.db',
default_dbname='catalog'):
"""Set up full text searching with repoze.catalog"""
# if its not an absolute path, make it relative to the instance dir
if not os.path.isabs(default_dbpath):
default_dbpath = os.path.join(app.instance_dir, default_dbpath)
app.add_config_var(DBPATH_CONF, str, default_dbpath)
app.add_config_var(DBNAME_CONF, str, default_dbname)
manager = ConnectionManager()
catalog_factory = FileStorageCatalogFactory(
app.cfg[DBPATH_CONF], app.cfg[DBNAME_CONF])
catalog = catalog_factory()
app.repozecatalog = catalog
manager.commit()
emit_event('repozecatalog-installed', catalog)
def _get_controller_before_wrapper(self, controller, view):
"""Looks for a __before__ method in controller and creates a wrapper
around it if one is found. This causes __before__ to be called prior
to the actual view method. If not found, ``view`` is returned."""
before = getattr(controller, '__before__', None)
if before:
emit_event('before-match', controller, before, view)
def _wrap(before, view):
@wraps(view)
def _inner(request, **values):
before(request)
return view(request, **values)
return _inner
return _wrap(before, view)
return view
def dispatch_request(self, environ, start_response):
local.url_adapter = adapter = self.map.bind_to_environ(environ)
local.request = request = self.request_cls(self, environ)
emit_event("request-start", request)
try:
endpoint, values = adapter.match()
request.endpoint = endpoint
request.endpoint_values = values
emit_event("request-end", request)
response = self.get_view(request, endpoint, values)
except HTTPException, err:
emit_event("request-error", request, err)
response = err.get_response(environ)
def _login_or_create(self, req, username, _recursive=False):
"""Trying to find the user based on the ID we get from the
cookie and set the session cookie or, if the user is not yet
in the database, create a new one."""
USERNAME_SCHEMA = u"FBConnect_%s"
user = User.query.filter(User.user_name==USERNAME_SCHEMA %
username).first()
if user:
log.debug("Logging in user via facebook connect: %r" % user)
emit_event("fconnect-login-start", req, user)
login(req, user)
emit_event("fconnect-login-end", req, user)
else:
# Creating a new user
user = User(USERNAME_SCHEMA % username, '')
# Make sure the user can only log in via facebook. Ha, we are
# smarter than pinax was. :D
user.set_unusable_password()
self._set_user_group(user)
# Initializing an empty profile. It's getting populated on first
# login.
profile = Profile()
profile.user = user
profile.uses_facebook_connect = True
emit_event("fconnect-create-user", user, profile)
session.add_all([user, profile])
session.commit()
if not _recursive:
# Make sure we don't loop because of some weird
# database failures.
log.debug("New user created. Logging in now.")
# Don't use user.user_name here, because it includes the
# FBConnect_ prefix!
return self._login_or_create(req, username, True)
def __call__(self, environ, start_response):
local.application = self
emit_event("wsgi-call")
emit_event("wsgi-env", environ)
return ClosingIterator(self.dispatch_request(environ, start_response), [local_manager.cleanup])
endpoint, values = adapter.match()
request.endpoint = endpoint
request.endpoint_values = values
emit_event("request-end", request)
response = self.get_view(request, endpoint, values)
except HTTPException, err:
emit_event("request-error", request, err)
response = err.get_response(environ)
except KeyboardInterrupt, err:
# Are there more special cases?
raise
except Exception:
# All non http-related errors
exc_info = sys.exc_info()
err = {"type": exc_info[0], "value": exc_info[1], "traceback": exc_info[2], "response": None}
emit_event("request-fatal", request, err)
if err["response"] is not None:
response = err["response"]
else:
raise
emit_event("response-start", response)
resp = response(environ, start_response)
emit_event("response-end", resp)
return resp
def get_view(self, request, endpoint, values):
emit_event("view-dispatch", endpoint, values)
view = self._find_view(endpoint)
if view:
except HTTPException, err:
emit_event('request-error', request, err)
response = err.get_response(environ)
except KeyboardInterrupt, err:
# Are there more special cases?
raise
except Exception:
# All non http-related errors
exc_info = sys.exc_info()
err = {
'type': exc_info[0],
'value': exc_info[1],
'traceback': exc_info[2],
'response': None
}
emit_event('request-fatal', request, err)
if err['response'] is not None:
response = err['response']
else:
raise
emit_event('response-start', response)
resp = response(environ, start_response)
emit_event('response-end', resp)
return resp
def get_view(self, request, endpoint, values):
emit_event('view-dispatch', endpoint, values)
view = self._find_view(endpoint)
if view:
def after_commit(self, session):
d = session._model_changes
if d:
emit_event('after_models_committed', changes=d.values())
d.clear()
return EXT_CONTINUE
def debug(msg):
# Racy
from glashammer.utils import emit_event
emit_event('log', 'debug', msg)
def warning(msg):
# Racy
from glashammer.utils import emit_event
emit_event('log', 'warning', msg)
def set_user_password(username, password):
emit_event('password-change', username, gen_pwhash(password))
def check_role(token, role_key):
roles = emit_event('role-check', token, role_key)
if any(roles):
return True
def check_username_password(username, password):
tokens = emit_event('password-check', username, password)
if any(tokens):
return username
def before_commit(self, session):
d = session._model_changes
if d:
emit_event('before_models_committed', changes=d.values())
return EXT_CONTINUE
def error(msg):
# Racy
from glashammer.utils import emit_event
emit_event('log', 'error', msg)
