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 save_global_settings(vars_, site_specific=False, custom_site_path=None): per_domain: Dict[str, Dict[Any, Any]] = {} # TODO: Uee _get_global_config_var_names() from domain class? for config_variable_class in config_variable_registry.values(): config_variable = config_variable_class() domain = config_variable.domain() varname = config_variable.ident() if varname not in vars_: continue per_domain.setdefault(domain().ident(), {})[varname] = vars_[varname] # Some settings are handed over from the central site but are not registered in the # configuration domains since the user must not change it directly. for varname in [ "wato_enabled", "userdb_automatic_sync", "user_login", ]: if varname in vars_: per_domain.setdefault(ConfigDomainGUI.ident(), {})[varname] = vars_[varname] for domain in ABCConfigDomain.enabled_domains(): domain_config = per_domain.get(domain().ident(), {}) if site_specific: domain().save_site_globals(domain_config, custom_site_path=custom_site_path) else: domain().save(domain_config, custom_site_path=custom_site_path)
def page_menu(self, breadcrumb: Breadcrumb) -> PageMenu: menu = make_simple_form_page_menu(_("Setting"), breadcrumb, form_name="value_editor", button_name="_save") reset_possible = self._config_variable.allow_reset( ) and self._is_configured() default_values = ABCConfigDomain.get_all_default_globals() defvalue = default_values[self._varname] value = self._current_settings.get( self._varname, self._global_settings.get(self._varname, defvalue)) menu.dropdowns[0].topics[0].entries.append( PageMenuEntry( title=_("Remove explicit setting") if value == defvalue else _("Reset to default"), icon_name="reset", item=make_confirmed_form_submit_link( form_name="value_editor", button_name="_reset", message=_( "Do you really want to reset this configuration variable " "back to its default value?"), ), is_enabled=reset_possible, is_shortcut=True, is_suggested=True, )) return menu
def save_global_settings(vars_, site_specific=False, custom_site_path=None): per_domain = {} # type: Dict[str, Dict[Any, Any]] # TODO: Uee _get_global_config_var_names() from domain class? for config_variable_class in config_variable_registry.values(): config_variable = config_variable_class() domain = config_variable.domain() varname = config_variable.ident() if varname not in vars_: continue per_domain.setdefault(domain.ident, {})[varname] = vars_[varname] # The global setting wato_enabled is not registered in the configuration domains # since the user must not change it directly. It is set by D-WATO on slave sites. if "wato_enabled" in vars_: per_domain.setdefault(ConfigDomainGUI.ident, {})["wato_enabled"] = vars_["wato_enabled"] if "userdb_automatic_sync" in vars_: per_domain.setdefault( ConfigDomainGUI.ident, {})["userdb_automatic_sync"] = vars_["userdb_automatic_sync"] for domain in ABCConfigDomain.enabled_domains(): domain_config = per_domain.get(domain.ident, {}) if site_specific: domain().save_site_globals(domain_config, custom_site_path=custom_site_path) else: domain().save(domain_config, custom_site_path=custom_site_path)
def load_configuration_settings(site_specific=False): settings = {} for domain in ABCConfigDomain.enabled_domains(): if site_specific: settings.update(domain().load_site_globals()) else: settings.update(domain().load()) return settings
def __init__(self): self._search = None self._show_only_modified = False super(GlobalSettingsMode, self).__init__() self._default_values = ABCConfigDomain.get_all_default_globals() self._global_settings = {} self._current_settings = {}
def __init__(self) -> None: self._search = None self._show_only_modified = False super().__init__() self._default_values = ABCConfigDomain.get_all_default_globals() self._global_settings: dict[str, Any] = {} self._current_settings: dict[str, Any] = {}
def page(self) -> None: is_configured = self._is_configured() is_configured_globally = self._varname in self._global_settings default_values = ABCConfigDomain.get_all_default_globals() defvalue = default_values[self._varname] value = self._current_settings.get( self._varname, self._global_settings.get(self._varname, defvalue)) hint = self._config_variable.hint() if hint: html.show_warning(hint) html.begin_form("value_editor", method="POST") title = self._valuespec.title() assert isinstance(title, str) forms.header(title) if not active_config.wato_hide_varnames: forms.section(_("Configuration variable:")) html.tt(self._varname) forms.section(_("Current setting")) self._valuespec.render_input("ve", value) self._valuespec.set_focus("ve") html.help(self._valuespec.help()) if is_configured_globally: self._show_global_setting() forms.section(_("Factory setting")) html.write_text(self._valuespec.value_to_html(defvalue)) forms.section(_("Current state")) if is_configured_globally: html.write_text( _('This variable is configured in <a href="%s">global settings</a>.' ) % ("wato.py?mode=edit_configvar&varname=%s" % self._varname)) elif not is_configured: html.write_text(_("This variable is at factory settings.")) else: curvalue = self._current_settings[self._varname] if is_configured_globally and curvalue == self._global_settings[ self._varname]: html.write_text( _("Site setting and global setting are identical.")) elif curvalue == defvalue: html.write_text( _("Your setting and factory settings are identical.")) else: html.write_text(self._valuespec.value_to_html(curvalue)) forms.end() html.hidden_fields() html.end_form()
def load_configuration_settings(site_specific=False, custom_site_path=None, full_config=False): settings = {} for domain in ABCConfigDomain.enabled_domains(): if full_config: settings.update(domain().load_full_config()) elif site_specific: settings.update(domain().load_site_globals(custom_site_path=custom_site_path)) else: settings.update(domain().load()) return settings
def _get_effective_global_setting(self, varname: str) -> Any: global_settings = load_configuration_settings() default_values = ABCConfigDomain.get_all_default_globals() if cmk.gui.config.is_wato_slave_site(): current_settings = load_configuration_settings(site_specific=True) else: sites = SiteManagementFactory.factory().load_sites() current_settings = sites[config.omd_site()].get("globals", {}) if varname in current_settings: return current_settings[varname] if varname in global_settings: return global_settings[varname] return default_values[varname]
def get_effective_global_setting(site_id: SiteId, is_wato_slave_site: bool, varname: str) -> Any: global_settings = load_configuration_settings() default_values = ABCConfigDomain.get_all_default_globals() if is_wato_slave_site: current_settings = load_configuration_settings(site_specific=True) else: sites = SiteManagementFactory.factory().load_sites() current_settings = sites.get(site_id, {}).get("globals", {}) if varname in current_settings: return current_settings[varname] if varname in global_settings: return global_settings[varname] return default_values[varname]
def execute(self) -> Iterator[ACResult]: local_connection = LocalConnection() row = local_connection.query_row( "GET status\nColumns: helper_usage_checker average_latency_fetcher\n" ) checker_usage_perc = 100 * row[0] fetcher_latency = row[1] usage_warn, usage_crit = 85, 95 if checker_usage_perc >= usage_crit: cls: Type[ACResult] = ACResultCRIT elif checker_usage_perc >= usage_warn: cls = ACResultWARN else: cls = ACResultOK yield cls( _( "The current checker usage is %.2f%%. " "The checks have an average check latency of %.3fs." ) % (checker_usage_perc, fetcher_latency) ) # Only report this as warning in case the user increased the default helper configuration default_values = ABCConfigDomain.get_all_default_globals() if ( self._get_effective_global_setting("cmc_checker_helpers") > default_values["cmc_checker_helpers"] and checker_usage_perc < 50 ): yield ACResultWARN( _( "The checker usage is below 50%, you may decrease the number of " "checkers to reduce the memory consumption." ) )