def _valuespec_diskstat_inventory():
return ListChoice(
title=_("Discovery mode for Disk IO check"),
help=_("This rule controls which and how many checks will be created "
"for monitoring individual physical and logical disks. "
"Note: the option <i>Create a summary for all read, one for "
"write</i> has been removed. Some checks will still support "
"this settings, but it will be removed there soon."),
choices=[
("summary", _("Create a summary over all physical disks")),
# This option is still supported by some checks, but is deprecated and
# we fade it out...
# ( "legacy", _("Create a summary for all read, one for write") ),
("physical", _("Create a separate check for each physical disk")),
("lvm", _("Create a separate check for each LVM volume (Linux)")),
("vxvm",
_("Creata a separate check for each VxVM volume (Linux)")),
("diskless",
_("Creata a separate check for each partition (XEN)")),
],
default_value=['summary'],
)
def hr_process_match_elements():
return [
('match_name_or_path',
CascadingDropdown(
title=_('Process Match textual description or path of process'),
choices=[
('match_name', _("Match textual description"),
hr_process_match_name_option()),
('match_path', _("Match process path"),
hr_process_match_path_option()),
('match_all', _("Match all processes")),
])),
('match_status',
ListChoice(title=_('Process Status Matching'),
choices=[
('running', _('Running')),
('runnable', _('Runnable (Waiting for resource)')),
('not_runnable',
_('Not runnable (Loaded but waiting for event)')),
('invalid', _('Invalid (Not loaded)')),
])),
]
def valuespec(self):
return Optional(
valuespec=ListChoice(
choices=[
("SNMPTRAP", _("Receive SNMP traps (UDP/162)")),
("SYSLOG", _("Receive Syslog messages (UDP/514)")),
("SYSLOG_TCP", _("Receive Syslog messages (TCP/514)")),
],
title=_("Listen for incoming messages via"),
empty_text=_("Locally enabled"),
),
title=_("Event Console"),
help=
_("This option enables the Event Console - The event processing and "
"classification daemon of Check_MK. You can also configure whether "
"or not the Event Console shal listen for incoming SNMP traps or "
"syslog messages. Please note that only a single Check_MK site per "
"Check_MK server can listen for such messages."),
label=_("Event Console enabled"),
none_label=_("Event Console disabled"),
indent=False,
)
def parameter_valuespec(self):
return Dictionary(elements=[
("error_states",
ListChoice(
title=_("Modem States that lead to a critical state"),
help=
_("If one of the selected states occurs the check will repsond with a critical state "
),
choices=[
(1, "other"),
(2, "notReady"),
(3, "notSynchronized"),
(4, "phySynchronized"),
(5, "usParametersAcquired"),
(6, "rangingComplete"),
(7, "ipComplete"),
(8, "todEstablished"),
(9, "securityEstablished"),
(10, "paramTransferComplete"),
(11, "registrationComplete"),
(12, "operational"),
(13, "accessDenied"),
],
default_value=[1, 2, 13],
)),
("tx_power",
Tuple(
title=_("Transmit Power"),
help=_("The operational transmit power"),
elements=[
Float(title=_("warning at"),
unit="dBmV",
default_value=20.0),
Float(title=_("critical at"),
unit="dBmV",
default_value=10.0),
],
)),
], )
def _valuespec_special_agents_gcp():
return Dictionary(
title=_("Google Cloud Platform"),
elements=[
("project",
TextInput(title=_("Project ID"), allow_empty=False, size=50)),
(
"credentials",
IndividualOrStoredPassword(
title=_("JSON credentials for service account"),
allow_empty=False),
),
(
"services",
ListChoice(
title=_("GCP services to monitor"),
choices=[
("gcs", _("Google Cloud Storage (GCS)")),
("cloud_run", _("Cloud Run")),
("cloud_functions", _("Cloud Functions")),
("cloud_sql", _("Cloud SQL")),
("filestore", _("Filestore")),
("redis", _("Memorystore Redis")),
],
default_value=[
"gcs",
"cloud_run",
"cloud_functions",
"cloud_sql",
"filestore",
"redis",
],
allow_empty=False,
),
),
],
optional_keys=[],
)
def _parameter_valuespec_if():
# Transform old traffic related levels which used "traffic" and "traffic_minimum"
# keys where each was configured with an Alternative valuespec
return Transform(
Dictionary(
ignored_keys=[
"aggregate",
"discovered_oper_status",
"discovered_admin_status",
"discovered_speed",
], # Created by discovery
elements=[
("errors_in", _vs_if_errors("IN")),
("errors_out", _vs_if_errors("OUT")),
("speed",
OptionalDropdownChoice(
title=_("Operating speed"),
help=_("If you use this parameter then the check goes warning if the "
"interface is not operating at the expected speed (e.g. it "
"is working with 100Mbit/s instead of 1Gbit/s.<b>Note:</b> "
"some interfaces do not provide speed information. In such cases "
"this setting is used as the assumed speed when it comes to "
"traffic monitoring (see below)."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
explicit=Integer(title=_("Other speed in bits per second"),
label=_("Bits per second")))),
("state",
Optional(ListChoice(
title=_("Allowed operational states:"),
choices=defines.interface_oper_states(),
allow_empty=False,
),
title=_("Operational state"),
help=_(
"If you activate the monitoring of the operational state "
"(<tt>ifOperStatus</tt>), the check will go critical if the current "
"state of the interface does not match one of the expected states."),
label=_("Ignore the operational state"),
none_label=_("ignore"),
negate=True)),
("map_operstates",
ListOf(
Tuple(orientation="horizontal",
elements=[
ListChoice(
choices=defines.interface_oper_states(),
allow_empty=False,
),
MonitoringState()
]),
title=_('Map operational states'),
help=_(
'Map the operational state (<tt>ifOperStatus</tt>) to a monitoring state.')
)),
("admin_state",
Optional(
ListChoice(
title=_("Allowed admin states:"),
choices=_admin_states(),
allow_empty=False,
),
title=_("Admin state (SNMP with 64-bit counters only)"),
help=_("If you activate the monitoring of the admin state "
"(<tt>ifAdminStatus</tt>), the check will go critical if the "
"current state of the interface does not match one of the expected "
"states. " + _note_for_admin_state_options()),
label=_("Ignore the admin state"),
none_label=_("ignore"),
negate=True)),
("map_admin_states",
ListOf(
Tuple(orientation="horizontal",
elements=[
ListChoice(
choices=_admin_states(),
allow_empty=False,
),
MonitoringState(),
]),
title=_('Map admin states (SNMP with 64-bit counters only)'),
help=_("Map the admin state (<tt>ifAdminStatus</tt>) to a monitoring state. " +
_note_for_admin_state_options()),
)),
("assumed_speed_in",
OptionalDropdownChoice(
title=_("Assumed input speed"),
help=_(
"If the automatic detection of the link speed does not work "
"or the switch's capabilities are throttled because of the network setup "
"you can set the assumed speed here."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
default_value=16000000,
explicit=Integer(title=_("Other speed in bits per second"),
label=_("Bits per second"),
size=10))),
("assumed_speed_out",
OptionalDropdownChoice(
title=_("Assumed output speed"),
help=_(
"If the automatic detection of the link speed does not work "
"or the switch's capabilities are throttled because of the network setup "
"you can set the assumed speed here."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
default_value=1500000,
explicit=Integer(title=_("Other speed in bits per second"),
label=_("Bits per second"),
size=12))),
("unit",
DropdownChoice(
title=_("Measurement unit"),
help=_("Here you can specifiy the measurement unit of the network interface"),
default_value="byte",
choices=[
("bit", _("Bits")),
("byte", _("Bytes")),
],
)),
("infotext_format",
DropdownChoice(
title=_("Change infotext in check output"),
help=
_("This setting allows you to modify the information text which is displayed between "
"the two brackets in the check output. Please note that this setting does not work for "
"grouped interfaces, since the additional information of grouped interfaces is different"
),
choices=[
("alias", _("Show alias")),
("description", _("Show description")),
("alias_and_description", _("Show alias and description")),
("alias_or_description", _("Show alias if set, else description")),
("desription_or_alias", _("Show description if set, else alias")),
("hide", _("Hide infotext")),
])),
("traffic",
ListOf(
CascadingDropdown(title=_("Direction"),
orientation="horizontal",
choices=[
('both', _("In / Out"), vs_interface_traffic()),
('in', _("In"), vs_interface_traffic()),
('out', _("Out"), vs_interface_traffic()),
]),
title=_("Used bandwidth (minimum or maximum traffic)"),
help=_("Setting levels on the used bandwidth is optional. If you do set "
"levels you might also consider using averaging."),
)),
("total_traffic",
ListOf(
CascadingDropdown(title=_("Direction"),
orientation="horizontal",
choices=[
('total', _("Total traffic"), vs_interface_traffic()),
]),
title=_("Used total bandwidth (in + out) (minimum or maximum traffic)"),
help=
_("By activating this item, the sum of incoming and outgoing traffic will "
"be monitored via a seperate metric. Setting levels on the used total bandwidth "
"is optional. If you do set levels you might also consider using averaging."
),
)),
("average",
Integer(
title=_("Average values for used bandwidth"),
help=_("By activating the computation of averages, the levels on "
"traffic and speed are applied to the averaged value. That "
"way you can make the check react only on long-time changes, "
"not on one-minute events."),
unit=_("minutes"),
minvalue=1,
default_value=15,
)),
(
"nucasts",
Tuple(
title=_("Non-unicast packet rates"),
help=_(
"Setting levels on non-unicast packet rates is optional. This may help "
"to detect broadcast storms and other unwanted traffic."),
elements=[
Integer(title=_("Warning at"), unit=_("pkts / sec")),
Integer(title=_("Critical at"), unit=_("pkts / sec")),
]),
),
("multicast",
Alternative(title=_("Multicast packet rates"),
help=_(
"These levels make the check go warning or critical whenever the "
"<b>percentual packet rate</b> or the <b>absolute packet "
"rate</b> of the monitored interface reaches the given "
"bounds. The percentual packet rate is computed by "
"dividing the number of multicast packets by the number "
"of unicast packets."),
elements=[
Tuple(title=_("Percentual levels for multicast packets"),
elements=[
Percentage(title=_("Warning at"),
unit=_("percent packets"),
default_value=10.0,
display_format='%.3f'),
Percentage(title=_("Critical at"),
unit=_("percent packets"),
default_value=20.0,
display_format='%.3f')
]),
Tuple(title=_("Absolute levels for multicast packets"),
elements=[
Integer(title=_("Warning at"), unit=_("pkts / sec")),
Integer(title=_("Critical at"), unit=_("pkts / sec"))
])
])),
("broadcast",
Alternative(title=_("Broadcast packet rates"),
help=_(
"These levels make the check go warning or critical whenever the "
"<b>percentual packet rate</b> or the <b>absolute packet "
"rate</b> of the monitored interface reaches the given "
"bounds. The percentual packet rate is computed by "
"dividing the number of broadcast packets by the number "
"of unicast packets."),
elements=[
Tuple(title=_("Percentual levels for broadcast packets"),
elements=[
Percentage(title=_("Warning at"),
unit=_("percent packets"),
default_value=10.0,
display_format='%.3f'),
Percentage(title=_("Critical at"),
unit=_("percent packets"),
default_value=20.0,
display_format='%.3f')
]),
Tuple(title=_("Absolute levels for broadcast packets"),
elements=[
Integer(title=_("Warning at"), unit=_("pkts / sec")),
Integer(title=_("Critical at"), unit=_("pkts / sec"))
])
])),
("average_bm",
Integer(
title=_("Average values for broad- and multicast packet rates"),
help=_(
"By activating the computation of averages, the levels on "
"broad- and multicast packet rates are applied to "
"the averaged value. That way you can make the check react only on long-time "
"changes, not on one-minute events."),
unit=_("minutes"),
minvalue=1,
default_value=15,
)),
("discards",
Tuple(title=_("Absolute levels for discards rates"),
elements=[
Integer(title=_("Warning at"), unit=_("discards")),
Integer(title=_("Critical at"), unit=_("discards"))
])),
("match_same_speed",
DropdownChoice(title=_("Speed of interface groups (Netapp only)"),
help=_("Choose the behaviour for different interface speeds in "
"interface groups. The default is \"Check and WARN\". This "
"feature is currently only supported by the check "
"netapp_api_if."),
choices=[
("check_and_warn", _("Check and WARN")),
("check_and_crit", _("Check and CRIT")),
("check_and_display", _("Check and display only")),
("dont_show_and_check", _("Don't show and check")),
])),
("home_port",
DropdownChoice(title=_("Is-Home state (Netapp only)"),
help=_("Choose the behaviour when the current port is not the "
"home port of the respective interface. The default is "
"\"Check and Display\". This feature is currently only "
"supported by the check netapp_api_if."),
choices=[
("check_and_warn", _("Check and WARN")),
("check_and_crit", _("Check and CRIT")),
("check_and_display", _("Check and display only")),
("dont_show_and_check", _("Don't show home port info")),
])),
],
),
forth=transform_if,
)
rulespec_registry.register(
HostRulespec(
group=RulespecGroupCheckParametersDiscovery,
match_type="list",
name="inventory_if_rules",
valuespec=_valuespec_inventory_if_rules,
))
vs_elements_if_groups_matches: List[DictionaryEntry] = [
("iftype",
Transform(
DropdownChoice(
title=_("Select interface port type"),
choices=ListChoice.dict_choices(defines.interface_port_types()),
help=_("Only interfaces with the given port type are put into this group. "
"For example 53 (propVirtual)."),
),
forth=str,
back=int,
)),
("items",
ListOfStrings(
title=_("Restrict interface items"),
help=_("Only interface with these item names are put into this group."),
)),
]
vs_elements_if_groups_group = [
("group_name",
def _valuespec_inventory_if_rules():
return Transform(
Dictionary(
title=_("Network Interface and Switch Port Discovery"),
elements=[
('item_appearance',
DropdownChoice(
title=_("Appearance of network interface"),
help=
_("This option lets Check_MK use either the interface description, alias or "
" port number as item. The port number is the fallback/default."
"used anyway."),
choices=[
('descr', _('Use description')),
('alias', _('Use alias')),
('index', _('Use index')),
],
default_value='index',
)),
("pad_portnumbers",
DropdownChoice(
choices=[
(True, _('Pad port numbers with zeros')),
(False, _('Do not pad')),
],
title=_("Port numbers"),
help=
_("If this option is activated then Check_MK will pad port numbers of "
"network interfaces with zeroes so that all port descriptions from "
"all ports of a host or switch have the same length and thus sort "
"currectly in the GUI. In versions prior to 1.1.13i3 there was no "
"padding. You can switch back to the old behaviour by disabling this "
"option. This will retain the old service descriptions and the old "
"performance data."),
)),
("match_alias",
ListOfStrings(
title=_("Match interface alias (regex)"),
help=
_("Only discover interfaces whose alias matches one of the configured "
"regular expressions. The match is done on the beginning of the alias. "
"This allows you to select interfaces based on the alias without having "
"the alias be part of the service description."),
orientation="horizontal",
valuespec=RegExp(
size=32,
mode=RegExp.prefix,
),
)),
("match_desc",
ListOfStrings(
title=_("Match interface description (regex)"),
help=
_("Only discover interfaces whose the description matches one of the configured "
"regular expressions. The match is done on the beginning of the description. "
"This allows you to select interfaces based on the description without having "
"the alias be part of the service description."),
orientation="horizontal",
valuespec=RegExp(
size=32,
mode=RegExp.prefix,
),
)),
("portstates",
ListChoice(
title=_("Network interface port states to discover"),
help=
_("When doing discovery on switches or other devices with network interfaces "
"then only ports found in one of the configured port states will be added to the monitoring. "
"Note: the state <i>admin down</i> is in fact not an <tt>ifOperStatus</tt> but represents the "
"<tt>ifAdminStatus</tt> of <tt>down</tt> - a port administratively switched off. If you check this option "
"then an alternate version of the check is being used that fetches the <tt>ifAdminState</tt> in addition. "
"This will add about 5% of additional SNMP traffic."),
choices=defines.interface_oper_states(),
toggle_all=True,
default_value=['1'],
)),
("porttypes",
DualListChoice(
title=_("Network interface port types to discover"),
help=
_("When doing discovery on switches or other devices with network interfaces "
"then only ports of the specified types will be created services for."
),
choices=defines.interface_port_types(),
rows=40,
default_value=[
'6', '32', '62', '117', '127', '128', '129', '180',
'181', '182', '205', '229'
],
)),
("rmon",
DropdownChoice(
choices=[
(True,
_("Create extra service with RMON statistics data (if available for the device)"
)),
(False, _('Do not create extra services')),
],
title=_("Collect RMON statistics data"),
help=
_("If you enable this option, for every RMON capable switch port an additional service will "
"be created which is always OK and collects RMON data. This will give you detailed information "
"about the distribution of packet sizes transferred over the port. Note: currently "
"this extra RMON check does not honor the inventory settings for switch ports. In a future "
"version of Check_MK RMON data may be added to the normal interface service and not add "
"an additional service."),
)),
],
help=
_('This rule can be used to control the inventory for network ports. '
'You can configure the port types and port states for inventory '
'and the use of alias or description as service name.'),
),
forth=_transform_discovery_if_rules,
)
def _parameter_valuespec_windows_printer_queues():
return Transform(
Dictionary(
title=_("Windows Printer Configuration"),
elements=[
(
"levels",
Tuple(
title=_("Levels for the number of print jobs"),
help=_(
"This rule is applied to the number of print jobs "
"currently waiting in windows printer queue."
),
elements=[
Integer(title=_("Warning at"), unit=_("jobs"), default_value=40),
Integer(title=_("Critical at"), unit=_("jobs"), default_value=60),
],
),
),
(
"crit_states",
ListChoice(
title=_("States who should lead to critical"),
choices=[
(0, "Unkown"),
(1, "Other"),
(2, "No Error"),
(3, "Low Paper"),
(4, "No Paper"),
(5, "Low Toner"),
(6, "No Toner"),
(7, "Door Open"),
(8, "Jammed"),
(9, "Offline"),
(10, "Service Requested"),
(11, "Output Bin Full"),
],
default_value=[9, 10],
),
),
(
"warn_states",
ListChoice(
title=_("States who should lead to warning"),
choices=[
(0, "Unkown"),
(1, "Other"),
(2, "No Error"),
(3, "Low Paper"),
(4, "No Paper"),
(5, "Low Toner"),
(6, "No Toner"),
(7, "Door Open"),
(8, "Jammed"),
(9, "Offline"),
(10, "Service Requested"),
(11, "Output Bin Full"),
],
default_value=[8, 11],
),
),
],
),
forth=windows_printer_queues_forth,
)
def get_vs_flexible_notifications():
# Make sure, that list is not trivially false
def validate_only_services(value, varprefix):
for s in value:
if s and s[0] != '!':
return
raise MKUserError(varprefix + "_0",
_("The list of services will never match"))
return CascadingDropdown(
title=_("Notification Method"),
choices=[
("email", _("Plain Text Email (using configured templates)")),
(
"flexible",
_("Flexible Custom Notifications"),
ListOf(
Foldable(
Dictionary(
optional_keys=[
"service_blacklist", "only_hosts",
"only_services", "escalation", "match_sl"
],
columns=1,
elements=[
(
"plugin",
DropdownChoice(
title=_("Notification Plugin"),
choices=notification_script_choices,
default_value="mail",
),
),
("parameters",
ListOfStrings(
title=_("Plugin Arguments"),
help=
_("You can specify arguments to the notification plugin here. "
"Please refer to the documentation about the plugin for what "
"parameters are allowed or required here."
),
)),
("disabled",
Checkbox(
title=_("Disabled"),
label=_(
"Currently disable this notification"
),
default_value=False,
)),
("timeperiod",
cmk.gui.watolib.timeperiods.
TimeperiodSelection(
title=_("Timeperiod"),
help=
_("Do only notifiy alerts within this time period"
),
)),
(
"escalation",
Tuple(
title=
_("Restrict to n<sup>th</sup> to m<sup>th</sup> notification (escalation)"
),
orientation="float",
elements=[
Integer(
label=_("from"),
help=
_("Let through notifications counting from this number"
),
default_value=1,
minvalue=1,
maxvalue=999999,
),
Integer(
label=_("to"),
help=
_("Let through notifications counting upto this number"
),
default_value=999999,
minvalue=1,
maxvalue=999999,
),
],
),
),
(
"match_sl",
Tuple(
title=_("Match service level"),
help=
_("Host or Service must be in the following service level to get notification"
),
orientation="horizontal",
show_titles=False,
elements=[
DropdownChoice(
label=_("from:"),
choices=cmk.gui.mkeventd.
service_levels,
prefix_values=True),
DropdownChoice(
label=_(" to:"),
choices=cmk.gui.mkeventd.
service_levels,
prefix_values=True),
],
),
),
("host_events",
ListChoice(
title=_("Host Events"),
choices=[
('d', _("Host goes down")),
('u', _("Host gets unreachble")),
('r', _("Host goes up again")),
('f',
_("Start or end of flapping state")),
('s',
_("Start or end of a scheduled downtime "
)),
('x',
_("Acknowledgement of host problem")
),
],
default_value=[
'd', 'u', 'r', 'f', 's', 'x'
],
)),
("service_events",
ListChoice(
title=_("Service Events"),
choices=[
('w',
_("Service goes into warning state")
),
('u',
_("Service goes into unknown state")
),
('c',
_("Service goes into critical state")
),
('r', _("Service recovers to OK")),
('f',
_("Start or end of flapping state")),
('s',
_("Start or end of a scheduled downtime"
)),
('x',
_("Acknowledgement of service problem"
)),
],
default_value=[
'w', 'c', 'u', 'r', 'f', 's', 'x'
],
)),
(
"only_hosts",
ListOfStrings(
title=_(
"Limit to the following hosts"),
help=
_("Configure the hosts for this notification. Without prefix, only exact, case sensitive matches, "
"<tt>!</tt> for negation and <tt>~</tt> for regex matches."
),
orientation="horizontal",
# TODO: Clean this up to use an alternative between TextAscii() and RegExp(). Also handle the negation in a different way
valuespec=TextAscii(size=20, ),
),
),
(
"only_services",
ListOfStrings(
title=_(
"Limit to the following services"),
help=
_("Configure regular expressions that match the beginning of the service names here. Prefix an "
"entry with <tt>!</tt> in order to <i>exclude</i> that service."
),
orientation="horizontal",
# TODO: Clean this up to use an alternative between TextAscii() and RegExp(). Also handle the negation in a different way
valuespec=TextAscii(size=20, ),
validate=validate_only_services,
),
),
(
"service_blacklist",
ListOfStrings(
title=_(
"Blacklist the following services"
),
help=
_("Configure regular expressions that match the beginning of the service names here."
),
orientation="horizontal",
valuespec=RegExp(
size=20,
mode=RegExp.prefix,
),
validate=validate_only_services,
),
),
]),
title_function=lambda v: _("Notify by: ") +
notification_script_title(v["plugin"]),
),
title=_("Flexible Custom Notifications"),
add_label=_("Add notification"),
),
),
])
def _valuespec_inventory_df_rules():
return Transform(
valuespec=Dictionary(
title=_("Filesystem discovery"),
elements=[
(
"mountpoint_for_block_devices",
DropdownChoice(
title=_("Mountpoint for block devices (brtfs)"),
choices=[
("volume_name_as_mountpoint",
_("Use volume name as mountpoint")),
("uuid_as_mountpoint",
_("Use UUID as mountpoint")),
],
default_value="volume_name_as_mountpoint",
),
),
(
"item_appearance",
DropdownChoice(
title=_("Item appearance"),
choices=[
("mountpoint", _("Use mountpoint")),
("volume_name_and_mountpoint",
_("Use volume name and mountpoint")),
("uuid_and_mountpoint",
_("Use UUID and mountpoint")),
],
default_value="mountpoint",
),
),
(
"grouping_behaviour",
DropdownChoice(
title=_("Grouping applies to"),
choices=[
("mountpoint", _("mountpoint only")),
("volume_name_and_mountpoint",
_("volume name and mountpoint")),
("uuid_and_mountpoint", _("UUID and mountpoint")),
],
help=_(
"Specifies how the <a href='wato.py?mode=edit_ruleset&varname=filesystem_groups'>Filesystem grouping patterns</a>"
" feature processes this filesystem."),
default_value="mountpoint",
),
),
(
"ignore_fs_types",
ListChoice(
title=_("Filesystem types to ignore"),
choices=[
("tmpfs", "tmpfs"),
("nfs", "nfs"),
("smbfs", "smbfs"),
("cifs", "cifs"),
("iso9660", "iso9660"),
],
default_value=[
"tmpfs", "nfs", "smbfs", "cifs", "iso9660"
],
),
),
(
"never_ignore_mountpoints",
ListOf(
valuespec=TextOrRegExp(),
title=_("Mountpoints to never ignore"),
help=_(
"Regardless of filesystem type, these mountpoints will always be discovered."
"Regular expressions are supported."),
),
),
],
validate=_validate_discovery_filesystem_params,
),
forth=_transform_discovery_filesystem_params,
)
def _werk_table_option_entries():
translator = cmk.utils.werks.WerkTranslator()
return [
(
"classes",
"double",
ListChoice(
title=_("Classes"),
choices=sorted(translator.classes()),
),
["feature", "fix", "security"],
),
(
"levels",
"double",
ListChoice(
title=_("Levels"),
choices=sorted(translator.levels()),
),
[1, 2, 3],
),
("date", "double", Timerange(title=_("Date")), ("date", (1383149313, int(time.time())))),
(
"id",
"single",
TextInput(
title=_("Werk ID"),
label="#",
regex="^[0-9]{1,5}$",
size=7,
),
"",
),
(
"compatibility",
"single",
DropdownChoice(
title=_("Compatibility"),
choices=[
(
["compat", "incomp_ack", "incomp_unack"],
_("Compatible and incompatible Werks"),
),
(["compat"], _("Compatible Werks")),
(["incomp_ack", "incomp_unack"], _("Incompatible Werks")),
(["incomp_unack"], _("Unacknowledged incompatible Werks")),
(["incomp_ack"], _("Acknowledged incompatible Werks")),
],
),
["compat", "incomp_ack", "incomp_unack"],
),
(
"component",
"single",
DropdownChoice(
title=_("Component"),
choices=[
(None, _("All components")),
]
+ sorted(translator.components()),
),
None,
),
(
"edition",
"single",
DropdownChoice(
title=_("Edition"),
choices=[
(None, _("All editions")),
*(
(e.short, _("Werks only concerning the %s") % e.title)
for e in (Edition.CPE, Edition.CME, Edition.CEE, Edition.CRE)
),
],
),
None,
),
(
"werk_content",
"single",
TextInput(
title=_("Werk title or content"),
size=41,
),
"",
),
(
"version",
"single",
Tuple(
title=_("Checkmk Version"),
orientation="float",
elements=[
TextInput(label=_("from:"), size=12),
TextInput(label=_("to:"), size=12),
],
),
(Version(__version__).version_base, ""),
),
(
"grouping",
"single",
DropdownChoice(
title=_("Group Werks by"),
choices=[
("version", _("Checkmk Version")),
("day", _("Day of creation")),
("week", _("Week of creation")),
(None, _("Do not group")),
],
),
"version",
),
(
"group_limit",
"single",
Integer(
title=_("Show number of groups"),
unit=_("groups"),
minvalue=1,
),
50,
),
]
def vs_graph_render_option_elements(default_values=None, exclude=None):
# Allow custom default values to be specified by the caller. This is, for example,
# needed by the dashlets which should add the host/service by default.
if default_values is None:
default_values = artwork.get_default_graph_render_options()
else:
default_values = default_values.copy()
for k, v in artwork.get_default_graph_render_options().items():
default_values.setdefault(k, v)
elements = [
("font_size", Fontsize(default_value=default_values["font_size"], )),
("show_title",
DropdownChoice(
title=_("Title"),
choices=[
(False, _("Don't show graph title")),
(True, _("Show graph title")),
("inline", _("Show graph title on graph area")),
],
default_value=default_values["show_title"],
)),
("title_format",
Transform(
CascadingDropdown(
title=_("Title format"),
orientation="vertical",
choices=[
("plain", _("Just show graph title")),
("add_title_infos", _("Add additional information"),
ListChoice(choices=[
("add_host_name", _("Add host name")),
("add_host_alias", _("Add host alias")),
("add_service_description",
_("Add service description")),
])),
],
),
forth=transform_graph_render_options_title_format,
)),
("show_graph_time",
Checkbox(
title=_("Show graph time range"),
label=_("Show the graph time range on top of the graph"),
default_value=default_values["show_graph_time"],
)),
("show_margin",
Checkbox(
title=_("Show margin round the graph"),
label=_("Show a margin round the graph"),
default_value=default_values["show_margin"],
)),
("show_legend",
Checkbox(
title=_("Show legend"),
label=_("Show the graph legend"),
default_value=default_values["show_legend"],
)),
("show_vertical_axis",
Checkbox(
title=_("Show vertical axis"),
label=_("Show the graph vertical axis"),
default_value=default_values["show_vertical_axis"],
)),
("vertical_axis_width",
CascadingDropdown(
title=_("Vertical axis width"),
orientation="horizontal",
choices=[
("fixed", _("Use fixed width (relative to font size)")),
("explicit", _("Use absolute width:"),
Float(title="", default_value=40.0, unit=_("pt"))),
],
)),
("show_time_axis",
Checkbox(
title=_("Show time axis"),
label=_("Show the graph time axis"),
default_value=default_values["show_time_axis"],
)),
("show_controls",
Checkbox(
title=_("Show controls"),
label=_("Show the graph controls"),
default_value=default_values["show_controls"],
)),
("show_pin",
Checkbox(
title=_("Show pin"),
label=_("Show the pin"),
default_value=default_values["show_pin"],
)),
("show_time_range_previews",
Checkbox(
title=_("Show time range previews"),
label="Show previews",
default_value=default_values["show_time_range_previews"],
)),
("foreground_color",
GraphColor(
title=_("Foreground color"),
default_value=default_values["foreground_color"],
)),
("background_color",
GraphColor(
title=_("Background color"),
default_value=default_values["background_color"],
)),
("canvas_color",
GraphColor(
title=_("Canvas color"),
default_value=default_values["canvas_color"],
)),
]
if exclude:
elements = [x for x in elements if x[0] not in exclude]
return elements
def _vs_matching_conditions():
return CascadingDropdown(
title=_("Conditions for this rule to apply"),
help=
_("Here, you can define conditions for applying this rule. These conditions are evaluated "
"on a per-interface basis. When discovering an interface, checkmk will first find all "
"rules whose conditions match this interface. Then, these rules are merged together, "
"whereby rules from subfolders overwrite rules from the main directory. Within a "
"directory, the order of the rules matters, i.e., rules further below in the list are "
"overwritten by rules further up."),
choices=[
(
True,
_("Match all interfaces"),
FixedValue(
{},
totext="",
),
),
(
False,
_("Specify matching conditions"),
Dictionary(elements=[
(
"porttypes",
DualListChoice(
title=_("Match port types"),
help=_(
"Apply this rule only to interfaces whose port type is listed "
"below."),
choices=defines.interface_port_types(),
rows=40,
default_value=[
'6', '32', '62', '117', '127', '128', '129',
'180', '181', '182', '205', '229'
],
),
),
(
"portstates",
ListChoice(
title=_("Match port states"),
help=
_("Apply this rule only to interfaces whose port state is listed "
"below. Note: the state <i>admin down</i> is in fact not a port "
"state but represents an <tt>ifAdminStatus</tt> (SNMP only) of "
"<tt>down</tt> - a port administratively switched off. If you check "
"this option, <tt>ifAdminState</tt> will be fetched in addition, "
"adding approximately 5% of additional SNMP traffic."
),
choices=defines.interface_oper_states(),
toggle_all=True,
default_value=['1'],
),
),
(
"match_index",
_vs_regex_matching("index"),
),
(
"match_alias",
_vs_regex_matching("alias"),
),
(
"match_desc",
_vs_regex_matching("description"),
),
], ),
),
],
sorted=False,
)
def _valuespec_special_agents_jenkins():
return Transform(
valuespec=Dictionary(
title=_("Jenkins jobs and builds"),
help=_("Requests data from a jenkins instance."),
optional_keys=["port"],
elements=[
(
"instance",
TextInput(
title=_("Jenkins instance to query."),
help=_(
"Use this option to set which instance should be "
"checked by the special agent. Please add the "
"hostname here, eg. my_jenkins.com."),
size=32,
allow_empty=False,
),
),
(
"user",
TextInput(
title=_("Username"),
help=
_("The username that should be used for accessing the "
"jenkins API. Has to have read permissions at least."
),
size=32,
allow_empty=False,
),
),
(
"password",
PasswordFromStore(
help=_("The password or API key of the user."),
title=_("Password of the user"),
allow_empty=False,
),
),
(
"protocol",
DropdownChoice(
title=_("Protocol"),
choices=[
("http", "HTTP"),
("https", "HTTPS"),
],
default_value="https",
),
),
(
"port",
Integer(
title=_("Port"),
help=
_("Use this option to query a port which is different from standard port 8080."
),
default_value=443,
),
),
(
"sections",
ListChoice(
title=_("Informations to query"),
help=
_("Defines what information to query. You can choose "
"between the instance state, job states, node states "
"and the job queue."),
choices=[
("instance", _("Instance state")),
("jobs", _("Job state")),
("nodes", _("Node state")),
("queue", _("Queue info")),
],
default_value=["instance", "jobs", "nodes", "queue"],
allow_empty=False,
),
),
],
),
forth=_transform_jenkins_infos,
)
def _valuespec_special_agents_kube():
return Dictionary(
elements=[
(
"cluster-name",
Hostname(
title=_("Cluster name"),
allow_empty=False,
help=
_("You must specify a name for your Kubernetes cluster. The provided name"
" will be used to make the objects from your cluster unique in a "
"multi-cluster setup."),
),
),
(
"token",
IndividualOrStoredPassword(
title=_("Token"),
allow_empty=False,
),
),
(
"kubernetes-api-server",
Dictionary(
elements=[
(
"endpoint",
HTTPUrl(
title=_("Endpoint"),
allow_empty=False,
default_value="https://<control plane ip>:443",
help=_(
"The full URL to the Kubernetes API server including the "
"protocol (http or https) and the port."),
size=80,
),
),
ssl_verification(),
(
"proxy",
HTTPProxyReference(
{"http",
"https"}), # Kubernetes client does not
# support socks proxies.
),
_tcp_timeouts(),
],
required_keys=["endpoint", "verify-cert"],
title=_("API server connection"),
),
),
(
"cluster-collector", # TODO: adjust help texts depending on ingress inclusion
Dictionary(
elements=[
(
"endpoint",
HTTPUrl(
title=_(
"Collector NodePort / Ingress endpoint"),
allow_empty=False,
default_value="https://<service url>:30035",
help=
_("The full URL to the Cluster Collector service including "
"the protocol (http or https) and the port. Depending on "
"the deployed configuration of the service this can "
"either be the NodePort or the Ingress endpoint."
),
size=80,
),
),
ssl_verification(),
(
"proxy",
HTTPProxyReference(),
),
_tcp_timeouts(),
],
required_keys=["endpoint", "verify-cert"],
title=_(
"Enrich with usage data from Checkmk Cluster Collector"
),
),
),
(
"monitored-objects",
ListChoice(
choices=[
("deployments", _("Deployments")),
("daemonsets", _("DaemonSets")),
("statefulsets", _("StatefulSets")),
("namespaces", _("Namespaces")),
("nodes", _("Nodes")),
("pods", _("Pods")),
("cronjobs_pods", _("Pods of CronJobs")),
],
default_value=[
"deployments",
"daemonsets",
"statefulsets",
"namespaces",
"nodes",
"pods",
],
allow_empty=False,
title=_("Collect information about..."),
help=
_("Select the Kubernetes objects you would like to monitor. Pods "
"controlled by CronJobs are treated separately as they are usually "
"quite short lived. Those pods will be monitored in the same "
"manner as regular pods. Your Dynamic host management rule should "
"be configured accordingly to avoid that the piggyback hosts for "
"terminated CronJob pods are kept for too long. This 'Pods of CronJobs' "
"option has no effect if Pods are not monitored"),
),
),
(
"namespaces",
CascadingDropdown(
choices=[
(
"namespace-include-patterns",
_("Monitor namespaces matching"),
ListOf(
valuespec=RegExp(
mode=RegExp.infix,
title=_("Pattern"),
allow_empty=False,
),
add_label=_("Add new pattern"),
allow_empty=False,
help=
_("You can specify a list of regex patterns to monitor specific "
"namespaces. Only those that do match the predefined patterns "
"will be monitored."),
),
),
(
"namespace-exclude-patterns",
_("Exclude namespaces matching"),
ListOf(
valuespec=RegExp(
mode=RegExp.infix,
title=_("Pattern"),
allow_empty=False,
),
add_label=_("Add new pattern"),
allow_empty=False,
help=
_("You can specify a list of regex patterns to exclude "
"namespaces. Only those that do not match the predefined "
"patterns are monitored."),
),
),
],
orientation="horizontal",
title=_("Monitor namespaces"),
help=
_("If your cluster has multiple namespaces, you can filter specific ones "
"to be monitored. Note that this concerns everything which is part of the "
"selected namespaces such as pods for example."),
),
),
(
"cluster-resource-aggregation",
CascadingDropdown(
title=("Cluster resource aggregation"),
choices=[
(
"cluster-aggregation-exclude-node-roles",
_("Exclude Nodes based on their role"),
ListOf(
valuespec=RegExp(
mode=RegExp.infix,
allow_empty=False,
size=50,
),
add_label=_("Add new role"),
allow_empty=True,
movable=False,
default_value=["control-plane", "infra"],
),
),
("cluster-aggregation-include-all-nodes",
_("Include all Nodes")),
],
orientation="horizontal",
help=_(
"You may find that some Nodes don't add resources to the overall "
"workload your Cluster can handle. This option allows you to remove "
"Nodes from aggregations on the Cluster host based on their role. A "
"node will be omitted, if any of the listed {role}s matches a label "
"with name 'node-role.kubernetes.io/{role}'. This affects the "
"following services: Memory resources, CPU resources, Pod resources. "
"Only Services on the Cluster host are affected. By default, Nodes "
"with role control-plane and infra are omitted.", ),
),
),
(
"import-annotations",
CascadingDropdown(
title=("Import annotations as host labels"),
choices=[
(
"include-matching-annotations-as-host-labels",
_("Filter valid annotations by key pattern"),
RegExp(
mode=RegExp.infix,
allow_empty=False,
default_value="checkmk-monitoring$",
size=50,
),
),
(
"include-annotations-as-host-labels",
_("Import all valid annotations"),
None,
),
],
orientation="horizontal",
help=
_("By default, Checkmk does not import annotations. If "
"this option is enabled, Checkmk will import any "
"annotation that is a valid Kubernetes label. These "
"imported annotations are added as host labels to their "
"respective piggyback host using the syntax "
"'cmk/kubernetes/annotation/{key}:{value}'. You can "
"further restrict the imported annotations by specifying "
"a pattern which Checkmk searches for in the key of the "
"annotation."),
),
),
],
optional_keys=[
"namespaces",
"cluster-collector",
"cluster-resource-aggregation",
"import-annotations",
],
default_keys=["cluster-collector"],
title=_("Kubernetes"),
)
def _valuespec_special_agents_kubernetes():
return Transform(
valuespec=Dictionary(
elements=[
(
"api-server-endpoint",
CascadingDropdown(
choices=[
(
"hostname",
_("Hostname"),
Dictionary(
elements=_kubernetes_connection_elements(
)),
),
(
"ipaddress",
_("IP address"),
Dictionary(
elements=_kubernetes_connection_elements(
)),
),
(
"url_custom",
_("Custom URL"),
TextInput(
allow_empty=False,
size=80,
),
),
],
orientation="horizontal",
title=_("API server endpoint"),
help=
_('The URL that will be contacted for Kubernetes API calls. If the "Hostname" '
'or the "IP Address" options are selected, the DNS hostname or IP address and '
"a secure protocol (HTTPS) are used."),
),
),
(
"token",
IndividualOrStoredPassword(
title=_("Token"),
allow_empty=False,
),
),
(
"no-cert-check",
Alternative(
title=_("SSL certificate verification"),
elements=[
FixedValue(value=False,
title=_("Verify the certificate"),
totext=""),
FixedValue(
value=True,
title=_(
"Ignore certificate errors (unsecure)"),
totext="",
),
],
default_value=False,
),
),
(
"namespaces",
Alternative(
title=_("Namespace prefix for hosts"),
elements=[
FixedValue(value=False,
title=_("Don't use a namespace prefix"),
totext=""),
FixedValue(value=True,
title=_("Use a namespace prefix"),
totext=""),
],
help=
_("If a cluster uses multiple namespaces you need to activate this option. "
"Hosts for namespaced Kubernetes objects will then be prefixed with the "
"name of their namespace. This makes Kubernetes resources in different "
"namespaces that have the same name distinguishable, but results in "
"longer hostnames."),
default_value=False,
),
),
(
"infos",
ListChoice(
choices=[
("nodes", _("Nodes")),
("services", _("Services")),
("ingresses", _("Ingresses")),
("deployments", _("Deployments")),
("pods", _("Pods")),
("endpoints", _("Endpoints")),
("daemon_sets", _("Daemon sets")),
("stateful_sets", _("Stateful sets")),
("jobs", _("Job")),
],
default_value=[
"nodes",
"endpoints",
"ingresses",
],
allow_empty=False,
title=_("Retrieve information about..."),
),
),
filter_kubernetes_namespace_element(),
],
optional_keys=[
"port", "url-prefix", "path-prefix",
"namespace_include_patterns"
],
title=_("Kubernetes (deprecated)"),
help=_(
"This special agent is deprecated and will be removed in "
'Checkmk version 2.2.0. Please use the "Kubernetes" ruleset to '
"configure the new special agent for Kubernetes."),
),
forth=special_agents_kubernetes_transform,
)
def _valuespec_special_agents_ibmsvc():
return Dictionary(
title=_("IBM SVC / V7000 storage systems"),
help=
_("This rule set selects the <tt>ibmsvc</tt> agent instead of the normal Check_MK Agent "
"and allows monitoring of IBM SVC / V7000 storage systems by calling "
"ls* commands there over SSH. "
"Make sure you have SSH key authentication enabled for your monitoring user. "
"That means: The user your monitoring is running under on the monitoring "
"system must be able to ssh to the storage system as the user you gave below "
"without password."),
elements=[
(
"user",
TextInput(
title=_("IBM SVC / V7000 user name"),
allow_empty=True,
help=
_("User name on the storage system. Read only permissions are sufficient."
),
),
),
(
"accept-any-hostkey",
Checkbox(
title=_("Accept any SSH Host Key"),
label=_("Accept any SSH Host Key"),
default_value=False,
help=
_("Accepts any SSH Host Key presented by the storage device. "
"Please note: This might be a security issue because man-in-the-middle "
"attacks are not recognized! Better solution would be to add the "
"SSH Host Key of the monitored storage devices to the .ssh/known_hosts "
"file for the user your monitoring is running under (on OMD: the site user)"
),
),
),
(
"infos",
Transform(
valuespec=ListChoice(
choices=[
("lshost", _("Hosts Connected")),
("lslicense", _("Licensing Status")),
("lsmdisk", _("MDisks")),
("lsmdiskgrp", _("MDisksGrps")),
("lsnode", _("IO Groups")),
("lsnodestats", _("Node Stats")),
("lssystem", _("System Info")),
("lssystemstats", _("System Stats")),
("lseventlog", _("Event Log")),
("lsportfc", _("FC Ports")),
("lsportsas", _("SAS Ports")),
("lsenclosure", _("Enclosures")),
("lsenclosurestats", _("Enclosure Stats")),
("lsarray", _("RAID Arrays")),
("disks", _("Physical Disks")),
],
default_value=[
"lshost",
"lslicense",
"lsmdisk",
"lsmdiskgrp",
"lsnode",
"lsnodestats",
"lssystem",
"lssystemstats",
"lsportfc",
"lsenclosure",
"lsenclosurestats",
"lsarray",
"disks",
],
allow_empty=False,
),
title=_("Retrieve information about..."),
),
),
],
optional_keys=[],
)
def _werk_table_option_entries():
translator = cmk.utils.werks.WerkTranslator()
return [
("classes", "double",
ListChoice(
title=_("Classes"),
choices=sorted(translator.classes()),
), ["feature", "fix", "security"]),
("levels", "double",
ListChoice(
title=_("Levels"),
choices=sorted(translator.levels()),
), [1, 2, 3]),
("date", "double", Timerange(title=_("Date")),
('date', (1383149313, int(time.time())))),
("id", "single",
TextAscii(
title=_("Werk ID"),
label="#",
regex="^[0-9]{1,5}$",
size=7,
), ""),
("compatibility", "single",
DropdownChoice(title=_("Compatibility"),
choices=[
(["compat", "incomp_ack", "incomp_unack"],
_("Compatible and incompatible Werks")),
(["compat"], _("Compatible Werks")),
(["incomp_ack",
"incomp_unack"], _("Incompatible Werks")),
(["incomp_unack"],
_("Unacknowledged incompatible Werks")),
(["incomp_ack"],
_("Acknowledged incompatible Werks")),
]), ["compat", "incomp_ack", "incomp_unack"]),
("component", "single",
DropdownChoice(
title=_("Component"),
choices=[
(None, _("All components")),
] + sorted(translator.components()),
), None),
("edition", "single",
DropdownChoice(
title=_("Edition"),
choices=[
(None, _("All editions")),
("cme",
_("Werks only concerning the Managed Services Edition")),
("cee", _("Werks only concerning the Enterprise Edition")),
("cre", _("Werks also concerning the Raw Edition")),
],
), None),
("werk_content", "single",
TextUnicode(
title=_("Werk title or content"),
size=41,
), ""),
("version", "single",
Tuple(title=_("Checkmk Version"),
orientation="float",
elements=[
TextAscii(label=_("from:"), size=12),
TextAscii(label=_("to:"), size=12),
]), ("", "")),
("grouping", "single",
DropdownChoice(
title=_("Group Werks by"),
choices=[
("version", _("Checkmk Version")),
("day", _("Day of creation")),
("week", _("Week of creation")),
(None, _("Do not group")),
],
), "version"),
("group_limit", "single",
Integer(
title=_("Show number of groups"),
unit=_("groups"),
minvalue=1,
), 20),
]
def _valuespec_special_agents_vsphere():
return Transform(
valuespec=Dictionary(
title=_("VMWare ESX via vSphere"),
help=_(
"This rule allows monitoring of VMWare ESX via the vSphere API. "
"You can configure your connection settings here.", ),
elements=[
(
"user",
TextInput(
title=_("vSphere User name"),
allow_empty=False,
),
),
(
"secret",
IndividualOrStoredPassword(
title=_("vSphere secret"),
allow_empty=False,
),
),
(
"direct",
DropdownChoice(
title=_("Type of query"),
choices=[
(True, _("Queried host is a host system")),
(False, _("Queried host is the vCenter")),
],
),
),
(
"tcp_port",
Integer(
title=_("TCP Port number"),
help=_("Port number for HTTPS connection to vSphere"),
default_value=443,
minvalue=1,
maxvalue=65535,
),
),
(
"ssl",
Alternative(
title=_("SSL certificate checking"),
elements=[
FixedValue(value=False,
title=_("Deactivated"),
totext=""),
FixedValue(value=True,
title=_("Use hostname"),
totext=""),
TextInput(
title=_("Use other hostname"),
help=
_("The IP of the other hostname needs to be the same IP as the host address"
),
),
],
default_value=True,
),
),
(
"timeout",
Integer(
title=_("Connect Timeout"),
help=
_("The network timeout in seconds when communicating with vSphere or "
"to the Check_MK Agent. The default is 60 seconds. Please note that this "
"is not a total timeout but is applied to each individual network transation."
),
default_value=60,
minvalue=1,
unit=_("seconds"),
),
),
(
"infos",
Transform(
valuespec=ListChoice(
choices=[
("hostsystem", _("Host Systems")),
("virtualmachine", _("Virtual Machines")),
("datastore", _("Datastores")),
("counters", _("Performance Counters")),
("licenses", _("License Usage")),
],
default_value=[
"hostsystem", "virtualmachine", "datastore",
"counters"
],
allow_empty=False,
),
forth=lambda v:
[x.replace("storage", "datastore") for x in v],
title=_("Retrieve information about..."),
),
),
(
"skip_placeholder_vms",
Checkbox(
title=_("Placeholder VMs"),
label=_("Do not monitor placeholder VMs"),
default_value=True,
true_label=_("ignore"),
false_label=_("monitor"),
help=
_("Placeholder VMs are created by the Site Recovery Manager(SRM) and act as backup "
"virtual machines in case the default vm is unable to start. This option tells the "
"vsphere agent to exclude placeholder vms in its output."
),
),
),
(
"host_pwr_display",
DropdownChoice(
title=_("Display ESX Host power state on"),
choices=[
(None,
_("The queried ESX system (vCenter / Host)")),
("esxhost", _("The ESX Host")),
("vm", _("The Virtual Machine")),
],
default_value=None,
),
),
(
"vm_pwr_display",
DropdownChoice(
title=_(
"Display VM power state <i>additionally</i> on"),
help=
_("The power state can be displayed additionally either "
"on the ESX host or the VM. This will result in services "
"for <i>both</i> the queried system and the ESX host / VM. "
"By disabling the unwanted services it is then possible "
"to configure where the services are displayed."),
choices=[
(None,
_("The queried ESX system (vCenter / Host)")),
("esxhost", _("The ESX Host")),
("vm", _("The Virtual Machine")),
],
default_value=None,
),
),
(
"snapshots_on_host",
Checkbox(
title=_("VM snapshot summary"),
label=_("Display snapshot summary on ESX hosts"),
default_value=False,
help=
_("By default the snapshot summary service is displayed on the vCenter. "
"Users who run an ESX host on its own or do not include their vCenter in the "
"monitoring can choose to display the snapshot summary on the ESX host itself."
),
),
),
(
"vm_piggyname",
DropdownChoice(
title=_("Piggyback name of virtual machines"),
choices=[
("alias",
_("Use the name specified in the ESX system")),
(
"hostname",
_("Use the VMs hostname if set, otherwise fall back to ESX name"
),
),
],
default_value="alias",
),
),
(
"spaces",
DropdownChoice(
title=_("Spaces in hostnames"),
choices=[
("cut", _("Cut everything after first space")),
("underscore", _("Replace with underscores")),
],
default_value="underscore",
),
),
],
optional_keys=[
"tcp_port",
"timeout",
"vm_pwr_display",
"host_pwr_display",
"vm_piggyname",
],
ignored_keys=["use_pysphere"],
),
forth=_transform_agent_vsphere,
)
def parameter_valuespec(self):
# Transform old traffic related levels which used "traffic" and "traffic_minimum"
# keys where each was configured with an Alternative valuespec
return Transform(
Dictionary(
ignored_keys=[
"aggregate"
], # Created by discovery when using interface grouping
elements=[
("errors",
Alternative(
title=_("Levels for error rates"),
help=
_("These levels make the check go warning or critical whenever the "
"<b>percentual error rate</b> or the <b>absolute error rate</b> of the monitored interface reaches "
"the given bounds. The percentual error rate is computed by dividing number of "
"errors by the total number of packets (successful plus errors)."
),
elements=[
Tuple(
title=_("Percentual levels for error rates"),
elements=[
Percentage(title=_("Warning at"),
unit=_("percent errors"),
default_value=0.01,
display_format='%.3f'),
Percentage(title=_("Critical at"),
unit=_("percent errors"),
default_value=0.1,
display_format='%.3f')
]),
Tuple(title=_("Absolute levels for error rates"),
elements=[
Integer(title=_("Warning at"),
unit=_("errors")),
Integer(title=_("Critical at"),
unit=_("errors"))
])
])),
("speed",
OptionalDropdownChoice(
title=_("Operating speed"),
help=
_("If you use this parameter then the check goes warning if the "
"interface is not operating at the expected speed (e.g. it "
"is working with 100Mbit/s instead of 1Gbit/s.<b>Note:</b> "
"some interfaces do not provide speed information. In such cases "
"this setting is used as the assumed speed when it comes to "
"traffic monitoring (see below)."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
explicit=Integer(
title=_("Other speed in bits per second"),
label=_("Bits per second")))),
("state",
Optional(
ListChoice(title=_("Allowed states:"),
choices=defines.interface_oper_states()),
title=_("Operational state"),
help=
_("If you activate the monitoring of the operational state (<tt>ifOperStatus</tt>) "
"the check will get warning or critical if the current state "
"of the interface does not match one of the expected states. Note: the status 9 (<i>admin down</i>) "
"is only visible if you activate this status during switch port inventory or if you manually "
"use the check plugin <tt>if64adm</tt> instead of <tt>if64</tt>."
),
label=_("Ignore the operational state"),
none_label=_("ignore"),
negate=True)),
("map_operstates",
ListOf(
Tuple(
orientation="horizontal",
elements=[
DropdownChoice(
choices=defines.interface_oper_states()),
MonitoringState()
]),
title=_('Map operational states'),
)),
("assumed_speed_in",
OptionalDropdownChoice(
title=_("Assumed input speed"),
help=
_("If the automatic detection of the link speed does not work "
"or the switch's capabilities are throttled because of the network setup "
"you can set the assumed speed here."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
default_value=16000000,
explicit=Integer(
title=_("Other speed in bits per second"),
label=_("Bits per second"),
size=10))),
("assumed_speed_out",
OptionalDropdownChoice(
title=_("Assumed output speed"),
help=
_("If the automatic detection of the link speed does not work "
"or the switch's capabilities are throttled because of the network setup "
"you can set the assumed speed here."),
choices=[
(None, _("ignore speed")),
(10000000, "10 Mbit/s"),
(100000000, "100 Mbit/s"),
(1000000000, "1 Gbit/s"),
(10000000000, "10 Gbit/s"),
],
otherlabel=_("specify manually ->"),
default_value=1500000,
explicit=Integer(
title=_("Other speed in bits per second"),
label=_("Bits per second"),
size=12))),
("unit",
RadioChoice(
title=_("Measurement unit"),
help=
_("Here you can specifiy the measurement unit of the network interface"
),
default_value="byte",
choices=[
("bit", _("Bits")),
("byte", _("Bytes")),
],
)),
("infotext_format",
DropdownChoice(
title=_("Change infotext in check output"),
help=
_("This setting allows you to modify the information text which is displayed between "
"the two brackets in the check output. Please note that this setting does not work for "
"grouped interfaces, since the additional information of grouped interfaces is different"
),
choices=[
("alias", _("Show alias")),
("description", _("Show description")),
("alias_and_description",
_("Show alias and description")),
("alias_or_description",
_("Show alias if set, else description")),
("desription_or_alias",
_("Show description if set, else alias")),
("hide", _("Hide infotext")),
])),
("traffic",
ListOf(
CascadingDropdown(title=_("Direction"),
orientation="horizontal",
choices=[
('both', _("In / Out"),
vs_interface_traffic()),
('in', _("In"),
vs_interface_traffic()),
('out', _("Out"),
vs_interface_traffic()),
]),
title=_(
"Used bandwidth (minimum or maximum traffic)"),
help=
_("Setting levels on the used bandwidth is optional. If you do set "
"levels you might also consider using averaging."),
)),
(
"nucasts",
Tuple(
title=_("Non-unicast packet rates"),
help=
_("Setting levels on non-unicast packet rates is optional. This may help "
"to detect broadcast storms and other unwanted traffic."
),
elements=[
Integer(title=_("Warning at"),
unit=_("pkts / sec")),
Integer(title=_("Critical at"),
unit=_("pkts / sec")),
]),
),
("discards",
Tuple(title=_("Absolute levels for discards rates"),
elements=[
Integer(title=_("Warning at"),
unit=_("discards")),
Integer(title=_("Critical at"),
unit=_("discards"))
])),
("average",
Integer(
title=_("Average values"),
help=
_("By activating the computation of averages, the levels on "
"errors and traffic are applied to the averaged value. That "
"way you can make the check react only on long-time changes, "
"not on one-minute events."),
unit=_("minutes"),
minvalue=1,
default_value=15,
)),
],
),
forth=transform_if,
)
def _valuespec_brocade_fcport_inventory():
return Dictionary(
title=_("Brocade port discovery"),
elements=[
(
"use_portname",
Checkbox(
title=_("Use port name as service name"),
label=_("use port name"),
default_value=True,
help=
_("This option lets Check_MK use the port name as item instead of the "
"port number. If no description is available then the port number is "
"used anyway."),
),
),
(
"show_isl",
Checkbox(
title=_(
'add "ISL" to service description for interswitch links'
),
label=_("add ISL"),
default_value=True,
help=_(
'This option lets Check_MK add the string "ISL" to the service '
"description for interswitch links."),
),
),
(
"admstates",
ListChoice(
title=_("Administrative port states to discover"),
help=_(
"When doing service discovery on brocade switches only ports with the given administrative "
"states will be added to the monitoring system."),
choices=_brocade_fcport_adm_choices,
columns=1,
toggle_all=True,
default_value=["1", "3", "4"],
),
),
(
"phystates",
ListChoice(
title=_("Physical port states to discover"),
help=_(
"When doing service discovery on brocade switches only ports with the given physical "
"states will be added to the monitoring system."),
choices=_brocade_fcport_phy_choices,
columns=1,
toggle_all=True,
default_value=[3, 4, 5, 6, 7, 8, 9, 10],
),
),
(
"opstates",
ListChoice(
title=_("Operational port states to discover"),
help=_(
"When doing service discovery on brocade switches only ports with the given operational "
"states will be added to the monitoring system."),
choices=_brocade_fcport_op_choices,
columns=1,
toggle_all=True,
default_value=[1, 2, 3, 4],
),
),
],
help=_(
"This rule can be used to control the service discovery for brocade ports. "
"You can configure the port states for inventory "
"and the use of the description as service name."),
)
def _parameter_valuespec_netapp_volumes():
return Dictionary(elements=[
("levels",
Alternative(
title=_("Levels for volume"),
show_alternative_title=True,
default_value=(80.0, 90.0),
match=match_dual_level_type,
elements=[
get_free_used_dynamic_valuespec("used", "volume"),
Transform(
get_free_used_dynamic_valuespec("free",
"volume",
default_value=(20.0,
10.0)),
forth=transform_filesystem_free,
back=transform_filesystem_free,
)
],
)),
("perfdata",
ListChoice(
title=_("Performance data for protocols"),
help=
_("Specify for which protocol performance data should get recorded."
),
choices=[
("", _("Summarized data of all protocols")),
("nfs", _("NFS")),
("cifs", _("CIFS")),
("san", _("SAN")),
("fcp", _("FCP")),
("iscsi", _("iSCSI")),
],
)),
("magic",
Float(title=_(
"Magic factor (automatic level adaptation for large volumes)"),
default_value=0.8,
minvalue=0.1,
maxvalue=1.0)),
("magic_normsize",
Integer(title=_("Reference size for magic factor"),
default_value=20,
minvalue=1,
unit=_("GB"))),
("levels_low",
Tuple(
title=_("Minimum levels if using magic factor"),
help=_(
"The volume levels will never fall below these values, when using "
"the magic factor and the volume is very small."),
elements=[
Percentage(title=_("Warning if above"),
unit=_("% usage"),
allow_int=True,
default_value=50),
Percentage(title=_("Critical if above"),
unit=_("% usage"),
allow_int=True,
default_value=60)
],
)),
("inodes_levels",
Alternative(
title=_("Levels for Inodes"),
help=_(
"The number of remaining inodes on the filesystem. "
"Please note that this setting has no effect on some filesystem checks."
),
elements=[
Tuple(
title=_("Percentage free"),
elements=[
Percentage(title=_("Warning if less than")),
Percentage(title=_("Critical if less than")),
],
),
Tuple(
title=_("Absolute free"),
elements=[
Integer(title=_("Warning if less than"),
size=10,
unit=_("inodes"),
minvalue=0,
default_value=10000),
Integer(title=_("Critical if less than"),
size=10,
unit=_("inodes"),
minvalue=0,
default_value=5000),
],
)
],
default_value=(10.0, 5.0),
)),
("show_inodes",
DropdownChoice(
title=_("Display inode usage in check output..."),
choices=[
("onproblem", _("Only in case of a problem")),
("onlow",
_("Only in case of a problem or if inodes are below 50%")),
("always", _("Always")),
],
default_value="onlow",
)),
("trend_range",
Optional(Integer(
title=_("Time Range for filesystem trend computation"),
default_value=24,
minvalue=1,
unit=_("hours")),
title=_("Trend computation"),
label=_("Enable trend computation"))),
("trend_mb",
Tuple(
title=_("Levels on trends in MB per time range"),
elements=[
Integer(title=_("Warning at"),
unit=_("MB / range"),
default_value=100),
Integer(title=_("Critical at"),
unit=_("MB / range"),
default_value=200)
],
)),
("trend_perc",
Tuple(
title=_("Levels for the percentual growth per time range"),
elements=[
Percentage(
title=_("Warning at"),
unit=_("% / range"),
default_value=5,
),
Percentage(
title=_("Critical at"),
unit=_("% / range"),
default_value=10,
),
],
)),
("trend_timeleft",
Tuple(
title=_("Levels on the time left until the filesystem gets full"),
elements=[
Integer(
title=_("Warning if below"),
unit=_("hours"),
default_value=12,
),
Integer(
title=_("Critical if below"),
unit=_("hours"),
default_value=6,
),
],
)),
("trend_showtimeleft",
Checkbox(
title=_("Display time left in check output"),
label=_("Enable"),
help=
_("Normally, the time left until the disk is full is only displayed when "
"the configured levels have been breached. If you set this option "
"the check always reports this information"))),
("trend_perfdata",
Checkbox(
title=_("Trend performance data"),
label=_("Enable generation of performance data from trends"))),
], )
def _valuespec_special_agents_emcvnx():
return Dictionary(
title=_("EMC VNX storage systems"),
help=
_("This rule selects the EMC VNX agent instead of the normal Check_MK Agent "
"and allows monitoring of EMC VNX storage systems by calling naviseccli "
"commandline tool locally on the monitoring system. Make sure it is installed "
"and working. You can configure your connection settings here."),
elements=[
(
"user",
TextInput(
title=_("EMC VNX admin user name"),
allow_empty=True,
help=
_("If you leave user name and password empty, the special agent tries to "
"authenticate against the EMC VNX device by Security Files. "
"These need to be created manually before using. Therefor run as "
"instance user (if using OMD) or Nagios user (if not using OMD) "
"a command like "
"<tt>naviseccli -AddUserSecurity -scope 0 -password PASSWORD -user USER</tt> "
"This creates <tt>SecuredCLISecurityFile.xml</tt> and "
"<tt>SecuredCLIXMLEncrypted.key</tt> in the home directory of the user "
"and these files are used then."),
),
),
(
"password",
Password(
title=_("EMC VNX admin user password"),
allow_empty=True,
),
),
(
"infos",
Transform(
valuespec=ListChoice(
choices=[
("disks", _("Disks")),
("hba", _("iSCSI HBAs")),
("hwstatus", _("Hardware status")),
("raidgroups", _("RAID groups")),
("agent", _("Model and revsion")),
("sp_util", _("Storage processor utilization")),
("writecache", _("Write cache state")),
("mirrorview", _("Mirror views")),
("storage_pools", _("Storage pools")),
],
default_value=[
"disks",
"hba",
"hwstatus",
],
allow_empty=False,
),
title=_("Retrieve information about..."),
),
),
],
optional_keys=[],
)
def parameter_valuespec(self):
return Dictionary(elements=[
("bw",
Alternative(
title=_("Throughput levels"),
help=
_("Please note: in a few cases the automatic detection of the link speed "
"does not work. In these cases you have to set the link speed manually "
"below if you want to monitor percentage values"),
elements=[
Tuple(title=_(
"Used bandwidth of port relative to the link speed"),
elements=[
Percentage(title=_("Warning at"),
unit=_("percent")),
Percentage(title=_("Critical at"),
unit=_("percent")),
]),
Tuple(title=_("Used Bandwidth of port in megabyte/s"),
elements=[
Integer(title=_("Warning at"),
unit=_("MByte/s")),
Integer(title=_("Critical at"),
unit=_("MByte/s")),
])
])),
("assumed_speed",
Float(title=_("Assumed link speed"),
help=_("If the automatic detection of the link speed does "
"not work you can set the link speed here."),
unit=_("GByte/s"))),
("rxcrcs",
Tuple(title=_("CRC errors rate"),
elements=[
Percentage(title=_("Warning at"), unit=_("percent")),
Percentage(title=_("Critical at"), unit=_("percent")),
])),
("rxencoutframes",
Tuple(title=_("Enc-Out frames rate"),
elements=[
Percentage(title=_("Warning at"), unit=_("percent")),
Percentage(title=_("Critical at"), unit=_("percent")),
])),
("rxencinframes",
Tuple(title=_("Enc-In frames rate"),
elements=[
Percentage(title=_("Warning at"), unit=_("percent")),
Percentage(title=_("Critical at"), unit=_("percent")),
])),
("notxcredits",
Tuple(title=_("No-TxCredits errors"),
elements=[
Percentage(title=_("Warning at"), unit=_("percent")),
Percentage(title=_("Critical at"), unit=_("percent")),
])),
("c3discards",
Tuple(title=_("C3 discards"),
elements=[
Percentage(title=_("Warning at"), unit=_("percent")),
Percentage(title=_("Critical at"), unit=_("percent")),
])),
("average",
Integer(
title=_("Averaging"),
help=
_("If this parameter is set, all throughputs will be averaged "
"over the specified time interval before levels are being applied. Per "
"default, averaging is turned off. "),
unit=_("minutes"),
minvalue=1,
default_value=60,
)),
("phystate",
Optional(
ListChoice(title=_(
"Allowed states (otherwise check will be critical)"),
choices=[
(1, _("noCard")),
(2, _("noTransceiver")),
(3, _("laserFault")),
(4, _("noLight")),
(5, _("noSync")),
(6, _("inSync")),
(7, _("portFault")),
(8, _("diagFault")),
(9, _("lockRef")),
]),
title=_("Physical state of port"),
negate=True,
label=_("ignore physical state"),
)),
("opstate",
Optional(
ListChoice(title=_(
"Allowed states (otherwise check will be critical)"),
choices=[
(0, _("unknown")),
(1, _("online")),
(2, _("offline")),
(3, _("testing")),
(4, _("faulty")),
]),
title=_("Operational state"),
negate=True,
label=_("ignore operational state"),
)),
("admstate",
Optional(
ListChoice(title=_(
"Allowed states (otherwise check will be critical)"),
choices=[
(1, _("online")),
(2, _("offline")),
(3, _("testing")),
(4, _("faulty")),
]),
title=_("Administrative state"),
negate=True,
label=_("ignore administrative state"),
)),
], )
def _vs_notify():
dest_choices: List[CascadingDropdownChoice] = [
("broadcast", _("Everybody (Broadcast)")),
(
"list",
_("A list of specific users"),
DualListChoice(
choices=sorted(
[(uid, u.get("alias", uid)) for uid, u in config.multisite_users.items()],
key=lambda x: x[1].lower(),
),
allow_empty=False,
),
),
# ('contactgroup', _('All members of a contact group')),
("online", _("All online users")),
]
return Dictionary(
elements=[
(
"text",
TextAreaUnicode(
title=_("Text"),
help=_("Insert the text to be sent to all reciepents."),
allow_empty=False,
empty_text=_("You need to provide a text."),
cols=50,
rows=10,
),
),
(
"dest",
CascadingDropdown(
title=_("Send notification to"),
help=_(
"You can send the notification to a list of multiple users, which "
"can be choosen out of these predefined filters."
),
choices=dest_choices,
),
),
(
"methods",
ListChoice(
title=_("How to notify"),
allow_empty=False,
choices=[(k, v["title"]) for k, v in _notify_methods().items()],
default_value=["popup"],
),
),
(
"valid_till",
Optional(
AbsoluteDate(
include_time=True,
),
title=_("Automatically invalidate notification"),
label=_("Enable automatic invalidation at"),
help=_(
"It is possible to automatically delete messages when the "
"configured time is reached. This makes it possible to inform "
"users about a scheduled event but suppress the notification "
"after the event has happened."
),
),
),
],
validate=_validate_msg,
optional_keys=[],
)
def _vs_matching_conditions():
return CascadingDropdown(
title=_("Conditions for this rule to apply"),
help=_(
"Here, you can define conditions for applying this rule. These conditions are evaluated "
"on a per-interface basis. When discovering an interface, checkmk will first find all "
"rules whose conditions match this interface. Then, these rules are merged together, "
"whereby rules from subfolders overwrite rules from the main directory. Within a "
"directory, the order of the rules matters, i.e., rules further below in the list are "
"overwritten by rules further up."),
choices=[
(
True,
_("Match all interfaces"),
FixedValue(
{},
totext="",
),
),
(
False,
_("Specify matching conditions"),
Dictionary(elements=[
(
"porttypes",
DualListChoice(
title=_("Match port types"),
help=_("Apply this rule only to interfaces whose port type is listed "
"below."),
choices=defines.interface_port_types(),
rows=40,
default_value=[
'6', '32', '62', '117', '127', '128', '129', '180', '181', '182',
'205', '229'
],
),
),
(
"portstates",
ListChoice(
title=_("Match port states"),
help=_("Apply this rule only to interfaces whose port state is listed "
"below."),
choices=defines.interface_oper_states(),
toggle_all=True,
default_value=['1'],
),
),
(
"admin_states",
ListChoice(
title=_("Match admin states (SNMP with 64-bit counters only)"),
help=_("Apply this rule only to interfaces whose admin state "
"(<tt>ifAdminStatus</tt>) is listed below. " +
_note_for_admin_state_options()),
choices=_admin_states(),
toggle_all=True,
default_value=['1', '2', '3'],
),
),
(
"match_index",
_vs_regex_matching("index"),
),
(
"match_alias",
_vs_regex_matching("alias"),
),
(
"match_desc",
_vs_regex_matching("description"),
),
],),
),
],
sorted=False,
)
def _valuespec_special_agents_rabbitmq():
return Dictionary(
title=_("RabbitMQ"),
help=_("Requests data from a RabbitMQ instance."),
elements=[
(
"instance",
TextInput(
title=_("RabbitMQ instance to query"),
help=_(
"Use this option to set which instance should be "
"checked by the special agent. Please add the "
"hostname here, eg. my_rabbitmq.com. If not set, the "
"assigned host is used as instance."),
size=32,
allow_empty=False,
),
),
(
"user",
TextInput(
title=_("Username"),
help=_(
"The username that should be used for accessing the "
"RabbitMQ API."),
size=32,
allow_empty=False,
),
),
(
"password",
PasswordFromStore(
title=_("Password of the user"),
allow_empty=False,
),
),
(
"protocol",
DropdownChoice(
title=_("Protocol"),
choices=[
("http", "HTTP"),
("https", "HTTPS"),
],
default_value="https",
),
),
(
"port",
Integer(
title=_("Port"),
default_value=15672,
help=_("The port that is used for the api call."),
),
),
(
"sections",
ListChoice(
title=_("Informations to query"),
help=_("Defines what information to query. You can choose "
"between the cluster, nodes, vhosts and queues."),
choices=[
("cluster", _("Clusterwide")),
("nodes", _("Nodes")),
("vhosts", _("Vhosts")),
("queues", _("Queues")),
],
default_value=["cluster", "nodes", "vhosts", "queues"],
allow_empty=False,
),
),
],
optional_keys=[
"instance",
"port",
],
)
def _vs_nagvis_maps(self) -> ListChoice:
return ListChoice(
title=_("NagVis Maps"),
choices=self._get_nagvis_maps,
toggle_all=True,
)
def _valuespec_special_agents_splunk():
return Dictionary(
title=_("Splunk"),
help=_("Requests data from a Splunk instance."),
optional_keys=["instance", "port"],
elements=[
(
"instance",
TextInput(
title=_("Splunk instance to query."),
help=_(
"Use this option to set which host should be checked "
"by the special agent."),
size=32,
allow_empty=False,
),
),
("user", TextInput(title=_("Username"), size=32,
allow_empty=False)),
(
"password",
PasswordFromStore(
title=_("Password of the user"),
allow_empty=False,
),
),
(
"protocol",
DropdownChoice(
title=_("Protocol"),
choices=[
("http", "HTTP"),
("https", "HTTPS"),
],
default_value="https",
),
),
(
"port",
Integer(
title=_("Port"),
help=
_("Use this option to query a port which is different from standard port 8089."
),
default_value=8089,
),
),
(
"infos",
ListChoice(
title=_("Informations to query"),
help=_("Defines what information to query. You can "
"choose to query license state and usage, Splunk "
"system messages, Splunk jobs, shown in the job "
"menu within Splunk. You can also query for "
"component health and fired alerts."),
choices=[
("license_state", _("Licence state")),
("license_usage", _("Licence usage")),
("system_msg", _("System messages")),
("jobs", _("Jobs")),
("health", _("Health")),
("alerts", _("Alerts")),
],
default_value=[
"license_state",
"license_usage",
"system_msg",
"jobs",
"health",
"alerts",
],
allow_empty=False,
),
),
],
)
