def test_request_processing(request_context):
global_request.set_var("varname", "1a")
global_request.set_var("varname2", "1")
global_request.get_unicode_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_unicode_input("site")
host = request.get_unicode_input("host")
service = request.get_unicode_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_unicode_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 _from_vars(self):
self._hostname = request.get_ascii_input_mandatory("host")
self._host = watolib.Folder.current().host(self._hostname)
if self._host is None:
raise MKUserError("host", _("The given host does not exist."))
self._host.need_permission("read")
# TODO: Validate?
self._service = request.get_unicode_input("service")
def ajax_render_tree():
aggr_group = request.get_unicode_input("group")
aggr_title = request.get_unicode_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 _ensure_connected(user: Optional[LoggedInUser],
force_authuser: Optional[UserId]) -> None:
if 'live' in g:
return
if user is None:
user = config.user
if force_authuser is None:
request_force_authuser = request.get_unicode_input("force_authuser")
force_authuser = UserId(
request_force_authuser) if request_force_authuser else None
g.site_status = {}
_connect_multiple_sites(user)
_set_livestatus_auth(user, force_authuser)
def page_show():
site = request.var("site") # optional site hint
host_name = request.var("host", "")
file_name = request.get_unicode_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 action(self) -> ActionResult:
if html.form_submitted("search"):
return None
alias = request.get_unicode_input("alias")
unique, info = watolib.is_alias_used("roles", self._role_id, alias)
if not unique:
raise MKUserError("alias", info)
new_id = request.get_ascii_input_mandatory("id")
if not new_id:
raise MKUserError("id", "You have to provide a ID.")
if not re.match("^[-a-z0-9A-Z_]*$", new_id):
raise MKUserError(
"id",
_("Invalid role ID. Only the characters a-z, A-Z, 0-9, _ and - are allowed."
))
if new_id != self._role_id:
if new_id in self._roles:
raise MKUserError("id",
_("The ID is already used by another role"))
self._role["alias"] = alias
# based on
if not self._role.get("builtin"):
basedon = request.get_ascii_input_mandatory("basedon")
if basedon not in config.builtin_role_ids:
raise MKUserError(
"basedon",
_("Invalid valid for based on. Must be id of builtin rule."
))
self._role["basedon"] = basedon
# Permissions
permissions = self._role["permissions"]
for var_name, value in request.itervars(prefix="perm_"):
try:
perm = permission_registry[var_name[5:]]
except KeyError:
continue
if value == "yes":
permissions[perm.name] = True
elif value == "no":
permissions[perm.name] = False
elif value == "default":
try:
del permissions[perm.name]
except KeyError:
pass # Already at defaults
if self._role_id != new_id:
self._roles[new_id] = self._role
del self._roles[self._role_id]
self._rename_user_role(self._role_id, new_id)
self._save_roles()
watolib.add_change("edit-roles",
_("Modified user role '%s'") % new_id,
sites=config.get_login_sites())
return redirect(mode_url("roles"))
def from_html_vars(self, varprefix):
value = request.get_unicode_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_unicode_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))
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_unicode_input('service')
host_service_graph_popup_cmk(site_id, host_name, service_description)
def filtername(self):
return request.get_unicode_input(self._varprefix + "name")
def display(self) -> None:
htmlvar = self.htmlvars[0]
value = request.get_unicode_input(htmlvar)
html.text_input(htmlvar, value if value is not None else '')
