tyler.durden
/
icinga2
mirror of https://github.com/Icinga/icinga2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
icinga2/itl/command-plugins.conf

1067 lines
23 KiB
Plaintext
Raw Blame History

/******************************************************************************
* Icinga 2 *
* Copyright (C) 2012-2015 Icinga Development Team (http://www.icinga.org) *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License *
* as published by the Free Software Foundation; either version 2 *
* of the License, or (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software Foundation *
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. *
******************************************************************************/
template CheckCommand "ipv4-or-ipv6" {
vars.check_address = {{
var addr_v4 = macro("$address$")
var addr_v6 = macro("$address6$")
if (addr_v4) {
return addr_v4
} else {
return addr_v6
}
}}
}
template CheckCommand "ping-common" {
import "plugin-check-command"
command = [ PluginDir + "/check_ping" ]
arguments = {
"-H" = "$ping_address$"
"-w" = "$ping_wrta$,$ping_wpl$%"
"-c" = "$ping_crta$,$ping_cpl$%"
"-p" = "$ping_packets$"
"-t" = "$ping_timeout$"
}
vars.ping_wrta = 100
vars.ping_wpl = 5
vars.ping_crta = 200
vars.ping_cpl = 15
}
object CheckCommand "ping" {
import "ping-common"
import "ipv4-or-ipv6"
vars.ping_address = "$check_address$"
}
object CheckCommand "ping4" {
import "ping-common"
command += [ "-4" ]
vars.ping_address = "$address$"
}
object CheckCommand "ping6" {
import "ping-common"
command += [ "-6" ]
vars.ping_address = "$address6$"
}
template CheckCommand "hostalive-common" {
vars.ping_wrta = 3000.0
vars.ping_wpl = 80
vars.ping_crta = 5000.0
vars.ping_cpl = 100
}
object CheckCommand "hostalive" {
import "ping"
import "hostalive-common"
}
object CheckCommand "hostalive4" {
import "ping4"
import "hostalive-common"
}
object CheckCommand "hostalive6" {
import "ping6"
import "hostalive-common"
}
template CheckCommand "fping-common" {
import "plugin-check-command"
command = [
PluginDir + "/check_fping",
"$fping_address$"
]
arguments = {
"-w" = "$fping_wrta$,$fping_wpl$%"
"-c" = "$fping_crta$,$fping_cpl$%"
"-n" = "$fping_number$"
"-i" = "$fping_interval$"
"-b" = "$fping_bytes$"
"-T" = "$fping_target_timeout$"
"-S" = "$fping_source_ip$"
"-I" = "$fping_source_interface$"
}
vars.fping_wrta = 100
vars.fping_wpl = 5
vars.fping_crta = 200
vars.fping_cpl = 15
vars.fping_number = 5
vars.fping_interval = 500
}
object CheckCommand "fping4" {
import "fping-common"
command += [ "-4" ]
vars.fping_address = "$address$"
}
object CheckCommand "fping6" {
import "fping-common"
command += [ "-6" ]
vars.fping_address = "$address6$"
}
object CheckCommand "dummy" {
import "plugin-check-command"
command = [
PluginDir + "/check_dummy",
"$dummy_state$",
"$dummy_text$"
]
vars.dummy_state = 0
vars.dummy_text = "Check was successful."
}
object CheckCommand "passive" {
import "dummy"
vars.dummy_state = 3
vars.dummy_text = "No Passive Check Result Received."
}
object CheckCommand "tcp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [
PluginDir + "/check_tcp",
"-H", "$tcp_address$",
"-p", "$tcp_port$"
]
vars.tcp_address = "$check_address$"
}
object CheckCommand "ssl" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_tcp" ]
arguments = {
"-H" = "$ssl_address$"
"-p" = "$ssl_port$"
"--ssl" = { }
"--timeout" = "$ssl_timeout$"
"-D" = "$ssl_cert_valid_days_warn$,$ssl_cert_valid_days_critical$"
}
vars.ssl_address = "$check_address$"
}
object CheckCommand "udp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [
PluginDir + "/check_udp",
"-H", "$udp_address$",
"-p", "$udp_port$"
]
arguments = {
"-s" = {
value = "$udp_send$"
required = true
}
"-e" = {
value = "$udp_expect$"
required = true
}
"-q" = "$udp_quit$"
}
vars.udp_address = "$check_address$"
}
object CheckCommand "http" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_http" ]
arguments = {
"-H" = "$http_vhost$"
"-I" = "$http_address$"
"-u" = "$http_uri$"
"-p" = "$http_port$"
"-S" = {
set_if = "$http_ssl$"
}
"--sni" = {
set_if = "$http_sni$"
}
"-C" = {
value = "$http_certificate$"
description = "Minimum number of days a certificate has to be valid. Port defaults to 443."
}
"-J" = {
value = "$http_clientcert$"
description = "Name of file contains the client certificate (PEM format)"
}
"-K" = {
value = "$http_privatekey$"
description = "Name of file contains the private key (PEM format)"
}
"-a" = {
value = "$http_auth_pair$"
description = "Username:password on sites with basic authentication"
}
"--no-body" = {
set_if = "$http_ignore_body$"
}
"-w" = "$http_warn_time$"
"-c" = "$http_critical_time$"
"-e" = "$http_expect$"
"-d" = {
value = "$http_headerstring$"
description = "String to expect in the response headers"
}
"-s" = {
value = "$http_string$"
description = "String to expect in the content"
}
"-P" = {
value = "$http_post$"
description = "URL encoded http POST data"
}
"-j" = {
value = "$http_method$"
description = "Set http method (for example: HEAD, OPTIONS, TRACE, PUT, DELETE)"
}
"-M" = {
value = "$http_maxage$"
description = "Warn if document is more than seconds old"
}
"-T" = {
value = "$http_contenttype$"
description = "Specify Content-Type header when POSTing"
}
"-l" = {
set_if = "$http_linespan$"
description = "Allow regex to span newline"
order = 1
}
"-r" = {
value = "$http_expect_body_regex$"
description = "Search page for regex"
order = 2
}
"-R" = {
value = "$http_expect_body_eregi$"
description = "Search page for case-insensitive regex"
order = 2
}
"--invert-regex" = {
set_if = "$http_invertregex$"
description = "Return CRITICAL if found, OK if not"
}
"-b" = {
value = "$http_proxy_auth_pair$"
description = "Username:password on proxy-servers with basic authentication"
}
"-A" = {
value = "$http_useragent$"
description = "String to be sent in http header as User Agent"
}
"-k" = {
value = "$http_header$"
description = "Any other tags to be sent in http header"
}
"-E" = {
set_if = "$http_extendedperfdata$"
description = "Print additional perfdata"
}
"-f" = {
value = "$http_onredirect$"
description = "How to handle redirect pages"
}
"-m" = {
value = "$http_pagesize$"
description = "Minim page size required:Maximum page size required"
}
"-t" = {
value = "$http_timeout$"
description = "Seconds before connection times out"
}
}
vars.http_address = "$check_address$"
vars.http_ssl = false
vars.http_sni = false
vars.http_linespan = false
vars.http_invertregex = false
}
object CheckCommand "ftp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_ftp" ]
arguments = {
"-H" = "$ftp_address$"
}
vars.ftp_address = "$check_address$"
}
object CheckCommand "smtp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_smtp" ]
arguments = {
"-H" = "$smtp_address$"
"-p" = "$smtp_port$"
"-f" = "$smtp_mail_from$"
}
vars.smtp_address = "$check_address$"
}
object CheckCommand "ssmtp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_ssmtp" ]
arguments = {
"-H" = "$ssmtp_address$"
"-p" = "$ssmtp_port$"
}
vars.ssmtp_address = "$check_address$"
}
object CheckCommand "imap" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_imap" ]
arguments = {
"-H" = "$imap_address$"
"-p" = "$imap_port$"
}
vars.imap_address = "$check_address$"
}
object CheckCommand "simap" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_simap" ]
arguments = {
"-H" = "$simap_address$"
"-p" = "$simap_port$"
}
vars.simap_address = "$check_address$"
}
object CheckCommand "pop" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_pop" ]
arguments = {
"-H" = "$pop_address$"
"-p" = "$pop_port$"
}
vars.pop_address = "$check_address$"
}
object CheckCommand "spop" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_spop" ]
arguments = {
"-H" = "$spop_address$"
"-p" = "$spop_port$"
}
vars.spop_address = "$check_address$"
}
object CheckCommand "ntp_time" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_ntp_time" ]
arguments = {
"-H" = "$ntp_address$"
}
vars.ntp_address = "$check_address$"
}
object CheckCommand "ssh" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_ssh" ]
arguments = {
"-p" = "$ssh_port$"
"-t" = "$ssh_timeout$"
"host" = {
value = "$ssh_address$"
skip_key = true
order = 1
}
}
vars.ssh_address = "$check_address$"
}
object CheckCommand "disk" {
import "plugin-check-command"
command = [ PluginDir + "/check_disk" ]
arguments = {
"-w" = {
value = "$disk_wfree$"
description = "Exit with WARNING status if less than INTEGER units of disk are free or Exit with WARNING status if less than PERCENT of disk space is free"
required = true
}
"-c" = {
value = "$disk_cfree$"
description = "Exit with CRITICAL status if less than INTEGER units of disk are free or Exit with CRITCAL status if less than PERCENT of disk space is free"
required = true
}
"-W" = {
value = "$disk_inode_wfree$"
description = "Exit with WARNING status if less than PERCENT of inode space is free"
}
"-K" = {
value = "$disk_inode_cfree$"
description = "Exit with CRITICAL status if less than PERCENT of inode space is free"
}
"-p" = {
value = "$disk_partitions$"
description = "Path or partition (may be repeated)"
repeat_key = true
order = 1
}
"-p_old" = {
key = "-p"
value = "$disk_partition$"
order = 1
}
"-x" = {
value = "$disk_partitions_excluded$"
description = "Ignore device (only works if -p unspecified)"
}
"-x_old" = {
key = "-x"
value = "$disk_partition_excluded$"
}
"-C" = {
set_if = "$disk_clear$"
description = "Clear thresholds"
}
"-E" = {
set_if = "$disk_exact_match$"
description = "For paths or partitions specified with -p, only check for exact paths"
}
"-e" = {
set_if = "$disk_errors_only$"
description = "Display only devices/mountpoints with errors"
}
"-g" = {
value = "$disk_group$"
description = "Group paths. Thresholds apply to (free-)space of all partitions together"
}
"-k" = {
set_if = "$disk_kilobytes$"
description = "Same as --units kB"
}
"-l" = {
set_if = "$disk_local$"
description = " Only check local filesystems"
}
"-L" = {
set_if = "$disk_stat_remote_fs$"
description = "Only check local filesystems against thresholds. Yet call stat on remote filesystems to test if they are accessible (e.g. to detect Stale NFS Handles)"
}
"-M" = {
set_if = "$disk_mountpoint$"
description = "Display the mountpoint instead of the partition"
}
"-m" = {
set_if = "$disk_megabytes$"
description = "Same as --units MB"
}
"-A" = {
set_if = "$disk_all$"
description = "Explicitly select all paths. This is equivalent to -R .*"
}
"-R" = {
value = "$disk_eregi_path$"
description = "Case insensitive regular expression for path/partition (may be repeated)"
repeat_key = true
}
"-r" = {
value = "$disk_ereg_path$"
description = "Regular expression for path or partition (may be repeated)"
repeat_key = true
}
"-I" = {
value = "$disk_ignore_eregi_path$"
description = "Regular expression to ignore selected path/partition (case insensitive) (may be repeated)"
repeat_key = true
order = 2
}
"-i" = {
value = "$disk_ignore_ereg_path$"
description = "Regular expression to ignore selected path or partition (may be repeated)"
repeat_key = true
order = 2
}
"-t" = {
value = "$disk_timeout$"
description = "Seconds before connection times out (default: 10)"
}
"-u" = {
value = "$disk_units$"
description = "Choose bytes, kB, MB, GB, TB (default: MB)"
}
"-X" = {
value = "$disk_exclude_type$"
description = "Ignore all filesystems of indicated type (may be repeated)"
repeat_key = true
}
}
vars.disk_wfree = "20%"
vars.disk_cfree = "10%"
vars.disk_megabytes = true
vars.disk_exclude_type = ["none", "tmpfs", "sysfs", "proc", "devtmpfs", "devfs", "mtmfs"]
}
object CheckCommand "users" {
import "plugin-check-command"
command = [ PluginDir + "/check_users" ]
arguments = {
"-w" = "$users_wgreater$"
"-c" = "$users_cgreater$"
}
vars.users_wgreater = 20
vars.users_cgreater = 50
}
object CheckCommand "procs" {
import "plugin-check-command"
command = [ PluginDir + "/check_procs" ]
arguments = {
"-w" = {
value = "$procs_warning$"
description = "Generate warning state if metric is outside this range"
}
"-c" = {
value = "$procs_critical$"
description = "Generate critical state if metric is outside this range"
}
"-m" = {
value = "$procs_metric$"
description = "Check thresholds against metric"
}
"-t" = {
value = "$procs_timeout$"
description = "Seconds before plugin times out"
}
"-T" = {
set_if = "$procs_traditional$"
description = "Filter own process the traditional way by PID instead of /proc/pid/exe"
}
"-s" = {
value = "$procs_state$"
description = "Only scan for processes that have one or more of the status flags you specify"
}
"-p" = {
value = "$procs_ppid$"
description = "Only scan for children of the parent process ID indicated"
}
"-z" = {
value = "$procs_vsz$"
description = "Only scan for processes with VSZ higher than indicated"
}
"-r" = {
value = "$procs_rss$"
description = "Only scan for processes with RSS higher than indicated"
}
"-P" = {
value = "$procs_pcpu$"
description = "Only scan for processes with PCPU higher than indicated"
}
"-u" = {
value = "$procs_user$"
description = "Only scan for processes with user name or ID indicated"
}
"-a" = {
value = "$procs_argument$"
description = "Only scan for processes with args that contain STRING"
}
"--ereg-argument-array" = {
value = "$procs_argument_regex$"
description = "Only scan for processes with args that contain the regex STRING"
}
"-C" = {
value = "$procs_command$"
description = "Only scan for exact matches of COMMAND (without path)"
}
"-k" = {
set_if = "$procs_nokthreads$"
description = "Only scan for non kernel threads"
}
}
vars.procs_traditional = false
vars.procs_nokthreads = false
vars.procs_warning = 250
vars.procs_critical = 400
}
object CheckCommand "swap" {
import "plugin-check-command"
command = [ PluginDir + "/check_swap" ]
arguments = {
"-w" = "$swap_wfree$%"
"-c" = "$swap_cfree$%"
}
vars.swap_wfree = 50
vars.swap_cfree = 25
}
object CheckCommand "load" {
import "plugin-check-command"
command = [ PluginDir + "/check_load" ]
arguments = {
"-w" = "$load_wload1$,$load_wload5$,$load_wload15$"
"-c" = "$load_cload1$,$load_cload5$,$load_cload15$"
}
vars.load_wload1 = 5.0
vars.load_wload5 = 4.0
vars.load_wload15 = 3.0
vars.load_cload1 = 10.0
vars.load_cload5 = 6.0
vars.load_cload15 = 4.0
}
object CheckCommand "snmp" {
import "plugin-check-command"
command = [ PluginDir + "/check_snmp" ]
arguments = {
"-H" = "$snmp_address$"
"-o" = "$snmp_oid$"
"-C" = "$snmp_community$"
"-c" = "$snmp_crit$"
"-w" = "$snmp_warn$"
"-s" = "$snmp_string$"
"-r" = "$snmp_ereg$"
"-R" = "$snmp_eregi$"
"-l" = "$snmp_label$"
"-u" = "$snmp_units$"
"-t" = "$snmp_timeout$"
"--invert-search" = {
set_if = "$snmp_invert_search$"
description = "Invert search result and return CRITICAL if found"
}
"-P" = "$snmp_version$"
"-m" = "$snmp_miblist$"
"--rate-multiplier" = "$snmp_rate_multiplier$"
"--rate" = {
set_if = "$snmp_rate$"
description = "Enable rate calculation"
}
"-n" = {
set_if = "$snmp_getnext$"
description = "Use SNMP GETNEXT instead of SNMP GET"
}
}
vars.snmp_address = {{
var addr_v4 = macro("$address$")
var addr_v6 = macro("$address6$")
if (addr_v4) {
return addr_v4
} else {
return "udp6:[" + addr_v6 + "]"
}
}}
vars.snmp_community = "public"
vars.snmp_invert_search = false
vars.snmp_timeout = "10"
}
object CheckCommand "snmpv3" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_snmp" ]
arguments = {
"-H" = "$snmpv3_address$"
"-P" = 3
"--seclevel" = "authPriv"
"-U" = "$snmpv3_user$"
"-a" = "$snmpv3_auth_alg$"
"-A" = "$snmpv3_auth_key$"
"-x" = "$snmpv3_priv_alg$"
"-X" = "$snmpv3_priv_key$"
"-o" = "$snmpv3_oid$"
"-c" = "$snmpv3_crit$"
"-w" = "$snmpv3_warn$"
"-l" = "$snmpv3_label$"
}
vars.snmpv3_address = "$check_address$"
vars.snmpv3_auth_alg = "SHA"
vars.snmpv3_priv_alg = "AES"
}
object CheckCommand "snmp-uptime" {
import "snmp"
vars.snmp_oid = "1.3.6.1.2.1.1.3.0"
}
object CheckCommand "apt" {
import "plugin-check-command"
command = [ PluginDir + "/check_apt" ]
}
object CheckCommand "dhcp" {
import "plugin-check-command"
command = [ PluginDir + "/check_dhcp" ]
arguments = {
"-s" = "$dhcp_serverip$"
"-r" = "$dhcp_requestedip$"
"-t" = "$dhcp_timeout$"
"-i" = "$dhcp_interface$"
"-m" = "$dhcp_mac$"
"-u" = {
set_if = "$dhcp_unicast$"
}
}
vars.dhcp_unicast = false
}
object CheckCommand "dns" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_dns" ]
arguments = {
"-H" = "$dns_lookup$"
"-s" = "$dns_server$"
"-a" = "$dns_expected_answers$"
"-a_old" = {
key = "-a"
value ="$dns_expected_answer$"
}
"-A" = {
set_if = "$dns_authoritative$"
}
}
vars.dns_lookup = "$host.name$"
vars.dns_expected_answer = "$check_address$"
}
object CheckCommand "dig" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_dig" ]
arguments = {
"-H" = "$dig_server$"
"-l" = "$dig_lookup$"
}
vars.dig_server = "$check_address$"
}
object CheckCommand "nscp" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_nt" ]
arguments = {
"-H" = "$nscp_address$"
"-p" = "$nscp_port$"
"-s" = "$nscp_password$"
"-v" = {
value = "$nscp_variable$"
required = true
}
"-l" = {
value = "$nscp_params$"
repeat_key = false
}
"-w" = "$nscp_warn$"
"-c" = "$nscp_crit$"
"-t" = "$nscp_timeout$"
"-d" = {
value = "SHOWALL"
description = "Use with SERVICESTATE to see working services or PROCSTATE for running processes"
set_if = "$nscp_showall$"
}
}
vars.nscp_address = "$check_address$"
vars.nscp_port = 12489
vars.nscp_showall = false
}
object CheckCommand "by_ssh" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_by_ssh" ]
arguments = {
"-H" = "$by_ssh_address$"
"-p" = "$by_ssh_port$"
"-C" = "$by_ssh_command$"
"-l" = "$by_ssh_logname$"
"-i" = "$by_ssh_identity$"
"-q" = {
set_if = "$by_ssh_quiet$"
}
"-w" = "$by_ssh_warn$"
"-c" = "$by_ssh_crit$"
"-t" = "$by_ssh_timeout$"
}
vars.by_ssh_address = "$check_address$"
vars.by_ssh_quiet = false
}
object CheckCommand "ups" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_ups" ]
arguments = {
"-H" = {
value = "$ups_address$"
description = "Address of the upsd server"
required = true
}
"-u" = {
value = "$ups_name$"
description = "Name of the UPS to monitor"
required = true
}
"-p" = {
value = "$ups_port$"
description = "Port number (default: 3493)"
}
"-v" = {
value = "$ups_variable$"
description = "Variable to monitor, valid strings are LINE, TEMP, BATTPCT or LOADPCT"
}
"-w" = {
value = "$ups_warning$"
description = "Warning threshold for the selected variable"
}
"-c" = {
value = "$ups_critical$"
description = "Critical threshold for the selected variable"
}
"-T" = {
set_if = "$ups_celsius$"
description = "Display temperature in degrees Celsius instead of Fahrenheit"
}
"-t" = {
value = "$ups_timeout$"
description = "Seconds before the connection times out (default: 10)"
}
}
vars.ups_address = "$check_address$"
vars.ups_name = "ups"
}
object CheckCommand "nrpe" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_nrpe" ]
arguments = {
"-H" = "$nrpe_address$"
"-p" = "$nrpe_port$"
"-c" = "$nrpe_command$"
"-n" = {
set_if = "$nrpe_no_ssl$"
description = "Do not use SSL."
}
"-u" = {
set_if = "$nrpe_timeout_unknown$"
description = "Make socket timeouts return an UNKNOWN state instead of CRITICAL"
}
"-t" = "$nrpe_timeout$"
"-a" = {
value = "$nrpe_arguments$"
repeat_key = false
order = 1
}
}
vars.nrpe_address = "$check_address$"
vars.nrpe_no_ssl = false
vars.nrpe_timeout_unknown = false
timeout = 5m
}
object CheckCommand "hpjd" {
import "plugin-check-command"
import "ipv4-or-ipv6"
command = [ PluginDir + "/check_hpjd" ]
arguments = {
"-H" = "$hpjd_address$"
"-C" = "$hpjd_community$"
"-p" = "$hpjd_port$"
}
vars.hpjd_address = "$check_address$"
}
object CheckCommand "icmp" {
import "plugin-check-command"
command = [ PluginDir + "/check_icmp" ]
arguments = {
"-H" = {
value = "$icmp_address$"
repeat_key = false
order = 1
}
"-w" = "$icmp_wrta$,$icmp_wpl$%"
"-c" = "$icmp_crta$,$icmp_cpl$%"
"-s" = "$icmp_source$"
"-n" = "$icmp_packets$"
"-i" = "$icmp_packet_interval$"
"-I" = "$icmp_target_interval$"
"-m" = "$icmp_hosts_alive$"
"-b" = "$icmp_data_bytes$"
"-t" = "$icmp_timeout$"
}
vars.icmp_address = "$address$"
vars.icmp_wrta = 100
vars.icmp_wpl = 5
vars.icmp_crta = 200
vars.icmp_cpl = 15
}
/* Contrib plugins */
object CheckCommand "running_kernel" {
import "plugin-check-command"
command = [ "sudo", PluginDir + "/check_running_kernel" ]
}
Reference in New Issue View Git Blame Copy Permalink