def scan_ilo():
helper.status(critical)
ps_data = walk_data(sess, oid_ps, helper)[0]
fan_data = walk_data(sess, oid_fan, helper)[0]
# we don't receive a result, if no physical drives are available.
phy_drv_status = attempt_walk_data(sess, oid_phy_drv_status)[0]
helper.add_long_output('Available devices:')
helper.add_long_output('')
# show the physical drives
if phy_drv_status:
for x, data in enumerate(phy_drv_status, 1):
helper.add_long_output('Physical drive %d: %s' % (x, phy_drv_state[int(data)]))
else:
helper.add_long_output("No physical drives detected")
# add a empty line after the pyhsical drives
helper.add_long_output('')
# show the power supplies
for x, data in enumerate(ps_data, 1):
helper.add_long_output('Power supply %d: %s' % (x, normal_state[int(data)]))
helper.add_long_output('')
# show the fans
for x, data in enumerate(fan_data, 1):
helper.add_long_output('Fan %d: %s' % (x, normal_state[int(data)]))
helper.exit(exit_code=ok, perfdata='')
def check_temperature_sensors():
"""
Check all temperature sensors of the server
All sensors with the value or threshold is -99 or 0 are ignored
"""
# walk all temperature sensor values and thresholds
env_temp = walk_data(sess, oid_env_temp, helper)[0]
env_temp_thresh = walk_data(sess, oid_env_temp_thres, helper)[0]
env_temp_zipped = zip(env_temp, env_temp_thresh)
for x, data in enumerate(env_temp_zipped, 1):
# skip the check if -99 or 0 is in the value or threshold, because these data we can not use
if '-99' not in data and '0' not in data:
#check if the value is over the treshold
if int(data[0]) > int(data[1]):
helper.add_summary(
'Temperature at sensor %d above threshold (%s / %s)' %
(x, data[0], data[1]))
helper.status(critical)
# always add the sensor to the output
helper.add_long_output(
'Temperature %d: %s Celsius (threshold: %s Celsius)' %
(x, data[0], data[1]))
# for the first sensor (envirnoment temperature, we add performance data)
if x == 1:
helper.add_metric("Environment Temperature", data[0], '',
":" + data[1], "", "", "Celsius")
def check_sensors():
"""
collect and check all available sensors
"""
all_sensors = walk_data(sess, oid_description, helper)[0]
all_status = walk_data(sess, oid_status, helper)[0]
# here we zip all index and descriptions to have a list like
# [('Fan Sensor', '2'), ('Power Supply Sensor', '4')]
# we are doomed if the lists do not have the same length ... but that should never happen ... hopefully
zipped = zip(all_sensors, all_status)
for sensor in zipped:
description = sensor[0]
status = sensor[1]
# translate the value to human readable
try:
status_string = senor_status_table[status]
except KeyError:
# if we receive an invalid value, we don't want to crash...
helper.exit(summary="received an undefined value from device: " +
status,
exit_code=unknown,
perfdata='')
# for each sensor the summary is added like: Fan Sensor: good
helper.add_summary("%s: %s" % (description, status_string))
# set the status
if status == "2":
helper.status(critical)
if status == "3":
helper.status(warning)
def check_sensors():
"""
collect and check all available sensors
"""
all_sensors = walk_data(sess, oid_description, helper)[0]
all_status = walk_data(sess, oid_status, helper)[0]
# here we zip all index and descriptions to have a list like
# [('Fan Sensor', '2'), ('Power Supply Sensor', '4')]
# we are doomed if the lists do not have the same length ... but that should never happen ... hopefully
zipped = zip(all_sensors, all_status)
for sensor in zipped:
description = sensor[0]
status = sensor[1]
# translate the value to human readable
try:
status_string = senor_status_table[status]
except KeyError:
# if we receive an invalid value, we don't want to crash...
helper.exit(summary="received an undefined value from device: " + status, exit_code=unknown, perfdata='')
# for each sensor the summary is added like: Fan Sensor: good
helper.add_summary("%s: %s" % (description, status_string))
# set the status
if status == "2":
helper.status(critical)
if status == "3":
helper.status(warning)
def check_tcp(helper, host, port, warning_param, critical_param, session):
"""
the check logic for check TCP ports
"""
# from tcpConnState from TCP-MIB
tcp_translate = {
"1": "closed",
"2": "listen",
"3": "synSent",
"4": "synReceived",
"5": "established",
"6": "finWait1",
"7": "finWait2",
"8": "closeWait",
"9": "lastAck",
"10": "closing",
"11": "timeWait",
"12": "deleteTCB"
}
# collect all open local ports
open_ports = walk_data(
session, '.1.3.6.1.2.1.6.13.1.3',
helper)[0] #tcpConnLocalPort from TCP-MIB (deprecated)
# collect all status information about the open ports
port_status = walk_data(session, '.1.3.6.1.2.1.6.13.1.1',
helper)[0] #tcpConnState from TCP-MIB (deprecated)
# make a dict out of the two lists
port_and_status = dict(zip(open_ports, port_status))
# here we show all open TCP ports and it's status
if scan:
print "All open TCP ports: " + host
for port in open_ports:
tcp_status = port_and_status[port]
tcp_status = tcp_translate[tcp_status]
print "TCP: \t" + port + "\t Status: \t" + tcp_status
quit()
#here we have the real check logic for TCP ports
if port in open_ports:
# if the port is available in the list of open_ports, then extract the status
tcp_status = port_and_status[port]
# translate the status from the integer value to a human readable string
tcp_status = tcp_translate[tcp_status]
# now let's set the status according to the warning / critical "threshold" parameter
if tcp_status in warning_param:
helper.status(warning)
elif tcp_status in critical_param:
helper.status(critical)
else:
helper.status(ok)
else:
# if there is no value in the list => the port is closed for sure
tcp_status = "CLOSED"
helper.status(critical)
return ("Current status for TCP port " + port + " is: " + tcp_status)
def scan_ilo():
helper.status(critical)
ps_data = walk_data(sess, oid_ps, helper)[0]
fan_data = walk_data(sess, oid_fan, helper)[0]
# we don't receive a result, if no physical drives are available.
phy_drv_status = attempt_walk_data(sess, oid_phy_drv_status)[0]
helper.add_long_output('Available devices:')
helper.add_long_output('')
# show the physical drives
if phy_drv_status:
for x, data in enumerate(phy_drv_status, 1):
helper.add_long_output('Physical drive %d: %s' %
(x, phy_drv_state[int(data)]))
else:
helper.add_long_output("No physical drives detected")
# add a empty line after the pyhsical drives
helper.add_long_output('')
# show the power supplies
for x, data in enumerate(ps_data, 1):
helper.add_long_output('Power supply %d: %s' %
(x, normal_state[int(data)]))
helper.add_long_output('')
# show the fans
for x, data in enumerate(fan_data, 1):
helper.add_long_output('Fan %d: %s' % (x, normal_state[int(data)]))
helper.exit(exit_code=ok, perfdata='')
def check_partition():
"""
check the defined partition
"""
all_index = walk_data(sess, oid_hrStorageIndex, helper)[0]
all_descriptions = walk_data(sess, oid_hrStorageDescr, helper)[0]
# we need the sucess flag for the error handling (partition found or not found)
sucess = False
# here we zip all index and descriptions to have a list like
# [('Physical memory', '1'), ('Virtual memory', '3'), ('/', '32'), ('/proc/xen', '33')]
zipped = zip(all_index, all_descriptions)
for partition in zipped:
index = partition[0]
description = partition[1]
if partition_found(disk, description):
# we found the partition
sucess = True
# receive all values we need
unit = float(get_data(sess, oid_hrStorageAllocationUnits + "." + index, helper))
size = float(get_data(sess, oid_hrStorageSize + "." + index, helper))
used = float(get_data(sess, oid_hrStorageUsed + "." + index, helper))
if size == 0 or used == 0:
# if the host return "0" as used or size, then we have a problem with the calculation (devision by zero)
helper.exit(summary="Received value 0 as StorageSize or StorageUsed: calculation error", exit_code=unknown, perfdata='')
# calculate the real size (size*unit) and convert the results to the target unit the user wants to see
used_result = convert_to_XX(calculate_real_size(used), unit, targetunit)
size_result = convert_to_XX(calculate_real_size(size), unit, targetunit)
# calculation of the used percentage
percent_used = used_result / size_result * 100
# we need a string and want only two decimals
used_string = str(float("{0:.2f}".format(used_result)))
size_string = str(float("{0:.2f}".format(size_result)))
percent_string = str(float("{0:.2f}".format(percent_used)))
if percent_used < 0 or percent_used > 100:
# just a validation that percent_used is not smaller then 0% or lager then 100%
helper.exit(summary="Calculation error - second counter overrun?", exit_code=unknown, perfdata='')
# show the summary
helper.add_summary("%s%% used (%s%s of %s%s) at '%s'" % (percent_string, used_string, targetunit, size_string, targetunit, description))
# add the metric in percent.
helper.add_metric(label='percent used',value=percent_string, min="0", max="100", uom="%")
else:
if not sucess:
# if the partition was not found in the data output, we return an error
helper.exit(summary="Partition '%s' not found" % disk, exit_code=unknown, perfdata='')
def test_walk_data(capsys):
"""
test of the walk_data function
"""
#run a walk on a not existing host
with pytest.raises(SystemExit):
assert snmpSessionBaseClass.walk_data(failSession, '.1', helper)
out, err = capsys.readouterr()
assert 'Unknown - snmpwalk failed - no data for host' in out
# check if we receive the system uptime via snmp and compare it with the local uptime from /proc/uptime (except the last digit)
assert snmpSessionBaseClass.walk_data(
session, '.1.3.6.1.2.1.25.1.1',
helper)[0][0][:-3] == get_system_uptime()[:-3]
def check_phy_drv(temp_drive_flag, input_phy_drv):
physical_drive_status = walk_data(sess, oid_phy_drv_status, helper)[0]
physical_drive_smart = walk_data(sess, oid_phy_drv_smrt, helper)[0]
physical_drive_temp = walk_data(sess, oid_phy_drv_temp, helper)[0]
physical_drive_temp_thres = walk_data(sess, oid_phy_drv_temp_thres, helper)[0]
phy_drv_count_ok = 0
summary_output = ''
long_output = ''
for x, data in enumerate(physical_drive_status, 0):
if phy_drv_state[int(physical_drive_status[x])] == 'ok' and phy_drv_smrt_state[int(physical_drive_smart[x])] == 'ok':
# check how many drives in OK state we find
phy_drv_count_ok += 1
else:
# status is not ok
helper.status(critical)
summary_output += ('Physical drive %d status: %s ' % (x+1, phy_drv_state[int(physical_drive_status[x])]))
summary_output += ('Physical drive %d smart status: %s ' % (x+1, phy_drv_smrt_state[int(physical_drive_smart[x])]))
# we always want to show the drive status in the long output, independend from the status
long_output += ('Physical drive %d status: %s\n' % (x+1, phy_drv_state[int(physical_drive_status[x])]))
long_output += ('Physical drive %d smart status: %s\n' % (x+1, phy_drv_state[int(physical_drive_smart[x])]))
# check of the harddrive temperatures
if temp_drive_flag:
# only evaluate the temperatures if temp_drive_flag is not set (--noDriveTemp). We need that for our 15k SAS drives.
if int(physical_drive_temp[x]) != -1:
# OID returns -1 if the drive temperature (threshold) cannot be calculated or if the controller does not support reporting drive temperature threshold
if int(physical_drive_temp_thres[x]) != -1:
if int(physical_drive_temp[x]) > int(physical_drive_temp_thres[x]):
summary_output += ('Physical drive %d temperature above threshold (%s / %s) ' % (x+1, physical_drive_temp[x], physical_drive_temp_thres[x]))
helper.status(critical)
long_output += ('Physical drive %d temperature: %s Celsius (threshold: %s Celsius)\n' % (x+1, physical_drive_temp[x], physical_drive_temp_thres[x]))
else:
long_output += ('Physical drive %d temperature: %s Celsius (no threshold given)\n' % (x+1, physical_drive_temp[x]))
# if the count of the found OK drives does not match the amount of configured drives (--drives parameter)
if int(phy_drv_count_ok) != int(input_phy_drv):
summary_output += ('%s physical drive(s) expected - %s physical drive(s) in ok state! ' % (input_phy_drv, phy_drv_count_ok))
helper.status(critical)
# Check Logical drive
logical_drive = walk_data(sess, oid_log_drv, helper)[0]
for x, data in enumerate(logical_drive, 1):
log_drv_summary_output, log_drv_long_output = state_summary(data, 'Logical drive %d' % x, log_drv_state, helper)
summary_output += log_drv_summary_output
long_output += log_drv_long_output
return (summary_output, long_output)
def check_accesspoints(sess):
"""
check the status of all connected access points
"""
ap_names = walk_data(sess, name_ap_oid, helper)[0]
ap_operationals = walk_data(sess, operational_ap_oid, helper)[0]
ap_availabilitys = walk_data(sess, availability_ap_oid, helper)[0]
ap_alarms = walk_data(sess, alarm_ap_oid, helper)[0]
#ap_ip = walk_data(sess, ip_ap_oid, helper) # no result
helper.add_summary("Access Points Status")
for x in range(len(ap_names)):
ap_name = ap_names[x]
ap_operational = ap_operationals[x]
ap_availability = ap_availabilitys[x]
ap_alarm = ap_alarms[x]
# Add all states to the long output
helper.add_long_output(
"%s - Operational: %s - Availabilty: %s - Alarm: %s" %
(ap_name, operational_states[int(ap_operational)],
availability_states[int(ap_availability)],
alarm_states[int(ap_alarm)]))
# Operational State
if ap_operational != "1" and ap_operational != "4":
helper.status(critical)
helper.add_summary(
"%s Operational State: %s" %
(ap_name, operational_states[int(ap_operational)]))
# Avaiability State
if ap_availability != "3":
helper.status(critical)
helper.add_summary(
"%s Availability State: %s" %
(ap_name, availability_states[int(ap_availability)]))
# Alarm State
if ap_alarm == "2":
helper.status(warning)
helper.add_summary("%s Controller Alarm State: %s" %
(ap_name, alarm_states[int(ap_alarm)]))
if ap_alarm == "3" or ap_alarm == "4":
helper.status(critical)
helper.add_summary("%s Controller Alarm State: %s" %
(ap_name, alarm_states[int(ap_alarm)]))
def check_phy_drv(temp_drive_flag, input_phy_drv):
physical_drive_status = walk_data(sess, oid_phy_drv_status, helper)[0]
physical_drive_smart = walk_data(sess, oid_phy_drv_smrt, helper)[0]
physical_drive_temp = walk_data(sess, oid_phy_drv_temp, helper)[0]
physical_drive_temp_thres = walk_data(sess, oid_phy_drv_temp_thres, helper)[0]
phy_drv_count_ok = 0
summary_output = ''
long_output = ''
for x, data in enumerate(physical_drive_status, 0):
if phy_drv_state[int(physical_drive_status[x])] == 'ok' and phy_drv_smrt_state[int(physical_drive_smart[x])] == 'ok':
# check how many drives in OK state we find
phy_drv_count_ok += 1
else:
# status is not ok
helper.status(critical)
summary_output += ('Physical drive %d status: %s ' % (x+1, phy_drv_state[int(physical_drive_status[x])]))
summary_output += ('Physical drive %d smart status: %s ' % (x+1, phy_drv_smrt_state[int(physical_drive_smart[x])]))
# we always want to show the drive status in the long output, independend from the status
long_output += ('Physical drive %d status: %s\n' % (x+1, phy_drv_state[int(physical_drive_status[x])]))
long_output += ('Physical drive %d smart status: %s\n' % (x+1, phy_drv_state[int(physical_drive_smart[x])]))
# check of the harddrive temperatures
if temp_drive_flag:
# only evaluate the temperatures if temp_drive_flag is not set (--noDriveTemp). We need that for our 15k SAS drives.
if int(physical_drive_temp[x]) != -1:
# OID returns -1 if the drive temperature (threshold) cannot be calculated or if the controller does not support reporting drive temperature threshold
if int(physical_drive_temp_thres[x]) != -1:
if int(physical_drive_temp[x]) > int(physical_drive_temp_thres[x]):
summary_output += ('Physical drive %d temperature above threshold (%s / %s) ' % (x+1, physical_drive_temp[x], physical_drive_temp_thres[x]))
helper.status(critical)
long_output += ('Physical drive %d temperature: %s Celsius (threshold: %s Celsius)\n' % (x+1, physical_drive_temp[x], physical_drive_temp_thres[x]))
else:
long_output += ('Physical drive %d temperature: %s Celsius (no threshold given)\n' % (x+1, physical_drive_temp[x]))
# if the count of the found OK drives does not match the amount of configured drives (--drives parameter)
if int(phy_drv_count_ok) != int(input_phy_drv):
summary_output += ('%s physical drive(s) expected - %s physical drive(s) in ok state! ' % (input_phy_drv, phy_drv_count_ok))
helper.status(critical)
# Check Logical drive
logical_drive = walk_data(sess, oid_log_drv, helper)[0]
for x, data in enumerate(logical_drive, 1):
log_drv_summary_output, log_drv_long_output = state_summary(data, 'Logical drive %d' % x, log_drv_state, helper)
summary_output += log_drv_summary_output
long_output += log_drv_long_output
return (summary_output, long_output)
def check_ps():
"""
Check if the power supplies are ok, and we have the configured amount
The check is skipped if --ps=0
"""
if int(input_pwr_sply) != 0:
ps_data = walk_data(sess, oid_ps, helper)[0]
ps_ok_count = 0
for x, state in enumerate(ps_data, 1):
# human readable status
hr_status = normal_state[int(state)]
if hr_status != "ok":
# if the power supply is ok, we will set a critical status and add it to the summary
helper.add_summary('Power supply status %s: %s' %
(x, hr_status))
helper.status(critical)
else:
# if everything is ok, we increase the ps_ok_count
ps_ok_count += 1
# we always want to see the status in the long output
helper.add_long_output('Power supply status %s: %s' %
(x, hr_status))
helper.add_long_output('')
if int(input_pwr_sply) != ps_ok_count:
# if the confiugred power supplies and power supplies in ok state are different
helper.add_summary(
'%s power supplies expected - %s power supplies ok ' %
(input_pwr_sply, ps_ok_count))
helper.status(critical)
def check_fan(input_fan):
"""
check the fans
"""
# get a list of all fans
fan_data = walk_data(sess, oid_fan, helper)[0]
fan_count = 0
summary_output = ''
long_output = ''
for x, fan in enumerate(fan_data, 1):
fan = int(fan)
if normal_state[fan] == 'ok':
# if the fan is ok, we increase the fan_count varaible
fan_count += 1
# we always want to the the status in the long output
long_output += 'Fan %d: %s.\n' % (x, normal_state[fan])
# check we have the correct amount ok fans in OK state, otherwise set status to critical and print the fan in the summary
if int(fan_count) != int(input_fan):
summary_output += '%s fan(s) expected - %s fan(s) ok. ' % (input_fan,
fan_count)
helper.status(critical)
return (summary_output, long_output)
def check_ps():
"""
Check if the power supplies are ok, and we have the configured amount
The check is skipped if --ps=0
"""
if int(input_pwr_sply) != 0:
ps_data = walk_data(sess, oid_ps, helper)[0]
ps_ok_count = 0
for x, state in enumerate(ps_data, 1):
# human readable status
hr_status = normal_state[int(state)]
if hr_status != "ok":
# if the power supply is ok, we will set a critical status and add it to the summary
helper.add_summary('Power supply status %s: %s' % (x, hr_status))
helper.status(critical)
else:
# if everything is ok, we increase the ps_ok_count
ps_ok_count += 1
# we always want to see the status in the long output
helper.add_long_output('Power supply status %s: %s' % (x, hr_status))
helper.add_long_output('')
if int(input_pwr_sply) != ps_ok_count:
# if the confiugred power supplies and power supplies in ok state are different
helper.add_summary('%s power supplies expected - %s power supplies ok ' % (input_pwr_sply, ps_ok_count))
helper.status(critical)
def run_scan():
"""
show all available partitions
"""
all_disks = walk_data(sess, oid_hrStorageDescr, helper)[0]
print "All available disks at: " + host
for disk in all_disks:
print "Disk: \t'" + disk + "'"
quit()
def check_storage_controllers():
"""
Check the status of the storage controllers
Skip this check, if --noController is set
"""
if ctrl_flag:
ctrl = walk_data(sess, oid_ctrl, helper)[0]
for x, data in enumerate(ctrl, 1):
ctrl_summary_output, ctrl_long_output = state_summary(data, 'Controller %d' % x, normal_state, helper)
add_output(ctrl_summary_output, ctrl_long_output, helper)
def run_scan():
"""
show all available partitions
"""
all_disks = walk_data(sess, oid_hrStorageDescr, helper)[0]
print "All available disks at: " + host
for disk in all_disks:
print "Disk: \t'" + disk + "'"
quit()
def check_storage_controllers():
"""
Check the status of the storage controllers
Skip this check, if --noController is set
"""
if ctrl_flag:
ctrl = walk_data(sess, oid_ctrl, helper)[0]
for x, data in enumerate(ctrl, 1):
ctrl_summary_output, ctrl_long_output = state_summary(data, 'Controller %d' % x, normal_state, helper)
add_output(ctrl_summary_output, ctrl_long_output, helper)
def check_temperature_sensors():
"""
Check all temperature sensors of the server
All sensors with the value or threshold is -99 or 0 are ignored
"""
# walk all temperature sensor values and thresholds
env_temp = walk_data(sess, oid_env_temp, helper)[0]
env_temp_thresh = walk_data(sess, oid_env_temp_thres, helper)[0]
env_temp_zipped = zip(env_temp, env_temp_thresh)
for x, data in enumerate(env_temp_zipped, 1):
# skip the check if -99 or 0 is in the value or threshold, because these data we can not use
if '-99' not in data and '0' not in data:
#check if the value is over the treshold
if int(data[0]) > int(data[1]):
helper.add_summary('Temperature at sensor %d above threshold (%s / %s)' % (x, data[0], data[1]))
helper.status(critical)
# always add the sensor to the output
helper.add_long_output('Temperature %d: %s Celsius (threshold: %s Celsius)' % (x, data[0], data[1]))
# for the first sensor (envirnoment temperature, we add performance data)
if x == 1:
helper.add_metric("Environment Temperature", data[0], '', ":" + data[1], "", "", "Celsius")
def check_accesspoints(sess):
"""
check the status of all connected access points
"""
ap_names = walk_data(sess, name_ap_oid, helper)[0]
ap_operationals = walk_data(sess, operational_ap_oid, helper)[0]
ap_availabilitys = walk_data(sess, availability_ap_oid, helper)[0]
ap_alarms = walk_data(sess, alarm_ap_oid, helper)[0]
#ap_ip = walk_data(sess, ip_ap_oid, helper) # no result
helper.add_summary("Access Points Status")
for x in range(len(ap_names)):
ap_name = ap_names[x]
ap_operational = ap_operationals[x]
ap_availability = ap_availabilitys[x]
ap_alarm = ap_alarms[x]
# Add all states to the long output
helper.add_long_output("%s - Operational: %s - Availabilty: %s - Alarm: %s" % (ap_name, operational_states[int(ap_operational)], availability_states[int(ap_availability)], alarm_states[int(ap_alarm)]))
# Operational State
if ap_operational != "1" and ap_operational != "4":
helper.status(critical)
helper.add_summary("%s Operational State: %s" % (ap_name, operational_states[int(ap_operational)]))
# Avaiability State
if ap_availability != "3":
helper.status(critical)
helper.add_summary("%s Availability State: %s" % (ap_name, availability_states[int(ap_availability)]))
# Alarm State
if ap_alarm == "2":
helper.status(warning)
helper.add_summary("%s Controller Alarm State: %s" % (ap_name, alarm_states[int(ap_alarm)]))
if ap_alarm == "3" or ap_alarm == "4":
helper.status(critical)
helper.add_summary("%s Controller Alarm State: %s" % (ap_name, alarm_states[int(ap_alarm)]))
def check_inlet(sess):
"""
check the Inlets of Raritan PDUs
"""
# walk the data
inlet_values = walk_data(sess, oid_inlet_value, helper)[0]
inlet_units = walk_data(sess, oid_inlet_unit, helper)[0]
inlet_digits = walk_data(sess, oid_inlet_digits, helper)[0]
inlet_states = walk_data(sess, oid_inlet_state, helper)[0]
inlet_warning_uppers = walk_data(sess, oid_inlet_warning_upper, helper)[0]
inlet_critical_uppers = walk_data(sess, oid_inlet_critical_upper,
helper)[0]
inlet_critical_lowers = walk_data(sess, oid_inlet_critical_lower,
helper)[0]
inlet_warning_lowers = walk_data(sess, oid_inlet_warning_lower, helper)[0]
# just print the summary, that the inlet sensors are checked
helper.add_summary("Inlet")
# all list must have the same length, if not something went wrong. that makes it easier and we need less loops
# translate the data in human readable units with help of the dicts
for x in range(len(inlet_values)):
inlet_unit = units[int(inlet_units[x])]
inlet_digit = inlet_digits[x]
inlet_state = states[int(inlet_states[x])]
inlet_value = real_value(inlet_values[x], inlet_digit)
inlet_warning_upper = real_value(inlet_warning_uppers[x], inlet_digit)
inlet_critical_upper = real_value(inlet_critical_uppers[x],
inlet_digit)
inlet_warning_lower = real_value(inlet_warning_lowers[x], inlet_digit)
inlet_critical_lower = real_value(inlet_critical_lowers[x],
inlet_digit)
if inlet_state != "normal":
# we don't want to use the thresholds. we rely on the state value of the device
helper.add_summary("%s %s is %s" %
(inlet_value, inlet_unit, inlet_state))
helper.status(critical)
# we always want to see the values in the long output and in the perf data
helper.add_summary("%s %s" % (inlet_value, inlet_unit))
helper.add_long_output("%s %s: %s" %
(inlet_value, inlet_unit, inlet_state))
helper.add_metric("Sensor " + str(x), inlet_value, inlet_warning_lower +\
":" + inlet_warning_upper, inlet_critical_lower + ":" +\
inlet_critical_upper, "", "", inlet_unit)
def check_power_redundancy():
"""
Check if the power supplies are redundant
The check is skipped if --noPowerRedundancy is set
"""
# skip the check if --noPowerRedundancy is set
if power_redundancy_flag:
# walk the data
ps_redundant_data = walk_data(sess, oid_ps_redundant, helper)[0]
for x, state in enumerate(ps_redundant_data, 1):
# human readable status
hr_status = ps_redundant_state[int(state)]
if hr_status != "redundant":
# if the power supply is not redundant, we will set a critical status and add it to the summary
helper.add_summary('Power supply %s: %s' % (x, hr_status))
helper.status(critical)
# we always want to see the redundancy status in the long output
helper.add_long_output('Power supply %s: %s' % (x, hr_status))
helper.add_long_output('')
def check_power_redundancy():
"""
Check if the power supplies are redundant
The check is skipped if --noPowerRedundancy is set
"""
# skip the check if --noPowerRedundancy is set
if power_redundancy_flag:
# walk the data
ps_redundant_data = walk_data(sess, oid_ps_redundant, helper)[0]
for x, state in enumerate(ps_redundant_data, 1):
# human readable status
hr_status = ps_redundant_state[int(state)]
if hr_status != "redundant":
# if the power supply is not redundant, we will set a critical status and add it to the summary
helper.add_summary('Power supply %s: %s' % (x, hr_status))
helper.status(critical)
# we always want to see the redundancy status in the long output
helper.add_long_output('Power supply %s: %s' % (x, hr_status))
helper.add_long_output('')
def check_udp(helper, host, port, session):
"""
the check logic for UDP ports
"""
open_ports = walk_data(
session, '.1.3.6.1.2.1.7.5.1.2',
helper)[0] # the udpLocaLPort from UDP-MIB.mib (deprecated)
# here we show all open UDP ports
if scan:
print "All open UDP ports at host " + host
for port in open_ports:
print "UDP: \t" + port
quit()
if port in open_ports:
udp_status = "OPEN"
else:
udp_status = "CLOSED"
helper.status(critical)
return ("Current status for UDP port " + port + " is: " + udp_status)
def check_fan(input_fan):
"""
check the fans
"""
# get a list of all fans
fan_data = walk_data(sess, oid_fan, helper)[0]
fan_count = 0
summary_output = ''
long_output = ''
for x, fan in enumerate(fan_data, 1):
fan = int(fan)
if normal_state[fan] == 'ok':
# if the fan is ok, we increase the fan_count varaible
fan_count += 1
# we always want to the the status in the long output
long_output += 'Fan %d: %s.\n' % (x, normal_state[fan])
# check we have the correct amount ok fans in OK state, otherwise set status to critical and print the fan in the summary
if int(fan_count) != int(input_fan):
summary_output += '%s fan(s) expected - %s fan(s) ok. ' % (input_fan, fan_count)
helper.status(critical)
return (summary_output, long_output)
secname, seclevel, authproto, authpass, privproto, privpass = a_helper.options.secname, \
a_helper.options.seclevel, \
a_helper.options.authproto, \
a_helper.options.authpass, \
a_helper.options.privproto, \
a_helper.options.privpass
host, version, community = snmpSessionBaseClass.get_common_options(a_helper)
snmpSessionBaseClass.verify_host(host, a_helper)
verify_type(a_helper.options.type, a_helper)
snmp_session = netsnmp.Session(Version=version, DestHost=host, SecLevel=seclevel, SecName=secname,
AuthProto=authproto,
AuthPass=authpass, PrivProto=privproto, PrivPass=privpass, Community=community)
# The default return value should be always OK
a_helper.status(pynag.Plugins.ok)
eaton_check = eaton_check_configs[a_helper.options.type]["check"]
eaton_oid = eaton_check_configs[a_helper.options.type]["oid"]
allow_empty = eaton_check_configs[a_helper.options.type].get("allow_snmp_empty", False)
a_snmp_value = snmpSessionBaseClass.walk_data(snmp_session, eaton_oid, a_helper)[0][0]
eaton_check(snmp_session, a_helper, a_snmp_value)
a_helper.check_all_metrics()
# Print out plugin information and exit nagios-style
a_helper.exit()
sess = netsnmp.Session(Version=version, DestHost=host, Community=community)
# The default return value should be always OK
helper.status(ok)
# if no partition / disk is set, we will do a scan
if service == "" or service is None:
scan = True
##########
# Here we do a scan
##########
if scan:
services = walk_data(sess, base_oid, helper)[0]
if not services:
print "No services found - SNMP disabled?"
quit()
print "Running services at host '" + host + "':\n"
for service in services:
print service
if len(services) == 0:
# if there are no running services, print the message
print "no service running at host"
# we don't want to return a icinga output, so we just end the script here
global_system_summary, global_system_long = state_summary(
global_system_data, 'Global System', normal_state, helper)
system_lcd_summary, system_lcd_long = state_summary(
system_lcd_data, 'System LCD', normal_state, helper)
global_storage_summary, global_storage_long = state_summary(
global_storage_data, 'Global Storage', normal_state, helper)
system_power_summary, system_power_long = state_summary(
system_power_data, 'System Power', system_power_state, helper, 'on')
add_output(global_system_summary, global_system_long, helper)
add_output(system_lcd_summary, system_lcd_long, helper)
add_output(global_storage_summary, global_storage_long, helper)
add_output(system_power_summary, system_power_long, helper)
# power unit
power_unit_redundancy_data = walk_data(sess, oid_power_unit_redundancy,
helper)[0]
power_unit_name_data = walk_data(sess, oid_power_unit_name, helper)[0]
power_unit_status_data = walk_data(sess, oid_power_unit_status, helper)[0]
power_unit_summary_output, power_unit_long_output = power_unit_check(
power_unit_redundancy_data, power_unit_name_data,
power_unit_status_data)
add_output(power_unit_summary_output, power_unit_long_output, helper)
# chassis
chassis_intrusion_data = walk_data(sess, oid_chassis_intrusion, helper)[0]
chassis_intrusion_location_data = walk_data(
sess, oid_chassis_intrusion_location, helper)[0]
chassis_intrusion_summary_output, chassis_intrusion_long_output = chassis_intrusion_check(
def check_partition():
"""
check the defined partition
"""
all_index = walk_data(sess, oid_hrStorageIndex, helper)[0]
all_descriptions = walk_data(sess, oid_hrStorageDescr, helper)[0]
# we need the sucess flag for the error handling (partition found or not found)
sucess = False
# here we zip all index and descriptions to have a list like
# [('Physical memory', '1'), ('Virtual memory', '3'), ('/', '32'), ('/proc/xen', '33')]
zipped = zip(all_index, all_descriptions)
for partition in zipped:
index = partition[0]
description = partition[1]
if partition_found(disk, description):
# we found the partition
sucess = True
# receive all values we need
unit = float(
get_data(sess, oid_hrStorageAllocationUnits + "." + index,
helper))
size = float(
get_data(sess, oid_hrStorageSize + "." + index, helper))
used = float(
get_data(sess, oid_hrStorageUsed + "." + index, helper))
if size == 0 or used == 0:
# if the host return "0" as used or size, then we have a problem with the calculation (devision by zero)
helper.exit(
summary=
"Received value 0 as StorageSize or StorageUsed: calculation error",
exit_code=unknown,
perfdata='')
# calculate the real size (size*unit) and convert the results to the target unit the user wants to see
used_result = convert_to_XX(calculate_real_size(used), unit,
targetunit)
size_result = convert_to_XX(calculate_real_size(size), unit,
targetunit)
# calculation of the used percentage
percent_used = used_result / size_result * 100
# we need a string and want only two decimals
used_string = str(float("{0:.2f}".format(used_result)))
size_string = str(float("{0:.2f}".format(size_result)))
percent_string = str(float("{0:.2f}".format(percent_used)))
if percent_used < 0 or percent_used > 100:
# just a validation that percent_used is not smaller then 0% or lager then 100%
helper.exit(
summary="Calculation error - second counter overrun?",
exit_code=unknown,
perfdata='')
# show the summary
helper.add_summary("%s%% used (%s%s of %s%s) at '%s'" %
(percent_string, used_string, targetunit,
size_string, targetunit, description))
# add the metric in percent.
helper.add_metric(label='percent used',
value=percent_string,
min="0",
max="100",
uom="%")
else:
if not sucess:
# if the partition was not found in the data output, we return an error
helper.exit(summary="Partition '%s' not found" % disk,
exit_code=unknown,
perfdata='')
add_output(system_power_summary, system_power_long, helper)
# power unit
power_unit_redundancy_data = attempt_walk_data(
sess, oid_power_unit_redundancy)[0]
power_unit_name_data = attempt_walk_data(sess, oid_power_unit_name)[0]
power_unit_status_data = attempt_walk_data(sess, oid_power_unit_status)[0]
power_unit_summary_output, power_unit_long_output = power_unit_check(
power_unit_redundancy_data, power_unit_name_data,
power_unit_status_data)
add_output(power_unit_summary_output, power_unit_long_output, helper)
# chassis
chassis_intrusion_data = walk_data(sess, oid_chassis_intrusion, helper)[0]
chassis_intrusion_location_data = walk_data(
sess, oid_chassis_intrusion_location, helper)[0]
chassis_intrusion_summary_output, chassis_intrusion_long_output = chassis_intrusion_check(
chassis_intrusion_data, chassis_intrusion_location_data)
add_output(chassis_intrusion_summary_output, chassis_intrusion_long_output,
helper)
# cooling unit
cooling_unit_name_data = walk_data(sess, oid_cooling_unit_name, helper)[0]
cooling_unit_status_data = walk_data(sess, oid_cooling_unit_status,
helper)[0]
cooling_unit_summary_output, cooling_unit_long_output = cooling_unit_check(
