def test_request_processing(request_context: RequestContextFixture) -> None:
global_request.set_var("varname", "1a")
global_request.set_var("varname2", "1")
global_request.get_str_input("varname", deflt="lol")
global_request.get_integer_input_mandatory("varname2")
global_request.get_request(exclude_vars=["varname2"])
def ajax_set_assumption() -> None:
site = request.get_str_input("site")
host = request.get_str_input("host")
service = request.get_str_input("service")
state = request.var("state")
if state == "none":
del user.bi_assumptions[_get_state_assumption_key(site, host, service)]
elif state is not None:
user.bi_assumptions[_get_state_assumption_key(site, host, service)] = int(state)
else:
raise Exception("ajax_set_assumption: state is None")
user.save_bi_assumptions()
def _ensure_connected(user: Optional[LoggedInUser],
force_authuser: Optional[UserId]) -> None:
"""Build up a connection to livestatus to either a single site or multiple sites."""
if "live" in g:
return
if user is None:
user = global_user
if force_authuser is None:
request_force_authuser = request.get_str_input("force_authuser")
force_authuser = UserId(
request_force_authuser) if request_force_authuser else None
logger.debug(
"Initializing livestatus connections as user %s (forced auth user: %s)",
user.id,
force_authuser,
)
g.site_status = {}
_connect_multiple_sites(user)
_set_livestatus_auth(user, force_authuser)
logger.debug("Site states: %r", g.site_status)
def ajax_tree_openclose() -> None:
tree = request.get_str_input_mandatory("tree")
name = request.get_unicode_input_mandatory("name")
config.user.set_tree_state(tree, name, request.get_str_input("state"))
config.user.save_tree_states()
response.set_data('OK') # Write out something to make debugging easier
def _from_vars(self):
self._hostname = request.get_ascii_input_mandatory("host")
host = watolib.Folder.current().host(self._hostname)
if host is None:
raise MKUserError("host", _("The given host does not exist."))
self._host: watolib.CREHost = host
self._host.need_permission("read")
# TODO: Validate?
self._service = request.get_str_input("service")
def ajax_render_tree():
aggr_group = request.get_str_input("group")
aggr_title = request.get_str_input("title")
omit_root = bool(request.var("omit_root"))
only_problems = bool(request.var("only_problems"))
rows = []
bi_manager = BIManager()
bi_manager.status_fetcher.set_assumed_states(user.bi_assumptions)
aggregation_id = request.get_str_input_mandatory("aggregation_id")
bi_aggregation_filter = BIAggregationFilter(
[],
[],
[aggregation_id],
[aggr_title] if aggr_title is not None else [],
[aggr_group] if aggr_group is not None else [],
[],
)
rows = bi_manager.computer.compute_legacy_result_for_filter(
bi_aggregation_filter)
# TODO: Cleanup the renderer to use a class registry for lookup
renderer_class_name = request.var("renderer")
if renderer_class_name == "FoldableTreeRendererTree":
renderer_cls: Type[ABCFoldableTreeRenderer] = FoldableTreeRendererTree
elif renderer_class_name == "FoldableTreeRendererBoxes":
renderer_cls = FoldableTreeRendererBoxes
elif renderer_class_name == "FoldableTreeRendererBottomUp":
renderer_cls = FoldableTreeRendererBottomUp
elif renderer_class_name == "FoldableTreeRendererTopDown":
renderer_cls = FoldableTreeRendererTopDown
else:
raise NotImplementedError()
renderer = renderer_cls(
rows[0],
omit_root=omit_root,
expansion_level=user.bi_expansion_level,
only_problems=only_problems,
lazy=False,
)
html.write_html(renderer.render())
def action(self) -> ActionResult:
if not transactions.transaction_valid():
return None
action_var = request.get_str_input("_action")
if action_var is None:
return None
if action_var != "delete":
return self._handle_custom_action(action_var)
if not transactions.check_transaction():
return redirect(mode_url(self._mode_type.list_mode_name()))
entries = self._store.load_for_modification()
ident = request.get_ascii_input("_delete")
if ident not in entries:
raise MKUserError(
"_delete",
_("This %s does not exist.") % self._mode_type.name_singular())
if ident not in self._store.filter_editable_entries(entries):
raise MKUserError(
"_delete",
_("You are not allowed to delete this %s.") %
self._mode_type.name_singular(),
)
self._validate_deletion(ident, entries[ident])
entry = entries.pop(ident)
self._add_change(
action="delete",
text=_("Removed the %s '%s'") %
(self._mode_type.name_singular(), ident),
affected_sites=self._mode_type.affected_sites(entry),
)
self._store.save(entries)
flash(_("The %s has been deleted.") % self._mode_type.name_singular())
return redirect(mode_url(self._mode_type.list_mode_name()))
def page_show():
site = request.var("site") # optional site hint
host_name = request.var("host", "")
file_name = request.get_str_input("file", "")
# Fix problem when URL is missing certain illegal characters
try:
file_name = form_file_to_ext(
find_matching_logfile(site, host_name,
form_file_to_int(file_name)))
except livestatus.MKLivestatusNotFoundError:
pass # host_name log dir does not exist
if not host_name:
show_log_list()
return
if file_name:
show_file(site, host_name, file_name)
else:
show_host_log_list(site, host_name)
def from_html_vars(self, varprefix: str) -> Optional[str]:
value = request.get_str_input(varprefix + "attr_" + self.name())
if value is None:
value = ""
return value.strip()
def _do_login(self) -> None:
"""handle the sent login form"""
if not request.var("_login"):
return
try:
if not config.user_login:
raise MKUserError(None,
_("Login is not allowed on this site."))
username_var = request.get_str_input("_username", "")
assert username_var is not None
username = UserId(username_var.rstrip())
if not username:
raise MKUserError("_username", _("Missing username"))
password = request.var("_password", "")
if not password:
raise MKUserError("_password", _("Missing password"))
default_origtarget = url_prefix() + "check_mk/"
origtarget = request.get_url_input("_origtarget",
default_origtarget)
# Disallow redirections to:
# - logout.py: Happens after login
# - side.py: Happens when invalid login is detected during sidebar refresh
if "logout.py" in origtarget or "side.py" in origtarget:
origtarget = default_origtarget
result = userdb.check_credentials(username, password)
if result:
# use the username provided by the successful login function, this function
# might have transformed the username provided by the user. e.g. switched
# from mixed case to lower case.
username = result
session_id = userdb.on_succeeded_login(username)
# The login succeeded! Now:
# a) Set the auth cookie
# b) Unset the login vars in further processing
# c) Redirect to really requested page
_create_auth_session(username, session_id)
# Never use inplace redirect handling anymore as used in the past. This results
# in some unexpected situations. We simpy use 302 redirects now. So we have a
# clear situation.
# userdb.need_to_change_pw returns either False or the reason description why the
# password needs to be changed
change_pw_result = userdb.need_to_change_pw(username)
if change_pw_result:
raise HTTPRedirect(
"user_change_pw.py?_origtarget=%s&reason=%s" %
(urlencode(origtarget), change_pw_result))
if userdb.is_two_factor_login_enabled(username):
raise HTTPRedirect(
"user_login_two_factor.py?_origtarget=%s" %
urlencode(makeuri(request, [])))
raise HTTPRedirect(origtarget)
userdb.on_failed_login(username)
raise MKUserError(None, _("Invalid login"))
except MKUserError as e:
user_errors.add(e)
def page_host_service_graph_popup() -> None:
site_id = request.var("site")
host_name = request.var("host_name")
service_description = request.get_str_input("service")
host_service_graph_popup_cmk(site_id, host_name, service_description)
