def _should_use_dns_cache(self) -> bool:
site = self._host.effective_attribute("site")
return watolib.sites.get_effective_global_setting(
site,
is_wato_slave_site(),
"use_dns_cache",
)
def site_globals_editable(site_id, site) -> bool:
# Site is a remote site of another site. Allow to edit probably pushed site
# specific globals when remote WATO is enabled
if is_wato_slave_site():
return True
# Local site: Don't enable site specific locals when no remote sites configured
if not has_wato_slave_sites():
return False
return site["replication"] or site_is_local(site_id)
def _check_site(self, site_id):
if _site_is_using_livestatus_proxy(site_id):
yield ACResultOK(_("Site is using the Livestatus Proxy Daemon"))
elif not is_wato_slave_site():
yield ACResultWARN(
_("The Livestatus Proxy is not only good for slave sites, "
"enable it for your master site"))
else:
yield ACResultWARN(
_("Use the Livestatus Proxy Daemon for your site"))
def user_sync_default_config(site_name: SiteId) -> UserSyncConfig:
global_user_sync = _transform_userdb_automatic_sync(
active_config.userdb_automatic_sync)
if global_user_sync == "master":
if site_is_local(site_name) and not is_wato_slave_site():
user_sync_default: UserSyncConfig = "all"
else:
user_sync_default = None
else:
user_sync_default = global_user_sync
return user_sync_default
def warn_about_renamed_remote_site(old_site_id: SiteId,
new_site_id: SiteId) -> None:
"""Warn user about central site that needs to be updated manually
Detect whether or not this is a remote site and issue a warning to let the user known"""
if not is_wato_slave_site():
return
logger.info("")
warning(
"You renamed a distributed remote site.\n\nTo make your distributed "
'setup work again, you will have to update the "Distributed Monitoring" '
"configuration in your central site.\n")
def activate(
self,
settings: Optional[SerializedSettings] = None
) -> ConfigurationWarnings:
current_settings = self._load_site_config()
settings = {}
settings.update(self._to_omd_config(self.load()))
settings.update(self._to_omd_config(self.load_site_globals()))
config_change_commands: List[str] = []
self._logger.debug("Set omd config: %r" % settings)
for key, val in settings.items():
if key not in current_settings:
continue # Skip settings unknown to current OMD
if current_settings[key] == val:
continue # Skip unchanged settings
config_change_commands.append("%s=%s" % (key, val))
if not config_change_commands:
self._logger.debug("Got no config change commands...")
return []
self._logger.debug('Executing "omd config change"')
self._logger.debug(" Commands: %r" % config_change_commands)
# We need a background job on remote sites to wait for the restart, so
# that the central site can gather the result of the activation.
# On a central site, the waiting for the end of the restart is already
# taken into account by the activate changes background job within
# async_progress.js. Just execute the omd config change command
if is_wato_slave_site():
job = OMDConfigChangeBackgroundJob()
if job.is_active():
raise MKUserError(
None,
_("Another omd config change job is already running."))
job.set_function(job.do_execute, config_change_commands)
job.start()
else:
_do_config_change(config_change_commands, self._logger)
return []
def available(self):
# This filter is also available on slave sites with disabled WATO
# To determine if this site is a slave we check the existance of the distributed_wato.mk
# file and the absence of any site configuration
return active_config.wato_enabled or site_config.is_wato_slave_site()
def _handle_ldap_sync_finished(logger, profiles_to_synchronize, changes):
_synchronize_profiles_to_sites(logger, profiles_to_synchronize)
if changes and active_config.wato_enabled and not is_wato_slave_site():
add_change("edit-users", "<br>".join(changes), add_user=False)
def execute_network_scan_job() -> None:
"""Executed by the multisite cron job once a minute. Is only executed in the
central site. Finds the next folder to scan and starts it via WATO
automation. The result is written to the folder in the master site."""
if is_wato_slave_site():
return # Don't execute this job on slaves.
folder = _find_folder_to_scan()
if not folder:
return # Nothing to do.
run_as = folder.attribute("network_scan")["run_as"]
if not userdb.user_exists(run_as):
raise MKGeneralException(
_("The user %s used by the network "
"scan of the folder %s does not exist.") %
(run_as, folder.title()))
with UserContext(run_as):
result: NetworkScanResult = {
"start": time.time(),
"end": True, # means currently running
"state": None,
"output": "The scan is currently running.",
}
# Mark the scan in progress: Is important in case the request takes longer than
# the interval of the cron job (1 minute). Otherwise the scan might be started
# a second time before the first one finished.
_save_network_scan_result(folder, result)
try:
if site_is_local(folder.site_id()):
found = _do_network_scan(folder)
else:
found = do_remote_automation(get_site_config(folder.site_id()),
"network-scan",
[("folder", folder.path())])
if not isinstance(found, list):
raise MKGeneralException(
_("Received an invalid network scan result: %r") % found)
_add_scanned_hosts_to_folder(folder, found)
result.update({
"state":
True,
"output":
_("The network scan found %d new hosts.") % len(found),
})
except Exception as e:
result.update({
"state": False,
"output": _("An exception occured: %s") % e,
})
logger.error("Exception in network scan:\n%s",
traceback.format_exc())
result["end"] = time.time()
_save_network_scan_result(folder, result)
def show(self):
if not site_config.is_wato_slave_site():
if not active_config.wato_enabled:
html.write_text(_("Setup is disabled."))
return False
user_folders = compute_foldertree()
#
# Render link target selection
#
# Apply some view specific filters
views_to_show: List[Tuple[str, ViewSpec]] = []
dflt_target_name: str = "allhosts"
dflt_topic_name: str = ""
for name, view in views.get_permitted_views().items():
if (not active_config.visible_views
or name in active_config.visible_views) and (
not active_config.hidden_views
or name not in active_config.hidden_views):
views_to_show.append((name, view))
if name == dflt_target_name:
dflt_topic_name = view["topic"]
selected_topic_name: str
selected_target_name: str
selected_topic_name, selected_target_name = user.load_file(
"foldertree", (dflt_topic_name, dflt_target_name))
visuals_to_show = [("views", e) for e in views_to_show]
visuals_to_show += [
("dashboards", e)
for e in dashboard.get_permitted_dashboards().items()
]
topics = make_topic_menu(visuals_to_show)
topic_choices: Choices = [(topic.title, topic.title)
for topic in topics]
html.open_table()
html.open_tr()
html.open_td()
html.dropdown(
"topic",
topic_choices,
deflt=selected_topic_name,
onchange="cmk.sidebar.wato_tree_topic_changed(this)",
)
html.close_td()
html.close_tr()
html.open_tr()
html.open_td()
for topic in topics:
targets: Choices = []
for item in topic.items:
if item.url and item.url.startswith("dashboard.py"):
name = "dashboard|" + item.name
else:
name = item.name
targets.append((name, item.title))
if topic.name != selected_topic_name:
default = ""
style: Optional[str] = "display:none"
else:
default = selected_target_name
style = None
html.dropdown(
"target_%s" % topic.title,
targets,
deflt=default,
onchange="cmk.sidebar.wato_tree_target_changed(this)",
style=style,
)
html.close_td()
html.close_tr()
html.close_table()
# Now render the whole tree
if user_folders:
render_tree_folder("wato-hosts",
list(user_folders.values())[0],
"cmk.sidebar.wato_tree_click")
def is_show_more(self) -> bool:
return not (has_wato_slave_sites() or is_wato_slave_site())