def parameter_valuespec(self): return Dictionary( elements=[ ( "memory", Alternative( title=_("Memory Levels"), style="dropdown", elements=[ Tuple( title=_("Memory usage in percent"), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")), ], ), Transform( Tuple( title=_("Absolute free memory"), elements=[ Filesize( title=_("Warning if less than")), Filesize( title=_("Critical if less than")), ], ), # Note: Filesize values lesser 1MB will not work # -> need hide option in filesize valuespec back=lambda x: (x[0] / 1024 / 1024, x[1] / 1024 / 1024), forth=lambda x: (x[0] * 1024 * 1024, x[1] * 1024 * 1024)), PredictiveLevels(unit=_("GB"), default_difference=(0.5, 1.0)) ], default_value=(80.0, 90.0))), ( "pagefile", Alternative( title=_("Commit charge Levels"), style="dropdown", elements=[ Tuple( title= _("Commit charge in percent (relative to commit limit)" ), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")), ], ), Transform( Tuple( title=_("Absolute commitable memory"), elements=[ Filesize( title=_("Warning if less than")), Filesize( title=_("Critical if less than")), ], ), # Note: Filesize values lesser 1MB will not work # -> need hide option in filesize valuespec back=lambda x: (x[0] / 1024 / 1024, x[1] / 1024 / 1024), forth=lambda x: (x[0] * 1024 * 1024, x[1] * 1024 * 1024)), PredictiveLevels(unit=_("GB"), default_difference=(0.5, 1.0)) ], default_value=(80.0, 90.0))), ("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, )), ], )
def _parameter_valuespec_cisco_dom(): return Dictionary(elements=[ (_vs_cisco_dom("upper")), (_vs_cisco_dom("lower")), ], )
def _parameter_valuespec_mongodb_cluster(): return Dictionary(elements=[ ("levels_number_jumbo", _mongodb_cluster_count_tuple( "Number of jumbo chunks per shard per collection", "above")), ])
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 TextInput() and RegExp(). Also handle the negation in a different way valuespec=TextInput(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 TextInput() and RegExp(). Also handle the negation in a different way valuespec=TextInput(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 _parameter_valuespec_rabbitmq_nodes_filedesc(): return Dictionary(elements=[ ( "levels", CascadingDropdown( title=_("Levels for file descriptor usage"), choices=[ ( "fd_perc", _("Percentual levels for used file descriptors"), Tuple(elements=[ Percentage( title=_("Warning at usage of"), default_value=80.0, maxvalue=None, ), Percentage( title=_("Critical at usage of"), default_value=90.0, maxvalue=None, ), ], ), ), ( "fd_abs", _("Absolut level for total number of used file descriptors" ), Tuple(elements=[ Integer(title=_("Warning at"), unit="descriptors"), Integer(title=_("Critical at"), unit="descriptors"), ], ), ), ], ), ), ( "fd_open_upper", Tuple( title=_("Upper level for file descriptor open attempts"), elements=[ Integer(title=_("Warning at"), unit="open attempts"), Integer(title=_("Critical at"), unit="open attempts"), ], ), ), ( "fd_open_rate_upper", Tuple( title=_("Upper level for file descriptor open attempts rate"), elements=[ Float(title=_("Warning at"), unit="1/s"), Float(title=_("Critical at"), unit="1/s"), ], ), ), ( "fd_open_rate_lower", Tuple( title=_("Lower level for file descriptor open attempts rate"), elements=[ Float(title=_("Warning below"), unit="1/s"), Float(title=_("Critical below"), unit="1/s"), ], ), ), ], )
def _vs_rules(self): if config.user.may('wato.add_or_modify_executables'): ds_option = [( 'datasource_program', TextAscii( title=_("Datasource Program (<a href=\"%s\">Rules</a>)") % watolib.folder_preserving_link( [('mode', 'edit_ruleset'), ('varname', 'datasource_programs')]), help= _("For agent based checks Check_MK allows you to specify an alternative " "program that should be called by Check_MK instead of connecting the agent " "via TCP. That program must output the agent's data on standard output in " "the same format the agent would do. This is for example useful for monitoring " "via SSH.") + monitoring_macro_help() + " " + _("This option can only be used with the permission \"Can add or modify executables\"." ), ))] # type: List[DictionaryEntry] else: ds_option = [] return Dictionary( optional_keys = False, elements = [ ('agent_port', Integer( minvalue = 1, maxvalue = 65535, default_value = 6556, title = _("Check_MK Agent Port (<a href=\"%s\">Rules</a>)") % watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'agent_ports')]), help = _("This variable allows to specify the TCP port to " "be used to connect to the agent on a per-host-basis.") )), ('tcp_connect_timeout', Float( minvalue = 1.0, default_value = 5.0, unit = _("sec"), display_format = "%.0f", # show values consistent to size = 2, # SNMP-Timeout title = _("TCP Connection Timeout (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'tcp_connect_timeouts')]), help = _("This variable allows to specify a timeout for the " "TCP connection to the Check_MK agent on a per-host-basis." "If the agent does not respond within this time, it is considered to be unreachable.") )), ('snmp_timeout', Integer( title = _("SNMP-Timeout (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]), help = _("After a request is sent to the remote SNMP agent we will wait up to this " "number of seconds until assuming the answer get lost and retrying."), default_value = 1, minvalue = 1, maxvalue = 60, unit = _("sec"), )), ('snmp_retries', Integer( title = _("SNMP-Retries (<a href=\"%s\">Rules</a>)") % \ watolib.folder_preserving_link([('mode', 'edit_ruleset'), ('varname', 'snmp_timing')]), default_value = 5, minvalue = 0, maxvalue = 50, )), ] + ds_option, )
def _parameter_valuespec_oracle_tablespaces(): return Dictionary( help=_( "A tablespace is a container for segments (tables, indexes, etc). A " "database consists of one or more tablespaces, each made up of one or " "more data files. Tables and indexes are created within a particular " "tablespace. " "This rule allows you to define checks on the size of tablespaces." ), elements=db_levels_common() + [ ( "autoextend", DropdownChoice( title=_("Expected autoextend setting"), choices=[ (True, _("Autoextend is expected to be ON")), (False, _("Autoextend is expected to be OFF")), (None, _("Autoextend will be ignored")), ], ), ), ( "autoextend_severity", MonitoringState( title=_("Severity of invalid autoextend setting"), default_value=2, ), ), ( "defaultincrement", DropdownChoice( title=_("Default Increment"), choices=[ (True, _("State is WARNING in case the next extent has the default size.")), (False, _("Ignore default increment")), ], ), ), ( "map_file_online_states", ListOf( Tuple( orientation="horizontal", elements=[ DropdownChoice( choices=[ ("RECOVER", _("Recover")), ("OFFLINE", _("Offline")), ], ), MonitoringState(), ], ), title=_("Map file online states"), ), ), ( "temptablespace", DropdownChoice( title=_("Monitor temporary Tablespace"), choices=[ (False, _("Ignore temporary Tablespaces (Default)")), (True, _("Apply rule to temporary Tablespaces")), ], ), ), ], )
from cmk.gui.i18n import _ from cmk.gui.plugins.wato.utils import ( CheckParameterRulespecWithItem, ManualCheckParameterRulespec, rulespec_registry, RulespecGroupCheckParametersApplications, RulespecGroupEnforcedServicesApplications, ) from cmk.gui.valuespec import Dictionary, DropdownChoice, TextInput, Transform rulespec_registry.register( ManualCheckParameterRulespec( check_group_name="local", group=RulespecGroupEnforcedServicesApplications, item_spec=lambda: TextInput(title=_("Name of local item")), parameter_valuespec=lambda: Transform(Dictionary(elements=[]), forth=lambda p: {}), title=lambda: _("Local checks"), )) # We only need the above, there are no "true" parameters to this check plugin. def _deprecation_message() -> str: return _( 'This ruleset is deprecated. Please use the ruleset <i>"%s"</i> instead.' ) % _("Aggregation options for clustered services") def _parameter_valuespec_local(): return Dictionary(elements=[
def _parameter_valuespec_cisco_ip_sla(): return Dictionary(elements=[ ("rtt_type", DropdownChoice( title=_("RTT type"), choices=[ ('echo', _("echo")), ('path echo', _("path echo")), ('file IO', _("file IO")), ('UDP echo', _("UDP echo")), ('TCP connect', _("TCP connect")), ('HTTP', _("HTTP")), ('DNS', _("DNS")), ('jitter', _("jitter")), ('DLSw', _("DLSw")), ('DHCP', _("DHCP")), ('FTP', _("FTP")), ('VoIP', _("VoIP")), ('RTP', _("RTP")), ('LSP group', _("LSP group")), ('ICMP jitter', _("ICMP jitter")), ('LSP ping', _("LSP ping")), ('LSP trace', _("LSP trace")), ('ethernet ping', _("ethernet ping")), ('ethernet jitter', _("ethernet jitter")), ('LSP ping pseudowire', _("LSP ping pseudowire")), ], default_value="echo", )), ("threshold", Integer( title=_("Treshold"), help=_("Depending on the precision the unit can be " "either milliseconds or micoseconds."), unit=_("ms/us"), minvalue=1, default_value=5000, )), ("state", DropdownChoice( title=_("State"), choices=[ ('active', _("active")), ('inactive', _("inactive")), ('reset', _("reset")), ('orderly stop', _("orderly stop")), ('immediate stop', _("immediate stop")), ('pending', _("pending")), ('restart', _("restart")), ], default_value="active", )), ("connection_lost_occured", DropdownChoice( title=_("Connection lost occured"), choices=[ ("yes", _("yes")), ("no", _("no")), ], default_value="no", )), ("timeout_occured", DropdownChoice( title=_("Timeout occured"), choices=[ ("yes", _("yes")), ("no", _("no")), ], default_value="no", )), ("completion_time_over_treshold_occured", DropdownChoice( title=_("Completion time over treshold occured"), choices=[ ("yes", _("yes")), ("no", _("no")), ], default_value="no", )), ("latest_rtt_completion_time", Tuple( title=_("Latest RTT completion time"), help=_("Depending on the precision the unit can be " "either milliseconds or micoseconds."), elements=[ Integer( title=_("Warning at"), unit=_("ms/us"), minvalue=1, default_value=100, ), Integer( title=_("Critical at"), unit=_("ms/us"), minvalue=1, default_value=200, ), ], )), ("latest_rtt_state", DropdownChoice( title=_("Latest RTT state"), choices=[ ('ok', _("OK")), ('disconnected', _("disconnected")), ('over treshold', _("over treshold")), ('timeout', _("timeout")), ('other', _("other")), ], default_value="ok", )), ], )
def _parameter_valuespec_azure_storageaccounts(): return Dictionary(elements=[ ('ingress_levels', Tuple( title=_("Levels on ingress data in bytes"), elements=[ Float(title=_("Warning at"), unit="B"), Float(title=_("Critical at"), unit="B"), ], )), ('egress_levels', Tuple( title=_("Levels on egress data in bytes"), elements=[ Float(title=_("Warning at"), unit="B"), Float(title=_("Critical at"), unit="B"), ], )), ('used_capacity_levels', Tuple( title=_("Levels on used capacity in bytes"), elements=[ Float(title=_("Warning at"), unit="B"), Float(title=_("Critical at"), unit="B"), ], )), ('server_latency_levels', Tuple( title=_("Levels on server latency in seconds"), help= _("Average latency used by Azure Storage to process a successful request" ), elements=[ Float(title=_("Warning at"), unit="s"), Float(title=_("Critical at"), unit="s"), ], )), ('e2e_latency_levels', Tuple( title=_("Levels on end-to-end latency in seconds"), help= _("Average end-to-end latency of successful requests made to a storage service" ), elements=[ Float(title=_("Warning at"), unit="s"), Float(title=_("Critical at"), unit="s"), ], )), ('transactions_levels', Tuple( title=_("Levels on transaction count"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], )), ('availability_levels', Tuple( title=_("Levels on availability in percent"), elements=[ Float(title=_("Warning at"), unit="%"), Float(title=_("Critical at"), unit="%"), ], )), ], )
def _valuespec_active_checks_sql() -> Dictionary: return Dictionary( title=_("Check SQL Database"), help= _("This check connects to the specified database, sends a custom SQL-statement " "or starts a procedure, and checks that the result has a defined format " "containing three columns, a number, a text, and performance data. Upper or " "lower levels may be defined here. If they are not defined the number is taken " "as the state of the check. If a procedure is used, input parameters of the " "procedures may by given as comma separated list. " "This check uses the active check <tt>check_sql</tt>."), optional_keys=[ "levels", "levels_low", "perfdata", "port", "procedure", "text", "host" ], elements=[ ( "description", TextInput( title=_("Service Description"), help=_("The name of this active service to be displayed."), allow_empty=False, ), ), ( "dbms", DropdownChoice( title=_("Type of Database"), choices=[ ("mysql", _("MySQL")), ("postgres", _("PostgreSQL")), ("mssql", _("MSSQL")), ("oracle", _("Oracle")), ("db2", _("DB2")), ], default_value="postgres", ), ), ( "port", Integer( title=_("Database Port"), help=_("The port the DBMS listens to"), ), ), ( "name", TextInput( title=_("Database Name"), help=_("The name of the database on the DBMS"), allow_empty=False, ), ), ( "user", TextInput( title=_("Database User"), help=_("The username used to connect to the database"), allow_empty=False, ), ), ( "password", IndividualOrStoredPassword( title=_("Database Password"), help=_("The password used to connect to the database"), allow_empty=False, ), ), ( "sql", Transform( valuespec=TextAreaUnicode( title=_("Query or SQL statement"), help= _("The SQL-statement or procedure name which is executed on the DBMS. It must return " "a result table with one row and at least two columns. The first column must be " "an integer and is interpreted as the state (0 is OK, 1 is WARN, 2 is CRIT). " "Alternatively the first column can be interpreted as number value and you can " "define levels for this number. The " "second column is used as check output. The third column is optional and can " "contain performance data."), allow_empty=False, monospaced=True, ), # Former Alternative(Text, Alternative(FileUpload, Text)) based implementation # would save a string or a tuple with a string or a binary array as third element # which would then be turned into a string. # Just make all this a string forth=lambda old_val: [ elem.decode() if isinstance(elem, bytes) else str(elem) for elem in ((old_val[-1] if isinstance(old_val, tuple) else old_val), ) ][0], ), ), ( "procedure", Dictionary( optional_keys=["input"], title=_("Use procedure call instead of SQL statement"), help=_( "If you activate this option, a name of a stored " "procedure is used instead of an SQL statement. " "The procedure should return one output variable, " "which is evaluated in the check. If input parameters " "are required, they may be specified below."), elements=[ ( "useprocs", FixedValue( value=True, totext=_("procedure call is used"), ), ), ( "input", TextInput( title=_("Input Parameters"), allow_empty=True, help= _("Input parameters, if required by the database procedure. " "If several parameters are required, use commas to separate them." ), ), ), ], ), ), ( "levels", Tuple( title=_("Upper levels for first output item"), elements=[ Float(title=_("Warning at")), Float(title=_("Critical at")) ], ), ), ( "levels_low", Tuple( title=_("Lower levels for first output item"), elements=[ Float(title=_("Warning below")), Float(title=_("Critical below")) ], ), ), ( "perfdata", Transform( TextInput( title=_("Performance Data"), help= _("Store output value into RRD database in a metric with this name." ), default_value="performance_data", allow_empty=False, ), forth=transform_check_sql_perfdata, ), ), ( "text", TextInput( title=_("Prefix text"), help=_("Additional text prefixed to the output"), allow_empty=False, ), ), ( "host", TextInput( title=_("DNS hostname or IP address"), help= _("This defaults to the host for which the active check is configured." ), ), ), ], )
def _parameter_valuespec_ddn_s2a_port_errors(): return Dictionary(elements=[ ("link_failure_errs", Tuple( title=_(u"Link failure errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("lost_sync_errs", Tuple( title=_(u"Lost synchronization errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("loss_of_signal_errs", Tuple( title=_(u"Loss of signal errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("prim_seq_errs", Tuple( title=_(u"PrimSeq erros"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("crc_errs", Tuple( title=_(u"CRC errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("receive_errs", Tuple( title=_(u"Receive errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("ctio_timeouts", Tuple( title=_(u"CTIO timeouts"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("ctio_xmit_errs", Tuple( title=_(u"CTIO transmission errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ("ctio_other_errs", Tuple( title=_(u"other CTIO errors"), elements=[ Integer(title=_(u"Warning at")), Integer(title=_(u"Critical at")), ], )), ], )
def _parameter_valuespec_memory(): return Dictionary(elements=[ ( "levels", Alternative( title=_("Levels for Cisco CPU memory"), help=_("The performance graph will always display the occupied memory. " "This is independent of the actual check levels which can be set " "for both free and occupied memory levels."), default_value=(150.0, 200.0), match=match_dual_level_type, elements=[ Alternative( title=_("Levels for occupied memory"), help=_( "Specify the threshold levels for the occupied memory. The occupied memory " "consists of used and kernel reserved memory."), 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(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=_( "Specify the threshold levels for the free memory space. The free memory " "excludes the reserved kernel memory."), forth=lambda val: tuple(-x for x in val), back=lambda val: tuple(-x for x in val), ), ], ), ), ],)
def _valuespec_inv_domino_tasks_rules(): return Transform( valuespec=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", TextInput( 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=[ TextInput( title=_("Exact name of the task"), size=50, ), Transform( valuespec=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( value=None, totext="", title=_("Match all tasks"), ), ], match=lambda x: (not x and 2) or (x[0] == "~" and 1 or 0), default_value="foo", ), ), ( "default_params", Dictionary( title=_("Check parameters"), elements=[ ( "levels", _vs_levels( _("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.")), ), ], optional_keys=False, ), ), ], optional_keys=False, ), forth=_transform_inv_domino_tasks_rules, )
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 _parameter_valuespec_jenkins_nodes(): return Dictionary( elements=[ ("jenkins_offline", MonitoringState(title=_("Node state: Offline"), default_value=2)), ( "jenkins_mode", DropdownChoice( title=_("Expected mode state."), help=_( "Choose between Normal (Utilize this node as much " "as possible) and Exclusive (Only build jobs with label " "restrictions matching this node). The state will " "change to warning state, if the mode differs." ), choices=[ ("NORMAL", _("Normal")), ("EXCLUSIVE", _("Exclusive")), ], default_value="NORMAL", ), ), ( "jenkins_numexecutors", Tuple( title=_("Lower level for number of executors of this node"), elements=[ Integer(title=_("Warning below")), Integer(title=_("Critical below")), ], ), ), ( "jenkins_busyexecutors", Tuple( title=_("Upper level for number of busy executors of this node"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], ), ), ( "jenkins_idleexecutors", Tuple( title=_("Upper level for number of idle executors of this node"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], ), ), ( "avg_response_time", Tuple( title=_("Average round-trip response time to this node"), elements=[ Age(title=_("Warning at")), Age(title=_("Critical at")), ], ), ), ( "jenkins_clock", Tuple( title=_("Clock difference"), elements=[ Age(title=_("Warning at")), Age(title=_("Critical at")), ], ), ), ( "jenkins_temp", Tuple( title=_("Absolute levels for free temp space"), elements=[ Integer( title=_("Warning if below"), unit=_("MB"), minvalue=0, ), Integer( title=_("Critical if below"), unit=_("MB"), minvalue=0, ), ], ), ), ], )
def _parameter_valuespec_graylog_messages(): return Dictionary(elements=[ ( "msgs_upper", Tuple( title=_("Total message count upper levels"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], ), ), ( "msgs_lower", Tuple( title=_("Total message count lower levels"), elements=[ Integer(title=_("Warning if below")), Integer(title=_("Critical if below")), ], ), ), ( "msgs_avg", Integer( title=_("Message averaging"), help= _("By activating averaging, Check_MK will compute the average of " "the message count over a given interval. If you define " "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=30, ), ), ( "msgs_avg_upper", Tuple( title=_("Average message count upper levels"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], ), ), ( "msgs_avg_lower", Tuple( title=_("Average message count lower levels"), elements=[ Integer(title=_("Warning if below")), Integer(title=_("Critical if below")), ], ), ), ( "msgs_diff", Age( title=_( "Timespan for difference calculation of total number of " "messages"), display=["days", "hours", "minutes"], default_value=1800, ), ), ( "msgs_diff_lower", Tuple( title=_("Number of messages in defined timespan lower level"), elements=[ Integer(title=_("Warning below"), unit="messages"), Integer(title=_("Critical below"), unit="messages"), ], ), ), ( "msgs_diff_upper", Tuple( title=_("Number of messages in defined timespan upper level"), elements=[ Integer(title=_("Warning at"), unit="messages"), Integer(title=_("Critical at"), unit="messages"), ], ), ), ], )
def _valuespec_special_agents_cisco_prime(): return Dictionary( elements=[ ( "host", CascadingDropdown( choices=[ ("ip_address", _("IP Address")), ("host_name", _("Host name")), ( "custom", _("Custom Host"), Dictionary( elements=[( "host", TextInput( title=_("Custom Host"), allow_empty=False, ), )], optional_keys=[], ), ), ], default_value="ip_address", title=_("Host to use for connecting to Cisco Prime"), ), ), ( "basicauth", Tuple( title=_("BasicAuth settings (optional)"), help=_( "The credentials for api calls with authentication."), elements=[ TextInput(title=_("Username"), allow_empty=False), PasswordFromStore(title=_("Password of the user"), allow_empty=False), ], ), ), ("port", Integer(title=_("Port"), default_value=8080)), ( "no-tls", FixedValue( value=True, title=_("Don't use TLS/SSL/Https (unsecure)"), totext=_("TLS/SSL/Https disabled"), ), ), ( "no-cert-check", FixedValue( value=True, title=_("Disable SSL certificate validation"), totext=_("SSL certificate validation is disabled"), ), ), ( "timeout", Integer( title=_("Connect Timeout"), help=_("The network timeout in seconds"), default_value=60, minvalue=1, unit=_("seconds"), ), ), ], title=_("Cisco Prime"), )
agent_config_dict_dirs = Dictionary( title=_("Change <b>default directories</b>"), help=_("This settings allow to override paths where Robotmk stores files. "), elements=[ ("robotdir", TextUnicode( help=_( "Defines where the Robotmk plugin will search for <b>Robot suites</b>. By default this is:<br>" " - <tt>/usr/lib/check_mk_agent/robot</tt> (Linux)<br>" " - <tt>C:\\ProgramData\\checkmk\\agent\\robot</tt> (Windows) <br>" "Windows paths can be given with single backslashes; OS dependent path validation is made during the agent baking.<br>" ), title=_("Robot suites directory (<tt>robotdir</tt>)"), allow_empty=False, size=100, default_value="" ) ), ("outputdir", TextUnicode( help=_( "Defines where Robot Framework <b>XML/HTML</b> and the <b>Robotmk JSON state files</b> will be stored. By default this is:<br>" " - <tt>/var/log/robotmk</tt> (Linux)<br>" " - <tt>C:\\ProgramData\\checkmk\\agent\\log\\robotmk</tt> (Windows) <br>" "Windows paths can be given with single backslashes; OS dependent path validation is made during the agent baking.<br>" ), title=_("Output directory"), allow_empty=False, size=100, default_value="" ) ), ("logdir", TextUnicode( help=_( "Defines where Robotmk <b>controller/runner execution log files</b> will be written to. By default this is:<br>" " - <tt>/var/log/robotmk</tt> (Linux)<br>" " - <tt>C:\\ProgramData\\checkmk\\agent\\log\\robotmk</tt> (Windows) <br>" "Windows paths can be given with single backslashes; OS dependent path validation is made during the agent baking.<br>" ), title=_("Log directory"), allow_empty=False, size=100, default_value="" ) ), ])
def _parameter_valuespec_mssql_tablespaces(): return Dictionary(elements=[ ("size", Tuple( title=_("Upper levels for size"), elements=[Filesize(title=_("Warning at")), Filesize(title=_("Critical at"))], )), ("reserved", Alternative( title=_("Upper levels for reserved space"), elements=[ Tuple( title=_("Absolute levels"), elements=[Filesize(title=_("Warning at")), Filesize(title=_("Critical at"))], ), Tuple( title=_("Percentage levels"), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")) ], ), ], )), ("data", Alternative( title=_("Upper levels for data"), elements=[ Tuple( title=_("Absolute levels"), elements=[Filesize(title=_("Warning at")), Filesize(title=_("Critical at"))], ), Tuple( title=_("Percentage levels"), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")) ], ), ], )), ("indexes", Alternative( title=_("Upper levels for indexes"), elements=[ Tuple( title=_("Absolute levels"), elements=[Filesize(title=_("Warning at")), Filesize(title=_("Critical at"))], ), Tuple( title=_("Percentage levels"), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")) ], ), ], )), ("unused", Alternative( title=_("Upper levels for unused space"), elements=[ Tuple( title=_("Absolute levels"), elements=[Filesize(title=_("Warning at")), Filesize(title=_("Critical at"))], ), Tuple( title=_("Percentage levels"), elements=[ Percentage(title=_("Warning at")), Percentage(title=_("Critical at")) ], ), ], )), ("unallocated", Alternative( title=_("Lower levels for unallocated space"), elements=[ Tuple( title=_("Absolute levels"), elements=[ Filesize(title=_("Warning below")), Filesize(title=_("Critical below")) ], ), Tuple( title=_("Percentage levels"), elements=[ Percentage(title=_("Warning below")), Percentage(title=_("Critical below")) ], ), ], )), ],)
def _parameter_valuespec_diskstat(): return Dictionary( help= _("With this rule you can set limits for various disk IO statistics. " "Keep in mind that not all of these settings may be applicable for the actual " "check. For example, if the check doesn't provide a <i>Read wait</i> information in its " "output, any configuration setting referring to <i>Read wait</i> will have no effect." ), elements=[ ( "read", Levels( title=_("Read throughput"), unit=_("MB/s"), default_levels=(50.0, 100.0), ), ), ( "write", Levels( title=_("Write throughput"), unit=_("MB/s"), default_levels=(50.0, 100.0), ), ), ( "utilization", Levels( title=_("Disk Utilization"), unit=_("%"), default_levels=(80.0, 90.0), ), ), ( "latency", Levels( title=_("Disk Latency"), unit=_("ms"), default_levels=(80.0, 160.0), ), ), ( "read_latency", Levels( title=_("Disk Read Latency"), unit=_("ms"), default_levels=(80.0, 160.0), ), ), ( "write_latency", Levels( title=_("Disk Write Latency"), unit=_("ms"), default_levels=(80.0, 160.0), ), ), ("read_wait", Levels(title=_("Read wait"), unit=_("ms"), default_levels=(30.0, 50.0))), ( "write_wait", Levels(title=_("Write wait"), unit=_("ms"), default_levels=(30.0, 50.0)), ), ( "average", Age( title=_("Averaging"), help= _("When averaging is set, then all of the disk's metrics are averaged " "over the selected interval - rather then the check interval. This allows " "you to make your monitoring less reactive to short peaks. But it will also " "introduce a loss of accuracy in your graphs. "), default_value=300, ), ), ( "read_ios", Levels(title=_("Read operations"), unit=_("1/s"), default_levels=(400.0, 600.0)), ), ( "write_ios", Levels(title=_("Write operations"), unit=_("1/s"), default_levels=(300.0, 400.0)), ), ], )
def _parameter_valuespec_brocade_fcport(): 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 _parameter_valuespec_jenkins_jobs(): return Dictionary(elements=[ ("jenkins_job_score", Tuple( title=_("Job score"), elements=[ Integer(title=_("Warning below"), unit="%"), Integer(title=_("Critical below"), unit="%"), ], )), ("jenkins_last_build", Tuple( title=_("Time since last build"), elements=[ Age(title=_("Warning if older than")), Age(title=_("Critical if older than")), ], )), ("jenkins_time_since", Tuple( title=_("Time since last successful build"), elements=[ Age(title=_("Warning if older than")), Age(title=_("Critical if older than")), ], )), ('jenkins_build_duration', Tuple( title=_("Duration of last build"), elements=[ Age(title=_("Warning at")), Age(title=_("Critical at")), ], )), ("job_state", Dictionary( title=_('Override check state based on job state'), elements=[ ("aborted", MonitoringState(title=_("State when job is in state aborted"), default_value=0)), ("blue", MonitoringState(title=_("State when job is in state success"), default_value=0)), ("disabled", MonitoringState(title=_("State when job is in state disabled"), default_value=0)), ("notbuilt", MonitoringState(title=_("State when job is in state not built"), default_value=0)), ("red", MonitoringState(title=_("State when job is in state failed"), default_value=2)), ("yellow", MonitoringState(title=_("State when job is in state unstable"), default_value=1)), ], )), ("build_result", Dictionary( title=_('Override check state based on last build result'), elements=[ ("success", MonitoringState(title=_("State when last build result is: success"), default_value=0)), ("unstable", MonitoringState(title=_("State when last build result is: unstable"), default_value=1)), ("failure", MonitoringState(title=_("State when last build result is: failed"), default_value=2)), ("aborted", MonitoringState(title=_("State when last build result is: aborted"), default_value=0)), ("null", MonitoringState(title=_("State when last build result is: module not built"), default_value=1)), ("none", MonitoringState(title=_("State when build result is: running"), default_value=0)), ], )), ],)
def _parameter_valuespec_redis_info_clients(): return Dictionary(elements=[ ("connected_lower", Tuple( title=_("Total number of client connections lower level"), elements=[ Integer( title=_("Warning below"), unit="connections", ), Integer( title=_("Critical below"), unit="connections", ), ], )), ("connected_upper", Tuple( title=_("Total number of client connections upper level"), elements=[ Integer( title=_("Warning at"), unit="connections", ), Integer( title=_("Critical at"), unit="connections", ), ], )), ("output_lower", Tuple( title=_("Longest output list lower level"), elements=[ Integer(title=_("Warning below")), Integer(title=_("Critical below")), ], )), ("output_upper", Tuple( title=_("Longest output list upper level"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], )), ("input_lower", Tuple( title=_("Biggest input buffer lower level"), elements=[ Integer(title=_("Warning below"), unit="issues"), Integer(title=_("Critical below"), unit="íssues"), ], )), ("input_upper", Tuple( title=_("Biggest input buffer upper level"), elements=[ Integer(title=_("Warning at")), Integer(title=_("Critical at")), ], )), ("blocked_lower", Tuple( title= _("Total number of clients pending on a blocking call lower level" ), elements=[ Integer( title=_("Warning below"), unit="clients", ), Integer( title=_("Critical below"), unit="clients", ), ], )), ("blocked_upper", Tuple( title= _("Total number of clients pending on a blocking call upper level" ), elements=[ Integer( title=_("Warning at"), unit="clients", ), Integer( title=_("Critical at"), unit="clients", ), ], )), ], )
def _vs_rules(self): return Dictionary( optional_keys=False, elements=[ ( "agent_port", Integer( minvalue=1, maxvalue=65535, default_value=6556, title=_('Checkmk Agent Port (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "agent_ports")]), help=_( "This variable allows to specify the TCP port to " "be used to connect to the agent on a per-host-basis." ), ), ), ( "tcp_connect_timeout", Float( minvalue=1.0, default_value=5.0, unit=_("sec"), display_format="%.0f", # show values consistent to size=2, # SNMP-Timeout title=_( 'TCP Connection Timeout (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "tcp_connect_timeouts")]), help= _("This variable allows to specify a timeout for the " "TCP connection to the Check_MK agent on a per-host-basis." "If the agent does not respond within this time, it is considered to be unreachable." ), ), ), ( "snmp_timeout", Integer( title=_('SNMP-Timeout (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "snmp_timing")]), help= _("After a request is sent to the remote SNMP agent we will wait up to this " "number of seconds until assuming the answer get lost and retrying." ), default_value=1, minvalue=1, maxvalue=60, unit=_("sec"), ), ), ( "snmp_retries", Integer( title=_('SNMP-Retries (<a href="%s">Rules</a>)') % watolib.folder_preserving_link( [("mode", "edit_ruleset"), ("varname", "snmp_timing")]), default_value=5, minvalue=0, maxvalue=50, ), ), ], )
def _parameter_valuespec_kernel_performance(): return Dictionary(elements=[ ("ctxt", Levels( unit=_("events per second"), title=_("Context Switches"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("processes", Levels( unit=_("events per second"), title=_("Process Creations"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ("pgmajfault", Levels( unit=_("events per second"), title=_("Major Page Faults"), default_levels=(1000, 5000), default_difference=(500.0, 1000.0), default_value=None, )), ( "page_swap_in_levels_lower", Tuple(title=_("Swap In Lower"), elements=[ Float(title=_("Swap In warning below"), unit=_("events per second")), Float(title=_("Swap In critical below"), unit=_("events per second")) ]), ), ( "page_swap_in_levels", Tuple(title=_("Swap In Upper"), elements=[ Float(title=_("Swap In warning at"), unit=_("events per second")), Float(title=_("Swap In critical at"), unit=_("events per second")) ]), ), ( "page_swap_out_levels_lower", Tuple(title=_("Swap Out Lower"), elements=[ Float(title=_("Swap Out warning below"), unit=_("events per second")), Float(title=_("Swap Out critical below"), unit=_("events per second")) ]), ), ( "page_swap_out_levels", Tuple(title=_("Swap Out Upper"), elements=[ Float(title=_("Swap Out warning at"), unit=_("events per second")), Float(title=_("Swap Out critical at"), unit=_("events per second")) ]), ), ], )
def _parameter_valuespec_oracle_dataguard_stats(): return Dictionary( help=_( "The Data-Guard statistics are available in Oracle Enterprise Edition with enabled Data-Guard. " "The <tt>init.ora</tt> parameter <tt>dg_broker_start</tt> must be <tt>TRUE</tt> for this check. " "The apply and transport lag can be configured with this rule." ), elements=[ ( "active_dataguard_option", MonitoringState( title=_("State in case of Active Data-Guard Option is active: "), help=_("The Active Data-Guard Option needs an addional License from Oracle."), default_value=1, ), ), ( "mrp_option", Tuple( title=_("State in case Managed Recovery Process (MRP) is started or stopped"), help=_( "The MRP is usally started on each physical " "standby node. But in some setups this may vary and the process should " "only be started on specific or random nodes. Here you may define which " "state a specific node or service should have in case the MRP is started " "or stopped." ), elements=[ MonitoringState(title=_("State in case MRP is started"), default_value=0), MonitoringState(title=_("State in case MRP is stopped"), default_value=2), ], ), ), ( "primary_broker_state", Checkbox( title=_("Check State of Broker on Primary: "), default_value=False, help=_( "Data-Guards with dg_broker_start=false needs Ignore Brokerstate to monitor " "the Switchoverstate on Primary." ), ), ), ( "apply_lag", Tuple( title=_("Apply Lag Maximum Time"), help=_("The maximum limit for the apply lag in <tt>v$dataguard_stats</tt>."), elements=[ Age( title=_("Warning at"), ), Age( title=_("Critical at"), ), ], ), ), ( "apply_lag_min", Tuple( title=_("Apply Lag Minimum Time"), help=_( "The minimum limit for the apply lag in <tt>v$dataguard_stats</tt>. " "This is only useful if also <i>Apply Lag Maximum Time</i> has been configured." ), elements=[ Age( title=_("Warning at"), ), Age( title=_("Critical at"), ), ], ), ), ( "transport_lag", Tuple( title=_("Transport Lag"), help=_("The limit for the transport lag in <tt>v$dataguard_stats</tt>"), elements=[ Age( title=_("Warning at"), ), Age( title=_("Critical at"), ), ], ), ), ], )
def valuespec(self): return Dictionary( elements=[ ( "start", Alternative( title=_("Started"), elements=[ FixedValue( value=None, totext=_("No scan has been started yet."), ), AbsoluteDate( include_time=True, default_value=0, ), ], ), ), ( "end", Alternative( title=_("Finished"), elements=[ FixedValue( value=None, totext=_("No scan has finished yet."), ), FixedValue( value=True, totext="", # currently running ), AbsoluteDate( include_time=True, default_value=0, ), ], ), ), ( "state", Alternative( title=_("State"), elements=[ FixedValue( value=None, totext="", # Not started or currently running ), FixedValue( value=True, totext=_("Succeeded"), ), FixedValue( value=False, totext=_("Failed"), ), ], ), ), ( "output", TextInput(title=_("Output"), ), ), ], title=_("Last Scan Result"), optional_keys=[], default_text=_("No scan performed yet."), )
def _parameter_valuespec_sshd_config(): return Dictionary(elements=[ ("PermitRootLogin", Transform(DropdownChoice( title=_("Permit root login"), choices=[ ('yes', _('yes')), ('key-based', _('without-password/prohibit-password (Key based)')), ('forced-commands-only', _('forced-commands-only')), ('no', _('no')), ], default_value="key-based", ), forth=transform_ssh_config)), ("Protocol", DropdownChoice( title=_("Allowed protocols"), choices=[ ('1', _('Version 1')), ('2', _('Version 2')), ('1,2', _('Version 1 and 2')), ], default_value="2", )), ("Port", ListOfIntegers( title=_("Allowed Ports"), minvalue=0, maxvalue=65535, orientation="horizontal", default_value=[22], )), ("PasswordAuthentication", DropdownChoice( title=_("Allow password authentication"), help=_("Specifies whether password authentication is allowed"), choices=[ ('yes', _('Yes')), ('no', _('No')), ], default_value="no", )), ("PermitEmptyPasswords", DropdownChoice( title=_("Permit empty passwords"), help=_("If password authentication is used this option " "specifies wheter the server allows login to accounts " "with empty passwords"), choices=[ ('yes', _('Yes')), ('no', _('No')), ], default_value="no", )), ("ChallengeResponseAuthentication", DropdownChoice( title=_("Allow challenge-response authentication"), choices=[ ('yes', _('Yes')), ('no', _('No')), ], default_value="no", )), ("X11Forwarding", DropdownChoice( title=_("Permit X11 forwarding"), choices=[ ('yes', _('Yes')), ('no', _('No')), ], default_value="no", )), ("UsePAM", DropdownChoice( title=_("Use pluggable authentication module"), choices=[ ('yes', _('Yes')), ('no', _('No')), ], default_value="no", )), ("Ciphers", ListOfStrings( title=_("Allowed Ciphers"), orientation="horizontal", )), ],)
def vs_parameters(cls): return Dictionary(title=_("Properties"), render="form", optional_keys=False, elements=cls._vs_elements())