def vs_bulk_discovery(render_form=False, include_subfolders=True): if render_form: render = "form" else: render = None if include_subfolders: selection_elements = [ Checkbox(label=_("Include all subfolders"), default_value=True) ] else: selection_elements = [] selection_elements += [ Checkbox( label=_("Only include hosts that failed on previous discovery"), default_value=False), Checkbox(label=_("Only include hosts with a failed discovery check"), default_value=False), Checkbox(label=_("Exclude hosts where the agent is unreachable"), default_value=False), ] return Dictionary( title=_("Bulk discovery"), render=render, elements=[ ("mode", RadioChoice( title=_("Mode"), orientation="vertical", default_value="new", choices=[ ("new", _("Add unmonitored services")), ("remove", _("Remove vanished services")), ("fixall", _("Add unmonitored & remove vanished services")), ("refresh", _("Refresh all services (tabula rasa)")), ], )), ("selection", Tuple(title=_("Selection"), elements=selection_elements)), ("performance", Tuple(title=_("Performance options"), elements=[ Checkbox(label=_("Use cached data if present"), default_value=True), Checkbox(label=_("Do full SNMP scan for SNMP devices"), default_value=True), Integer(label=_("Number of hosts to handle at once"), default_value=10), ])), ("error_handling", Checkbox(title=_("Error handling"), label=_("Ignore errors in single check plugins"), default_value=True)), ], optional_keys=[], )
def _parameter_valuespec_heartbeat_crm(): return Transform(Dictionary( elements=[ ("max_age", Integer( title=_("Maximum age"), help=_( "Maximum accepted age of the reported data in seconds"), unit=_("seconds"), default_value=60, )), ("dc", TextAscii( allow_empty=False, title=_("Expected DC"), help= _("The hostname of the expected distinguished controller of the cluster" ), )), ("num_nodes", Integer( minvalue=0, default_value=2, title=_("Number of Nodes"), help=_("The expected number of nodes in the cluster"), )), ("num_resources", Integer( minvalue=0, title=_("Number of Resources"), help=_("The expected number of resources in the cluster"), )), ("show_failed_actions", RadioChoice( title=_('Show "Failed Actions"'), orientation='vertical', choices=[ (False, _('Don\'t show or warn if "Failed Actions" are present (default)' )), (True, _('Show "Failed Actions" and warn if any is present')), ], default_value=False, help=_( 'If activated, any "Failed Action" entry will be shown in the main check ' 'and the check will go to the WARN state.'), )), ], optional_keys=[ "dc", "num_nodes", "num_resources", "show_failed_actions" ], ), forth=_heartbeat_crm_transform_heartbeat_crm)
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 process_level_elements(): return [ ("cpu_rescale_max", RadioChoice( title=_("CPU rescale maximum load"), help=_( "CPU utilization is delivered by the Operating " "System as a per CPU core basis. Thus each core contributes " "with a 100% at full utilization, producing a maximum load " "of N*100% (N=number of cores). For simplicity this maximum " "can be rescaled down, making 100% the maximum and thinking " "in terms of total CPU utilization."), default_value=True, orientation="vertical", choices=[ (True, _("100% is all cores at full load")), (False, HTML( _("<b>N</b> * 100% as each core contributes with 100% at full load" ))), ], invalid_choice_title=_("Unspecified.") + " " + _("Starting from version 1.6.0 this value must be configured. " "Read Werk #6646 for further information."), invalid_choice_error=_("CPU rescale maximum load is Unspecified.") + " " + _("Starting from version 1.6.0 this value must be configured. " "Read Werk #6646 for further information."), )), ('levels', Tuple( title=_('Levels for process count'), 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=99999, ), Integer( title=_("Critical above"), unit=_("processes"), default_value=99999, ), ], )), ("cpulevels", Tuple( title=_("Levels on total CPU utilization"), help=_( "By activating this options you can set levels on the total " "CPU utilization of all included processes."), elements=[ Percentage(title=_("Warning at"), default_value=90, maxvalue=10000), Percentage(title=_("Critical at"), default_value=98, maxvalue=10000), ], )), ("cpu_average", Integer( title=_("CPU Averaging"), help= _("By activating averaging, Check_MK will compute the average of " "the total CPU utilization over a given interval. If you have defined " "alerting levels then these will automatically be applied on the " "averaged value. This helps to mask out short peaks. "), unit=_("minutes"), minvalue=1, default_value=15, )), ("single_cpulevels", Tuple( title=_("Levels on CPU utilization of a single process"), help=_( "Here you can define levels on the CPU utilization of single " "processes. For performance reasons CPU Averaging will not be " "applied to to the levels of single processes."), elements=[ Percentage(title=_("Warning at"), default_value=90, maxvalue=10000), Percentage(title=_("Critical at"), default_value=98, maxvalue=10000), ], )), ("max_age", Tuple( title=_("Maximum allowed age"), help=_( "Alarms you if the age of the process (not the consumed CPU " "time, but the real time) exceed the configured levels."), elements=[ Age(title=_("Warning at"), default_value=3600), Age(title=_("Critical at"), default_value=7200), ])), ("virtual_levels", Tuple( title=_("Virtual memory usage"), elements=[ Filesize(title=_("Warning at"), default_value=1000 * 1024 * 1024 * 1024), Filesize(title=_("Critical at"), default_value=2000 * 1024 * 1024 * 1024), ], )), ("resident_levels", Tuple( title=_("Physical memory usage"), elements=[ Filesize(title=_("Warning at"), default_value=100 * 1024 * 1024), Filesize(title=_("Critical at"), default_value=200 * 1024 * 1024), ], )), ("resident_levels_perc", Tuple(title=_("Physical memory usage, in percentage of total RAM"), elements=[ Percentage(title=_("Warning at"), default_value=25.0), Percentage(title=_("Critical at"), default_value=50.0), ])), ("handle_count", Tuple( title=_('Handle Count (Windows only)'), help= _("The number of object handles in the processes object table. This includes " "open handles to threads, files and other resources like registry keys." ), elements=[ Integer( title=_("Warning above"), unit=_("handles"), ), Integer( title=_("Critical above"), unit=_("handles"), ), ], )), ('process_info', DropdownChoice( title=_("Enable per-process details in long-output"), label=_("Enable per-process details"), help= _("If active, the long output of this service will contain a list of all the " "matching processes and their details (i.e. PID, CPU usage, memory usage). " "Please note that HTML output will only work if \"Escape HTML codes in " "plugin output\" is disabled in global settings. This might expose you to " "Cross-Site-Scripting (everyone with write-access to checks could get " "scripts executed on the monitoring site in the context of the user of the " "monitoring site) so please do this if you understand the consequences." ), choices=[ (None, _("Disable")), ("text", _("Text output")), ("html", _("HTML output")), ], default_value="disable", )), ('process_info_arguments', Integer( title=_("Include process arguments in long-output"), label=_("Include per-process arguments (security risk!)"), help= _("If non-zero, the the list of all the matching processes and their details" " in the long-output will include up to the first N arguments of each" " processes. Please note this may include sensitive data like credentials," " and is strongly discouraged."), default_value=0, )), ('icon', UserIconOrAction( title=_("Add custom icon or action"), help= _("You can assign icons or actions to the found services in the status GUI." ), )), ]
def _parameter_valuespec_cisco_qos(): return Dictionary(elements=[ ("unit", RadioChoice( title=_("Measurement unit"), help= _("Here you can specifiy the measurement unit of the network interface" ), default_value="bit", choices=[ ("bit", _("Bits")), ("byte", _("Bytes")), ], )), ("post", Alternative( title=_("Used bandwidth (traffic)"), help=_( "Settings levels on the used bandwidth is optional. If you do set " "levels you might also consider using averaging."), elements=[ Tuple( title=_( "Percentual levels (in relation to policy speed)"), elements=[ Percentage(title=_("Warning at"), maxvalue=1000, label=_("% of port speed")), Percentage(title=_("Critical at"), maxvalue=1000, label=_("% of port speed")), ], ), Tuple( title=_("Absolute levels in bits or bytes per second"), help= _("Depending on the measurement unit (defaults to bit) the absolute levels are set in bit or byte" ), elements=[ Integer(title=_("Warning at"), size=10, label=_("bits / bytes per second")), Integer(title=_("Critical at"), size=10, label=_("bits / bytes per second")), ], ) ], )), ("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, )), ("drop", Alternative( title=_("Number of dropped bits or bytes per second"), help=_( "Depending on the measurement unit (defaults to bit) you can set the warn and crit " "levels for the number of dropped bits or bytes"), elements=[ Tuple( title=_( "Percentual levels (in relation to policy speed)"), elements=[ Percentage(title=_("Warning at"), maxvalue=1000, label=_("% of port speed")), Percentage(title=_("Critical at"), maxvalue=1000, label=_("% of port speed")), ], ), Tuple(elements=[ Integer(title=_("Warning at"), size=8, label=_("bits / bytes per second")), Integer(title=_("Critical at"), size=8, label=_("bits / bytes per second")), ], ) ], )), ], )