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), RequestContext(
req=req,
resp=resp,
funnel=funnel,
config_obj=config_obj,
user=LoggedInNobody(),
html_obj=htmllib.html(req, resp, funnel, output_format),
timeout_manager=timeout_manager,
display_options=DisplayOptions(),
theme=theme,
), patch_json(json):
config_module.initialize()
theme.from_config(config.ui_theme)
return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response):
req = http.Request(environ)
with AppContext(self), RequestContext(req=req,
html_obj=htmllib.html(req)):
config.initialize()
html.init_modes()
return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response):
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()
with AppContext(self), RequestContext(
req=req,
resp=resp,
funnel=funnel,
html_obj=htmllib.html(req, resp, funnel, output_format),
timeout_manager=timeout_manager,
display_options=DisplayOptions(),
theme=theme,
), patch_json(json):
config.initialize()
theme.from_config(config.ui_theme, config.theme_choices())
return self.wsgi_app(environ, start_response)
def __call__(self, environ, start_response) -> Response:
req = http.Request(environ)
with AppContext(self), RequestContext(req=req,
display_options=DisplayOptions(),
html_obj=htmllib.html(req)):
config.initialize()
return _process_request(environ, start_response)
def with_context(environ, start_response):
req = http.Request(environ)
with AppContext(app), \
RequestContext(req=req, display_options=DisplayOptions()), \
cmk.utils.store.cleanup_locks(), \
sites.cleanup_connections():
config.initialize()
return app(environ, start_response)
def with_context(environ, start_response):
req = cmk.gui.http.Request(environ)
resp = cmk.gui.http.Response(is_secure=req.is_secure)
with AppContext(app), RequestContext(cmk.gui.htmllib.html(req, resp)):
config.initialize()
html.init_modes()
return app(environ, start_response)
def etags_off_fixture():
def _set_config():
config.rest_api_etag_locking = False
config.register_post_config_load_hook(_set_config)
config.initialize()
yield
config._post_config_load_hooks.remove(_set_config)
config.initialize()
def _process_request(self, request, response): # pylint: disable=too-many-branches
try:
config.initialize()
html.init_modes()
# Make sure all plugins are available as early as possible. At least
# we need the plugins (i.e. the permissions declared in these) at the
# time before the first login for generating auth.php.
_load_all_plugins()
page_handler = get_and_wrap_page(request, html.myfile)
page_handler()
# If page_handler didn't raise we assume everything is OK.
response.status_code = httplib.OK
except HTTPRedirect as e:
response.status_code = e.status
response.headers["Location"] = e.url
except FinalizeRequest as e:
response.status_code = e.status
except livestatus.MKLivestatusNotFoundError as e:
_render_exception(e, title=_("Data not found"))
except MKUserError as e:
_render_exception(e, title=_("Invalid user Input"))
except MKAuthException as e:
_render_exception(e, title=_("Permission denied"))
except livestatus.MKLivestatusException as e:
_render_exception(e, title=_("Livestatus problem"))
response.status_code = httplib.BAD_GATEWAY
except MKUnauthenticatedException as e:
_render_exception(e, title=_("Not authenticated"))
response.status_code = httplib.UNAUTHORIZED
except MKConfigError as e:
_render_exception(e, title=_("Configuration error"))
logger.error("MKConfigError: %s", e)
except MKGeneralException as e:
_render_exception(e, title=_("General error"))
logger.error("MKGeneralException: %s", e)
except Exception:
crash = crash_reporting.GUICrashReport.from_exception()
crash_reporting.CrashReportStore().save(crash)
logger.exception("Unhandled exception (Crash-ID: %s)",
crash.ident_to_text())
crash_reporting.show_crash_dump_message(crash, _plain_error(),
_fail_silently())
def with_context(environ, start_response):
req = http.Request(environ)
resp = http.Response()
with AppContext(app), \
RequestContext(req=req, resp=resp, funnel=OutputFunnel(resp),
config_obj=config.make_config_object(config.get_default_config()),
display_options=DisplayOptions()), \
cmk.utils.store.cleanup_locks(), \
sites.cleanup_connections():
config.initialize()
return app(environ, start_response)
def load_config(register_builtin_html):
old_root_log_level = cmk.utils.log.logger.getEffectiveLevel()
config.initialize()
yield
cmk.utils.log.logger.setLevel(old_root_log_level)
def load_config(request_context: None) -> Iterator[None]:
old_root_log_level = cmk.utils.log.logger.getEffectiveLevel()
config_module.initialize()
yield
cmk.utils.log.logger.setLevel(old_root_log_level)
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)
def _process_request(environ, start_response): # pylint: disable=too-many-branches
try:
config.initialize()
html.init_modes()
# Make sure all plugins are available as early as possible. At least
# we need the plugins (i.e. the permissions declared in these) at the
# time before the first login for generating auth.php.
_load_all_plugins()
page_handler = get_and_wrap_page(html.myfile)
response = page_handler()
# If page_handler didn't raise we assume everything is OK.
response.status_code = http_client.OK
except HTTPRedirect as e:
# This can't be a new Response as it can have already cookies set/deleted by the pages.
# We can't return the response because the Exception has been raised instead.
# TODO: Remove all HTTPRedirect exceptions from all pages. Making the Exception a subclass
# of Response may also work as it can then be directly returned from here.
response = html.response
response.status_code = e.status
response.headers["Location"] = e.url
except FinalizeRequest as e:
# This doesn't seem to serve much purpose anymore.
# TODO: Remove all FinalizeRequest exceptions from all pages and replace it with a `return`.
# It may be necessary to rewire the control-flow a bit as this exception could have
# been used to short-circuit some code and jump directly to the response. This
# needs to be changed as well.
response = html.response
response.status_code = e.status
except livestatus.MKLivestatusNotFoundError as e:
response = _render_exception(e, title=_("Data not found"))
except MKUserError as e:
response = _render_exception(e, title=_("Invalid user Input"))
except MKAuthException as e:
response = _render_exception(e, title=_("Permission denied"))
except livestatus.MKLivestatusException as e:
response = _render_exception(e, title=_("Livestatus problem"))
response.status_code = http_client.BAD_GATEWAY
except MKUnauthenticatedException as e:
response = _render_exception(e, title=_("Not authenticated"))
response.status_code = http_client.UNAUTHORIZED
except MKConfigError as e:
response = _render_exception(e, title=_("Configuration error"))
logger.error("MKConfigError: %s", e)
except MKGeneralException as e:
response = _render_exception(e, title=_("General error"))
logger.error("MKGeneralException: %s", e)
except Exception:
crash_reporting.handle_exception_as_gui_crash_report(
_plain_error(), _fail_silently())
# This needs to be cleaned up.
response = html.response
return response(environ, start_response)
def with_context(environ, start_response):
req = http.Request(environ)
with AppContext(app), RequestContext(req=req):
config.initialize()
return app(environ, start_response)
def with_context(environ, start_response):
req = http.Request(environ)
with AppContext(app), RequestContext(req=req,
display_options=DisplayOptions()):
config.initialize()
return app(environ, start_response)