def _delete_tag_group(self) -> ActionResult:
del_id = request.get_item_input("_delete",
dict(self._tag_config.get_tag_group_choices()))[1]
if not request.has_var("_repair") and self._is_cleaning_up_user_tag_group_to_builtin(
del_id):
message: Union[bool,
str] = _("Transformed the user tag group \"%s\" to builtin.") % del_id
else:
message = _rename_tags_after_confirmation(self.breadcrumb(),
OperationRemoveTagGroup(del_id))
if message is False:
return FinalizeRequest(code=200)
if message:
self._tag_config.remove_tag_group(del_id)
try:
self._tag_config.validate_config()
except MKGeneralException as e:
raise MKUserError(None, "%s" % e)
self._save_tags_and_update_hosts(self._tag_config.get_dict_format())
add_change("edit-tags", _("Removed tag group %s (%s)") % (message, del_id))
if isinstance(message, str):
flash(message)
return redirect(mode_url("tags"))
def _move_to_imported_folders(self, host_names_to_move) -> ActionResult:
c = wato_confirm(
_("Confirm moving hosts"),
_('You are going to move the selected hosts to folders '
'representing their original folder location in the system '
'you did the import from. Please make sure that you have '
'done an <b>inventory</b> before moving the hosts.'))
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
if not c:
return None # browser reload
# Create groups of hosts with the same target folder
target_folder_names: Dict[str, List[HostName]] = {}
for host_name in host_names_to_move:
host = self._folder.host(host_name)
imported_folder_name = host.attribute('imported_folder')
if imported_folder_name is None:
continue
target_folder_names.setdefault(imported_folder_name, []).append(host_name)
# Remove target folder information, now that the hosts are
# at their target position.
host.remove_attribute('imported_folder')
# Now handle each target folder
for imported_folder, host_names in target_folder_names.items():
# Next problem: The folder path in imported_folder refers
# to the Alias of the folders, not to the internal file
# name. And we need to create folders not yet existing.
target_folder = self._create_target_folder_from_aliaspath(imported_folder)
self._folder.move_hosts(host_names, target_folder)
flash(_("Successfully moved hosts to their original folder destinations."))
return None
def action(self) -> ActionResult:
delname = html.request.var("_delete")
if delname and html.transaction_valid():
if delname in watolib.timeperiods.builtin_timeperiods():
raise MKUserError("_delete",
_("Builtin timeperiods can not be modified"))
usages = self._find_usages_of_timeperiod(delname)
if usages:
message = "<b>%s</b><br>%s:<ul>" % \
(_("You cannot delete this timeperiod."),
_("It is still in use by"))
for title, link in usages:
message += '<li><a href="%s">%s</a></li>\n' % (link, title)
message += "</ul>"
raise MKUserError(None, message)
c = wato_confirm(
_("Confirm deletion of time period %s") % delname,
_("Do you really want to delete the time period '%s'? I've checked it: "
"it is not being used by any rule or user profile right now."
) % delname)
if c:
del self._timeperiods[delname]
watolib.timeperiods.save_timeperiods(self._timeperiods)
watolib.add_change("edit-timeperiods",
_("Deleted timeperiod %s") % delname)
elif c is False:
return FinalizeRequest(code=200)
return None
def _action(self) -> None:
assert user.id is not None
users = userdb.load_users(lock=True)
user_spec = users[user.id]
language = request.get_ascii_input_mandatory("language", "")
# Set the users language if requested to set it explicitly
if language != "_default_":
user_spec["language"] = language
user.language = language
set_language_cookie(request, response, language)
else:
if "language" in user_spec:
del user_spec["language"]
user.reset_language()
# load the new language
localize(user.language)
if user.may("general.edit_notifications") and user_spec.get(
"notifications_enabled"):
value = forms.get_input(get_vs_flexible_notifications(),
"notification_method")
user_spec["notification_method"] = value
# Custom attributes
if user.may("general.edit_user_attributes"):
for name, attr in userdb.get_user_attributes():
if not attr.user_editable():
continue
perm_name = attr.permission()
if perm_name and not user.may(perm_name):
continue
vs = attr.valuespec()
value = vs.from_html_vars("ua_" + name)
vs.validate_value(value, "ua_" + name)
# TODO: Dynamically fiddling around with a TypedDict is a bit questionable
user_spec[name] = value # type: ignore[literal-required]
userdb.save_users(users)
flash(_("Successfully updated user profile."))
# In distributed setups with remote sites where the user can login, start the
# user profile replication now which will redirect the user to the destination
# page after completion. Otherwise directly open up the destination page.
if user.authorized_login_sites():
back_url = "user_profile_replicate.py?back=user_profile.py"
else:
back_url = "user_profile.py"
# Ensure theme changes are applied without additional user interaction
html.reload_whole_page(back_url)
html.footer()
raise FinalizeRequest(code=200)
def action(self) -> ActionResult:
if html.request.var("_delete"):
delid = html.request.get_ascii_input_mandatory("_delete")
if delid not in self._roles:
raise MKUserError(None, _("This role does not exist."))
if html.transaction_valid() and self._roles[delid].get('builtin'):
raise MKUserError(None, _("You cannot delete the builtin roles!"))
users = userdb.load_users()
for user in users.values():
if delid in user["roles"]:
raise MKUserError(
None, _("You cannot delete roles, that are still in use (%s)!" % delid))
c = wato_confirm(
_("Confirm deletion of role %s") % delid,
_("Do you really want to delete the role %s?") % delid)
if c:
self._rename_user_role(delid, None) # Remove from existing users
del self._roles[delid]
self._save_roles()
watolib.add_change("edit-roles",
_("Deleted role '%s'") % delid,
sites=config.get_login_sites())
elif c is False:
return FinalizeRequest(code=200)
elif html.request.var("_clone"):
if html.check_transaction():
cloneid = html.request.get_ascii_input_mandatory("_clone")
try:
cloned_role = self._roles[cloneid]
except KeyError:
raise MKUserError(None, _("This role does not exist."))
newid = cloneid
while newid in self._roles:
newid += "x"
new_role = {}
new_role.update(cloned_role)
new_alias = new_role["alias"]
while not watolib.is_alias_used("roles", newid, new_alias)[0]:
new_alias += _(" (copy)")
new_role["alias"] = new_alias
if cloned_role.get("builtin"):
new_role["builtin"] = False
new_role["basedon"] = cloneid
self._roles[newid] = new_role
self._save_roles()
watolib.add_change("edit-roles",
_("Created new role '%s'") % newid,
sites=config.get_login_sites())
return None
def action(self) -> ActionResult:
if transactions.check_transaction():
keys = self.load()
try:
key_id_str = request.var("key")
if key_id_str is None:
raise Exception(
"cannot happen") # is this really the case?
key_id = int(key_id_str)
except ValueError:
raise MKUserError(None,
_("You need to provide a valid key id."))
if key_id not in keys:
raise MKUserError(None,
_("You need to provide a valid key id."))
private_key = keys[key_id]["private_key"]
value = self._vs_key().from_html_vars("key")
self._vs_key().validate_value(value, "key")
decrypt_private_key(private_key, value["passphrase"])
self._send_download(keys, key_id)
return FinalizeRequest(code=200)
return None
def _delete_aux_tag(self) -> ActionResult:
del_id = request.get_item_input("_del_aux",
dict(self._tag_config.aux_tag_list.get_choices()))[1]
# Make sure that this aux tag is not begin used by any tag group
for group in self._tag_config.tag_groups:
for grouped_tag in group.tags:
if del_id in grouped_tag.aux_tag_ids:
raise MKUserError(
None,
_("You cannot delete this auxiliary tag. "
"It is being used in the tag group <b>%s</b>.") % group.title)
message = _rename_tags_after_confirmation(self.breadcrumb(), OperationRemoveAuxTag(del_id))
if message is False:
return FinalizeRequest(code=200)
if message:
self._tag_config.aux_tag_list.remove(del_id)
try:
self._tag_config.validate_config()
except MKGeneralException as e:
raise MKUserError(None, "%s" % e)
self._save_tags_and_update_hosts(self._tag_config.get_dict_format())
add_change("edit-tags", _("Removed auxiliary tag %s (%s)") % (message, del_id))
if isinstance(message, str):
flash(message)
return redirect(mode_url("tags"))
def action(self) -> ActionResult:
connections = load_connection_config(lock=True)
if html.request.has_var("_delete"):
index = html.request.get_integer_input_mandatory("_delete")
connection = connections[index]
c = wato_confirm(
_("Confirm deletion of LDAP connection"),
_("Do you really want to delete the LDAP connection <b>%s</b>?"
) % (connection["id"]))
if c:
self._add_change(
"delete-ldap-connection",
_("Deleted LDAP connection %s") % (connection["id"]))
del connections[index]
save_connection_config(connections)
elif c is False:
return FinalizeRequest(code=200)
else:
return None
elif html.request.has_var("_move"):
if not html.check_transaction():
return None
from_pos = html.request.get_integer_input_mandatory("_move")
to_pos = html.request.get_integer_input_mandatory("_index")
connection = connections[from_pos]
self._add_change(
"move-ldap-connection",
_("Changed position of LDAP connection %s to %d") %
(connection["id"], to_pos))
del connections[from_pos] # make to_pos now match!
connections[to_pos:to_pos] = [connection]
save_connection_config(connections)
return None
def action(self) -> ActionResult:
if html.request.has_var("_delete"):
icon_name = html.request.var("_delete")
if icon_name in self._load_custom_icons():
c = wato_confirm(
_("Confirm Icon deletion"),
_("Do you really want to delete the icon <b>%s</b>?") %
icon_name)
if c:
os.remove(
"%s/local/share/check_mk/web/htdocs/images/icons/%s.png"
% (cmk.utils.paths.omd_root, icon_name))
elif c is False:
return FinalizeRequest(code=200)
else:
return None
elif html.request.has_var("_do_upload"):
if not html.check_transaction():
return None
vs_upload = self._vs_upload()
icon_info = vs_upload.from_html_vars('_upload_icon')
vs_upload.validate_value(icon_info, '_upload_icon')
self._upload_icon(icon_info)
return None
def action(self) -> ActionResult:
if self._may_edit_config() and html.request.has_var("_delete"):
key_id_as_str = html.request.var("_delete")
if key_id_as_str is None:
raise Exception("cannot happen")
key_id = int(key_id_as_str)
if key_id not in self.keys:
return None
key = self.keys[key_id]
if self._key_in_use(key_id, key):
raise MKUserError("", _("This key is still used."))
message = self._delete_confirm_msg()
if key["owner"] != config.user.id:
message += _(
"<br><b>Note</b>: this key has created by user <b>%s</b>"
) % key["owner"]
c = html.confirm(message, add_header=self.title())
if c:
self.delete(key_id)
self.save(self.keys)
elif c is False:
return FinalizeRequest(code=200)
return None
def _export_audit_log(self) -> ActionResult:
html.set_output_format("csv")
if self._options["display"] == "daily":
filename = "wato-auditlog-%s_%s.csv" % (render.date(
time.time()), render.time_of_day(time.time()))
else:
filename = "wato-auditlog-%s_%s_days.csv" % (render.date(
time.time()), self._options["display"][1])
html.write(filename)
html.response.headers[
"Content-Disposition"] = "attachment; filename=\"%s\"" % filename
titles = (
_('Date'),
_('Time'),
_('Linkinfo'),
_('User'),
_('Action'),
_('Text'),
)
html.write(','.join(titles) + '\n')
for t, linkinfo, user, action, text in self._parse_audit_log():
if linkinfo == '-':
linkinfo = ''
html.write_text(','.join((render.date(int(t)),
render.time_of_day(int(t)), linkinfo,
user, action, '"' + text + '"')) + '\n')
return FinalizeRequest(code=200)
def action(self) -> ActionResult:
if watolib.get_pending_changes_info():
raise MKUserError(
"newname",
_("You cannot rename a host while you have pending changes."))
newname = html.request.var("newname")
self._check_new_host_name("newname", newname)
c = wato_confirm(
_("Confirm renaming of host"),
_("Are you sure you want to rename the host <b>%s</b> into <b>%s</b>? "
"This involves a restart of the monitoring core!") %
(self._host.name(), newname))
if c:
# Creating pending entry. That makes the site dirty and that will force a sync of
# the config to that site before the automation is being done.
host_renaming_job = RenameHostBackgroundJob(
self._host,
title=_("Renaming of %s -> %s") % (self._host.name(), newname))
renamings = [(watolib.Folder.current(), self._host.name(), newname)
]
host_renaming_job.set_function(rename_hosts_background_job,
renamings)
try:
host_renaming_job.start()
except background_job.BackgroundJobAlreadyRunning as e:
raise MKGeneralException(
_("Another host renaming job is already running: %s") % e)
return redirect(host_renaming_job.detail_url())
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None
def action(self) -> ActionResult:
if not transactions.check_transaction():
return redirect(mode_url("tags"))
vs = self._valuespec()
tag_group_spec = vs.from_html_vars("tag_group")
vs.validate_value(tag_group_spec, "tag_group")
# Create new object with existing host tags
changed_hosttags_config = cmk.utils.tags.TagConfig.from_config(
self._tag_config_file.load_for_modification())
changed_tag_group = cmk.utils.tags.TagGroup.from_config(tag_group_spec)
self._tag_group = changed_tag_group
if self._new:
# Inserts and verifies changed tag group
changed_hosttags_config.insert_tag_group(changed_tag_group)
try:
changed_hosttags_config.validate_config()
except MKGeneralException as e:
raise MKUserError(None, "%s" % e)
self._save_tags_and_update_hosts(
changed_hosttags_config.get_dict_format())
_changes.add_change(
"edit-hosttags",
_("Created new host tag group '%s'") % changed_tag_group.id)
flash(
_("Created new host tag group '%s'") % changed_tag_group.title)
return redirect(mode_url("tags"))
# Updates and verifies changed tag group
changed_hosttags_config.update_tag_group(changed_tag_group)
try:
changed_hosttags_config.validate_config()
except MKGeneralException as e:
raise MKUserError(None, "%s" % e)
remove_tag_ids, replace_tag_ids = identify_modified_tags(
changed_tag_group, self._untainted_tag_group)
tg_id = self._tag_group.id
if tg_id is None:
raise Exception("tag group ID not set")
operation = OperationReplaceGroupedTags(tg_id, remove_tag_ids,
replace_tag_ids)
# Now check, if any folders, hosts or rules are affected
message = _rename_tags_after_confirmation(self.breadcrumb(), operation)
if message is False:
return FinalizeRequest(code=200)
self._save_tags_and_update_hosts(
changed_hosttags_config.get_dict_format())
_changes.add_change(
"edit-hosttags",
_("Edited host tag group %s (%s)") % (message, self._id))
if isinstance(message, str):
flash(message)
return redirect(mode_url("tags"))
def _action(self) -> None:
assert config.user.id is not None
users = userdb.load_users(lock=True)
user = users[config.user.id]
language = html.request.get_ascii_input_mandatory('language', "")
# Set the users language if requested to set it explicitly
if language != "_default_":
user['language'] = language
config.user.language = language
html.set_language_cookie(language)
else:
if 'language' in user:
del user['language']
config.user.reset_language()
# load the new language
cmk.gui.i18n.localize(config.user.language)
if config.user.may('general.edit_notifications') and user.get(
"notifications_enabled"):
value = forms.get_input(watolib.get_vs_flexible_notifications(),
"notification_method")
user["notification_method"] = value
# Custom attributes
if config.user.may('general.edit_user_attributes'):
for name, attr in userdb.get_user_attributes():
if not attr.user_editable():
continue
if attr.permission() and not config.user.may(
attr.permission()):
continue
vs = attr.valuespec()
value = vs.from_html_vars('ua_' + name)
vs.validate_value(value, "ua_" + name)
user[name] = value
userdb.save_users(users)
flash(_("Successfully updated user profile."))
# In distributed setups with remote sites where the user can login, start the
# user profile replication now which will redirect the user to the destination
# page after completion. Otherwise directly open up the destination page.
if config.user.authorized_login_sites():
back_url = "user_profile_replicate.py?back=user_profile.py"
else:
back_url = "user_profile.py"
# Ensure theme changes are applied without additional user interaction
html.reload_whole_page(back_url)
html.footer()
raise FinalizeRequest(code=200)
def _export_audit_log(self,
audit: List[AuditLogStore.Entry]) -> ActionResult:
response.set_content_type("text/csv")
if self._options["display"] == "daily":
filename = "wato-auditlog-%s_%s.csv" % (
render.date(time.time()),
render.time_of_day(time.time()),
)
else:
filename = "wato-auditlog-%s_%s_days.csv" % (
render.date(time.time()),
self._options["display"][1],
)
response.headers[
"Content-Disposition"] = 'attachment; filename="%s"' % filename
titles = [
_("Date"),
_("Time"),
_("Object type"),
_("Object"),
_("User"),
_("Action"),
_("Summary"),
]
if self._show_details:
titles.append(_("Details"))
resp = []
resp.append(",".join(titles) + "\n")
for entry in audit:
columns = [
render.date(int(entry.time)),
render.time_of_day(int(entry.time)),
entry.object_ref.object_type.name if entry.object_ref else "",
entry.object_ref.ident if entry.object_ref else "",
entry.user_id,
entry.action,
'"' + escaping.strip_tags(entry.text).replace('"', "'") + '"',
]
if self._show_details:
columns.append(
'"' +
escaping.strip_tags(entry.diff_text).replace('"', "'") +
'"')
resp.append(",".join(columns) + "\n")
response.set_data("".join(resp))
return FinalizeRequest(code=200)
def _clear_audit_log_after_confirm(self) -> ActionResult:
c = wato_confirm(_("Confirm deletion of audit log"),
_("Do you really want to clear the audit log?"))
if c:
self._clear_audit_log()
flash(_("Cleared audit log."))
return None
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def delete_host_after_confirm(delname) -> ActionResult:
c = wato_confirm(_("Confirm host deletion"),
_("Do you really want to delete the host <tt>%s</tt>?") % delname)
if c:
watolib.Folder.current().delete_hosts([delname])
# Delete host files
return redirect(mode_url("folder", folder=watolib.Folder.current().path()))
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def action(self) -> ActionResult:
if request.var("_action") != "discard":
return None
if not transactions.check_transaction():
return None
if not self._may_discard_changes():
return None
if not self.has_changes():
return None
# Now remove all currently pending changes by simply restoring the last automatically
# taken snapshot. Then activate the configuration. This should revert all pending changes.
file_to_restore = self._get_last_wato_snapshot_file()
if not file_to_restore:
raise MKUserError(None,
_("There is no WATO snapshot to be restored."))
msg = _("Discarded pending changes (Restored %s)") % file_to_restore
# All sites and domains can be affected by a restore: Better restart everything.
_changes.add_change(
"changes-discarded",
msg,
domains=ABCConfigDomain.enabled_domains(),
need_restart=True,
)
self._extract_snapshot(file_to_restore)
activate_changes.execute_activate_changes([
d.get_domain_request([])
for d in ABCConfigDomain.enabled_domains()
])
for site_id in activation_sites():
self.confirm_site_changes(site_id)
build_index_background()
make_header(
html,
self.title(),
breadcrumb=self.breadcrumb(),
show_body_start=display_options.enabled(display_options.H),
show_top_heading=display_options.enabled(display_options.T),
)
html.open_div(class_="wato")
html.show_message(_("Successfully discarded all pending changes."))
html.javascript("hide_changes_buttons();")
html.footer()
return FinalizeRequest(code=200)
def _delete_hosts_after_confirm(self, host_names) -> ActionResult:
c = wato_confirm(
_("Confirm deletion of %d hosts") % len(host_names),
_("Do you really want to delete the %d selected hosts?") % len(host_names))
if c:
self._folder.delete_hosts(host_names)
flash(_("Successfully deleted %d hosts") % len(host_names))
return redirect(mode_url("folder", folder=self._folder.path()))
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def action(self) -> ActionResult:
renaming_config = self._vs_renaming_config().from_html_vars("")
self._vs_renaming_config().validate_value(renaming_config, "")
renamings = self._collect_host_renamings(renaming_config)
if not renamings:
flash(_("No matching host names"))
return None
warning = self._renaming_collision_error(renamings)
if warning:
flash(warning)
return None
message = HTMLWriter.render_b(
_("Do you really want to rename to following hosts?"
"This involves a restart of the monitoring core!"))
rows = []
for _folder, host_name, target_name in renamings:
rows.append(
HTMLWriter.render_tr(
HTMLWriter.render_td(host_name) +
HTMLWriter.render_td(" → %s" % target_name)))
message += HTMLWriter.render_table(HTML().join(rows))
nr_rename = len(renamings)
c = _confirm(
_("Confirm renaming of %d %s") %
(nr_rename, ungettext("host", "hosts", nr_rename)),
message,
)
if c:
title = _("Renaming of %s") % ", ".join("%s → %s" % x[1:]
for x in renamings)
host_renaming_job = RenameHostsBackgroundJob(title=title)
host_renaming_job.set_function(rename_hosts_background_job,
renamings)
try:
host_renaming_job.start()
except background_job.BackgroundJobAlreadyRunning as e:
raise MKGeneralException(
_("Another host renaming job is already running: %s") % e)
return redirect(host_renaming_job.detail_url())
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def page(self) -> None:
_invalidate_auth_session()
if auth_type == 'cookie':
raise HTTPRedirect(config.url_prefix() + 'check_mk/login.py')
# Implement HTTP logout with cookie hack
if not html.request.has_cookie('logout'):
html.response.headers['WWW-Authenticate'] = (
'Basic realm="OMD Monitoring Site %s"' % config.omd_site())
html.response.set_http_cookie('logout', '1')
raise FinalizeRequest(http.client.UNAUTHORIZED)
html.response.delete_cookie('logout')
raise HTTPRedirect(config.url_prefix() + 'check_mk/')
def _export_audit_log(self,
audit: List[AuditLogStore.Entry]) -> ActionResult:
html.set_output_format("csv")
if self._options["display"] == "daily":
filename = "wato-auditlog-%s_%s.csv" % (render.date(
time.time()), render.time_of_day(time.time()))
else:
filename = "wato-auditlog-%s_%s_days.csv" % (render.date(
time.time()), self._options["display"][1])
html.response.headers[
"Content-Disposition"] = "attachment; filename=\"%s\"" % filename
titles = [
_('Date'),
_('Time'),
_('Object type'),
_('Object'),
_('User'),
_('Action'),
_('Summary'),
]
if self._show_details:
titles.append(_('Details'))
html.write(','.join(titles) + '\n')
for entry in audit:
columns = [
render.date(int(entry.time)),
render.time_of_day(int(entry.time)),
entry.object_ref.object_type.name if entry.object_ref else "",
entry.object_ref.ident if entry.object_ref else "",
entry.user_id,
entry.action,
'"' + escaping.strip_tags(entry.text).replace('"', "'") + '"',
]
if self._show_details:
columns.append(
'"' +
escaping.strip_tags(entry.diff_text).replace('"', "'") +
'"')
html.write(','.join(columns) + '\n')
return FinalizeRequest(code=200)
def _delete_subfolder_after_confirm(self, subfolder_name) -> ActionResult:
subfolder = self._folder.subfolder(subfolder_name)
msg = _("Do you really want to delete the folder %s?") % subfolder.title()
if not config.wato_hide_filenames:
msg += _(" Its directory is <tt>%s</tt>.") % subfolder.filesystem_path()
num_hosts = subfolder.num_hosts_recursively()
if num_hosts:
msg += _(
" The folder contains <b>%d</b> hosts, which will also be deleted!") % num_hosts
c = wato_confirm(_("Confirm folder deletion"), msg)
if c:
self._folder.delete_subfolder(subfolder_name)
return redirect(mode_url("folder", folder=self._folder.path()))
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def action(self) -> ActionResult:
if not html.transaction_valid():
return None
action_var = html.request.get_str_input("_action")
if action_var is None:
return None
if action_var != "delete":
return self._handle_custom_action(action_var)
confirm = wato_confirm(_("Confirm deletion"),
self._delete_confirm_message())
if confirm is False:
return FinalizeRequest(code=200)
if not confirm:
return None
html.check_transaction() # invalidate transid
entries = self._store.load_for_modification()
ident = html.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(
"delete", entry,
_("Removed the %s '%s'") %
(self._mode_type.name_singular(), ident))
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 action(self) -> ActionResult:
renaming_config = self._vs_renaming_config().from_html_vars("")
self._vs_renaming_config().validate_value(renaming_config, "")
renamings = self._collect_host_renamings(renaming_config)
if not renamings:
flash(_("No matching host names"))
return None
warning = self._renaming_collision_error(renamings)
if warning:
flash(warning)
return None
message = _(
"<b>Do you really want to rename to following hosts? This involves a restart of the monitoring core!</b>"
)
message += "<table>"
for _folder, host_name, target_name in renamings:
message += u"<tr><td>%s</td><td> → %s</td></tr>" % (host_name,
target_name)
message += "</table>"
c = wato_confirm(
_("Confirm renaming of %d hosts") % len(renamings), HTML(message))
if c:
title = _("Renaming of %s") % ", ".join(u"%s → %s" % x[1:]
for x in renamings)
host_renaming_job = RenameHostsBackgroundJob(title=title)
host_renaming_job.set_function(rename_hosts_background_job,
renamings)
try:
host_renaming_job.start()
except background_job.BackgroundJobAlreadyRunning as e:
raise MKGeneralException(
_("Another host renaming job is already running: %s") % e)
return redirect(host_renaming_job.detail_url())
if c is False: # not yet confirmed
return FinalizeRequest(code=200)
return None # browser reload
def action(self) -> ActionResult:
varname = html.request.var("_varname")
if not varname:
return None
action = html.request.var("_action")
config_variable = config_variable_registry[varname]()
def_value = self._default_values[varname]
if action == "reset" and not is_a_checkbox(config_variable.valuespec()):
c = wato_confirm(
_("Resetting configuration variable"),
_("Do you really want to reset the configuration variable <b>%s</b> "
"back to the default value of <b><tt>%s</tt></b>?") %
(varname, config_variable.valuespec().value_to_text(def_value)))
else:
if not html.check_transaction():
return None
c = True # no confirmation for direct toggle
if c:
if varname in self._current_settings:
self._current_settings[varname] = not self._current_settings[varname]
else:
self._current_settings[varname] = not def_value
msg = _("Changed Configuration variable %s to %s.") % (
varname, "on" if self._current_settings[varname] else "off")
watolib.save_global_settings(self._current_settings)
watolib.add_change("edit-configvar",
msg,
domains=[config_variable.domain()],
need_restart=config_variable.need_restart())
if action == "_reset":
flash(msg)
return redirect(mode_url("globalvars"))
if c is False:
return FinalizeRequest(code=200)
return None
def page(self) -> None:
assert config.user.id is not None
_invalidate_auth_session()
session_id = _get_session_id_from_cookie(config.user.id,
revalidate_cookie=True)
userdb.on_logout(config.user.id, session_id)
if auth_type == 'cookie':
raise HTTPRedirect(config.url_prefix() + 'check_mk/login.py')
# Implement HTTP logout with cookie hack
if not request.has_cookie('logout'):
response.headers['WWW-Authenticate'] = (
'Basic realm="OMD Monitoring Site %s"' % config.omd_site())
response.set_http_cookie('logout', '1', secure=request.is_secure)
raise FinalizeRequest(http.client.UNAUTHORIZED)
response.delete_cookie('logout')
raise HTTPRedirect(config.url_prefix() + 'check_mk/')
def page(self) -> None:
assert user.id is not None
_invalidate_auth_session()
session_id = _get_session_id_from_cookie(user.id,
revalidate_cookie=True)
userdb.on_logout(user.id, session_id)
if auth_type == "cookie": # type: ignore[has-type]
raise HTTPRedirect(url_prefix() + "check_mk/login.py")
# Implement HTTP logout with cookie hack
if not request.has_cookie("logout"):
response.headers["WWW-Authenticate"] = (
'Basic realm="OMD Monitoring Site %s"' % omd_site())
response.set_http_cookie("logout", "1", secure=request.is_secure)
raise FinalizeRequest(http.client.UNAUTHORIZED)
response.delete_cookie("logout")
raise HTTPRedirect(url_prefix() + "check_mk/")
def action(self) -> ActionResult:
if html.request.var("_reset"):
if not is_a_checkbox(self._valuespec):
c = wato_confirm(
_("Resetting configuration variable"),
_("Do you really want to reset this configuration variable "
"back to its default value?"))
if c is False:
return FinalizeRequest(code=200)
if c is None:
return None
elif not html.check_transaction():
return None
try:
del self._current_settings[self._varname]
except KeyError:
pass
msg: Union[
HTML, str] = _("Resetted configuration variable %s to its default.") % self._varname
else:
new_value = self._valuespec.from_html_vars("ve")
self._valuespec.validate_value(new_value, "ve")
self._current_settings[self._varname] = new_value
msg = _("Changed global configuration variable %s to %s.") \
% (self._varname, self._valuespec.value_to_text(new_value))
# FIXME: THIS HTML(...) is needed because we do not know what we get from value_to_text!!
msg = HTML(msg)
self._save()
watolib.add_change("edit-configvar",
msg,
sites=self._affected_sites(),
domains=[self._config_variable.domain()],
need_restart=self._config_variable.need_restart())
page_menu = self.parent_mode()
assert page_menu is not None
return redirect(mode_url(page_menu.name()))
def action(self) -> ActionResult:
if html.request.var('_delete'):
delname = html.request.var("_delete")
# FIXME: Raise an error if the attribute is still used
confirm_txt = _(
'Do you really want to delete the custom attribute "%s"?') % (
delname)
c = wato_confirm(
_("Confirm deletion of attribute \"%s\"") % delname,
confirm_txt)
if c:
for index, attr in enumerate(self._attrs):
if attr['name'] == delname:
self._attrs.pop(index)
save_custom_attrs_to_mk_file(self._all_attrs)
self._update_config()
add_change("edit-%sattrs" % self._type,
_("Deleted attribute %s") % (delname))
elif c is False:
return FinalizeRequest(code=200)
return None
