def action(self) -> ActionResult:
if not transactions.check_transaction():
return redirect(self.mode_url())
connections = load_connection_config(lock=True)
if html.request.has_var("_delete"):
index = html.request.get_integer_input_mandatory("_delete")
connection = connections[index]
self._add_change(
"delete-ldap-connection",
_("Deleted LDAP connection %s") % (connection["id"]))
del connections[index]
save_connection_config(connections)
elif html.request.has_var("_move"):
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 redirect(self.mode_url())
def action(self) -> ActionResult:
if not html.check_transaction():
return redirect(self.mode_url())
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))
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 html.request.var("_clone"):
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 redirect(self.mode_url())
def action(self) -> ActionResult:
delname = request.var("_delete")
if not delname:
return redirect(mode_url("timeperiods"))
if not transactions.check_transaction():
return redirect(mode_url("timeperiods"))
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)
del self._timeperiods[delname]
watolib.timeperiods.save_timeperiods(self._timeperiods)
watolib.add_change("edit-timeperiods",
_("Deleted timeperiod %s") % delname)
return redirect(mode_url("timeperiods"))
def action(self) -> ActionResult:
if not transactions.check_transaction():
return None
vs = self._valuespec()
self._connection_cfg = vs.from_html_vars("connection")
vs.validate_value(self._connection_cfg, "connection")
self._connection_cfg["type"] = "ldap"
if self._new:
self._connections.insert(0, self._connection_cfg)
self._connection_id = self._connection_cfg["id"]
else:
self._connection_cfg["id"] = self._connection_id
self._connections[self._connection_nr] = self._connection_cfg
assert self._connection_id is not None
if self._new:
log_what = "new-ldap-connection"
log_text = _("Created new LDAP connection")
else:
log_what = "edit-ldap-connection"
log_text = _("Changed LDAP connection %s") % self._connection_id
self._add_change(log_what, log_text)
save_connection_config(self._connections)
config.user_connections = self._connections # make directly available on current page
if html.request.var("_save"):
return redirect(mode_url("ldap_config"))
# Handle the case where a user hit "Save & Test" during creation
return redirect(self.mode_url(_test="1", id=self._connection_id))
def action(self) -> ActionResult:
if not transactions.check_transaction():
return redirect(mode_url("tags"))
vs = self._valuespec()
aux_tag_spec = vs.from_html_vars("aux_tag")
vs.validate_value(aux_tag_spec, "aux_tag")
self._aux_tag = cmk.utils.tags.AuxTag(aux_tag_spec)
self._aux_tag.validate()
changed_hosttags_config = cmk.utils.tags.TagConfig()
changed_hosttags_config.parse_config(self._tag_config_file.load_for_reading())
if self._new:
changed_hosttags_config.aux_tag_list.append(self._aux_tag)
else:
changed_hosttags_config.aux_tag_list.update(self._id, self._aux_tag)
try:
changed_hosttags_config.validate_config()
except MKGeneralException as e:
raise MKUserError(None, "%s" % e)
self._tag_config_file.save(changed_hosttags_config.get_dict_format())
return redirect(mode_url("tags"))
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()
changed_hosttags_config.parse_config(
self._tag_config_file.load_for_modification())
changed_tag_group = cmk.utils.tags.TagGroup(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())
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())
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:
job_details_page = ModeBackgroundJobDetails()
action_handler = gui_background_job.ActionHandler(job_details_page.breadcrumb())
action_handler.handle_actions()
if action_handler.did_delete_job():
if job_details_page.back_url():
raise redirect(job_details_page.back_url())
raise redirect(mode_url("background_jobs_overview"))
def action(self) -> ActionResult:
action_handler = gui_background_job.ActionHandler(self.breadcrumb())
action_handler.handle_actions()
if action_handler.did_delete_job():
if self._back_url():
raise redirect(self._back_url())
return redirect(mode_url("background_jobs_overview"))
return None
def _import(self, csv_reader: CSVReader) -> ActionResult:
if self._has_title_line:
try:
next(csv_reader) # skip header
except StopIteration:
pass
num_succeeded, num_failed = 0, 0
fail_messages = []
selected = []
imported_hosts = []
for row_num, row in enumerate(csv_reader):
if not row:
continue # skip empty lines
host_name, attributes = self._get_host_info_from_row(row, row_num)
try:
watolib.Folder.current().create_hosts(
[(host_name, attributes, None)],
bake_hosts=False,
)
imported_hosts.append(host_name)
selected.append('_c_%s' % host_name)
num_succeeded += 1
except Exception as e:
fail_messages.append(
_("Failed to create a host from line %d: %s") %
(csv_reader.line_num, e))
num_failed += 1
watolib.hosts_and_folders.try_bake_agents_for_hosts(imported_hosts)
self._delete_csv_file()
msg = _("Imported %d hosts into the current folder.") % num_succeeded
if num_failed:
msg += "<br><br>" + (_("%d errors occured:") % num_failed)
msg += "<ul>"
for fail_msg in fail_messages:
msg += "<li>%s</li>" % fail_msg
msg += "</ul>"
if num_succeeded > 0 and html.request.var(
"do_service_detection") == "1":
# Create a new selection for performing the bulk discovery
config.user.set_rowselection(
weblib.selection_id(),
'wato-folder-/' + watolib.Folder.current().path(), selected,
'set')
return redirect(
mode_url("bulkinventory",
_bulk_inventory='1',
show_checkboxes='1'))
flash(msg)
return redirect(mode_url("folder"))
def action(self) -> ActionResult:
if not transactions.check_transaction():
return redirect(mode_url("folder", folder=watolib.Folder.current().path()))
count = html.request.get_integer_input_mandatory("count")
folders = html.request.get_integer_input_mandatory("folders")
levels = html.request.get_integer_input_mandatory("levels")
created = self._create_random_hosts(watolib.Folder.current(), count, folders, levels)
flash(_("Added %d random hosts.") % created)
return redirect(mode_url("folder", folder=watolib.Folder.current().path()))
def action(self) -> ActionResult:
if not html.check_transaction():
return None
if self._job.is_active() or self._diagnostics_parameters is None:
return redirect(self._job.detail_url())
self._job.set_function(self._job.do_execute, self._diagnostics_parameters)
self._job.start()
return redirect(self._job.detail_url())
def action(self) -> ActionResult:
if not transactions.check_transaction():
return redirect(mode_url("tags"))
if request.has_var("_delete"):
return self._delete_tag_group()
if request.has_var("_del_aux"):
return self._delete_aux_tag()
if request.var("_move"):
return self._move_tag_group()
return redirect(mode_url("tags"))
def action(self) -> ActionResult:
if not html.check_transaction():
return redirect(self.mode_url())
if not html.request.var('_delete'):
return redirect(self.mode_url())
delname = html.request.var("_delete")
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))
return redirect(self.mode_url())
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 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 _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:
if not html.check_transaction():
return redirect(mode_url("%s_groups" % self.type_name))
alias = html.request.get_unicode_input_mandatory("alias").strip()
self.group = {"alias": alias}
self._determine_additional_group_data()
if self._new:
self._name = html.request.get_ascii_input_mandatory("name").strip()
watolib.add_group(self._name, self.type_name, self.group)
else:
watolib.edit_group(self._name, self.type_name, self.group)
return redirect(mode_url("%s_groups" % self.type_name))
def action(self) -> ActionResult:
settings = self._vs().from_html_vars("_read_only")
self._vs().validate_value(settings, "_read_only")
self._settings = settings
self._save()
flash(_("Saved read only settings"))
return redirect(mode_url("read_only"))
def action(self) -> ActionResult:
if not html.check_transaction():
return redirect(self.mode_url())
if html.request.has_var("_delete"):
icon_name = html.request.var("_delete")
if icon_name in self._load_custom_icons():
os.remove("%s/local/share/check_mk/web/htdocs/images/icons/%s.png" %
(cmk.utils.paths.omd_root, icon_name))
elif html.request.has_var("_do_upload"):
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 redirect(self.mode_url())
def action(self) -> ActionResult:
if html.form_submitted("search"):
return None
alias = html.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 = html.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 = html.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 html.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 action(self) -> ActionResult:
if not transactions.check_transaction():
return None
vs_ical = self._vs_ical()
ical = vs_ical.from_html_vars("ical")
vs_ical.validate_value(ical, "ical")
filename, _ty, content = ical['file']
try:
# TODO(ml): If we could open the file in text mode, we would not
# need to `decode()` here.
data = self._parse_ical(content.decode("utf-8"), ical['horizon'])
except Exception as e:
if config.debug:
raise
raise MKUserError('ical_file', _('Failed to parse file: %s') % e)
get_vars = {
'timeperiod_p_alias': data.get('descr', data.get('name',
filename)),
}
for day in defines.weekday_ids():
get_vars['%s_0_from' % day] = ''
get_vars['%s_0_until' % day] = ''
# Default to whole day
if not ical["times"]:
ical["times"] = [((0, 0), (24, 0))]
get_vars['timeperiod_p_exceptions_count'] = "%d" % len(data['events'])
for index, event in enumerate(data['events']):
index += 1
get_vars['timeperiod_p_exceptions_%d_0' % index] = event['date']
get_vars['timeperiod_p_exceptions_indexof_%d' %
index] = "%d" % index
get_vars['timeperiod_p_exceptions_%d_1_count' %
index] = "%d" % len(ical["times"])
for n, time_spec in enumerate(ical["times"]):
n += 1
start_time = ":".join("%02d" % x for x in time_spec[0])
end_time = ":".join("%02d" % x for x in time_spec[1])
get_vars['timeperiod_p_exceptions_%d_1_%d_from' %
(index, n)] = start_time
get_vars['timeperiod_p_exceptions_%d_1_%d_until' %
(index, n)] = end_time
get_vars['timeperiod_p_exceptions_%d_1_indexof_%d' %
(index, n)] = "%d" % index
return redirect(mode_url("edit_timeperiod", **get_vars))
def action(self) -> ActionResult:
if not html.check_transaction():
return redirect(mode_url("%s_groups" % self.type_name))
if html.request.var('_delete'):
delname = html.request.get_ascii_input_mandatory("_delete")
usages = watolib.find_usages_of_group(delname, self.type_name)
if usages:
message = "<b>%s</b><br>%s:<ul>" % \
(_("You cannot delete this %s group.") % self.type_name,
_("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)
watolib.delete_group(delname, self.type_name)
self._groups = self._load_groups()
return redirect(mode_url("%s_groups" % self.type_name))
def action(self) -> ActionResult:
if not html.check_transaction():
return redirect(self.mode_url())
if html.request.var('_delete'):
delete_users([html.request.get_unicode_input("_delete")])
elif html.request.var('_sync'):
try:
job = userdb.UserSyncBackgroundJob()
job.set_function(job.do_sync,
add_to_changelog=True,
enforce_sync=True,
load_users_func=userdb.load_users,
save_users_func=userdb.save_users)
try:
job.start()
except background_job.BackgroundJobAlreadyRunning as e:
raise MKUserError(None,
_("Another synchronization job is already running: %s") % e)
self._job_snapshot = job.get_status_snapshot()
except Exception:
logger.exception("error syncing users")
raise MKUserError(None, traceback.format_exc().replace('\n', '<br>\n'))
elif html.request.var("_bulk_delete_users"):
self._bulk_delete_users_after_confirm()
else:
action_handler = gui_background_job.ActionHandler(self.breadcrumb())
action_handler.handle_actions()
if action_handler.did_acknowledge_job():
self._job_snapshot = userdb.UserSyncBackgroundJob().get_status_snapshot()
flash(_("Synchronization job acknowledged"))
return redirect(self.mode_url())
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 = html.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(
html.render_tr(
html.render_td(host_name) +
html.render_td(" → %s" % target_name)))
message += html.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 action(self) -> ActionResult:
if not html.check_transaction():
return None
vs = self._valuespec() # returns a Dictionary object
vs_spec = vs.from_html_vars("timeperiod")
vs.validate_value(vs_spec, "timeperiod")
self._timeperiod = self._from_valuespec(vs_spec)
if self._new:
self._name = vs_spec["name"]
watolib.add_change("edit-timeperiods", _("Created new time period %s") % self._name)
else:
watolib.add_change("edit-timeperiods", _("Modified time period %s") % self._name)
assert self._name is not None
self._timeperiods[self._name] = self._timeperiod
watolib.timeperiods.save_timeperiods(self._timeperiods)
return redirect(mode_url("timeperiods"))
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:
if not transactions.check_transaction():
return None
if request.var('_try'):
try:
self._validate_diag_html_vars()
except MKUserError as e:
user_errors.add(e)
return None
if request.var('_save'):
# Save the ipaddress and/or community
vs_host = self._vs_host()
new = vs_host.from_html_vars('vs_host')
vs_host.validate_value(new, 'vs_host')
# If both snmp types have credentials set - snmpv3 takes precedence
return_message = []
if "ipaddress" in new:
return_message.append(_("IP address"))
if "snmp_v3_credentials" in new:
if "snmp_community" in new:
return_message.append(
_("SNMPv3 credentials (SNMPv2 community was discarded)"
))
else:
return_message.append(_("SNMPv3 credentials"))
new["snmp_community"] = new["snmp_v3_credentials"]
elif "snmp_community" in new:
return_message.append(_("SNMP credentials"))
self._host.update_attributes(new)
flash(_("Updated attributes: ") + ", ".join(return_message))
return redirect(
mode_url(
"edit_host",
host=self._hostname,
folder=watolib.Folder.current().path(),
))
return None
def action(self) -> ActionResult:
if watolib.get_pending_changes_info():
raise MKUserError("newname",
_("You cannot rename a host while you have pending changes."))
newname = request.var("newname")
self._check_new_host_name("newname", newname)
# 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())
def action(self) -> ActionResult:
# TODO: remove subclass specific things specifict things (everything with _type == 'user')
if not html.check_transaction():
return None
title = html.request.get_unicode_input_mandatory("title").strip()
if not title:
raise MKUserError("title", _("Please specify a title."))
for this_attr in self._attrs:
if title == this_attr['title'] and self._name != this_attr['name']:
raise MKUserError(
"alias",
_("This alias is already used by the attribute %s.") %
this_attr['name'])
topic = html.request.get_unicode_input_mandatory('topic', '').strip()
help_txt = html.request.get_unicode_input_mandatory('help', '').strip()
show_in_table = html.get_checkbox('show_in_table')
add_custom_macro = html.get_checkbox('add_custom_macro')
if self._new:
self._name = html.request.get_ascii_input_mandatory("name",
'').strip()
if not self._name:
raise MKUserError(
"name", _("Please specify a name for the new attribute."))
if ' ' in self._name:
raise MKUserError(
"name",
_("Sorry, spaces are not allowed in attribute names."))
if not re.match("^[-a-z0-9A-Z_]*$", self._name):
raise MKUserError(
"name",
_("Invalid attribute name. Only the characters a-z, A-Z, 0-9, _ and - are allowed."
))
if [a for a in self._attrs if a['name'] == self._name]:
raise MKUserError(
"name",
_("Sorry, there is already an attribute with that name."))
ty = html.request.get_ascii_input_mandatory('type', '').strip()
if ty not in [t[0] for t in custom_attr_types()]:
raise MKUserError('type',
_('The choosen attribute type is invalid.'))
self._attr = {
'name': self._name,
'type': ty,
}
self._attrs.append(self._attr)
add_change(
"edit-%sattr" % self._type,
_("Create new %s attribute %s") % (self._type, self._name))
else:
add_change(
"edit-%sattr" % self._type,
_("Modified %s attribute %s") % (self._type, self._name))
self._attr.update({
'title': title,
'topic': topic,
'help': help_txt,
'show_in_table': show_in_table,
'add_custom_macro': add_custom_macro,
})
self._add_extra_attrs_from_html_vars()
save_custom_attrs_to_mk_file(self._all_attrs)
self._update_config()
return redirect(mode_url(self._type + "_attrs"))
def _clear_audit_log_after_confirm(self) -> ActionResult:
self._clear_audit_log()
flash(_("Cleared audit log."))
return redirect(self.mode_url())