def __init__(self):
super(ModeCustomAttrs, self).__init__()
# TODO: Inappropriate Intimacy: custom host attributes should not now about
# custom user attributes and vice versa. The only reason they now about
# each other now is that they are stored in one file.
self._all_attrs = load_custom_attrs_from_mk_file(
lock=html.is_transaction())
def page_handler() -> None:
initialize_wato_html_head()
if not config.wato_enabled:
raise MKGeneralException(
_("WATO is disabled. Please set <tt>wato_enabled = True</tt>"
" in your <tt>multisite.mk</tt> if you want to use WATO."))
# config.current_customer can not be checked with CRE repos
if cmk_version.is_managed_edition() and not managed.is_provider(
config.current_customer): # type: ignore[attr-defined]
raise MKGeneralException(
_("Check_MK can only be configured on "
"the managers central site."))
current_mode = html.request.var("mode") or "main"
mode_permissions, mode_class = _get_mode_permission_and_class(current_mode)
display_options.load_from_html(html)
if display_options.disabled(display_options.N):
html.add_body_css_class("inline")
# If we do an action, we aquire an exclusive lock on the complete WATO.
if html.is_transaction():
with store.lock_checkmk_configuration():
_wato_page_handler(current_mode, mode_permissions, mode_class)
else:
_wato_page_handler(current_mode, mode_permissions, mode_class)
def _from_vars(self):
# TODO: Should we turn the both fields below into Optional[UserId]?
self._user_id = html.request.get_unicode_input(
"edit") # missing -> new user
# This is needed for the breadcrumb computation:
# When linking from user notification rules page the request variable is "user"
# instead of "edit". We should also change that variable to "user" on this page,
# then we can simply use self._user_id.
if not self._user_id and html.request.has_var("user"):
self._user_id = html.request.get_str_input_mandatory("user")
self._cloneid = html.request.get_unicode_input(
"clone") # Only needed in 'new' mode
# TODO: Nuke the field below? It effectively hides facts about _user_id for mypy.
self._is_new_user = self._user_id is None
self._users = userdb.load_users(lock=html.is_transaction())
new_user = userdb.new_user_template('htpasswd')
if self._user_id is not None:
self._user = self._users.get(UserId(self._user_id), new_user)
elif self._cloneid:
self._user = self._users.get(UserId(self._cloneid), new_user)
else:
self._user = new_user
self._locked_attributes = userdb.locked_attributes(
self._user.get('connector'))
def handle_edit_annotations():
# Avoid reshowing edit form after edit and reload
if html.is_transaction() and not html.transaction_valid():
return False
if html.request.var("anno_host") and not html.request.var("_delete_annotation"):
finished = edit_annotation()
else:
finished = False
return finished
def _from_vars(self):
# TODO: Should we turn the both fields below into Optional[UserId]?
self._user_id = html.request.get_unicode_input("edit") # missing -> new user
self._cloneid = html.request.get_unicode_input("clone") # Only needed in 'new' mode
# TODO: Nuke the field below? It effectively hides facts about _user_id for mypy.
self._is_new_user = self._user_id is None
self._users = userdb.load_users(lock=html.is_transaction())
new_user = userdb.new_user_template('htpasswd')
if self._user_id is not None:
self._user = self._users.get(UserId(self._user_id), new_user)
elif self._cloneid:
self._user = self._users.get(UserId(self._cloneid), new_user)
else:
self._user = new_user
self._locked_attributes = userdb.locked_attributes(self._user.get('connector'))
def _from_vars(self):
self._user_id = html.get_unicode_input("edit") # missing -> new user
self._cloneid = html.get_unicode_input("clone") # Only needed in 'new' mode
self._is_new_user = self._user_id is None
self._users = userdb.load_users(lock=html.is_transaction())
if self._is_new_user:
if self._cloneid:
self._user = self._users.get(self._cloneid, userdb.new_user_template('htpasswd'))
else:
self._user = userdb.new_user_template('htpasswd')
else:
self._user = self._users.get(self._user_id, userdb.new_user_template('htpasswd'))
self._locked_attributes = userdb.locked_attributes(self._user.get('connector'))
def _from_vars(self):
self._connection_id = html.request.get_ascii_input("id")
self._connection_cfg = {}
self._connections = load_connection_config(lock=html.is_transaction())
if self._connection_id is None:
clone_id = html.request.var("clone")
if clone_id is not None:
self._connection_cfg = self._get_connection_cfg_and_index(clone_id)[0]
self._new = True
return
self._new = False
self._connection_cfg, self._connection_nr = self._get_connection_cfg_and_index(
self._connection_id)
def _from_vars(self):
self._name = html.request.get_ascii_input("edit") # missing -> new custom attr
self._new = self._name is None
# TODO: Inappropriate Intimacy: custom host attributes should not now about
# custom user attributes and vice versa. The only reason they now about
# each other now is that they are stored in one file.
self._all_attrs = load_custom_attrs_from_mk_file(lock=html.is_transaction())
if not self._new:
matching_attrs = [a for a in self._attrs if a['name'] == self._name]
if not matching_attrs:
raise MKUserError(None, _('The attribute does not exist.'))
self._attr: Dict[str, Any] = matching_attrs[0]
else:
self._attr = {}
def _wato_page_handler(current_mode: str,
mode_permissions: Optional[List[PermissionName]],
mode_class: Type[WatoMode]) -> None:
try:
init_wato_datastructures(with_wato_lock=not html.is_transaction())
except Exception:
# Snapshot must work in any case
if current_mode == 'snapshot':
pass
else:
raise
# Check general permission for this mode
if mode_permissions is not None and not config.user.may("wato.seeall"):
_ensure_mode_permissions(mode_permissions)
mode = mode_class()
# Do actions (might switch mode)
if html.is_transaction():
try:
config.user.need_permission("wato.edit")
# Even if the user has seen this mode because auf "seeall",
# he needs an explicit access permission for doing changes:
if config.user.may("wato.seeall"):
if mode_permissions:
_ensure_mode_permissions(mode_permissions)
if cmk.gui.watolib.read_only.is_enabled(
) and not cmk.gui.watolib.read_only.may_override():
raise MKUserError(None, cmk.gui.watolib.read_only.message())
result = mode.action()
if isinstance(result, (tuple, str, bool)):
raise MKGeneralException(
f"WatoMode \"{current_mode}\" returns unsupported return value: {result!r}"
)
# We assume something has been modified and increase the config generation ID by one.
update_config_generation()
if config.wato_use_git:
do_git_commit()
# Handle two cases:
# a) Don't render the page content after action
# (a confirm dialog is displayed by the action, or a non-HTML content was sent)
# b) Redirect to another page
if isinstance(result, FinalizeRequest):
raise result
except MKUserError as e:
html.add_user_error(e.varname, str(e))
except MKAuthException as e:
reason = e.args[0]
html.add_user_error(None, reason)
breadcrumb = make_main_menu_breadcrumb(
mode.main_menu()) + mode.breadcrumb()
page_menu = mode.page_menu(breadcrumb)
wato_html_head(title=mode.title(),
breadcrumb=breadcrumb,
page_menu=page_menu,
show_body_start=display_options.enabled(display_options.H),
show_top_heading=display_options.enabled(display_options.T))
if not html.is_transaction() or (cmk.gui.watolib.read_only.is_enabled() and
cmk.gui.watolib.read_only.may_override()):
_show_read_only_warning()
# Show outcome of failed action on this page
if html.has_user_errors():
html.show_user_errors()
# Show outcome of previous page (that redirected to this one)
for message in get_flashed_messages():
html.show_message(message)
# Show content
mode.handle_page()
if is_sidebar_reload_needed():
html.reload_whole_page()
wato_html_footer(show_body_end=display_options.enabled(display_options.H))
def _wato_page_handler(current_mode: str,
mode_permissions: List[PermissionName],
mode_class: Type[WatoMode]) -> None:
try:
init_wato_datastructures(with_wato_lock=not html.is_transaction())
except Exception:
# Snapshot must work in any case
if current_mode == 'snapshot':
pass
else:
raise
# Check general permission for this mode
if mode_permissions is not None and not config.user.may("wato.seeall"):
_ensure_mode_permissions(mode_permissions)
mode = mode_class()
# Do actions (might switch mode)
action_message: Optional[str] = None
if html.is_transaction():
try:
config.user.need_permission("wato.edit")
# Even if the user has seen this mode because auf "seeall",
# he needs an explicit access permission for doing changes:
if config.user.may("wato.seeall"):
if mode_permissions:
_ensure_mode_permissions(mode_permissions)
if cmk.gui.watolib.read_only.is_enabled(
) and not cmk.gui.watolib.read_only.may_override():
raise MKUserError(None, cmk.gui.watolib.read_only.message())
result = mode.action()
if isinstance(result, tuple):
newmode, action_message = result
else:
newmode = result
# We assume something has been modified and increase the config generation ID by one.
update_config_generation()
# If newmode is False, then we shall immediately abort.
# This is e.g. the case, if the page outputted non-HTML
# data, such as a tarball (in the export function). We must
# be sure not to output *any* further data in that case.
if newmode is False:
return
# if newmode is not None, then the mode has been changed
if newmode is not None:
assert not isinstance(newmode, bool)
if newmode == "": # no further information: configuration dialog, etc.
if action_message:
html.show_message(action_message)
wato_html_footer()
return
mode_permissions, mode_class = _get_mode_permission_and_class(
newmode)
current_mode = newmode
mode = mode_class()
html.request.set_var("mode",
newmode) # will be used by makeuri
# Check general permissions for the new mode
if mode_permissions is not None and not config.user.may(
"wato.seeall"):
for pname in mode_permissions:
if '.' not in pname:
pname = "wato." + pname
config.user.need_permission(pname)
except MKUserError as e:
action_message = "%s" % e
html.add_user_error(e.varname, action_message)
except MKAuthException as e:
reason = e.args[0]
action_message = reason
html.add_user_error(None, reason)
breadcrumb = make_main_menu_breadcrumb(
mode.main_menu()) + mode.breadcrumb()
page_menu = mode.page_menu(breadcrumb)
wato_html_head(title=mode.title(),
breadcrumb=breadcrumb,
page_menu=page_menu,
show_body_start=display_options.enabled(display_options.H),
show_top_heading=display_options.enabled(display_options.T))
if not html.is_transaction() or (cmk.gui.watolib.read_only.is_enabled() and
cmk.gui.watolib.read_only.may_override()):
_show_read_only_warning()
# Show outcome of action
if html.has_user_errors():
html.show_user_errors()
elif action_message:
html.show_message(action_message)
# Show content
mode.handle_page()
if is_sidebar_reload_needed():
html.reload_sidebar()
if config.wato_use_git and html.is_transaction():
do_git_commit()
wato_html_footer(show_footer=display_options.enabled(display_options.Z),
show_body_end=display_options.enabled(display_options.H))
