def get_flashed_messages() -> List[HTML]: """Return the messages flashed from the previous request to this one Move the flashes from the session object to the current request once and cache them for the current request. """ flashes = request_stack().top.flashes if flashes is None: if not hasattr(session, "session_info") or not session.session_info.flashes: request_stack().top.flashes = [] else: request_stack().top.flashes = session.session_info.flashes session.session_info.flashes = [] return [HTML(s) for s in request_stack().top.flashes]
def mock_livestatus( with_context: bool = False, with_html: bool = False ) -> Generator[MockLiveStatusConnection, None, None]: live = MockLiveStatusConnection() env = EnvironBuilder().get_environ() req = http.Request(env) resp = http.Response() app_context: ContextManager req_context: ContextManager if with_html: html_obj = None else: html_obj = HTMLGenerator( request=req, output_funnel=OutputFunnel(resp), output_format="html", mobile=is_mobile(req, resp), ) if with_context: app_context = AppContext(None, stack=app_stack()) req_context = RequestContext( html_obj=html_obj, req=req, resp=resp, funnel=OutputFunnel(resp), config_obj=make_config_object(get_default_config()), user=LoggedInNobody(), display_options=DisplayOptions(), prefix_logs_with_url=False, stack=request_stack(), url_filter=PrependURLFilter(), ) else: app_context = contextlib.nullcontext() req_context = contextlib.nullcontext() with app_context, req_context, mock.patch( "cmk.gui.sites._get_enabled_and_disabled_sites", new=live.enabled_and_disabled_sites), mock.patch( "livestatus.MultiSiteConnection.expect_query", new=live.expect_query, create=True), mock.patch( "livestatus.SingleSiteConnection._create_socket", new=live.create_socket), mock.patch.dict( os.environ, { "OMD_ROOT": "/", "OMD_SITE": "NO_SITE" }): # We don't want to be polluted by other tests. omd_site.cache_clear() yield live # We don't want to pollute other tests. omd_site.cache_clear()
def with_request_context(): environ = create_environ() resp = Response() with AppContext(session_wsgi_app(debug=False), stack=app_stack()), RequestContext( req=Request(environ), resp=resp, funnel=OutputFunnel(resp), config_obj=make_config_object(get_default_config()), user=LoggedInNobody(), display_options=DisplayOptions(), stack=request_stack(), url_filter=PrependURLFilter(), ): yield
def make_request_context( environ: Optional[Mapping[str, Any]] = None) -> RequestContext: req = Request( dict(create_environ(), REQUEST_URI="") if environ is None else environ) resp = Response(mimetype="text/html") funnel = OutputFunnel(resp) return RequestContext( req=req, resp=resp, funnel=funnel, config_obj=make_config_object(get_default_config()), user=LoggedInNobody(), html_obj=html(req, resp, funnel, output_format="html"), display_options=DisplayOptions(), timeout_manager=TimeoutManager(), theme=Theme(), prefix_logs_with_url=False, stack=request_stack(), url_filter=PrependURLFilter(), )
def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> WSGIResponse: req = http.Request(environ) output_format = get_output_format( req.get_ascii_input_mandatory("output_format", "html").lower()) mime_type = get_mime_type_from_output_format(output_format) resp = Response(headers=default_response_headers(req), mimetype=mime_type) funnel = OutputFunnel(resp) timeout_manager = TimeoutManager() timeout_manager.enable_timeout(req.request_timeout) theme = Theme() config_obj = config_module.make_config_object( config_module.get_default_config()) with AppContext(self, stack=app_stack()), RequestContext( req=req, resp=resp, funnel=funnel, config_obj=config_obj, user=LoggedInNobody(), html_obj=HTMLGenerator(req, funnel, output_format, is_mobile(req, resp)), timeout_manager=timeout_manager, display_options=DisplayOptions(), theme=theme, stack=request_stack(), url_filter=PrependURLFilter(), ), patch_json(json): config_module.initialize() theme.from_config(active_config.ui_theme) return self.wsgi_app(environ, start_response)
def _wsgi_app(self, environ: WSGIEnvironment, start_response: StartResponse) -> WSGIResponse: urls = self.url_map.bind_to_environ(environ) endpoint: Optional[Endpoint] = None try: result: Tuple[str, Mapping[str, Any]] = urls.match(return_rule=False) endpoint_ident, matched_path_args = result # pylint: disable=unpacking-non-sequence wsgi_app = self.endpoints[endpoint_ident] if isinstance(wsgi_app, Authenticate): endpoint = wsgi_app.endpoint # Remove _path again (see Submount above), so the validators don't go crazy. path_args = { key: value for key, value in matched_path_args.items() if key != "_path" } # This is an implicit dependency, as we only know the args at runtime, but the # function at setup-time. environ[ARGS_KEY] = path_args req = Request(environ) resp = Response() with AppContext(self, stack=app_stack()), RequestContext( req=req, resp=resp, funnel=OutputFunnel(resp), config_obj=config.make_config_object( config.get_default_config()), endpoint=endpoint, user=LoggedInNobody(), display_options=DisplayOptions(), stack=request_stack(), url_filter=PrependURLFilter(), ), cmk.utils.store.cleanup_locks(), sites.cleanup_connections(): config.initialize() load_dynamic_permissions() return wsgi_app(environ, start_response) except ProblemException as exc: return exc(environ, start_response) except HTTPException as exc: # We don't want to log explicit HTTPExceptions as these are intentional. assert isinstance(exc.code, int) return problem( status=exc.code, title=http.client.responses[exc.code], detail=str(exc), )(environ, start_response) except MKException as exc: if self.debug: raise return problem( status=EXCEPTION_STATUS.get(type(exc), 500), title="An exception occurred.", detail=str(exc), )(environ, start_response) except Exception as exc: crash = APICrashReport.from_exception() crash_reporting.CrashReportStore().save(crash) logger.exception("Unhandled exception (Crash-ID: %s)", crash.ident_to_text()) if self.debug: raise request = Request(environ) site = config.omd_site() query_string = urllib.parse.urlencode([ ("crash_id", (crash.ident_to_text())), ("site", site), ]) crash_url = f"{request.host_url}{site}/check_mk/crash.py?{query_string}" crash_details = { "crash_id": (crash.ident_to_text()), "crash_report": { "href": crash_url, "method": "get", "rel": "cmk/crash-report", "type": "text/html", }, } if user.may("general.see_crash_reports"): crash_details["stack_trace"] = traceback.format_exc().split( "\n") return problem( status=500, title=http.client.responses[500], detail=str(exc), ext=crash_details, )(environ, start_response)