|
|
@@ -0,0 +1,626 @@
|
|
|
+__version__ = '0.0.100802'
|
|
|
+__all__ = ['MonitoringPlugin', 'SNMPMonitoringPlugin']
|
|
|
+
|
|
|
+import optparse, os, re, sys
|
|
|
+
|
|
|
+try:
|
|
|
+ import netsnmp
|
|
|
+except ImportError:
|
|
|
+ pass
|
|
|
+
|
|
|
+class MonitoringPlugin(object):
|
|
|
+
|
|
|
+ RETURNSTRINGS = { 0: "OK", 1: "WARNING", 2: "CRITICAL", 3: "UNKNOWN", 127: "UNKNOWN" }
|
|
|
+ RETURNCODE = { 'OK': 0, 'WARNING': 1, 'CRITICAL': 2, 'UNKNOWN': 3 }
|
|
|
+
|
|
|
+ returncode_priority = [2, 1, 3, 0]
|
|
|
+
|
|
|
+ powers_binary = ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']
|
|
|
+ powers_binary_lower = [ p.lower() for p in powers_binary]
|
|
|
+ powers_si = ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z']
|
|
|
+ powers_si_lower = [ p.lower() for p in powers_si]
|
|
|
+
|
|
|
+
|
|
|
+ def __init__(self, *args, **kwargs):
|
|
|
+ self.__pluginname = kwargs.get('pluginname') or ''
|
|
|
+ self.__version = kwargs.get('version') or None
|
|
|
+ self.__tagforstatusline = kwargs.get('tagforstatusline') or ''
|
|
|
+ self.__tagforstatusline = self.__tagforstatusline.replace('|', ' ')
|
|
|
+ self.__description = kwargs.get('description') or None
|
|
|
+
|
|
|
+ self.__output = []
|
|
|
+ self.__multilineoutput = []
|
|
|
+ self.__performancedata = []
|
|
|
+ self.__returncode = []
|
|
|
+
|
|
|
+ self.__brain_checks = []
|
|
|
+ self.__brain_perfdata = []
|
|
|
+ self.__brain_perfdatalabels = []
|
|
|
+
|
|
|
+ self.__optparser = optparse.OptionParser(version=self.__version, description=self.__description)
|
|
|
+ self._cmdlineoptions_parsed = False
|
|
|
+
|
|
|
+
|
|
|
+ def add_cmdlineoption(self, shortoption, longoption, dest, help, **kwargs):
|
|
|
+ self.__optparser.add_option(shortoption, longoption, dest=dest, help=help, **kwargs)
|
|
|
+
|
|
|
+
|
|
|
+ def parse_cmdlineoptions(self):
|
|
|
+ if self._cmdlineoptions_parsed:
|
|
|
+ return
|
|
|
+# self.__optparser.add_option('-V', '--version', action='version', help='show version number and exit')
|
|
|
+ self.__optparser.add_option('-v', '--verbose', dest='verbose', help='Verbosity, more for more ;-)', action='count')
|
|
|
+
|
|
|
+ (self.options, self.args) = self.__optparser.parse_args()
|
|
|
+ self._cmdlineoptions_parsed = True
|
|
|
+
|
|
|
+
|
|
|
+ def range_to_limits(self, range):
|
|
|
+ # Check if we must negate result
|
|
|
+ if len(range) > 0 and range[0] == '@':
|
|
|
+ negate = True
|
|
|
+ range = range[1:]
|
|
|
+ else:
|
|
|
+ negate = False
|
|
|
+
|
|
|
+ # Look for a ':'...
|
|
|
+ if range.find(':') >= 0:
|
|
|
+ # ... this is a range
|
|
|
+ (low, high) = range.split(':')
|
|
|
+
|
|
|
+ if not low:
|
|
|
+ low = float(0.0)
|
|
|
+ elif low[0] == '~':
|
|
|
+ low = float('-infinity')
|
|
|
+ else:
|
|
|
+ low = float(low)
|
|
|
+
|
|
|
+ if high:
|
|
|
+ high = float(high)
|
|
|
+ else:
|
|
|
+ high = float('infinity')
|
|
|
+
|
|
|
+ elif len(range) == 0:
|
|
|
+ low = float('-infinity')
|
|
|
+ high = float('infinity')
|
|
|
+
|
|
|
+ else:
|
|
|
+ # ... this is just a number
|
|
|
+ low = float(0.0)
|
|
|
+ high = float(range)
|
|
|
+
|
|
|
+ return (low, high, negate)
|
|
|
+
|
|
|
+
|
|
|
+ def value_in_range(self, value, range):
|
|
|
+ (low, high, negate) = self.range_to_limits(range)
|
|
|
+
|
|
|
+ if value < low or value > high:
|
|
|
+ result = False
|
|
|
+ else:
|
|
|
+ result = True
|
|
|
+
|
|
|
+ if negate:
|
|
|
+ result = not result
|
|
|
+
|
|
|
+ return result
|
|
|
+
|
|
|
+
|
|
|
+ def value_wc_to_returncode(self, value, range_warn, range_crit):
|
|
|
+ if not self.value_in_range(value, range_crit):
|
|
|
+ return 2
|
|
|
+ elif not self.value_in_range(value, range_warn):
|
|
|
+ return 1
|
|
|
+
|
|
|
+ return 0
|
|
|
+
|
|
|
+
|
|
|
+ def is_float(self, string):
|
|
|
+ try:
|
|
|
+ float(string)
|
|
|
+ return True
|
|
|
+ except ValueError:
|
|
|
+ return False
|
|
|
+
|
|
|
+
|
|
|
+ def special_value_wc_to_returncode(self, value, warn, crit):
|
|
|
+ # Special add on: WARN > CRIT
|
|
|
+ if self.is_float(warn) and self.is_float(crit) and float(warn) > float(crit):
|
|
|
+ # Test if value is *smaller* than thresholds
|
|
|
+ warn = '@0:' + warn
|
|
|
+ crit = '@0:' + crit
|
|
|
+
|
|
|
+ return self.value_wc_to_returncode(value, warn, crit)
|
|
|
+
|
|
|
+
|
|
|
+ def add_output(self, value):
|
|
|
+ self.__output.append(value)
|
|
|
+
|
|
|
+
|
|
|
+ def add_multilineoutput(self, value):
|
|
|
+ self.__multilineoutput.append(value)
|
|
|
+
|
|
|
+
|
|
|
+ def format_performancedata(self, label, value, unit, *args, **kwargs):
|
|
|
+ label = label.lstrip().rstrip()
|
|
|
+ if re.search('[=\' ]', label):
|
|
|
+ label = '\'' + label + '\''
|
|
|
+ perfdata = label + '=' + str(value)
|
|
|
+ if unit:
|
|
|
+ perfdata += str(unit).lstrip().rstrip()
|
|
|
+ for key in ['warn', 'crit', 'min', 'max']:
|
|
|
+ perfdata += ';'
|
|
|
+ if key in kwargs:
|
|
|
+ perfdata += str(kwargs[key])
|
|
|
+
|
|
|
+ return perfdata
|
|
|
+
|
|
|
+
|
|
|
+ def add_performancedata(self, perfdata):
|
|
|
+ self.__performancedata.append(perfdata)
|
|
|
+
|
|
|
+
|
|
|
+ def format_add_performancedata(self, label, value, unit, *args, **kwargs):
|
|
|
+ self.add_performancedata(self.format_performancedata(label, value, unit, *args, **kwargs))
|
|
|
+
|
|
|
+
|
|
|
+ def add_returncode(self, value):
|
|
|
+ self.__returncode.append(value)
|
|
|
+
|
|
|
+
|
|
|
+ def tagtarget(self, tag, target):
|
|
|
+ if target:
|
|
|
+ return str(tag) + ':' + str(target)
|
|
|
+ else:
|
|
|
+ return str(tag)
|
|
|
+
|
|
|
+
|
|
|
+ def remember_check(self, tag, returncode, output, multilineoutput=None, perfdata=None, target=None):
|
|
|
+ check = {}
|
|
|
+ check['tag'] = tag
|
|
|
+ check['returncode'] = returncode
|
|
|
+ check['output'] = output
|
|
|
+ check['multilineoutout'] = multilineoutput
|
|
|
+ check['perfdata'] = perfdata
|
|
|
+ check['target'] = target
|
|
|
+
|
|
|
+ self.remember_perfdata(perfdata)
|
|
|
+
|
|
|
+ self.__brain_checks.append(check)
|
|
|
+
|
|
|
+ return check
|
|
|
+
|
|
|
+
|
|
|
+ def remember_perfdata(self, perfdata=None):
|
|
|
+ if perfdata:
|
|
|
+ for pd in perfdata:
|
|
|
+ if pd['label'] in self.__brain_perfdatalabels:
|
|
|
+ pdidx = self.__brain_perfdatalabels.index(pd['label'])
|
|
|
+ self.__brain_perfdata[pdidx] = pd
|
|
|
+ else:
|
|
|
+ self.__brain_perfdata.append(pd)
|
|
|
+ self.__brain_perfdatalabels.append(pd['label'])
|
|
|
+
|
|
|
+
|
|
|
+ def dump_brain(self):
|
|
|
+ return (self.__brain_checks, self.__brain_perfdata)
|
|
|
+
|
|
|
+
|
|
|
+ def brain2output(self):
|
|
|
+ out = [[], [], [], []]
|
|
|
+ for check in self.__brain_checks:
|
|
|
+ tagtarget = self.tagtarget(check['tag'], check.get('target'))
|
|
|
+ returncode = check.get('returncode') or 0
|
|
|
+ self.add_returncode(returncode)
|
|
|
+
|
|
|
+ out[returncode].append(tagtarget)
|
|
|
+ #if returncode == 0:
|
|
|
+ # self.add_output(tagtarget)
|
|
|
+ #else:
|
|
|
+ # self.add_output(tagtarget + '(' + check.get('output') + ') ')
|
|
|
+
|
|
|
+ self.add_multilineoutput(self.RETURNSTRINGS[returncode] + ' ' + tagtarget + ' - ' + check.get('output'))
|
|
|
+ if check.get('multilineoutput'):
|
|
|
+ self.add_multilineoutput(check.get('multilineoutput'))
|
|
|
+
|
|
|
+ statusline = []
|
|
|
+ for retcode in [2, 1, 3, 0]:
|
|
|
+ if len(out[retcode]):
|
|
|
+ statusline.append(str(len(out[retcode])) + ' ' + self.RETURNSTRINGS[retcode] + ': ' + '/'.join(out[retcode]))
|
|
|
+ statusline = ', '.join(statusline)
|
|
|
+ self.add_output(statusline)
|
|
|
+
|
|
|
+ for pd in self.__brain_perfdata:
|
|
|
+ self.format_add_performancedata(**pd)
|
|
|
+
|
|
|
+
|
|
|
+ def value_to_human_binary(self, value, unit=''):
|
|
|
+ for power in self.powers_binary:
|
|
|
+ if value < 1024.0:
|
|
|
+ return "%3.1f%s%s" % (value, power, unit)
|
|
|
+ value /= 1024.0
|
|
|
+ if float(value) not in [float('inf'), float('-inf')]:
|
|
|
+ return "%3.1fYi%s" % (value, unit)
|
|
|
+ else:
|
|
|
+ return value
|
|
|
+
|
|
|
+
|
|
|
+ def value_to_human_si(self, value, unit=''):
|
|
|
+ for power in self.powers_si:
|
|
|
+ if value < 1000.0:
|
|
|
+ return "%3.1f%s%s" % (value, power, unit)
|
|
|
+ value /= 1000.0
|
|
|
+ if float(value) not in [float('inf'), float('-inf')]:
|
|
|
+ return "%3.1fY%s" % (value, unit)
|
|
|
+ else:
|
|
|
+ return value
|
|
|
+
|
|
|
+
|
|
|
+ def human_to_number(self, value, total=None):
|
|
|
+ if total:
|
|
|
+ if not self.is_float(total):
|
|
|
+ total = self.human_to_number(total)
|
|
|
+
|
|
|
+ if self.is_float(value):
|
|
|
+ return float(value)
|
|
|
+ elif value[-1] == '%':
|
|
|
+ if total:
|
|
|
+ return float(value[:-1])/100.0 * float(total)
|
|
|
+ else:
|
|
|
+ return float(value[:-1])
|
|
|
+ elif value[-1].lower() in self.powers_si_lower:
|
|
|
+ return 1000.0 ** self.powers_si_lower.index(value[-1].lower()) * float(value[:-1])
|
|
|
+ elif value[-2:].lower() in self.powers_binary_lower:
|
|
|
+ return 1024.0 ** self.powers_binary_lower.index(value[-2:].lower()) * float(value[:-2])
|
|
|
+ else:
|
|
|
+ return value
|
|
|
+
|
|
|
+
|
|
|
+ def range_dehumanize(self, range, total=None):
|
|
|
+ newrange = ''
|
|
|
+
|
|
|
+ if len(range):
|
|
|
+ if range[0] == '@':
|
|
|
+ newrange += '@'
|
|
|
+ range = range[1:]
|
|
|
+
|
|
|
+ parts = range.split(':')
|
|
|
+ newrange += str(self.human_to_number(parts[0], total))
|
|
|
+
|
|
|
+ if len(parts) > 1:
|
|
|
+ newrange += ':' + str(self.human_to_number(parts[1], total))
|
|
|
+
|
|
|
+ if range != newrange:
|
|
|
+ self.verbose(3, 'Changed range/thresold from "' + range + '" to "' + newrange + '"')
|
|
|
+
|
|
|
+ return newrange
|
|
|
+ else:
|
|
|
+ return ''
|
|
|
+
|
|
|
+
|
|
|
+ def verbose(self, level, output):
|
|
|
+ if level <= self.options.verbose:
|
|
|
+ print 'V' + str(level) + ': ' + output
|
|
|
+
|
|
|
+
|
|
|
+ def exit(self):
|
|
|
+ for returncode in self.returncode_priority:
|
|
|
+ if returncode in self.__returncode:
|
|
|
+ break
|
|
|
+
|
|
|
+ self.back2nagios(returncode, statusline=self.__output, multiline=self.__multilineoutput, performancedata=self.__performancedata)
|
|
|
+
|
|
|
+
|
|
|
+ def back2nagios(self, returncode, statusline=None, multiline=None, performancedata=None, subtag=None, exit=True):
|
|
|
+ # FIXME: Make 'returncode' also accept strings
|
|
|
+ # Build status line
|
|
|
+ out = self.__tagforstatusline
|
|
|
+ if subtag:
|
|
|
+ out += '(' + subtag.replace('|', ' ') + ')'
|
|
|
+ out += ' ' + self.RETURNSTRINGS[returncode]
|
|
|
+
|
|
|
+ # Check if there's a status line text and build it
|
|
|
+ if statusline:
|
|
|
+ out += ' - '
|
|
|
+ if type(statusline) == str:
|
|
|
+ out += statusline
|
|
|
+ elif type(statusline) in [list, tuple]:
|
|
|
+ out += ', '.join(statusline).replace('|', ' ')
|
|
|
+
|
|
|
+ # Check if we have multi line output and build it
|
|
|
+ if multiline:
|
|
|
+ if type(multiline) == str:
|
|
|
+ out += '\n' + multiline.replace('|', ' ')
|
|
|
+ elif type(multiline) in [list, tuple]:
|
|
|
+ out += '\n' + '\n'.join(multiline).replace('|', ' ')
|
|
|
+
|
|
|
+ # Check if there's perfdata
|
|
|
+ if performancedata:
|
|
|
+ out += '|'
|
|
|
+ if type(performancedata) == str:
|
|
|
+ out += performancedata
|
|
|
+ elif type(performancedata) in [list, tuple]:
|
|
|
+ out += ' '.join(performancedata).replace('|', ' ')
|
|
|
+
|
|
|
+ # Exit program or return output line(s)
|
|
|
+ if exit:
|
|
|
+ print out
|
|
|
+ sys.exit(returncode)
|
|
|
+ else:
|
|
|
+ return (returncode, out)
|
|
|
+
|
|
|
+##############################################################################
|
|
|
+
|
|
|
+class SNMPMonitoringPlugin(MonitoringPlugin):
|
|
|
+
|
|
|
+ def __init__(self, *args, **kwargs):
|
|
|
+ # Same as "MonitoringPlugin.__init__(*args, **kwargs)" but a little bit more flexible
|
|
|
+ #super(MonitoringPlugin, self).__init__(*args, **kwargs)
|
|
|
+ MonitoringPlugin.__init__(self, *args, **kwargs)
|
|
|
+
|
|
|
+ self.add_cmdlineoption('-H', '', 'host', 'Host to check', default='127.0.0.1')
|
|
|
+ self.add_cmdlineoption('-P', '', 'snmpversion', 'SNMP protocol version', default='1')
|
|
|
+ self.add_cmdlineoption('-C', '', 'snmpauth', 'SNMP v1/v2c community OR SNMP v3 quadruple', default='public')
|
|
|
+ self.add_cmdlineoption('', '--snmpcmdlinepath', 'snmpcmdlinepath', 'Path to "snmpget" and "snmpwalk"', default='/usr/bin')
|
|
|
+ # FIXME
|
|
|
+ self.add_cmdlineoption('', '--nonetsnmp', 'nonetsnmp', 'Do not use NET-SNMP python bindings', action='store_true')
|
|
|
+ # self.__optparser.add_option('', '--nonetsnmp', dest='nonetsnmp', help='Do not use NET-SNMP python bindings', action='store_true')
|
|
|
+
|
|
|
+ self.__SNMP_Cache = {}
|
|
|
+
|
|
|
+ self.__use_netsnmp = False
|
|
|
+ self.__prepared_snmp = False
|
|
|
+
|
|
|
+
|
|
|
+ def prepare_snmp(self):
|
|
|
+ if not self._cmdlineoptions_parsed:
|
|
|
+ self.parse_cmdlineoptions()
|
|
|
+
|
|
|
+ if not self.options.nonetsnmp:
|
|
|
+ try:
|
|
|
+ import netsnmp
|
|
|
+ self.__use_netsnmp = True
|
|
|
+ except ImportError:
|
|
|
+ pass
|
|
|
+
|
|
|
+ if self.__use_netsnmp:
|
|
|
+ self.verbose(1, 'Using NET-SNMP Python bindings')
|
|
|
+
|
|
|
+ self.SNMPGET_wrapper = self.__SNMPGET_netsnmp
|
|
|
+ self.SNMPWALK_wrapper = self.__SNMPWALK_netsnmp
|
|
|
+
|
|
|
+ if self.options.snmpversion == '2c':
|
|
|
+ self.options.snmpversion = '2'
|
|
|
+
|
|
|
+ else:
|
|
|
+ self.verbose(1, 'Using NET-SNMP command line tools')
|
|
|
+
|
|
|
+ self.SNMPGET_wrapper = self.__SNMPGET_cmdline
|
|
|
+ self.SNMPWALK_wrapper = self.__SNMPWALK_cmdline
|
|
|
+
|
|
|
+ # Building command lines
|
|
|
+ self.__CMDLINE_get = os.path.join(self.options.snmpcmdlinepath, 'snmpget') + ' -OqevtU '
|
|
|
+ self.__CMDLINE_walk = os.path.join(self.options.snmpcmdlinepath, 'snmpwalk') + ' -OqevtU '
|
|
|
+
|
|
|
+ if self.options.snmpversion in [1, 2, '1', '2', '2c']:
|
|
|
+ if self.options.snmpversion in [2, '2']:
|
|
|
+ self.options.snmpversion = '2c'
|
|
|
+ self.__CMDLINE_get += ' -v' + str(self.options.snmpversion) + ' -c' + self.options.snmpauth + ' '
|
|
|
+ self.__CMDLINE_walk += ' -v' + str(self.options.snmpversion) + ' -c' + self.options.snmpauth + ' '
|
|
|
+ elif options.snmpversion == [3, '3']:
|
|
|
+ # FIXME: Better error handling
|
|
|
+ try:
|
|
|
+ snmpauth = self.options.snmpauth.split(':')
|
|
|
+ self.__CMDLINE_get += ' -v3 -l' + snmpauth[0] + ' -u' + snmpauth[1] + ' -a' + snmpauth[2] + ' -A' + snmpauth[3] + ' '
|
|
|
+ self.__CMDLINE_walk += ' -v3 -l' + snmpauth[0] + ' -u' + snmpauth[1] + ' -a' + snmpauth[2] + ' -A' + snmpauth[3] + ' '
|
|
|
+ except:
|
|
|
+ self.back2nagios(3, 'Could not build SNMPv3 command line, need "SecLevel:SecName:AuthProtocol:AuthKey"')
|
|
|
+ else:
|
|
|
+ self.back2nagios(3, 'Unknown SNMP version "' + str(self.options.snmpversion) + '"')
|
|
|
+
|
|
|
+ self.__CMDLINE_get += ' ' + self.options.host + ' %s 2>/dev/null'
|
|
|
+ self.__CMDLINE_walk += ' ' + self.options.host + ' %s 2>/dev/null'
|
|
|
+
|
|
|
+ self.verbose(3, 'Using commandline: ' + self.__CMDLINE_get)
|
|
|
+ self.verbose(3, 'Using commandline: ' + self.__CMDLINE_walk)
|
|
|
+
|
|
|
+ self.__prepared_snmp = True
|
|
|
+
|
|
|
+
|
|
|
+ def find_index_for_value(self, list_indexes, list_values, wanted):
|
|
|
+ self.verbose(2, 'Look for "' + str(wanted) + '"')
|
|
|
+
|
|
|
+ index = None
|
|
|
+
|
|
|
+ if len(list_indexes) != len(list_values):
|
|
|
+ self.verbose(1, 'Length of index and value lists do not match!')
|
|
|
+ return None
|
|
|
+
|
|
|
+ try:
|
|
|
+ index = list_values.index(wanted)
|
|
|
+ index = list_indexes[index]
|
|
|
+ except ValueError:
|
|
|
+ pass
|
|
|
+
|
|
|
+ if index:
|
|
|
+ self.verbose(2, 'Found "' + str(wanted) +'" with index "' + str(index) + '"')
|
|
|
+ else:
|
|
|
+ self.verbose(2, 'Nothing found!')
|
|
|
+
|
|
|
+ return str(index)
|
|
|
+
|
|
|
+
|
|
|
+ def find_in_table(self, oid_index, oid_values, wanted):
|
|
|
+ self.verbose(2, 'Look for "' + str(wanted) + '" in "' + str(oid_values) +'"')
|
|
|
+
|
|
|
+ index = None
|
|
|
+ indexes = list(self.SNMPWALK(oid_index))
|
|
|
+ values = list(self.SNMPWALK(oid_values))
|
|
|
+
|
|
|
+ if len(indexes) != len(values):
|
|
|
+ self.back2nagios(3, 'Different data from 2 SNMP Walks!')
|
|
|
+
|
|
|
+ return str(self.find_index_for_value(indexes, values, wanted))
|
|
|
+
|
|
|
+
|
|
|
+ def SNMPGET(self, baseoid, idx=None, exitonerror=True):
|
|
|
+ if type(baseoid) in (list, tuple) and idx != None:
|
|
|
+ idx = str(idx)
|
|
|
+
|
|
|
+ if self.options.snmpversion in [1, '1']:
|
|
|
+ value_low = long(self.SNMPGET_wrapper(baseoid[1] + '.' + idx, exitonerror=exitonerror))
|
|
|
+ if value_low < 0L:
|
|
|
+ value_low += 2 ** 32
|
|
|
+
|
|
|
+ value_hi = long(self.SNMPGET_wrapper(baseoid[2] + '.' + idx, exitonerror=exitonerror))
|
|
|
+ if value_hi < 0L:
|
|
|
+ value_hi += 2 ** 32
|
|
|
+
|
|
|
+ return value_hi * 2L ** 32L + value_low
|
|
|
+
|
|
|
+ elif self.options.snmpversion in [2, 3, '2', '2c', '3']:
|
|
|
+ return long(self.SNMPGET_wrapper(baseoid[0] + '.' + idx, exitonerror=exitonerror))
|
|
|
+
|
|
|
+ elif type(baseoid) in (str, ) and idx != None:
|
|
|
+ return self.SNMPGET_wrapper(baseoid + str(idx), exitonerror=exitonerror)
|
|
|
+ else:
|
|
|
+ return self.SNMPGET_wrapper(baseoid, exitonerror=exitonerror)
|
|
|
+
|
|
|
+
|
|
|
+ def SNMPWALK(self, baseoid, exitonerror=True):
|
|
|
+ return self.SNMPWALK_wrapper(baseoid, exitonerror=exitonerror)
|
|
|
+
|
|
|
+
|
|
|
+ def __SNMPGET_netsnmp(self, oid, exitonerror=True):
|
|
|
+ if not self.__prepared_snmp:
|
|
|
+ self.prepare_snmp()
|
|
|
+
|
|
|
+ if oid in self.__SNMP_Cache:
|
|
|
+ self.verbose(2, "%40s -> (CACHED) %s" % (oid, self.__SNMP_Cache[oid]))
|
|
|
+ return self.__SNMP_Cache[oid]
|
|
|
+
|
|
|
+ result = netsnmp.snmpget(oid, Version=int(self.options.snmpversion), DestHost=self.options.host, Community=self.options.snmpauth)[0]
|
|
|
+
|
|
|
+ if not result:
|
|
|
+ if exitonerror:
|
|
|
+ self.back2nagios(3, 'Timeout or no answer from "%s" looking for "%s"' % (self.options.host, oid))
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+
|
|
|
+ self.__SNMP_Cache[oid] = result
|
|
|
+
|
|
|
+ self.verbose(2, "%40s -> %s" % (oid, result))
|
|
|
+ return result
|
|
|
+
|
|
|
+
|
|
|
+ def __SNMPWALK_netsnmp(self, oid, exitonerror=True):
|
|
|
+ if not self.__prepared_snmp:
|
|
|
+ self.prepare_snmp()
|
|
|
+
|
|
|
+ if oid in self.__SNMP_Cache:
|
|
|
+ self.verbose(2, "%40s -> (CACHED) %s" % (oid, self.__SNMP_Cache[oid]))
|
|
|
+ return self.__SNMP_Cache[oid]
|
|
|
+
|
|
|
+ result = netsnmp.snmpwalk(oid, Version=int(self.options.snmpversion), DestHost=self.options.host, Community=self.options.snmpauth)
|
|
|
+
|
|
|
+ if not result:
|
|
|
+ if exitonerror:
|
|
|
+ self.back2nagios(3, 'Timeout or no answer from "%s" looking for "%s"' % (self.options.host, oid))
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+
|
|
|
+ self.__SNMP_Cache[oid] = result
|
|
|
+
|
|
|
+ self.verbose(2, "%40s -> %s" % (oid, result))
|
|
|
+ return result
|
|
|
+
|
|
|
+
|
|
|
+ def __SNMPGET_cmdline(self, oid, exitonerror=True):
|
|
|
+ if not self.__prepared_snmp:
|
|
|
+ self.prepare_snmp()
|
|
|
+
|
|
|
+ cmdline = self.__CMDLINE_get % oid
|
|
|
+ self.verbose(2, cmdline)
|
|
|
+
|
|
|
+ cmd = os.popen(cmdline)
|
|
|
+ out = cmd.readline().rstrip().replace('"','')
|
|
|
+ retcode = cmd.close()
|
|
|
+
|
|
|
+ if retcode:
|
|
|
+ if not exitonerror:
|
|
|
+ return None
|
|
|
+ if retcode == 256:
|
|
|
+ self.back2nagios(3, 'Timeout - no SNMP answer from "' + self.options.host + '"')
|
|
|
+ elif retcode ==512:
|
|
|
+ self.back2nagios(3, 'OID "' + oid + '" not found')
|
|
|
+ else:
|
|
|
+ self.back2nagios(3, 'Unknown error code "' + str(retcode) + '" from command line utils')
|
|
|
+
|
|
|
+ self.verbose(1, out)
|
|
|
+ return out
|
|
|
+
|
|
|
+
|
|
|
+ def __SNMPWALK_cmdline(self, oid, exitonerror=True):
|
|
|
+ if not self.__prepared_snmp:
|
|
|
+ self.prepare_snmp()
|
|
|
+
|
|
|
+ cmdline = self.__CMDLINE_walk % oid
|
|
|
+ self.verbose(2, cmdline)
|
|
|
+
|
|
|
+ cmd = os.popen(cmdline)
|
|
|
+ out = cmd.readlines()
|
|
|
+ retcode = cmd.close()
|
|
|
+
|
|
|
+ if retcode:
|
|
|
+ if not exitonerror:
|
|
|
+ return None
|
|
|
+ if retcode == 256:
|
|
|
+ self.back2nagios(3, 'Timeout - no SNMP answer from "' + self.options.host + '"')
|
|
|
+ elif retcode ==512:
|
|
|
+ self.back2nagios(3, 'OID "' + oid + '" not found')
|
|
|
+ else:
|
|
|
+ self.back2nagios(3, 'Unknown error code "' + str(retcode) + '" from command line utils')
|
|
|
+
|
|
|
+ for line in range(0,len(out)):
|
|
|
+ out[line] = out[line].rstrip().replace('"','')
|
|
|
+
|
|
|
+ self.verbose(1, out)
|
|
|
+ return out
|
|
|
+
|
|
|
+
|
|
|
+##############################################################################
|
|
|
+
|
|
|
+def main():
|
|
|
+ myplugin = MonitoringPlugin(pluginname='check_testplugin', tagforstatusline='TEST')
|
|
|
+
|
|
|
+ from pprint import pprint
|
|
|
+ pprint(myplugin.back2nagios(0, 'Nr. 01: Simple plugin', exit=False) )
|
|
|
+ pprint(myplugin.back2nagios(0, 'Nr. 02: Simple plugin with sub tag', subtag='MySubTag', exit=False) )
|
|
|
+
|
|
|
+ pprint(myplugin.back2nagios(0, 'Nr. 10: Exit Code OK', exit=False) )
|
|
|
+ pprint(myplugin.back2nagios(1, 'Nr. 11: Exit Code WARNING', exit=False) )
|
|
|
+ pprint(myplugin.back2nagios(2, 'Nr. 12: Exit Code CRITICAL', exit=False) )
|
|
|
+ pprint(myplugin.back2nagios(3, 'Nr. 13: Exit Code UNKNOWN', exit=False) )
|
|
|
+
|
|
|
+ ret = myplugin.back2nagios(0, 'Nr. 20: Plugin with string-based multiline output', 'Line 2\nLine 3\nLine4', exit=False)
|
|
|
+ print ret[1]
|
|
|
+ print 'Returncode: ' + str(ret[0])
|
|
|
+ ret = myplugin.back2nagios(0, 'Nr. 21: Plugin with list-based multiline output', ['Line 2', 'Line 3', 'Line4'], exit=False)
|
|
|
+ print ret[1]
|
|
|
+ print 'Returncode: ' + str(ret[0])
|
|
|
+ ret = myplugin.back2nagios(0, 'Nr. 22: Plugin with tuple-based multiline output', ('Line 2', 'Line 3', 'Line4'), exit=False)
|
|
|
+ print ret[1]
|
|
|
+ print 'Returncode: ' + str(ret[0])
|
|
|
+
|
|
|
+ myplugin.add_performancedata('Val1', 42, '')
|
|
|
+ myplugin.add_performancedata('Val2', 23, 'c', warn=10, crit=20, min=0, max=100)
|
|
|
+ myplugin.add_performancedata('Val 3', '2342', 'c', warn=10, crit=20, min=0, max=100)
|
|
|
+ pprint(myplugin.back2nagios(0, 'Nr. 30: With perfdatas', exit=False) )
|
|
|
+
|
|
|
+ myplugin.back2nagios(0, 'Nr. 99: Exit test suite with OK')
|
|
|
+
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ main()
|
|
|
+
|
|
|
+#vim: ts=4 sw=4
|
Sven Velt
14 years ago