def save_timeperiods(timeperiods: TimeperiodSpecs) -> None:
store.mkdir(wato_root_dir())
store.save_to_mk_file(wato_root_dir() + "timeperiods.mk",
"timeperiods",
_filter_builtin_timeperiods(timeperiods),
pprint_value=config.wato_pprint_config)
g.timeperiod_information = timeperiods
def log_entry(linkinfo, action, message, user_id=None):
# Using attrencode here is against our regular rule to do the escaping
# at the last possible time: When rendering. But this here is the last
# place where we can distinguish between HTML() encapsulated (already)
# escaped / allowed HTML and strings to be escaped.
message = cmk.utils.make_utf8(html.attrencode(message)).strip()
# TODO: Create a more generic referencing
# linkinfo identifies the object operated on. It can be a Host or a Folder
# or a text.
# linkinfo is either a Folder, or a Host or a hostname or None
if hasattr(linkinfo, "linkinfo"):
link = linkinfo.linkinfo()
elif linkinfo is None:
link = "-"
else:
link = linkinfo
if user_id is None and config.user.id is not None:
user_id = config.user.id
elif user_id == '':
user_id = '-'
if user_id:
user_id = user_id.encode("utf-8")
store.mkdir(os.path.dirname(audit_log_path))
with open(audit_log_path, "ab") as f:
os.chmod(f.name, 0660)
f.write("%d %s %s %s %s\n" % (int(time.time()), link, user_id, action,
message.replace("\n", "\\n")))
def _confdir_for_user_id(user_id: Optional[UserId]) -> Optional[str]:
if user_id is None:
return None
confdir = config_dir + "/" + ensure_str(user_id)
store.mkdir(confdir)
return confdir
def save_notification_rules(rules):
store.mkdir(wato_root_dir())
store.save_to_mk_file(
wato_root_dir() + "notifications.mk",
"notification_rules",
rules,
pprint_value=config.wato_pprint_config)
def _confdir_for_user_id(user_id: Optional[UserId]) -> Optional[str]:
if user_id is None:
return None
confdir = cmk.utils.paths.profile_dir / user_id
store.mkdir(confdir)
return str(confdir)
def save_notification_rules(rules):
# type: (List[Dict]) -> None
store.mkdir(wato_root_dir())
store.save_to_mk_file(wato_root_dir() + "notifications.mk",
"notification_rules",
rules,
pprint_value=config.wato_pprint_config)
def _save_folder(self, folder):
store.mkdir(folder.get_root_dir())
has_content = False
content = ""
for varname, ruleset in sorted(self._rulesets.items(), key=lambda x: x[0]):
if varname not in rulespec_registry:
continue # don't save unknown rulesets
if ruleset.is_empty_in_folder(folder):
continue # don't save empty rule sets
has_content = True
content += ruleset.to_config(folder)
rules_file_path = folder.rules_file_path()
# Remove rules files if it has no content. This prevents needless reads
if not has_content:
if os.path.exists(rules_file_path):
os.unlink(rules_file_path) # Do not keep empty rules.mk files
return
# Adding this instead of the full path makes it easy to move config
# files around. The real FOLDER_PATH will be added dynamically while
# loading the file in cmk.base.config
content = content.replace("'%s'" % _FOLDER_PATH_MACRO, "'/%s/' % FOLDER_PATH")
store.save_mk_file(rules_file_path, content, add_header=not config.wato_use_git)
def save_user_file(name: str, data: Any, user_id: Optional[UserId]) -> None:
if user_id is None:
raise TypeError("The profiles of LoggedInSuperUser and LoggedInNobody cannot be saved")
path = config_dir + "/" + ensure_str(user_id) + "/" + name + ".mk"
store.mkdir(os.path.dirname(path))
store.save_object_to_file(path, data)
def _save_user_profiles(updated_profiles: Users) -> None:
non_contact_keys = _non_contact_keys()
multisite_keys = _multisite_keys()
for user_id, user in updated_profiles.items():
user_dir = cmk.utils.paths.var_dir + "/web/" + ensure_str(user_id)
store.mkdir(user_dir)
# authentication secret for local processes
auth_file = user_dir + "/automation.secret"
if "automation_secret" in user:
store.save_file(auth_file, "%s\n" % user["automation_secret"])
elif os.path.exists(auth_file):
os.unlink(auth_file)
# Write out user attributes which are written to dedicated files in the user
# profile directory. The primary reason to have separate files, is to reduce
# the amount of data to be loaded during regular page processing
save_custom_attr(user_id, 'serial', str(user.get('serial', 0)))
save_custom_attr(user_id, 'num_failed_logins', str(user.get('num_failed_logins', 0)))
save_custom_attr(user_id, 'enforce_pw_change', str(int(user.get('enforce_pw_change',
False))))
save_custom_attr(user_id, 'last_pw_change', str(user.get('last_pw_change',
int(time.time()))))
if "idle_timeout" in user:
save_custom_attr(user_id, "idle_timeout", user["idle_timeout"])
else:
remove_custom_attr(user_id, "idle_timeout")
_save_cached_profile(user_id, user, multisite_keys, non_contact_keys)
def create_snapshot(comment):
logger.debug("Start creating backup snapshot")
start = time.time()
store.mkdir(snapshot_dir)
snapshot_name = "wato-snapshot-%s.tar" % time.strftime(
"%Y-%m-%d-%H-%M-%S", time.localtime(time.time())
)
data: Dict[str, Any] = {}
data["comment"] = _("Activated changes by %s.") % user.id
if comment:
data["comment"] += _("Comment: %s") % comment
# with SuperUserContext the user.id is None; later this value will be encoded for tar
data["created_by"] = "" if user.id is None else user.id
data["type"] = "automatic"
data["snapshot_name"] = snapshot_name
_do_create_snapshot(data)
_do_snapshot_maintenance()
log_audit("snapshot-created", _("Created snapshot %s") % snapshot_name)
logger.debug("Backup snapshot creation took %.4f", time.time() - start)
def save_timeperiods(timeperiods):
# type: (TimeperiodSpecs) -> None
store.mkdir(wato_root_dir())
store.save_to_mk_file(wato_root_dir() + "timeperiods.mk",
"timeperiods",
_filter_builtin_timeperiods(timeperiods),
pprint_value=config.wato_pprint_config)
def _confdir_for_user_id(user_id):
# type: (Optional[UserId]) -> Optional[str]
if user_id is None:
return None
confdir = config_dir + "/" + user_id.encode("utf-8")
store.mkdir(confdir)
return confdir
def save_notification_rules(rules: list[EventRule]) -> None:
store.mkdir(wato_root_dir())
store.save_to_mk_file(
wato_root_dir() + "notifications.mk",
"notification_rules",
rules,
pprint_value=active_config.wato_pprint_config,
)
def save_user_file(name, data, user_id):
# type: (str, Any, Optional[UserId]) -> None
if user_id is None:
raise TypeError("The profiles of LoggedInSuperUser and LoggedInNobody cannot be saved")
path = config_dir + "/" + user_id.encode("utf-8") + "/" + name + ".mk"
store.mkdir(os.path.dirname(path))
store.save_object_to_file(path, data)
def save_timeperiods(timeperiods: TimeperiodSpecs) -> None:
store.mkdir(wato_root_dir())
store.save_to_mk_file(
wato_root_dir() + "timeperiods.mk",
"timeperiods",
_filter_builtin_timeperiods(timeperiods),
pprint_value=active_config.wato_pprint_config,
)
load_timeperiods.cache_clear()
def save_custom_attrs_to_mk_file(attrs):
output = watolib.wato_fileheader()
for what in ["user", "host"]:
if what in attrs and len(attrs[what]) > 0:
output += "if type(wato_%s_attrs) != list:\n wato_%s_attrs = []\n" % (what, what)
output += "wato_%s_attrs += %s\n\n" % (what, pprint.pformat(attrs[what]))
store.mkdir(watolib.multisite_dir())
store.save_text_to_file(watolib.multisite_dir() + "custom_attrs.mk", output)
def save_connection_config(connections, base_dir=None):
# type: (List[UserConnectionSpec], str) -> None
if not base_dir:
base_dir = _multisite_dir()
store.mkdir(base_dir)
store.save_to_mk_file(os.path.join(base_dir, "user_connections.mk"),
"user_connections", connections)
for connector_class in user_connector_registry.values():
connector_class.config_changed()
def _update_replication_status(site_id, vars_):
"""Updates one or more dict elements of a site in an atomic way."""
store.mkdir(var_dir)
repl_status = _load_site_replication_status(site_id, lock=True)
try:
repl_status.setdefault("times", {})
repl_status.update(vars_)
finally:
_save_site_replication_status(site_id, repl_status)
def _save_site_globals_on_slave_site(self, tarcontent):
tmp_dir = cmk.utils.paths.tmp_dir + "/sitespecific-%s" % id(html)
try:
if not os.path.exists(tmp_dir):
store.mkdir(tmp_dir)
multitar.extract_from_buffer(tarcontent, [("dir", "sitespecific", tmp_dir)])
site_globals = store.load_object_from_file(tmp_dir + "/sitespecific.mk", default={})
save_site_global_settings(site_globals)
finally:
shutil.rmtree(tmp_dir)
def save_connection_config(connections: List[UserConnectionSpec],
base_dir: Optional[str] = None) -> None:
if not base_dir:
base_dir = _multisite_dir()
store.mkdir(base_dir)
store.save_to_mk_file(os.path.join(base_dir, "user_connections.mk"),
"user_connections", connections)
for connector_class in user_connector_registry.values():
connector_class.config_changed()
clear_user_connection_cache()
def _create_auth_file(callee, users=None):
if users is None:
users = userdb.load_users()
store.mkdir(_auth_base_dir)
contactgroups = load_contact_group_information()
groups = {}
for gid, group in contactgroups.items():
if 'nagvis_maps' in group and group['nagvis_maps']:
groups[gid] = group['nagvis_maps']
_create_php_file(callee, users, config.get_role_permissions(), groups)
def _save_roles(self):
# Reflect the data in the roles dict kept in the config module Needed
# for instant changes in current page while saving modified roles.
# Otherwise the hooks would work with old data when using helper
# functions from the config module
config.roles.update(self._roles)
store.mkdir(watolib.multisite_dir())
store.save_to_mk_file(watolib.multisite_dir() + "roles.mk",
"roles",
self._roles,
pprint_value=config.wato_pprint_config)
hooks.call("roles-saved", self._roles)
def create_auth_file(callee, users=None):
from cmk.gui.watolib.groups import load_contact_group_information
import cmk.gui.userdb as userdb # TODO: Cleanup
if users is None:
users = userdb.load_users()
store.mkdir(g_auth_base_dir)
contactgroups = load_contact_group_information()
groups = {}
for gid, group in contactgroups.items():
if 'nagvis_maps' in group and group['nagvis_maps']:
groups[gid] = group['nagvis_maps']
create_php_file(callee, users, config.get_role_permissions(), groups)
def _save_folder(self, folder):
store.mkdir(folder.get_root_dir())
content = ""
for varname, ruleset in sorted(self._rulesets.items(),
key=lambda x: x[0]):
if varname not in rulespec_registry:
continue # don't save unknown rulesets
if ruleset.is_empty_in_folder(folder):
continue # don't save empty rule sets
content += ruleset.to_config(folder)
store.save_mk_file(folder.rules_file_path(),
content,
add_header=not config.wato_use_git)
def save_sites(cls, sites, activate=True):
# TODO: Clean this up
from cmk.gui.watolib.hosts_and_folders import Folder
store.mkdir(multisite_dir())
store.save_to_mk_file(cls._sites_mk(), "sites", sites)
# Do not activate when just the site's global settings have
# been edited
if activate:
config.load_config() # make new site configuration active
_update_distributed_wato_file(sites)
Folder.invalidate_caches()
cmk.gui.watolib.sidebar_reload.need_sidebar_reload()
_create_nagvis_backends(sites)
# Call the sites saved hook
hooks.call("sites-saved", sites)
def create_snapshot(comment):
store.mkdir(snapshot_dir)
snapshot_name = "wato-snapshot-%s.tar" % time.strftime(
"%Y-%m-%d-%H-%M-%S", time.localtime(time.time()))
data = {}
data["comment"] = _("Activated changes by %s.") % config.user.id
if comment:
data["comment"] += _("Comment: %s") % comment
data["created_by"] = config.user.id
data["type"] = "automatic"
data["snapshot_name"] = snapshot_name
_do_create_snapshot(data)
_do_snapshot_maintenance()
return snapshot_name
def _save_folder(self, folder):
store.mkdir(folder.get_root_dir())
content = ""
for varname, ruleset in sorted(self._rulesets.items(),
key=lambda x: x[0]):
if varname not in rulespec_registry:
continue # don't save unknown rulesets
if ruleset.is_empty_in_folder(folder):
continue # don't save empty rule sets
content += ruleset.to_config(folder)
# Adding this instead of the full path makes it easy to move config
# files around. The real FOLDER_PATH will be added dynamically while
# loading the file in cmk_base.config
content = content.replace("'%s'" % _FOLDER_PATH_MACRO,
"'/' + FOLDER_PATH")
store.save_mk_file(folder.rules_file_path(),
content,
add_header=not config.wato_use_git)
def create_snapshot(comment):
logger.debug("Start creating backup snapshot")
start = time.time()
store.mkdir(snapshot_dir)
snapshot_name = "wato-snapshot-%s.tar" % time.strftime("%Y-%m-%d-%H-%M-%S",
time.localtime(time.time()))
data = {} # type: Dict[str, Any]
data["comment"] = _("Activated changes by %s.") % config.user.id
if comment:
data["comment"] += _("Comment: %s") % comment
data["created_by"] = config.user.id
data["type"] = "automatic"
data["snapshot_name"] = snapshot_name
_do_create_snapshot(data)
_do_snapshot_maintenance()
log_audit(None, "snapshot-created", _("Created snapshot %s") % snapshot_name)
logger.debug("Backup snapshot creation took %.4f", time.time() - start)
def save_user_file(name: str, data: Any, user_id: UserId) -> None:
path = cmk.utils.paths.profile_dir.joinpath(user_id, name + ".mk")
store.mkdir(path.parent)
store.save_object_to_file(path, data)
def save_gui_messages(messages, user_id=None):
if user_id is None:
user_id = config.user.id
path = config.config_dir + "/" + six.ensure_str(user_id) + '/messages.mk'
store.mkdir(os.path.dirname(path))
store.save_object_to_file(path, messages)
