def get_bi_aggregation_node_choices():
return Transform(
CascadingDropdown(choices=_get_aggregation_choices()),
forth=_convert_bi_aggr_to_vs,
back=_convert_bi_aggr_from_vs,
)
def vs_conditions():
return Transform(
VSExplicitConditions(rulespec=dummy_rulespec(), render="form_part"),
forth=lambda c: RuleConditions(**c),
back=lambda c: dict(c._asdict()),
)
def _valuespec_active_checks_tcp():
return Tuple(
title=_("Check TCP port connection"),
help=_("This check tests the connection to a TCP port. It uses "
"<tt>check_tcp</tt> from the standard Nagios plugins."),
elements=[
Integer(title=_("TCP Port"), minvalue=1, maxvalue=65535),
Dictionary(
title=_("Optional parameters"),
elements=[
(
"svc_description",
TextInput(
title=_("Service description"),
allow_empty=False,
help=_(
"Here you can specify a service description. "
"If this parameter is not set, the service is named <tt>TCP Port [PORT NUMBER]</tt>"
),
),
),
(
"hostname",
TextInput(
title=_("DNS Hostname"),
allow_empty=False,
help=
_("If you specify a hostname here, then a dynamic DNS lookup "
"will be done instead of using the IP address of the host "
"as configured in your host properties."),
),
),
(
"response_time",
Tuple(
title=_("Expected response time"),
elements=[
Float(title=_("Warning if above"),
unit="ms",
default_value=100.0),
Float(title=_("Critical if above"),
unit="ms",
default_value=200.0),
],
),
),
(
"timeout",
Integer(
title=_("Seconds before connection times out"),
unit=_("sec"),
default_value=10,
),
),
(
"refuse_state",
DropdownChoice(
title=_("State for connection refusal"),
choices=[
("crit", _("CRITICAL")),
("warn", _("WARNING")),
("ok", _("OK")),
],
),
),
("send_string",
TextInput(title=_("String to send"), size=30)),
(
"escape_send_string",
FixedValue(
value=True,
title=
_("Expand <tt>\\n</tt>, <tt>\\r</tt> and <tt>\\t</tt> in the sent string"
),
totext=_("expand escapes"),
),
),
(
"expect",
ListOfStrings(
title=_("Strings to expect in response"),
orientation="horizontal",
valuespec=TextInput(size=30),
),
),
(
"expect_all",
FixedValue(
value=True,
totext=_("expect all"),
title=
_("Expect <b>all</b> of those strings in the response"
),
),
),
(
"jail",
FixedValue(
value=True,
title=_("Hide response from socket"),
help=
_("As soon as you configure expected strings in "
"the response the check will output the response - "
"as long as you do not hide it with this option"
),
totext=_("hide response"),
),
),
(
"mismatch_state",
DropdownChoice(
title=_("State for expected string mismatch"),
choices=[
("crit", _("CRITICAL")),
("warn", _("WARNING")),
("ok", _("OK")),
],
),
),
(
"delay",
Integer(
title=_("Seconds to wait before polling"),
help=
_("Seconds to wait between sending string and polling for response"
),
unit=_("sec"),
default_value=0,
),
),
(
"maxbytes",
Integer(
title=_("Maximum number of bytes to receive"),
help=
_("Close connection once more than this number of "
"bytes are received. Per default the number of "
"read bytes is not limited. This setting is only "
"used if you expect strings in the response."),
default_value=1024,
),
),
(
"ssl",
FixedValue(value=True,
totext=_("use SSL"),
title=_("Use SSL for the connection.")),
),
(
"cert_days",
Transform(
valuespec=Tuple(
title=_("SSL certificate validation"),
help=
_("Minimum number of days a certificate has to be valid"
),
elements=[
Integer(title=_("Warning at or below"),
minvalue=0,
unit=_("days")),
Integer(title=_("Critical at or below"),
minvalue=0,
unit=_("days")),
],
),
forth=transform_cert_days,
),
),
(
"quit_string",
TextInput(
title=_("Final string to send"),
help=_(
"String to send server to initiate a clean close of "
"the connection"),
size=30,
),
),
],
),
],
)
def parameter_valuespec(self):
return Dictionary(
title=_("Configure levels for used space"),
elements=[
("ignore_levels",
FixedValue(
title=
_("Ignore used space (this option disables any other options)"
),
help=
_("Some luns, e.g. jfs formatted, tend to report incorrect used space values"
),
label=_("Ignore used space"),
value=True,
totext="",
)),
("levels",
Alternative(
title=_("Levels for LUN"),
show_alternative_title=True,
default_value=(80.0, 90.0),
match=match_dual_level_type,
elements=[
get_free_used_dynamic_valuespec("used", "LUN"),
Transform(
get_free_used_dynamic_valuespec(
"free", "LUN", default_value=(20.0, 10.0)),
allow_empty=False,
forth=transform_filesystem_free,
back=transform_filesystem_free,
)
],
)),
("trend_range",
Optional(Integer(title=_(
"Time Range for lun 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 lun 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 lun filesystem 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"))
),
("read_only",
Checkbox(
title=_("LUN is read-only"),
help=_(
"Display a warning if a LUN is not read-only. Without "
"this setting a warning will be displayed if a LUN is "
"read-only."),
label=_("Enable"))),
],
)
def _network_scan_elements(self):
elements = [
("ip_ranges",
ListOf(
self._vs_ip_range(),
title=_("IP ranges to scan"),
add_label=_("Add new IP range"),
text_if_empty=_("No IP range configured"),
)),
("exclude_ranges",
ListOf(
self._vs_ip_range(),
title=_("IP ranges to exclude"),
add_label=_("Add new IP range"),
text_if_empty=_("No exclude range configured"),
)),
(
"scan_interval",
Age(
title=_("Scan interval"),
display=["days", "hours"],
default_value=60 * 60 * 24,
minvalue=3600, # 1 hour
)),
("time_allowed",
Transform(
ListOf(
TimeofdayRange(allow_empty=False, ),
title=_("Time allowed"),
help=_(
"Limit the execution of the scan to this time range."
),
allow_empty=False,
style=ListOf.Style.FLOATING,
movable=False,
default_value=[((0, 0), (24, 0))],
),
forth=lambda x: [x] if isinstance(x, tuple) else x,
back=sorted,
)),
("set_ipaddress",
Checkbox(
title=_("Set IPv4 address"),
help=_(
"Whether or not to configure the found IP address as the IPv4 "
"address of the found hosts."),
default_value=True,
)),
]
elements += self._optional_tag_criticality_element()
elements += [
("max_parallel_pings",
Integer(
title=_("Parallel pings to send"),
help=_(
"Set the maximum number of concurrent pings sent to target IP "
"addresses."),
minvalue=1,
maxvalue=200,
default_value=100,
)),
("run_as",
DropdownChoice(
title=_("Run as"),
help=
_("Execute the network scan in the Check_MK user context of the "
"choosen user. This user needs the permission to add new hosts "
"to this folder."),
choices=self._get_all_user_ids,
default_value=lambda: config.user.id,
)),
("translate_names",
HostnameTranslation(title=_("Translate Hostnames"), )),
]
return elements
def _parameter_valuespec_mail_queue_length():
return Transform(
mailqueue_params,
forth=lambda old: not isinstance(old, dict) and {"deferred": old} or old,
)
def _valuespec_inventory_df_rules():
return Transform(
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(
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 _valuespec_active_checks_form_submit():
return Transform(
Tuple(
title=_("Check HTML Form Submit"),
help=_(
"Check submission of HTML forms via HTTP/HTTPS using the plugin <tt>check_form_submit</tt> "
"provided with Check_MK. This plugin provides more functionality than <tt>check_http</tt>, "
"as it automatically follows HTTP redirect, accepts and uses cookies, parses forms "
"from the requested pages, changes vars and submits them to check the response "
"afterwards."
),
elements=[
TextInput(
title=_("Name"),
help=_("The name will be used in the service description"),
allow_empty=False,
),
Dictionary(
title=_("Check the URL"),
elements=[
(
"hosts",
ListOfStrings(
title=_("Check specific host(s)"),
help=_(
"By default, if you do not specify any host addresses here, "
"the host address of the host this service is assigned to will "
"be used. But by specifying one or several host addresses here, "
"it is possible to let the check monitor one or multiple hosts."
),
),
),
(
"uri",
TextInput(
title=_("URI to fetch (default is <tt>/</tt>)"),
allow_empty=False,
default_value="/",
regex="^/.*",
),
),
(
"port",
Integer(
title=_("TCP Port"),
minvalue=1,
maxvalue=65535,
default_value=80,
),
),
(
"tls_configuration",
DropdownChoice(
title=_("TLS/HTTPS configuration"),
help=_(
"Activate or deactivate TLS for the connection. No certificate validation means that "
"the server certificate will not be validated by the locally available certificate authorities."
),
choices=[
(
"no_tls",
_("No TLS"),
),
(
"tls_standard",
_("TLS"),
),
(
"tls_no_cert_valid",
_("TLS without certificate validation"),
),
],
),
),
(
"timeout",
Integer(
title=_("Seconds before connection times out"),
unit=_("sec"),
default_value=10,
),
),
(
"expect_regex",
RegExp(
title=_("Regular expression to expect in content"),
mode=RegExp.infix,
),
),
(
"form_name",
TextInput(
title=_("Name of the form to populate and submit"),
help=_(
"If there is only one form element on the requested page, you "
"do not need to provide the name of that form here. But if you "
"have several forms on that page, you need to provide the name "
"of the form here, to enable the check to identify the correct "
"form element."
),
allow_empty=True,
),
),
(
"query",
TextInput(
title=_("Send HTTP POST data"),
help=_(
"Data to send via HTTP POST method. Please make sure, that the data "
'is URL-encoded (for example "key1=val1&key2=val2").'
),
size=40,
),
),
(
"num_succeeded",
Tuple(
title=_("Multiple Hosts: Number of successful results"),
elements=[
Integer(title=_("Warning if equal or below")),
Integer(title=_("Critical if equal or below")),
],
),
),
],
),
],
),
forth=_transform_form_submit,
)
def livestatus_proxy_valuespec(cls):
return Alternative(
title=_("Use Livestatus Proxy Daemon"),
elements=[
FixedValue(
None,
title=_("Connect directly, without Livestatus Proxy"),
totext="",
),
Transform(
Dictionary(
title=_("Use Livestatus Proxy Daemon"),
optional_keys=["tcp"],
columns=1,
elements=[
(
"params",
Alternative(
title=_("Parameters"),
elements=[
FixedValue(
None,
title=
_("Use global connection parameters"
),
totext=
_('Use the <a href="%s">global parameters</a> for this connection'
) %
"wato.py?mode=edit_configvar&site=&varname=liveproxyd_default_connection_params",
),
Dictionary(
title=
_("Use custom connection parameters"
),
elements=cls.
liveproxyd_connection_params_elements(
),
),
],
),
),
(
"tcp",
LivestatusViaTCP(
title=_("Allow access via TCP"),
help=
_("This option can be useful to build a cascading distributed setup. "
"The Livestatus Proxy of this site connects to the site configured "
"here via Livestatus and opens up a TCP port for clients. The "
"requests of the clients are forwarded to the destination site. "
"You need to configure a TCP port here that is not used on the "
"local system yet."),
tcp_port=6560,
),
),
],
),
forth=cls.transform_old_connection_params,
),
],
)
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 _render_options(cls):
return [
(
"metric_render_options",
Transform(
Dictionary(
elements=[
("font_size",
CascadingDropdown(
title=_("Metric value font size"),
orientation="horizontal",
choices=[
("fix", _("Set the metric value font size to:"),
Fontsize(default_value="22.5")),
("dynamic",
_("Dynamically adapt the metric font size to the dashlet size"
))
],
default_value="dynamic")),
("link_to_svc_detail",
DropdownChoice(
title=_("Link to service detail page"),
choices=[
("true",
_("Open service detail page when clicking on the metric value"
)), ("false", _("Do not add a link to the metric value"))
],
default_value="true")),
("show_site",
CascadingDropdown(
title=_("Show the site name"),
orientation="horizontal",
sorted=False,
choices=[("above", _("... above the metric value with font size:"),
Fontsize(default_value="12.0")),
("below", _("... below the metric value with font size:"),
Fontsize(default_value="12.0")),
("tooltip",
_("... in a tooltip when hovering the metric value")),
("false", _("Do not show the site name"))],
default_value="false")),
("show_host",
CascadingDropdown(
title=_("Show the host name"),
orientation="horizontal",
sorted=False,
choices=[("above", _("... above the metric value with font size:"),
Fontsize(default_value="12.0")),
("below", _("... below the metric value with font size:"),
Fontsize(default_value="12.0")),
("tooltip",
_("... in a tooltip when hovering the metric value")),
("false", _("Do not show the host name"))],
default_value="false")),
("show_service",
CascadingDropdown(
title=_("Show the service name"),
orientation="horizontal",
sorted=False,
choices=[("above", _("... above the metric value with font size:"),
Fontsize(default_value="12.0")),
("below", _("... below the metric value with font size:"),
Fontsize(default_value="12.0")),
("tooltip",
_("... in a tooltip when hovering the metric value")),
("false", _("Do not show the service name"))],
default_value="tooltip")),
("show_metric",
CascadingDropdown(
title=_("Show the metric name"),
orientation="horizontal",
sorted=False,
choices=[("above", _("... above the metric value with font size:"),
Fontsize(default_value="12.0")),
("below", _("... below the metric value with font size:"),
Fontsize(default_value="12.0")),
("tooltip",
_("... in a tooltip when hovering the metric value")),
("false", _("Do not show the metric name"))],
default_value="above")),
("show_state_color",
DropdownChoice(title=_("Show the service state color"),
choices=[
("background", _("... as background color")),
("font", _("... as font color")),
("false", _("Do not show the service state color")),
],
default_value="background")),
("show_unit",
DropdownChoice(title=_("Show the metric's unit"),
choices=[
("true", _("Show the metric's unit")),
("false", _("Do not show the metric's unit")),
],
default_value="true")),
],
optional_keys=[],
title=_("Metric rendering options"),
),),
),
]
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 _parameter_valuespec_ibm_svc_host():
return Transform(
Dictionary(
elements=[
(
"active_hosts",
Tuple(
title=_("Count of active hosts"),
elements=[
Integer(
title=_("Warning at or below"), minvalue=0, unit=_("active hosts")
),
Integer(
title=_("Critical at or below"), minvalue=0, unit=_("active hosts")
),
],
),
),
(
"inactive_hosts",
Tuple(
title=_("Count of inactive hosts"),
elements=[
Integer(
title=_("Warning at or above"), minvalue=0, unit=_("inactive hosts")
),
Integer(
title=_("Critical at or above"),
minvalue=0,
unit=_("inactive hosts"),
),
],
),
),
(
"degraded_hosts",
Tuple(
title=_("Count of degraded hosts"),
elements=[
Integer(
title=_("Warning at or above"), minvalue=0, unit=_("degraded hosts")
),
Integer(
title=_("Critical at or above"),
minvalue=0,
unit=_("degraded hosts"),
),
],
),
),
(
"offline_hosts",
Tuple(
title=_("Count of offline hosts"),
elements=[
Integer(
title=_("Warning at or above"), minvalue=0, unit=_("offline hosts")
),
Integer(
title=_("Critical at or above"), minvalue=0, unit=_("offline hosts")
),
],
),
),
(
"other_hosts",
Tuple(
title=_("Count of other hosts"),
elements=[
Integer(
title=_("Warning at or above"), minvalue=0, unit=_("other hosts")
),
Integer(
title=_("Critical at or above"), minvalue=0, unit=_("other hosts")
),
],
),
),
],
),
forth=transform_ibm_svc_host,
)
def get_bi_rule_node_choices_vs():
return Transform(
CascadingDropdown(choices=_get_rule_choices(), sorted=False),
forth=_convert_bi_rule_to_vs,
back=_convert_bi_rule_from_vs,
)
def _valuespec_inventory_processes_rules():
return Transform(
Dictionary(
title=_("Process discovery"),
help=_(
"This ruleset defines criteria for automatically creating checks for running "
"processes based upon what is running when the service discovery is "
"done. These services will be created with default parameters. They will get "
"critical when no process is running and OK otherwise. You can parameterize "
"the check with the ruleset <i>State and count of processes</i>."
),
elements=[
("descr", process_discovery_descr_option()),
("match", process_match_options()),
(
"user",
user_match_options(
[
FixedValue(
False,
title=_("Grab user from found processess"),
totext="",
help=_(
'Specifying "grab user" makes the created check expect the process to '
"run as the same user as during inventory: the user name will be "
"hardcoded into the check. In that case if you put %u into the service "
"description, that will be replaced by the actual user name during "
"inventory. You need that if your rule might match for more than one "
"user - your would create duplicate services with the same description "
"otherwise."
),
)
]
),
),
("cgroup", cgroup_match_options()),
(
"label",
Labels(
Labels.World.CONFIG,
title=_("Host Label"),
help=_(
"Here you can set host labels that automatically get created when discovering the services."
),
),
),
(
"default_params",
Dictionary(
title=_("Default parameters for detected services"),
help=_(
"Here you can select default parameters that are being set "
"for detected services. Note: the preferred way for setting parameters is to use "
'the rule set <a href="wato.py?varname=checkgroup_parameters:ps&mode=edit_ruleset"> '
"State and Count of Processes</a> instead. "
"A change there will immediately be active, while a change in this rule "
"requires a re-discovery of the services."
),
elements=process_level_elements(),
ignored_keys=["match_groups"],
required_keys=["cpu_rescale_max"],
),
),
],
required_keys=["descr", "default_params"],
),
forth=convert_inventory_processes,
)
def cascading_dropdown_choice_element(cls):
return (cls.type(), _("No search"),
Transform(FixedValue(""),
forth=lambda x: "",
back=lambda x: {"type": cls.type()}))
result.append((item[0], tuple_convert(item[1])))
return result
fs_levels_elements = [
("levels",
Alternative(
title=_("Levels for filesystem"),
show_alternative_title=True,
default_value=(80.0, 90.0),
match=match_dual_level_type,
elements=[
get_free_used_dynamic_valuespec("used", "filesystem"),
Transform(
get_free_used_dynamic_valuespec("free", "filesystem", default_value=(20.0, 10.0)),
title=_("Levels for filesystem free space"),
forth=transform_filesystem_free,
back=transform_filesystem_free,
)
],
)),
("show_levels",
DropdownChoice(
title=_("Display warn/crit levels in check output..."),
choices=[
("onproblem", _("Only if the status is non-OK")),
("onmagic", _("If the status is non-OK or a magic factor is set")),
("always", _("Always")),
],
default_value="onmagic",
)),
]
def parameter_valuespec(self):
return Transform(
Dictionary(
elements=[
(
"levels",
Alternative(
title=_("Levels for memory"),
show_alternative_title=True,
default_value=(150.0, 200.0),
match=match_dual_level_type,
help=
_("The used and free levels for the memory on UNIX systems take into account the "
"currently used memory (RAM or SWAP) by all processes and sets this in relation "
"to the total RAM of the system. This means that the memory usage can exceed 100%. "
"A usage of 200% means that the total size of all processes is twice as large as "
"the main memory, so <b>at least</b> half of it is currently swapped out. For systems "
"without Swap space you should choose levels below 100%."
),
elements=[
Alternative(
title=_("Levels for used memory"),
style="dropdown",
elements=[
Tuple(
title=
_("Specify levels in percentage of total RAM"
),
elements=[
Percentage(title=_(
"Warning at a usage of"),
maxvalue=None),
Percentage(title=_(
"Critical at a usage of"),
maxvalue=None)
],
),
Tuple(
title=
_("Specify levels in absolute values"
),
elements=[
Integer(title=_("Warning at"),
unit=_("MB")),
Integer(title=_("Critical at"),
unit=_("MB"))
],
),
],
),
Transform(Alternative(
style="dropdown",
elements=[
Tuple(
title=
_("Specify levels in percentage of total RAM"
),
elements=[
Percentage(title=_(
"Warning if less than"),
maxvalue=None),
Percentage(title=_(
"Critical if less than"),
maxvalue=None)
],
),
Tuple(
title=
_("Specify levels in absolute values"
),
elements=[
Integer(title=_(
"Warning if below"),
unit=_("MB")),
Integer(title=_(
"Critical if below"),
unit=_("MB"))
],
),
],
),
title=_("Levels for free memory"),
help=
_("Keep in mind that if you have 1GB RAM and 1GB SWAP you need to "
"specify 120% or 1200MB to get an alert if there is only 20% free RAM available. "
"The free memory levels do not work with the fortigate check, because it does "
"not provide total memory data."),
allow_empty=False,
forth=lambda val: tuple(
-x for x in val),
back=lambda val: tuple(-x
for x in val))
],
),
),
("average",
Integer(
title=_("Averaging"),
help=
_("If this parameter is set, all measured values 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,
)),
],
optional_keys=["average"],
),
forth=lambda t: isinstance(t, tuple) and {"levels": t} or t,
)
def _valuespec_filesystem_groups():
return Transform(
Dictionary(
title=_("Filesystem grouping patterns"),
optional_keys=False,
elements=[(
FILESYSTEM_GROUPS_WRAPPER_KEY,
ListOf(
Dictionary(
optional_keys=False,
elements=[
(
"group_name",
TextInput(title=_("Group name"), ),
),
(
"patterns_include",
ListOfStrings(
title=_("Inclusion patterns"),
orientation="horizontal",
help=
_("You can specify one or several globbing patterns containing "
"<tt>*</tt>, <tt>?</tt> and <tt>[...]</tt>, for example "
"<tt>/spool/tmpspace*</tt>. The filesystems matching the "
"patterns will be grouped together and monitored as one big "
"filesystem in a single service. Note that specifically for "
"the check <tt>df</tt>, the pattern matches either the mount "
"point or the combination of volume and mount point, "
"depending on the configuration in "
"<a href='wato.py?mode=edit_ruleset&varname=inventory_df_rules'>"
"Filesystem discovery</a>."),
),
),
(
"patterns_exclude",
ListOfStrings(
title=_("Exclusion patterns"),
orientation="horizontal",
help=
_("You can specify one or several globbing patterns containing "
"<tt>*</tt>, <tt>?</tt> and <tt>[...]</tt>, for example "
"<tt>/spool/tmpspace*</tt>. The filesystems matching the "
"patterns will excluded from grouping and monitored "
"individually. Note that specifically for the check "
"<tt>df</tt>, the pattern matches either the mount point or "
"the combination of volume and mount point, depending on the "
"configuration in "
"<a href='wato.py?mode=edit_ruleset&varname=inventory_df_rules'>"
"Filesystem discovery</a>."),
),
),
],
),
add_label=_("Add group"),
title=_("Filesystem grouping patterns"),
help=
_("By default, the filesystem checks (<tt>df</tt>, <tt>hr_fs</tt> and others) will "
"create a single service for each filesystem. By defining grouping patterns, you "
"can handle groups of filesystems like one filesystem. For each group, you can "
"define one or several include and exclude patterns. The filesystems matching one "
"of the include patterns will be monitored like one big filesystem in a single "
"service. The filesystems matching one of the exclude patterns will be excluded "
"from the group and monitored individually."),
),
)],
),
forth=_transform_filesystem_groups,
)
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(
valuespec=vs_title_infos(),
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"],
),
),
(
"fixed_timerange",
Checkbox(
title=_("Timerange synchronization"),
label="Do not follow timerange changes of other graphs on the current page",
default_value=default_values["fixed_timerange"],
),
),
]
if exclude:
elements = [x for x in elements if x[0] not in exclude]
return elements
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=[],
)
_('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,
)
vs_elements_if_groups_matches = [
("iftype",
Transform(
DropdownChoice(
title=_("Select interface port type"),
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 _parameter_valuespec_temperature():
return Transform(
Dictionary(elements=[
(
"levels",
Transform(
Tuple(
title=_("Upper Temperature Levels"),
elements=[
Float(title=_("Warning at"),
unit=u"°C",
default_value=26),
Float(title=_("Critical at"),
unit=u"°C",
default_value=30),
],
),
forth=lambda elems: (float(elems[0]), float(elems[1])),
),
),
(
"levels_lower",
Transform(
Tuple(
title=_("Lower Temperature Levels"),
elements=[
Float(title=_("Warning below"),
unit=u"°C",
default_value=0),
Float(title=_("Critical below"),
unit=u"°C",
default_value=-10),
],
),
forth=lambda elems: (float(elems[0]), float(elems[1])),
),
),
("output_unit",
DropdownChoice(
title=_("Display values in "),
choices=[
("c", _("Celsius")),
("f", _("Fahrenheit")),
("k", _("Kelvin")),
],
)),
("input_unit",
DropdownChoice(
title=_("Override unit of sensor"),
help=
_("In some rare cases the unit that is signalled by the sensor "
"is wrong and e.g. the sensor sends values in Fahrenheit while "
"they are misinterpreted as Celsius. With this setting you can "
"force the reading of the sensor to be interpreted as customized. "
),
choices=[
("c", _("Celsius")),
("f", _("Fahrenheit")),
("k", _("Kelvin")),
],
)),
("device_levels_handling",
DropdownChoice(
title=_(
"Interpretation of the device's own temperature status"),
choices=[
("usr", _("Ignore device's own levels")),
("dev", _("Only use device's levels, ignore yours")),
("best",
_("Use least critical of your and device's levels")),
("worst",
_("Use most critical of your and device's levels")),
("devdefault",
_("Use device's levels if present, otherwise yours")),
("usrdefault",
_("Use your own levels if present, otherwise the device's"
)),
],
default_value="usrdefault",
)),
(
"trend_compute",
Dictionary(
title=_("Trend computation"),
elements=
[("period",
Integer(
title=
_("Observation period for temperature trend computation"
),
default_value=30,
minvalue=5,
unit=_("minutes"),
)),
("trend_levels",
Tuple(
title=_("Levels on temperature increase per period"),
elements=[
Integer(
title=_("Warning at"),
unit=u"°C / " + _("period"),
default_value=5,
),
Integer(
title=_("Critical at"),
unit=u"°C / " + _("period"),
default_value=10,
)
],
)),
("trend_levels_lower",
Tuple(
title=_("Levels on temperature decrease per period"),
elements=[
Integer(
title=_("Warning at"),
unit=u"°C / " + _("period"),
default_value=5,
),
Integer(
title=_("Critical at"),
unit=u"°C / " + _("period"),
default_value=10,
)
],
)),
("trend_timeleft",
Tuple(
title=
_("Levels on the time left until a critical temperature (upper or lower) is reached"
),
elements=[
Integer(
title=_("Warning if below"),
unit=_("minutes"),
default_value=240,
),
Integer(
title=_("Critical if below"),
unit=_("minutes"),
default_value=120,
),
],
))],
optional_keys=[
"trend_levels", "trend_levels_lower", "trend_timeleft"
],
),
),
], ),
forth=lambda v: isinstance(v, tuple) and {"levels": v} or v,
)
def valuespec(self):
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(),
custom_order=True,
rows=40,
toggle_all=True,
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 valuespec(self):
return Transform(
LockedByValuespec(),
forth=tuple,
back=list,
)
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,
)),
("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")),
])),
],
),
forth=transform_if,
)
result.append((item[0], tuple_convert(item[1])))
return result
fs_levels_elements = [
("levels",
Alternative(
title=_("Levels for filesystem"),
show_alternative_title=True,
default_value=(80.0, 90.0),
match=match_dual_level_type,
elements=[
get_free_used_dynamic_valuespec("used", "filesystem"),
Transform(
get_free_used_dynamic_valuespec("free", "filesystem", default_value=(20.0, 10.0)),
title=_("Levels for filesystem free space"),
forth=transform_filesystem_free,
back=transform_filesystem_free,
)
],
)),
("show_levels",
DropdownChoice(
title=_("Display warn/crit levels in check output..."),
choices=[
("onproblem", _("Only if the status is non-OK")),
("onmagic", _("If the status is non-OK or a magic factor is set")),
("always", _("Always")),
],
default_value="onmagic",
)),
]
def _valuespec_inv_domino_tasks_rules():
return Dictionary(
title=_('Lotus Domino task discovery'),
help=_(
"This rule controls the discovery of tasks on Lotus Domino systems. "
"Any changes later on require a host re-discovery"),
elements=[
('descr',
TextAscii(
title=_('Service Description'),
allow_empty=False,
help=
_('<p>The service description may contain one or more occurances of <tt>%s</tt>. In this '
'case, the pattern must be a regular expression prefixed with ~. For each '
'<tt>%s</tt> in the description, the expression has to contain one "group". A group '
'is a subexpression enclosed in brackets, for example <tt>(.*)</tt> or '
'<tt>([a-zA-Z]+)</tt> or <tt>(...)</tt>. When the inventory finds a task '
'matching the pattern, it will substitute all such groups with the actual values when '
'creating the check. In this way one rule can create several checks on a host.</p>'
'<p>If the pattern contains more groups than occurrences of <tt>%s</tt> in the service '
'description, only the first matching subexpressions are used for the service '
'descriptions. The matched substrings corresponding to the remaining groups '
'are nevertheless copied into the regular expression.</p>'
'<p>As an alternative to <tt>%s</tt> you may also use <tt>%1</tt>, <tt>%2</tt>, etc. '
'These expressions will be replaced by the first, second, ... matching group, allowing '
'you to reorder things.</p>'),
)),
(
'match',
Alternative(
title=_("Task Matching"),
elements=[
TextAscii(
title=_("Exact name of the task"),
size=50,
),
Transform(
RegExp(
size=50,
mode=RegExp.prefix,
),
title=_(
"Regular expression matching command line"),
help=
_("This regex must match the <i>beginning</i> of the task"
),
forth=lambda x: x[1:], # remove ~
back=lambda x: "~" + x, # prefix ~
),
FixedValue(
None,
totext="",
title=_("Match all tasks"),
)
],
match=lambda x: (not x and 2) or (x[0] == '~' and 1 or 0),
default_value='foo')),
('levels',
Tuple(
title=_('Levels'),
help=
_("Please note that if you specify and also if you modify levels here, the change is "
"activated only during an inventory. Saving this rule is not enough. This is due to "
"the nature of inventory rules."),
elements=[
Integer(
title=_("Critical below"),
unit=_("processes"),
default_value=1,
),
Integer(
title=_("Warning below"),
unit=_("processes"),
default_value=1,
),
Integer(
title=_("Warning above"),
unit=_("processes"),
default_value=1,
),
Integer(
title=_("Critical above"),
unit=_("processes"),
default_value=1,
),
],
)),
],
required_keys=['match', 'levels', 'descr'],
)
def _parameter_valuespec_cpu_utilization_os():
return Transform(
cpu_util_common_dict,
forth=transform_legacy_cpu_utilization_os,
)
def parameter_valuespec(self):
return Transform(
Dictionary(
elements=[
("capacity",
Tuple(
title=_("Levels of battery capacity"),
elements=[
Percentage(
title=_("Warning below"),
default_value=95.0,
),
Percentage(
title=_("Critical below"),
default_value=90.0,
),
])),
("calibration_state",
MonitoringState(
title=_("State if calibration is invalid"),
default_value=0,
)),
("post_calibration_levels",
Dictionary(
title=_("Levels of battery parameters after calibration"),
help=
_("After a battery calibration the battery capacity is reduced until the "
"battery is fully charged again. Here you can specify an alternative "
"lower level in this post-calibration phase. "
"Since apc devices remember the time of the last calibration only "
"as a date, the alternative lower level will be applied on the whole "
"day of the calibration until midnight. You can extend this time period "
"with an additional time span to make sure calibrations occuring just "
"before midnight do not trigger false alarms."),
elements=[
("altcapacity",
Percentage(
title=_(
"Alternative critical battery capacity after calibration"),
default_value=50,
)),
("additional_time_span",
Integer(
title=("Extend post-calibration phase by additional time span"),
unit=_("minutes"),
default_value=0,
)),
],
optional_keys=False,
)),
("battime",
Tuple(
title=_("Time left on battery"),
elements=[
Age(title=_("Warning at"),
help=
_("Time left on Battery at and below which a warning state is triggered"
),
default_value=0,
display=["hours", "minutes"]),
Age(title=_("Critical at"),
help=
_("Time Left on Battery at and below which a critical state is triggered"
),
default_value=0,
display=["hours", "minutes"]),
],
)),
("battery_replace_state",
MonitoringState(
title=_("State if battery needs replacement"),
default_value=1,
)),
],
optional_keys=['post_calibration_levels', 'output_load', 'battime'],
),
forth=self._transform_apc_symmetra,
)
