def _show_aux_tag_used_by_tags(tags: Set[cmk.utils.tags.GroupedTag]) -> None: if not tags: return html.open_ul() html.open_li() builtin_config = cmk.utils.tags.BuiltinTagConfig() for index, tag in enumerate(sorted(tags, key=lambda t: t.choice_title)): if index > 0: html.write_text(", ") # Builtin tag groups can not be edited if builtin_config.tag_group_exists(tag.group.id): html.write_text(_u(tag.choice_title)) else: edit_url = watolib.folder_preserving_link([("mode", "edit_tag"), ("edit", tag.group.id)]) html.a(_u(tag.choice_title), href=edit_url) html.close_li() html.close_ul()
def _find_usages_in_notification_rule(self, tpname: str, index: int, rule: EventRule, user_id: _Optional[UserId] = None ) -> List[TimeperiodUsage]: used_in: List[TimeperiodUsage] = [] if self._used_in_tp_condition(rule, tpname) or self._used_in_bulking(rule, tpname): url = watolib.folder_preserving_link([ ("mode", "notification_rule"), ("edit", index), ("user", user_id), ]) if user_id: title = _("Notification rule of user '%s'") % user_id else: title = _("Notification rule") used_in.append((title, url)) return used_in
def buttons(self): global_buttons() if self._host: if self._item: title = _("Show Logfile") else: title = _("Host Logfiles") html.context_button( title, html.makeuri_contextless([("host", self._hostname), ("file", self._item)], filename="logwatch.py"), 'logwatch') html.context_button( _('Edit Logfile Rules'), watolib.folder_preserving_link([ ('mode', 'edit_ruleset'), ('varname', 'logwatch_rules'), ]), 'edit')
def _find_usages_in_host_and_service_rules(self, tpname: str) -> List[TimeperiodUsage]: used_in: List[TimeperiodUsage] = [] rulesets = watolib.AllRulesets() rulesets.load() for varname, ruleset in rulesets.get_rulesets().items(): if not isinstance(ruleset.valuespec(), watolib.timeperiods.TimeperiodSelection): continue for _folder, _rulenr, rule in ruleset.get_rules(): if rule.value == tpname: used_in.append( ( "%s: %s" % (_("Ruleset"), ruleset.title()), watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", varname)] ), ) ) break return used_in
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu: page_menu: PageMenu = PageMenu( dropdowns=[ PageMenuDropdown( name="connections", title=_("Connections"), topics=[ PageMenuTopic( title=_("Add connection"), entries=[ PageMenuEntry( title=_("Add connection"), icon_name="new", item=make_simple_link( watolib.folder_preserving_link( [("mode", "edit_ldap_connection")] ) ), is_shortcut=True, is_suggested=True, ), ], ), ], ), PageMenuDropdown( name="related", title=_("Related"), topics=[ PageMenuTopic( title=_("Setup"), entries=list(self._page_menu_entries_related()), ), ], ), ], breadcrumb=breadcrumb, inpage_search=PageMenuSearch(), ) page_menu.add_doc_reference(title=self.title(), doc_ref=DocReference.LDAP) return page_menu
def _page_menu_entries_synchronized_users(self) -> Iterator[PageMenuEntry]: if userdb.sync_possible(): if not self._job_snapshot.is_active(): yield PageMenuEntry( title=_("Start user synchronization"), icon_name="replicate", item=make_simple_link(html.makeactionuri([("_sync", 1)])), ) yield PageMenuEntry( title=_("Last synchronization result"), icon_name="background_job_details", item=make_simple_link(self._job.detail_url()), ) yield PageMenuEntry( title=_("LDAP & Active Directory"), icon_name="ldap", item=make_simple_link( watolib.folder_preserving_link([("mode", "ldap_config")])), )
def _show_tag_icons(self, tag_group, nr): # Tag groups were made builtin with ~1.4. Previously users could modify # these groups. These users now have the modified tag groups in their # user configuration and should be able to cleanup this using the GUI # for the moment. Make the buttons available to the users. if self._builtin_config.tag_group_exists( tag_group.id ) and not self._tag_config.tag_group_exists(tag_group.id): html.i("(%s)" % _("builtin")) return edit_url = watolib.folder_preserving_link([("mode", "edit_tag"), ("edit", tag_group.id)]) html.icon_button(edit_url, _("Edit this tag group"), "edit") html.element_dragger_url("tr", base_url=make_action_link([("mode", "tags"), ("_move", nr)])) delete_url = make_confirm_link( url=make_action_link([("mode", "tags"), ("_delete", tag_group.id)]), message=_("Do you really want to delete the tag group '%s'?") % tag_group.id, ) html.icon_button(delete_url, _("Delete this tag group"), "delete")
def action(self) -> ActionResult: if not html.transaction_valid(): return redirect(mode_url("folder")) attributes = watolib.collect_attributes(self._host_type_name(), new=True) cluster_nodes = self._get_cluster_nodes() hostname = html.request.get_ascii_input_mandatory("host") Hostname().validate_value(hostname, "host") folder = watolib.Folder.current() if html.check_transaction(): folder.create_hosts([(hostname, attributes, cluster_nodes)]) self._host = folder.host(hostname) inventory_url = watolib.folder_preserving_link([ ("mode", "inventory"), ("host", self._host.name()), ("_scan", "1"), ]) create_msg = None if self._host.is_ping_host() else ( _('Successfully created the host. Now you should do a ' '<a href="%s">service discovery</a> in order to auto-configure ' 'all services to be checked on this host.') % inventory_url) if html.request.var("services"): raise redirect(inventory_url) if html.request.var("diag_host"): if create_msg: flash(create_msg) return redirect( mode_url("diag_host", folder=folder.path(), host=self._host.name(), _try="1")) if create_msg: flash(create_msg) return redirect(mode_url("folder", folder=folder.path()))
def _page_menu_entries_this_folder(self) -> Iterator[PageMenuEntry]: if self._folder.may("read"): yield PageMenuEntry( title=_("Properties"), icon_name="edit", item=make_simple_link(self._folder.edit_url(backfolder=self._folder)), ) if not self._folder.locked_subfolders() and not self._folder.locked(): if self._folder.may("write") and config.user.may("wato.manage_folders"): yield PageMenuEntry( title=_("Add subfolder"), icon_name="newfolder", item=make_simple_link(self._folder.url([("mode", "newfolder")])), is_shortcut=True, is_suggested=True, ) yield make_folder_status_link(watolib.Folder.current(), view_name="allhosts") if config.user.may("wato.rulesets") or config.user.may("wato.seeall"): yield PageMenuEntry( title=_("Rules"), icon_name="rulesets", item=make_simple_link( watolib.folder_preserving_link([ ("mode", "rule_search"), ("filled_in", "rule_search"), ("folder", watolib.Folder.current().path()), ("search_p_ruleset_used", DropdownChoice.option_id(True)), ("search_p_ruleset_used_USE", "on"), ])), ) if config.user.may("wato.auditlog"): yield PageMenuEntry( title=_("Audit log"), icon_name="auditlog", item=make_simple_link(make_object_audit_log_url(self._folder.object_ref())), )
def _find_usages_in_notification_rule(self, tpname, index, rule, user_id=None): used_in = [] if self._used_in_tp_condition(rule, tpname) or self._used_in_bulking( rule, tpname): url = watolib.folder_preserving_link([ ("mode", "notification_rule"), ("edit", index), ("user", user_id), ]) if user_id: title = _("Notification rule of user '%s'") % user_id else: title = _("Notification rule") used_in.append((title, url)) return used_in
def action(self): if not html.transaction_valid(): return "folder" attributes = watolib.collect_attributes(self._host_type_name(), new=True) cluster_nodes = self._get_cluster_nodes() hostname = html.request.get_ascii_input_mandatory("host") Hostname().validate_value(hostname, "host") if html.check_transaction(): watolib.Folder.current().create_hosts([(hostname, attributes, cluster_nodes)]) self._host = watolib.Folder.current().host(hostname) inventory_url = watolib.folder_preserving_link([ ("mode", "inventory"), ("host", self._host.name()), ("_scan", "1"), ]) if not self._host.is_ping_host(): create_msg = _( 'Successfully created the host. Now you should do a ' '<a href="%s">service discovery</a> in order to auto-configure ' 'all services to be checked on this host.') % inventory_url else: create_msg = None if html.request.var("services"): raise HTTPRedirect(inventory_url) if html.request.var("diag_host"): html.request.set_var("_try", "1") return "diag_host", create_msg return "folder", create_msg
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu: return PageMenu( dropdowns=[ PageMenuDropdown( name="attributes", title=_("Attributes"), topics=[ PageMenuTopic( title=_("Create"), entries=[ PageMenuEntry( title=_("Add attribute"), icon_name="new", item=make_simple_link( watolib.folder_preserving_link([ ("mode", "edit_%s_attr" % self._type) ])), is_shortcut=True, is_suggested=True, ), ], ), ], ), PageMenuDropdown( name="related", title=_("Related"), topics=[ PageMenuTopic( title=_("Setup"), entries=list(self._page_menu_entries_related()), ), ], ), ], breadcrumb=breadcrumb, inpage_search=PageMenuSearch(), )
def page(self): if not self._attrs: html.div(_("No custom attributes are defined yet."), class_="info") return with table_element(self._type + "attrs") as table: for custom_attr in sorted(self._attrs, key=lambda x: x['title']): table.row() table.cell(_("Actions"), css="buttons") edit_url = watolib.folder_preserving_link([ ("mode", "edit_%s_attr" % self._type), ("edit", custom_attr['name']) ]) delete_url = html.makeactionuri([("_delete", custom_attr['name'])]) html.icon_button(edit_url, _("Properties"), "edit") html.icon_button(delete_url, _("Delete"), "delete") table.text_cell(_("Name"), custom_attr['name']) table.text_cell(_("Title"), custom_attr['title']) table.cell(_("Type"), dict(custom_attr_types())[custom_attr['type']])
def buttons(self) -> None: global_buttons() if self.name() != "download_agents_windows": html.context_button( _("Windows files"), folder_preserving_link([("mode", "download_agents_windows")]), "download_agents") if self.name() != "download_agents_linux": html.context_button( _("Linux files"), folder_preserving_link([("mode", "download_agents_linux")]), "download_agents") if self.name() != "download_agents": html.context_button( _("Other files"), folder_preserving_link([("mode", "download_agents")]), "download_agents") if watolib.has_agent_bakery(): html.context_button( _("Baked agents"), watolib.folder_preserving_link([("mode", "agents")]), "agents")
def _find_usages_in_time_specific_parameters(self, tpname: str) -> List[TimeperiodUsage]: used_in: List[TimeperiodUsage] = [] rulesets = watolib.AllRulesets() rulesets.load() for ruleset in rulesets.get_rulesets().values(): vs = ruleset.valuespec() if not isinstance(vs, cmk.gui.plugins.wato.utils.TimeperiodValuespec): continue for rule_folder, rule_index, rule in ruleset.get_rules(): if not vs.is_active(rule.value): continue for index, (rule_tp_name, _value) in enumerate(rule.value["tp_values"]): if rule_tp_name != tpname: continue edit_url = watolib.folder_preserving_link([ ("mode", "edit_rule"), ("back_mode", "timeperiods"), ("varname", ruleset.name), ("rulenr", rule_index), ("rule_folder", rule_folder.path()), ]) used_in.append((_("Time specific check parameter #%d") % (index + 1), edit_url)) return used_in
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu: return PageMenu( dropdowns=[ PageMenuDropdown( name="connections", title=_("Connections"), topics=[ PageMenuTopic( title=_("Add connection"), entries=[ PageMenuEntry( title=_("Add connection"), icon_name="new", item=make_simple_link( watolib.folder_preserving_link([ ("mode", "edit_ldap_connection") ])), is_shortcut=True, is_suggested=True, ), ], ), ], ), PageMenuDropdown( name="related", title=_("Related"), topics=[ PageMenuTopic( title=_("Setup"), entries=list(self._page_menu_entries_related()), ), ], ), ], breadcrumb=breadcrumb, )
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu: menu = PageMenu( dropdowns=[ PageMenuDropdown( name="roles", title=_("Roles"), topics=[ PageMenuTopic( title=_("Overview"), entries=[ PageMenuEntry( title=_("Permission matrix"), icon_name="matrix", item=make_simple_link( watolib.folder_preserving_link([("mode", "role_matrix")])), ), ], ), ], ), ], breadcrumb=breadcrumb, ) return menu
def buttons(self): super(ModeEditHost, self).buttons() host_status_button(self._host.name(), "hoststatus") html.context_button( _("Services"), watolib.folder_preserving_link([("mode", "inventory"), ("host", self._host.name())]), "services") if watolib.has_agent_bakery() and config.user.may('wato.download_agents'): html.context_button( _("Monitoring Agent"), watolib.folder_preserving_link([("mode", "agent_of_host"), ("host", self._host.name())]), "agents") if config.user.may('wato.rulesets'): html.context_button( _("Parameters"), watolib.folder_preserving_link([("mode", "object_parameters"), ("host", self._host.name())]), "rulesets") if self._is_cluster(): html.context_button( _("Clustered Services"), watolib.folder_preserving_link([("mode", "edit_ruleset"), ("varname", "clustered_services")]), "rulesets") if not watolib.Folder.current().locked_hosts(): if config.user.may("wato.rename_hosts"): html.context_button( self._is_cluster() and _("Rename cluster") or _("Rename host"), watolib.folder_preserving_link([("mode", "rename_host"), ("host", self._host.name())]), "rename_host") html.context_button(self._is_cluster() and _("Delete cluster") or _("Delete host"), html.makeactionuri([("delete", "1")]), "delete") if not self._is_cluster(): html.context_button( _("Diagnostic"), watolib.folder_preserving_link([("mode", "diag_host"), ("host", self._host.name())]), "diagnose") html.context_button(_("Update DNS Cache"), html.makeactionuri([("_update_dns_cache", "1")]), "update")
def _rules_url(self) -> str: return watolib.folder_preserving_link([("mode", "rule_search"), ("filled_in", "search"), ("search", "contactgroups")])
def _rules_url(self) -> str: return watolib.folder_preserving_link([("mode", "edit_ruleset"), ("varname", "service_groups")])
def page_menu_host_entries(mode_name: str, host: CREHost) -> Iterator[PageMenuEntry]: if mode_name != "edit_host": yield PageMenuEntry( title=_("Properties"), icon_name="edit", item=make_simple_link( watolib.folder_preserving_link([("mode", "edit_host"), ("host", host.name())])), ) if mode_name != "inventory": yield PageMenuEntry( title=_("Service configuration"), icon_name="services", item=make_simple_link( watolib.folder_preserving_link([("mode", "inventory"), ("host", host.name())])), ) if mode_name != "diag_host" and not host.is_cluster(): yield PageMenuEntry( title=_("Connection tests"), icon_name="diagnose", item=make_simple_link( watolib.folder_preserving_link([("mode", "diag_host"), ("host", host.name())])), ) if mode_name != "object_parameters" and user.may("wato.rulesets"): yield PageMenuEntry( title=_("Effective parameters"), icon_name="rulesets", item=make_simple_link( watolib.folder_preserving_link([("mode", "object_parameters"), ("host", host.name())])), ) if mode_name == "object_parameters" or mode_name == "edit_host" and user.may( "wato.rulesets"): yield PageMenuEntry( title=_("Rules"), icon_name="rulesets", item=make_simple_link( makeuri_contextless( request, [ ("mode", "rule_search"), ("filled_in", "search"), ("search_p_ruleset_deprecated", "OFF"), ("search_p_rule_host_list_USE", "ON"), ("search_p_rule_host_list", host.name()), ], filename="wato.py", )), ) yield make_host_status_link(host_name=host.name(), view_name="hoststatus") if user.may("wato.rulesets") and host.is_cluster(): yield PageMenuEntry( title=_("Clustered services"), icon_name="rulesets", item=make_simple_link( watolib.folder_preserving_link([("mode", "edit_ruleset"), ("varname", "clustered_services")])), ) if watolib.has_agent_bakery() and user.may("wato.download_agents"): yield PageMenuEntry( title=_("Monitoring agent"), icon_name="agents", item=make_simple_link( watolib.folder_preserving_link([("mode", "agent_of_host"), ("host", host.name())])), ) if mode_name == "edit_host" and not host.locked(): if user.may("wato.rename_hosts"): yield PageMenuEntry( title=_("Rename"), icon_name="rename_host", item=make_simple_link( watolib.folder_preserving_link([("mode", "rename_host"), ("host", host.name())])), ) if user.may("wato.manage_hosts") and user.may("wato.clone_hosts"): yield PageMenuEntry( title=_("Clone"), icon_name="insert", item=make_simple_link(host.clone_url()), ) yield PageMenuEntry( title=_("Delete"), icon_name="delete", item=make_simple_link( make_confirm_link( url=makeactionuri(request, transactions, [("delete", "1")]), message=_( "Do you really want to delete the host <tt>%s</tt>?") % host.name(), )), ) if user.may("wato.auditlog"): yield PageMenuEntry( title=_("Audit log"), icon_name="auditlog", item=make_simple_link( make_object_audit_log_url(host.object_ref())), )
def _output_analysed_ruleset(self, all_rulesets, rulespec, svc_desc_or_item, svc_desc, known_settings=None): if known_settings is None: known_settings = self._PARAMETERS_UNKNOWN def rule_url(rule): return watolib.folder_preserving_link([ ('mode', 'edit_rule'), ('varname', varname), ('rule_folder', rule.folder.path()), ('rulenr', rule.index()), ('host', self._hostname), ('item', watolib.mk_repr(svc_desc_or_item) if svc_desc_or_item else ''), ('service', watolib.mk_repr(svc_desc) if svc_desc else ''), ]) varname = rulespec.name valuespec = rulespec.valuespec url = watolib.folder_preserving_link([ ('mode', 'edit_ruleset'), ('varname', varname), ('host', self._hostname), ('item', watolib.mk_repr(svc_desc_or_item)), ('service', watolib.mk_repr(svc_desc)), ]) forms.section(html.render_a(rulespec.title, url)) ruleset = all_rulesets.get(varname) setting, rules = ruleset.analyse_ruleset(self._hostname, svc_desc_or_item, svc_desc) html.open_table(class_="setting") html.open_tr() html.open_td(class_="reason") # Show reason for the determined value if len(rules) == 1: rule_folder, rule_index, rule = rules[0] url = rule_url(rule) html.a(_("Rule %d in %s") % (rule_index + 1, rule_folder.title()), href=rule_url(rule)) elif len(rules) > 1: html.a("%d %s" % (len(rules), _("Rules")), href=url) else: html.i(_("Default Value")) html.close_td() # Show the resulting value or factory setting html.open_td( class_=["settingvalue", "used" if len(rules) > 0 else "unused"]) if isinstance(known_settings, dict) and "tp_computed_params" in known_settings: computed_at = known_settings["tp_computed_params"]["computed_at"] html.write_text( _("Timespecific parameters computed at %s") % cmk.utils.render.date_and_time(computed_at)) html.br() known_settings = known_settings["tp_computed_params"]["params"] # In some cases we now the settings from a check_mk automation if known_settings is self._PARAMETERS_OMIT: return # Special handling for logwatch: The check parameter is always None. The actual # patterns are configured in logwatch_rules. We do not have access to the actual # patterns here but just to the useless "None". In order not to complicate things # we simply display nothing here. if varname == "logwatch_rules": pass elif known_settings is not self._PARAMETERS_UNKNOWN: try: html.write(valuespec.value_to_text(known_settings)) except Exception as e: if config.debug: raise html.write_text( _("Invalid parameter %r: %s") % (known_settings, e)) else: # For match type "dict" it can be the case the rule define some of the keys # while other keys are taken from the factory defaults. We need to show the # complete outcoming value here. if rules and ruleset.match_type() == "dict": if rulespec.factory_default is not watolib.Rulespec.NO_FACTORY_DEFAULT \ and rulespec.factory_default is not watolib.Rulespec.FACTORY_DEFAULT_UNUSED: fd = rulespec.factory_default.copy() fd.update(setting) setting = fd if valuespec and not rules: # show the default value if rulespec.factory_default is watolib.Rulespec.FACTORY_DEFAULT_UNUSED: # Some rulesets are ineffective if they are empty html.write_text(_("(unused)")) elif rulespec.factory_default is not watolib.Rulespec.NO_FACTORY_DEFAULT: # If there is a factory default then show that one setting = rulespec.factory_default html.write(valuespec.value_to_text(setting)) elif ruleset.match_type() in ("all", "list"): # Rulesets that build lists are empty if no rule matches html.write_text(_("(no entry)")) else: # Else we use the default value of the valuespec html.write( valuespec.value_to_text(valuespec.default_value())) # We have a setting elif valuespec: if ruleset.match_type() == "all": html.write(", ".join( [valuespec.value_to_text(e) for e in setting])) else: html.write(valuespec.value_to_text(setting)) # Binary rule, no valuespec, outcome is True or False else: icon_name = "rule_%s%s" % ("yes" if setting else "no", "_off" if not rules else '') html.icon(title=_("yes") if setting else _("no"), icon=icon_name) html.close_td() html.close_tr() html.close_table()
def _show_service_info(self, all_rulesets): serviceinfo = watolib.check_mk_automation( self._host.site_id(), "analyse-service", [self._hostname, self._service]) if not serviceinfo: return forms.header(_("Check origin and parameters"), isopen=True, narrow=True, css="rulesettings") origin = serviceinfo["origin"] origin_txt = { "active": _("Active check"), "static": _("Manual check"), "auto": _("Inventorized check"), "classic": _("Classical check"), }[origin] self._render_rule_reason(_("Type of check"), None, "", "", False, origin_txt) # First case: discovered checks. They come from var/check_mk/autochecks/HOST. if origin == "auto": checkgroup = serviceinfo["checkgroup"] checktype = serviceinfo["checktype"] if not checkgroup: self._render_rule_reason( _("Parameters"), None, "", "", True, _("This check is not configurable via WATO")) # Logwatch needs a special handling, since it is not configured # via checkgroup_parameters but via "logwatch_rules" in a special # WATO module. elif checkgroup == "logwatch": rulespec = rulespec_registry["logwatch_rules"] self._output_analysed_ruleset( all_rulesets, rulespec, svc_desc_or_item=serviceinfo["item"], svc_desc=self._service, known_settings=serviceinfo["parameters"]) else: # Note: some discovered checks have a check group but # *no* ruleset for discovered checks. One example is "ps". # That can be configured as a manual check or created by # inventory. But in the later case all parameters are set # by the inventory. This will be changed in a later version, # but we need to address it anyway. grouprule = "checkgroup_parameters:" + checkgroup if grouprule not in rulespec_registry: try: rulespec = rulespec_registry["static_checks:" + checkgroup] except KeyError: rulespec = None if rulespec: url = watolib.folder_preserving_link([ ('mode', 'edit_ruleset'), ('varname', "static_checks:" + checkgroup), ('host', self._hostname) ]) self._render_rule_reason( _("Parameters"), url, _("Determined by discovery"), None, False, rulespec.valuespec._elements[2].value_to_text( serviceinfo["parameters"])) else: self._render_rule_reason( _("Parameters"), None, "", "", True, _("This check is not configurable via WATO")) else: rulespec = rulespec_registry[grouprule] self._output_analysed_ruleset( all_rulesets, rulespec, svc_desc_or_item=serviceinfo["item"], svc_desc=self._service, known_settings=serviceinfo["parameters"]) elif origin == "static": checkgroup = serviceinfo["checkgroup"] checktype = serviceinfo["checktype"] if not checkgroup: html.write_text(_("This check is not configurable via WATO")) else: rulespec = rulespec_registry["static_checks:" + checkgroup] itemspec = rulespec.item_spec if itemspec: item_text = itemspec.value_to_text(serviceinfo["item"]) title = rulespec.item_spec.title() else: item_text = serviceinfo["item"] title = _("Item") self._render_rule_reason(title, None, "", "", False, item_text) self._output_analysed_ruleset( all_rulesets, rulespec, svc_desc_or_item=serviceinfo["item"], svc_desc=self._service, known_settings=self._PARAMETERS_OMIT) html.write(rulespec.valuespec._elements[2].value_to_text( serviceinfo["parameters"])) html.close_td() html.close_tr() html.close_table() elif origin == "active": checktype = serviceinfo["checktype"] rulespec = rulespec_registry["active_checks:" + checktype] self._output_analysed_ruleset( all_rulesets, rulespec, svc_desc_or_item=None, svc_desc=None, known_settings=serviceinfo["parameters"]) elif origin == "classic": ruleset = all_rulesets.get("custom_checks") origin_rule_result = self._get_custom_check_origin_rule( ruleset, self._hostname, self._service) if origin_rule_result is None: raise MKUserError( None, _("Failed to determine origin rule of %s / %s") % (self._hostname, self._service)) rule_folder, rule_index, _rule = origin_rule_result url = watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', "custom_checks"), ('host', self._hostname)]) forms.section(html.render_a(_("Command Line"), href=url)) url = watolib.folder_preserving_link([('mode', 'edit_rule'), ('varname', "custom_checks"), ('rule_folder', rule_folder.path()), ('rulenr', rule_index), ('host', self._hostname)]) html.open_table(class_="setting") html.open_tr() html.open_td(class_="reason") html.a("%s %d %s %s" % (_("Rule"), rule_index + 1, _("in"), rule_folder.title()), href=url) html.close_td() html.open_td(class_=["settingvalue", "used"]) if "command_line" in serviceinfo: html.tt(serviceinfo["command_line"]) else: html.write_text(_("(no command line, passive check)")) html.close_td() html.close_tr() html.close_table() self._show_labels(serviceinfo.get("labels", {}), "service", serviceinfo.get("label_sources", {}))
def _vs_rules(self): if config.user.may('wato.add_or_modify_executables'): ds_option = [( 'datasource_program', TextAscii( title=_("Datasource Program (<a href=\"%s\">Rules</a>)") % watolib.folder_preserving_link( [('mode', 'edit_ruleset'), ('varname', 'datasource_programs')]), help= _("For agent based checks Check_MK allows you to specify an alternative " "program that should be called by Check_MK instead of connecting the agent " "via TCP. That program must output the agent's data on standard output in " "the same format the agent would do. This is for example useful for monitoring " "via SSH.") + monitoring_macro_help() + " " + _("This option can only be used with the permission \"Can add or modify executables\"." ), ))] # type: List[DictionaryEntry] else: ds_option = [] return Dictionary( optional_keys = False, elements = [ ('agent_port', Integer( minvalue = 1, maxvalue = 65535, default_value = 6556, title = _("Check_MK Agent Port (<a href=\"%s\">Rules</a>)") % watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'agent_ports')]), help = _("This variable allows to specify the TCP port to " "be used to connect to the agent on a per-host-basis.") )), ('tcp_connect_timeout', Float( minvalue = 1.0, default_value = 5.0, unit = _("sec"), display_format = "%.0f", # show values consistent to size = 2, # SNMP-Timeout title = _("TCP Connection Timeout (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'tcp_connect_timeouts')]), help = _("This variable allows to specify a timeout for the " "TCP connection to the Check_MK agent on a per-host-basis." "If the agent does not respond within this time, it is considered to be unreachable.") )), ('snmp_timeout', Integer( title = _("SNMP-Timeout (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]), help = _("After a request is sent to the remote SNMP agent we will wait up to this " "number of seconds until assuming the answer get lost and retrying."), default_value = 1, minvalue = 1, maxvalue = 60, unit = _("sec"), )), ('snmp_retries', Integer( title = _("SNMP-Retries (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]), default_value = 5, minvalue = 0, maxvalue = 50, )), ] + ds_option, )
def buttons(self) -> None: html.context_button( _("All groups"), watolib.folder_preserving_link([ ("mode", "%s_groups" % self.type_name) ]), "back")
def home_button(): html.context_button(_("Main Menu"), watolib.folder_preserving_link([("mode", "main")]), "home")
def _activation_status(self): with table_element("site-status", searchable=False, sortable=False, css="activation") as table: for site_id, site in sort_sites( cmk.gui.watolib.changes.activation_sites()): table.row() site_status, status = self._get_site_status(site_id, site) is_online = self._site_is_online(status) is_logged_in = self._site_is_logged_in(site_id, site) has_foreign = self._site_has_foreign_changes(site_id) can_activate_all = not has_foreign or config.user.may( "wato.activateforeign") # Disable actions for offline sites and not logged in sites if not is_online or not is_logged_in: can_activate_all = False need_restart = self._is_activate_needed(site_id) need_sync = self.is_sync_needed(site_id) need_action = need_restart or need_sync # Activation checkbox table.cell("", css="buttons") if can_activate_all and need_action: html.checkbox("site_%s" % site_id, cssclass="site_checkbox") # Iconbuttons table.cell(_("Actions"), css="buttons") if config.user.may("wato.sites"): edit_url = watolib.folder_preserving_link([ ("mode", "edit_site"), ("edit", site_id) ]) html.icon_button(edit_url, _("Edit the properties of this site"), "edit") # State if can_activate_all and need_sync: html.icon_button( url="javascript:void(0)", id_="activate_%s" % site_id, cssclass="activate_site", title= _("This site is not update and needs a replication. Start it now." ), icon="need_replicate", onclick= "cmk.activation.activate_changes(\"site\", \"%s\")" % site_id) if can_activate_all and need_restart: html.icon_button( url="javascript:void(0)", id_="activate_%s" % site_id, cssclass="activate_site", title= _("This site needs a restart for activating the changes. Start it now." ), icon="need_restart", onclick= "cmk.activation.activate_changes(\"site\", \"%s\")" % site_id) if can_activate_all and not need_action: html.icon(_("This site is up-to-date."), "siteuptodate") site_url = site.get("multisiteurl") if site_url: html.icon_button( site_url, _("Open this site's local web user interface"), "url", target="_blank") table.text_cell(_("Site"), site.get("alias", site_id)) # Livestatus table.cell(_("Status"), css="narrow nobr") html.status_label(content=status, status=status, title=_("This site is %s") % status) # Livestatus-/Check_MK-Version table.cell(_("Version"), site_status.get("livestatus_version", ""), css="narrow nobr") table.cell(_("Changes"), "%d" % len(self._changes_of_site(site_id)), css="number narrow nobr") table.cell(_("Progress"), css="repprogress") html.open_div(id_="site_%s_status" % site_id, class_=["msg"]) html.close_div() html.open_div(id_="site_%s_progress" % site_id, class_=["progress"]) html.close_div() # Hidden on initial rendering and shown on activation start table.cell(_("Details"), css="details") html.open_div(id_="site_%s_details" % site_id) # Shown on initial rendering and hidden on activation start table.cell(_("Last result"), css="last_result") last_state = self._last_activation_state(site_id) if not is_logged_in: html.write_text(_("Is not logged in.") + " ") if not last_state: html.write_text(_("Has never been activated")) else: html.write_text("%s: %s. " % (_("State"), last_state["_status_text"])) if last_state["_status_details"]: html.write(last_state["_status_details"])
def buttons(self): html.context_button( _("Folder"), watolib.folder_preserving_link([("mode", "folder")]), "back")
def _vs_rules(self): return Dictionary( optional_keys=False, elements=[ ( "agent_port", Integer( minvalue=1, maxvalue=65535, default_value=6556, title=_('Checkmk Agent Port (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "agent_ports")] ), help=_( "This variable allows to specify the TCP port to " "be used to connect to the agent on a per-host-basis." ), ), ), ( "tcp_connect_timeout", Float( minvalue=1.0, default_value=5.0, unit=_("sec"), display_format="%.0f", # show values consistent to size=2, # SNMP-Timeout title=_('TCP Connection Timeout (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "tcp_connect_timeouts")] ), help=_( "This variable allows to specify a timeout for the " "TCP connection to the Check_MK agent on a per-host-basis." "If the agent does not respond within this time, it is considered to be unreachable." ), ), ), ( "snmp_timeout", Integer( title=_('SNMP-Timeout (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "snmp_timing")] ), help=_( "After a request is sent to the remote SNMP agent we will wait up to this " "number of seconds until assuming the answer get lost and retrying." ), default_value=1, minvalue=1, maxvalue=60, unit=_("sec"), ), ), ( "snmp_retries", Integer( title=_('SNMP-Retries (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "snmp_timing")] ), default_value=5, minvalue=0, maxvalue=50, ), ), ], )
def page(self): with table_element("roles") as table: users = userdb.load_users() for rid, role in sorted(self._roles.items(), key=lambda a: (a[1]["alias"], a[0])): table.row() # Actions table.cell(_("Actions"), css="buttons") edit_url = watolib.folder_preserving_link([("mode", "edit_role"), ("edit", rid)]) clone_url = make_action_link([("mode", "roles"), ("_clone", rid)]) delete_url = make_confirm_link( url=make_action_link([("mode", "roles"), ("_delete", rid)]), message=_("Do you really want to delete the role %s?") % rid, ) html.icon_button(edit_url, _("Properties"), "edit") html.icon_button(clone_url, _("Clone"), "clone") if not role.get("builtin"): html.icon_button(delete_url, _("Delete this role"), "delete") # ID table.cell(_("Name"), rid) # Alias table.cell(_("Alias"), role["alias"]) # Type table.cell( _("Type"), _("builtin") if role.get("builtin") else _("custom")) # Modifications table.cell( _("Modifications"), html.render_span( str(len(role["permissions"])), title= _("That many permissions do not use the factory defaults." ), ), ) # Users table.cell( _("Users"), HTML(", ").join([ html.render_a( user.get("alias", user_id), watolib.folder_preserving_link([ ("mode", "edit_user"), ("edit", user_id) ]), ) for (user_id, user) in users.items() if rid in user["roles"] ]), )