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)