async def __aexit__(self, *args): set_authenticated_user(None) # make sure to close out connection await self.abort()
async def __aenter__(self): task_vars.request.set(self.request) task_vars.db.set(self.db) set_authenticated_user(self.user) return self
def logout(): set_authenticated_user(None)
async def real_resolve(self, request: IRequest) -> Optional[MatchInfo]: """Main function to resolve a request.""" if request.method not in app_settings["http_methods"]: raise HTTPMethodNotAllowed( method=request.method, allowed_methods=[ k for k in app_settings["http_methods"].keys() ]) method = app_settings["http_methods"][request.method] try: resource, tail = await self.traverse(request) except ConflictError: # can also happen from connection errors so we bubble this... raise except Exception as _exc: logger.error("Unhandled exception occurred", exc_info=True) request.resource = request.tail = None request.exc = _exc data = { "success": False, "exception_message": str(_exc), "exception_type": getattr(type(_exc), "__name__", str(type(_exc))), # noqa } if app_settings.get("debug"): data["traceback"] = traceback.format_exc() raise HTTPBadRequest(content={"reason": data}) request.record("traversed") request.resource = resource request.tail = tail if tail and len(tail) > 0: # convert match lookups view_name = routes.path_to_view_name(tail) elif not tail: view_name = "" request.record("beforeauthentication") authenticated = await authenticate_request(request) # Add anonymous participation if authenticated is None: authenticated = AnonymousUser() set_authenticated_user(authenticated) request.record("authentication") policy = get_security_policy(authenticated) for language in get_acceptable_languages(request): translator = query_adapter((resource, request), ILanguage, name=language) if translator is not None: resource = translator.translate() break # container registry lookup try: view = query_multi_adapter((resource, request), method, name=view_name) except AttributeError: view = None if view is None and method == IOPTIONS: view = DefaultOPTIONS(resource, request) # Check security on context to AccessContent unless # is view allows explicit or its OPTIONS permission = get_utility(IPermission, name="guillotina.AccessContent") if not policy.check_permission(permission.id, resource): # Check if its a CORS call: if IOPTIONS != method: # Check if the view has permissions explicit if view is None or not view.__allow_access__: logger.info( "No access content {content} with {auth}".format( content=resource, auth=authenticated.id), request=request, ) raise HTTPUnauthorized( content={ "reason": "You are not authorized to access content", "content": str(resource), "auth": authenticated.id, }) if not view and len(tail) > 0: # we should have a view in this case because we are matching routes await notify(TraversalViewMissEvent(request, tail)) raise HTTPNotFound( content={"reason": "object and/or route not found"}) request.found_view = view request.view_name = view_name request.record("viewfound") ViewClass = view.__class__ view_permission = get_view_permission(ViewClass) if view_permission is None: # use default view permission view_permission = app_settings["default_permission"] if not policy.check_permission(view_permission, view): if IOPTIONS != method: raise HTTPUnauthorized( content={ "reason": "You are not authorized to view", "content": str(resource), "auth": authenticated.id, }) try: view.__route__.matches(request, tail or []) except (KeyError, IndexError): await notify(TraversalRouteMissEvent(request, tail)) return None except AttributeError: pass await notify(ObjectLoadedEvent(resource)) if hasattr(view, "prepare"): view = (await view.prepare()) or view request.record("authorization") return MatchInfo(resource, request, view)
def login(*, user=RootUser("foobar")): set_authenticated_user(user)