def configure(self, args):
self.__snmp_executor.configure(args)
self.__num_raids = args.disks
self.__warning = args.warning
self.__critical = args.critical
failed = False
if self.__critical > 100:
self.__status_builder.unknown(
Output('Critical value can\'t be greater than 100 %'))
failed = True
elif self.__critical < 0:
self.__status_builder.unknown(
Output('Critical value must be at least 0 %'))
failed = True
if self.__warning > self.__critical:
self.__status_builder.unknown(
Output('Warning value can\'t be greater than critical value'))
failed = True
elif self.__warning < 0:
self.__status_builder.unknown(
Output('Warning value must be at least 0 %'))
failed = True
if failed:
self.__status_builder.exit()
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(f'Couldn\'t get Battery remaining runtime information'))
return
value = oids[0]['value']
remaining = int(value[value.find('(') + 1:value.find(')')])
sec = timedelta(seconds=remaining)
d = datetime(1, 1, 1) + sec
output = Output(
f'Remaining runtime {remaining}s ({d.day - 1}d {d.hour}h {d.minute}m {d.second}s)',
[
Perfdata('remaining',
remaining,
unit='s',
warning=self.__warning,
critical=self.__critical,
min=0)
])
if remaining <= self.__critical:
self.__status_builder.critical(output)
elif remaining <= self.__warning:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
services_running = {}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
config = services_running.get(id, {})
if '2' == base[0]:
config['service'] = oid['value'].lower()
elif '3' == base[0]:
config['users'] = oid['value']
services_running[id] = config
for service_id in services_running:
config = services_running[service_id]
if config['service'] == self.__service.lower():
output = Output(f"Service \"{config['service']}\" is currently used by {config['users']} users.",
[Perfdata(config["service"].replace('/', '_'), config["users"])])
if config['users'] >= self.__critical:
self.__status_builder.critical(output)
elif config['users'] >= self.__warning:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
self.__status_builder.exit()
self.__status_builder.unknown(Output(f'Service "{self.__service}" not found. Is it running?'))
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(f'Couldn\'t get Battery capacity information'))
return
capacity = oids[0]['value']
output = Output(f'Capacity is {capacity}%', [
Perfdata('capacity',
capacity,
unit='%',
warning=self.__warning,
critical=self.__critical,
min=0,
max=100)
])
if capacity <= self.__critical:
self.__status_builder.critical(output)
elif capacity <= self.__warning:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def configure(self, args):
self.__snmp_executor.configure(args)
self.__disk_id = args.disk
warning = args.warning
if None is not warning:
warning = warning.split(',')
if len(warning) != 3:
self.__status_builder.unknown(
Output('Format for warning load mismatch. Expected Format: LOAD1,LOAD5,LOAD15'))
self.__status_builder.exit()
self.__warning = [int(warning[0]), int(warning[1]), int(warning[2])]
critical = args.critical
if None is not critical:
critical = critical.split(',')
if len(critical) != 3:
self.__status_builder.unknown(
Output('Format for critical load mismatch. Expected Format: LOAD1,LOAD5,LOAD15'))
self.__status_builder.exit()
self.__critical = [int(critical[0]), int(critical[1]), int(critical[2])]
if None is self.__warning and self.__critical is not None:
self.__status_builder.unknown(Output('If critical load is defined, you have to set warning load'))
self.__status_builder.exit()
if None is not self.__warning and self.__critical is None:
self.__status_builder.unknown(Output('If warning load is defined, you have to set critical load'))
self.__status_builder.exit()
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(f'Couldn\'t get Battery temperature information'))
return
temperature = oids[0]['value']
output = Output(f'Temperature is {temperature}°', [
Perfdata('temperature',
temperature,
unit='°',
warning=self.__warning,
critical=self.__critical,
min=0,
max=50)
])
if temperature >= self.__critical:
self.__status_builder.critical(output)
elif temperature >= self.__warning:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
if len(oids) != 1:
self.__status_builder.unknown(
Output('Can\'t find the temperature of the system.'))
self.__status_builder.exit()
perfdata = [
Perfdata("temperature",
oids[0]['value'],
warning=self.__warning,
critical=self.__critical),
]
output = Output('Temperature is "' + str(oids[0]['value']) + '°C"',
perfdata)
if self.__critical <= oids[0]['value']:
self.__status_builder.critical(output)
elif self.__warning <= oids[0]['value']:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
self.__status_builder.exit(True)
def run(self):
running_config = self.__apachectl_executor.get_running_config()
for file in running_config:
config = running_config[file]
is_enabled = False
for c in config:
option = c['option'].lower()
if "proxyrequests" in option and "on" in option:
is_enabled = True
if file in self.__allow:
self.__status_builder.success(
Output(
f'Open proxy detected and it is allowed. File: "{file}", line: "{c["line"]}"'
))
else:
self.__status_builder.critical(
Output(
f'Open proxy detected! File: "{file}", line: "{c["line"]}"'
))
if file in self.__allow and not is_enabled:
self.__status_builder.warning(
Output(
f'Open proxy not configured but it should be in file: "{file}"'
))
for allowed_file in self.__allow:
if None is running_config.get(allowed_file, None):
self.__status_builder.warning(
Output(
f'Open proxy not configured but it should be in file: "{allowed_file}"'
))
def run(self):
oids = self.__snmp_executor.run()
status_data = {1: {}, 2: {}, 3: {}}
keys = {
'2': 'name',
'3': 'load',
'4': 'configuredError',
'5': 'loadInt',
'6': 'loadFloat',
'100': 'error',
'101': 'errorMessage',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if base[0] == '1':
continue
status_data[id][keys.get(base[0])] = oid['value']
for status_data_id in status_data:
data = status_data[status_data_id]
index = status_data_id - 1
perfdata = [
Perfdata(f'load',
data['loadFloat'],
warning=self.__warning[index],
critical=self.__critical[index]),
]
if 0 != data['error']:
output = Output(
f'Load \"{data["name"]}\" Got an unexpected error "{data["errorMessage"]}" (code {data["swapError"]})',
perfdata)
self.__status_builder.critical(output)
continue
output = Output(f"Disk load \"{data['name']}\"", perfdata)
if None is self.__warning:
self.__status_builder.success(output)
else:
if self.__critical[index] <= data['loadFloat']:
self.__status_builder.critical(output)
elif self.__warning[index] <= data['loadFloat']:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
services_running = {}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
config = services_running.get(id, {})
if '2' == base[0]:
config['service'] = oid['value'].lower()
elif '3' == base[0]:
config['users'] = oid['value']
services_running[id] = config
for service in self.__services:
found = False
for services_running_id in services_running:
config = services_running[services_running_id]
if config['service'] == service:
found = True
self.__status_builder.success(
Output(f'Service "{service}" up and running',
[Perfdata(f'{service}', config["users"])]))
break
if not found:
self.__status_builder.critical(
Output(
f'Service "{service}" should running but it doesn\'t'))
for services_running_id in services_running:
config = services_running[services_running_id]
found = False
for service in self.__services:
if service == config['service']:
found = True
break
if not found:
self.__status_builder.warning(
Output(
f'Service "{config["service"]}" is running but it shouldn\'t',
[Perfdata(f'{config["service"]}', config["users"])]))
self.__status_builder.exit(True)
def __check_value(self, suffix, name, data, warning, critical, check):
if not check:
return
self.__logger.debug(f'Check memory {suffix}')
value = data.get(suffix, None)
if value is None:
self.__status_builder.unknown(
Output(
f"Couldn't check {name} because it either not exist or is not accessible "
f"(value not found).|{suffix}=0;0;0;0;0"))
return
perfdata = f";;;" if None is warning else f"{warning};{critical};;"
output = f"Memory \"{name}\";| {suffix}={value};{perfdata}"
if None is warning:
self.__status_builder.success(output)
else:
if critical <= value:
self.__status_builder.critical(output)
elif self.__warning_total <= value:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
if len(oids) != 1:
self.__status_builder.unknown(
Output('Can\'t find the upgrade status of the system.'))
self.__status_builder.exit()
if 1 == oids[0]['value']:
self.__status_builder.critical(
Output('System upgrade is available'))
elif 2 == oids[0]['value']:
self.__status_builder.success(
Output('No system upgrade is available'))
elif 3 == oids[0]['value']:
self.__status_builder.unknown(
Output('Connecting to update server'))
elif 4 == oids[0]['value']:
self.__status_builder.unknown(
Output('Disconnected from update server'))
elif 5 == oids[0]['value']:
self.__status_builder.unknown(Output('Other unknown status'))
else:
self.__status_builder.unknown(
Output('Can\'t find the upgrade status of the system.'))
def run(self):
oids = self.__snmp_executor.run()
if len(oids) != 1:
self.__status_builder.unknown(
Output('Can\'t find the status of the system.'))
self.__status_builder.exit()
if 1 == oids[0]['value']:
self.__status_builder.success(Output('System status is normal'))
elif 2 == oids[0]['value']:
self.__status_builder.critical(Output('System status is critical'))
else:
self.__status_builder.unknown(
Output('Got an unknown status code "{code}"'.format(
code=oids[0]['value'])))
self.__status_builder.exit(True)
def run(self):
oids = self.__snmp_executor.run()
if len(oids) != self.__num_disks * 6:
self.__status_builder.unknown(
Output(
'You try to check "{disks}" but there are "{configured}" disks in your system.'
.format(disks=self.__num_disks,
configured=int(len(oids) / 6))))
self.__status_builder.exit()
disks = [{} for i in range(0, self.__num_disks)]
for oid in oids:
base = oid['oid'].split('.')
disk_id = int(base[1])
if '1' == base[0]:
disks[disk_id]['index'] = oid['value']
elif '2' == base[0]:
disks[disk_id]['id'] = oid['value']
elif '3' == base[0]:
disks[disk_id]['model'] = oid['value']
elif '4' == base[0]:
disks[disk_id]['type'] = oid['value']
elif '5' == base[0]:
disks[disk_id]['status'] = oid['value']
elif '6' == base[0]:
disks[disk_id]['temperature'] = oid['value']
for disk in disks:
if self.__critical <= disk['temperature']:
self.__status_builder.critical(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
elif self.__warning <= disk['temperature']:
if 4 <= disk['status']:
self.__status_builder.critical(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
else:
self.__status_builder.warning(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
else:
if 4 <= disk['status']:
self.__status_builder.critical(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
elif 2 <= disk['status']:
self.__status_builder.warning(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
else:
self.__status_builder.success(
Output(self.__get_disk_description(disk),
self.__get_disk_perfdata(disk)))
self.__status_builder.exit(True)
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(f'Couldn\'t get Battery replacement information'))
return
if 1 == oids[0]['value']:
self.__status_builder.success(
Output(f'No Battery replacement needed'))
elif 2 == oids[0]['value']:
self.__status_builder.critical(
Output(f'Battery replacement needed'))
else:
self.__status_builder.unknown(
Output(
f'Got unknown Battery replacement information "{oids[0]["value"]}"'
))
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(
f'Couldn\'t get the number of attached external battery packs'
))
return
defective = oids[0]['value']
output = Output(
f'There are currently {defective} external batteries defective')
if defective > 0:
self.__status_builder.critical(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(Output(f'Couldn\'t get last diagnostic test result time'))
return
last_run = oids[0]["value"]
last_check = datetime.strptime(last_run, '%m/%d/%Y')
now = datetime.now()
warning = timedelta(days=self.__warning)
critical = timedelta(days=self.__critical)
output = Output(f'Last selftest runtime {last_run}')
if (now - critical) >= last_check:
self.__status_builder.critical(output)
elif (now - warning) >= last_check:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def require_module(self, module: str):
enabled_modules = self.list_enabled_mods()
if not self.is_module_enabled(module, enabled_modules) \
and not self.is_module_enabled(f"{module}_module", enabled_modules):
module = module.replace("_module", "")
self.__status_builder.unknown(
Output(
f'Required module "mod_{module}" is not enabled. You need to enable it with '
f'"sudo a2enmod {module}" and "systemctl restart apache2".'
))
self.__status_builder.exit()
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(
f'Couldn\'t get the number of attached external battery packs'
))
return
attached = oids[0]['value']
output = Output(
f'There are currently {attached} external batteries attached (required {self.__count})'
)
if attached != self.__count:
self.__status_builder.critical(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
first_datapoint = self.__disk_id * 17 - 16
last_datapoint = self.__disk_id * 17
status_data = {}
keys = {
'3': 'attributeName',
'4': 'attributeId',
'5': 'current',
'6': 'worst',
'7': 'threshold',
'8': 'raw',
'9': 'status',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if base[0] in ['1', '2'] or id < first_datapoint or id > last_datapoint:
continue
data = status_data.get(id, {})
data[keys.get(base[0])] = oid['value']
status_data[id] = data
critical_values = ['pre-fail', 'pre fail', 'pre_fail', 'old-age', 'old age', 'old_age']
for status_data_id in status_data:
data = status_data[status_data_id]
perfdata = [
Perfdata(f"{data['attributeName']}.id", data['attributeId']),
Perfdata(f"{data['attributeName']}.status", data['status']),
Perfdata(f"{data['attributeName']}.current", data['current']),
Perfdata(f"{data['attributeName']}.threshold", data['threshold']),
Perfdata(f"{data['attributeName']}.worst", data['worst']),
Perfdata(f"{data['attributeName']}.raw", data['raw']),
]
output = Output(f"{data['attributeName']} [{data['attributeId']}] is \"{data['status']}\" current: " \
f"{data['current']}, worst: {data['worst']}, threshold: {data['threshold']}, raw: " \
f"{data['raw']}", perfdata)
if data['status'].lower() == 'ok':
self.__status_builder.success(output)
elif data['status'].lower() in critical_values:
self.__status_builder.critical(output)
else:
self.__status_builder.warning(output)
def run(self):
reboot_file = Path("/var/run/reboot-required")
scheduled_file = Path("/run/systemd/shutdown/scheduled")
self.__logger.debug('Check if file "/var/run/reboot-required" exist.')
if reboot_file.is_file():
self.__logger.debug('File "/var/run/reboot-required" exist.')
if scheduled_file.exists() and scheduled_file.is_file():
with open('/run/systemd/shutdown/scheduled', 'r') as file:
file_content = file.readlines()
timestamp = None
mode = None
for line in file_content:
if "USEC=" in line:
timestamp = datetime.fromtimestamp(
int(line.replace('USEC=', '').replace('\n', '')) /
1000000)
elif "MODE=" in line:
mode = line.replace('MODE=', '').replace('\n', '')
output = Output(
f'Reboot required but scheduled at {timestamp.strftime("%Y-m-%d, %H:%M:%S")} in mode {mode}'
)
if self.__ignore_if_scheduled:
self.__status_builder.success(output)
elif self.__exit_critical:
self.__status_builder.critical(output)
else:
self.__status_builder.warning(output)
return
else:
if self.__exit_critical:
self.__status_builder.critical('Reboot is required.')
else:
self.__status_builder.warning('Reboot is required.')
return
self.__logger.debug('File "/var/run/reboot-required" does not exist.')
self.__status_builder.success('No reboot is required.')
def configure(self, args):
self.__snmp_executor.configure(args)
self.__gpu_id = args.gpu
self.__warning = args.warning
self.__critical = args.critical
failed = False
if None is not self.__critical:
if self.__critical > 100:
self.__status_builder.unknown(
Output('Critical value can\'t be greater than 100 %'))
failed = True
elif self.__critical < 0:
self.__status_builder.unknown(
Output('Critical value must be at least 0 %'))
failed = True
if None is not self.__warning:
if self.__warning < 0:
self.__status_builder.unknown(
Output('Warning value must be at least 0 %'))
failed = True
if None is not self.__critical and None is self.__warning:
self.__status_builder.unknown(
Output(
'If you set a critical bound you have to specify a warning bound'
))
failed = True
elif None is self.__critical and None is not self.__warning:
self.__status_builder.unknown(
Output(
'If you set a warning bound you have to specify a critical bound'
))
failed = True
elif None is not self.__critical and None is not self.__warning:
if self.__warning > self.__critical:
self.__status_builder.unknown(
Output(
'Warning value can\'t be greater than critical value'))
failed = True
if failed:
self.__status_builder.exit()
def __check_bounds(self, warning, critical, name):
success = True
if None is not critical:
if critical > 100:
self.__status_builder.unknown(
Output(
f'Critical value for {name} can\'t be greater than 100 %'
))
success = False
elif critical < 0:
self.__status_builder.unknown(
Output(f'Critical value for {name} must be at least 0 %'))
success = False
if None is not warning:
if warning < 0:
self.__status_builder.unknown(
Output(f'Warning value for {name} must be at least 0 %'))
success = False
if None is not critical and None is warning:
self.__status_builder.unknown(
Output(
f'If you set a critical bound for {name} you have to specify a warning bound'
))
success = False
elif None is critical and None is not warning:
self.__status_builder.unknown(
Output(
f'If you set a warning bound for {name} you have to specify a critical bound'
))
success = False
elif None is not critical and None is not warning:
if warning > critical:
self.__status_builder.unknown(
Output(
f'Warning value for {name} can\'t be greater than critical value'
))
success = False
return success
def run(self):
oids = self.__snmp_executor.run()
if 1 != len(oids) or '0' != oids[0]['oid']:
self.__status_builder.unknown(
Output(f'Couldn\'t get Battery status information'))
return
if 1 == oids[0]['value']:
self.__status_builder.unknown(
Output(f'Got unknown battery status'))
elif 2 == oids[0]['value']:
self.__status_builder.success(Output(f'Battery status normal'))
elif 3 == oids[0]['value']:
self.__status_builder.warning(Output(f'Low Battery status'))
elif 4 == oids[0]['value']:
self.__status_builder.critical(
Output(f'Battery in pre-fail status'))
else:
self.__status_builder.unknown(
Output(
f'Got unknown Battery status information "{oids[0]["value"]}"'
))
def run(self):
oids = self.__snmp_executor.run()
status_data = {}
keys = {
'2': 'device',
'3': 'bytesRead32',
'4': 'bytesWrite32',
'5': 'reads',
'6': 'writes',
'8': 'load',
'9': 'load1',
'10': 'load5',
'11': 'load15',
'12': 'bytesRead64',
'13': 'bytesWrite64',
'14': 'uuid',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if base[0] == '1' or int(base[1]) != self.__volume_id:
continue
data = status_data.get(id, {})
data[keys.get(base[0])] = oid['value']
status_data[id] = data
if 0 == len(status_data):
self.__status_builder.unknown(
Output(
f'Volume "{self.__volume_id}" either does not exist or not accessible'
))
self.__status_builder.exit()
for status_data_id in status_data:
data = status_data[status_data_id]
perfdata = [
Perfdata("load15", data['load15']),
Perfdata("bytesRead32", data['bytesRead32']),
Perfdata("bytesRead64", data['bytesRead64']),
Perfdata("bytesWrite32", data['bytesWrite32']),
Perfdata("bytesWrite64", data['bytesWrite64']),
Perfdata("reads", data['reads']),
Perfdata("writes", data['writes']),
]
if None is self.__warning:
perfdata += [
Perfdata("load", data['load']),
Perfdata("load1", data['load1']),
Perfdata("load5", data['load5']),
]
else:
perfdata += [
Perfdata("load",
data['load'],
warning=self.__warning[0],
critical=self.__critical[0]),
Perfdata("load1",
data['load1'],
warning=self.__warning[0],
critical=self.__critical[0]),
Perfdata("load5",
data['load5'],
warning=self.__warning[0],
critical=self.__critical[0]),
]
output = Output(
f"Volume \"{data['device']}\" [{data.get('uuid', 'unknown UUID')}]",
perfdata)
if None is self.__warning:
self.__status_builder.success(output)
else:
if self.__critical[0] <= data['load1'] \
or self.__critical[1] <= data['load5'] \
or self.__critical[2] <= data['load15']:
self.__status_builder.critical(output)
elif self.__warning[0] <= data['load1'] \
or self.__warning[1] <= data['load5'] \
or self.__warning[2] <= data['load15']:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
status_data = {}
keys = {
'1': 'index',
'2': 'device',
'3': 'numberReads',
'4': 'numberWrites',
'5': 'reads',
'6': 'writes',
'9': 'load1',
'10': 'load5',
'11': 'load15',
'12': 'reads64',
'13': 'writes64',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if None is not self.__disk and id != self.__disk:
continue
data = status_data.get(id, {})
data[keys.get(base[0])] = oid['value']
status_data[id] = data
if 0 == len(status_data):
if None is self.__disk:
self.__status_builder.unknown(
Output(
f'Either no disks exist or they are not accessible'))
else:
self.__status_builder.unknown(
Output(
f'Disk "{self.__disk}" either does not exist or not accessible'
))
self.__status_builder.exit()
for status_data_id in status_data:
data = status_data[status_data_id]
prefix = '' if None is not self.__disk else f"{data['device'].replace(' ', '_')}."
perfdata = [
Perfdata(f'{prefix}numberReads', data['numberReads'],
unit='c'),
Perfdata(f'{prefix}numberWrites',
data['numberWrites'],
unit='c'),
Perfdata(f'{prefix}reads', data['reads'], unit='c'),
Perfdata(f'{prefix}writes', data['writes'], unit='c'),
Perfdata(f'{prefix}reads64', data['reads64'], unit='c'),
Perfdata(f'{prefix}writes64', data['writes64'], unit='c'),
]
if None is self.__warning:
perfdata += [
Perfdata("load", data['load']),
Perfdata("load1", data['load1']),
Perfdata("load5", data['load5']),
]
else:
perfdata += [
Perfdata("load",
data['load'],
warning=self.__warning[0],
critical=self.__critical[0]),
Perfdata("load1",
data['load1'],
warning=self.__warning[0],
critical=self.__critical[0]),
Perfdata("load5",
data['load5'],
warning=self.__warning[0],
critical=self.__critical[0]),
]
output = Output(f"Disk load \"{data['device']}\"", perfdata)
if None is self.__warning:
self.__status_builder.success(output)
else:
if self.__critical[0] <= data['load1'] \
or self.__critical[1] <= data['load5'] \
or self.__critical[2] <= data['load15']:
self.__status_builder.critical(output)
elif self.__warning[0] <= data['load1'] \
or self.__warning[1] <= data['load5'] \
or self.__warning[2] <= data['load15']:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def configure(self, args):
self.__snmp_executor.configure(args)
self.__disk = args.disk
if None is args.warning and args.critical is not None:
self.__status_builder.unknown(
Output(
'If critical load is defined, you have to set warning load'
))
self.__status_builder.exit()
if None is not args.warning and args.critical is None:
self.__status_builder.unknown(
Output(
'If warning load is defined, you have to set critical load'
))
self.__status_builder.exit()
warning = args.warning
if None is not warning:
warning = warning.split(',')
if len(warning) != 3:
self.__status_builder.unknown(
Output(
'Format for warning load mismatch. Expected Format: LOAD1,LOAD5,LOAD15'
))
self.__status_builder.exit()
self.__warning = [
float(warning[0]),
float(warning[1]),
float(warning[2])
]
else:
if args.critical is not None:
self.__status_builder.unknown(
Output(
'If you set a critical value, you have to set a warning value too.'
))
self.__status_builder.exit()
critical = args.critical
if None is not critical:
critical = critical.split(',')
if len(critical) != 3:
self.__status_builder.unknown(
Output(
'Format for critical load mismatch. Expected Format: LOAD1,LOAD5,LOAD15'
))
self.__status_builder.exit()
self.__critical = [
float(critical[0]),
float(critical[1]),
float(critical[2])
]
else:
if args.warning is not None:
self.__status_builder.unknown(
Output(
'If you set a warning value, you have to set a critical value too.'
))
self.__status_builder.exit()
def run(self):
oids = self.__snmp_executor.run()
status_data = {}
keys = {
'1': 'supported',
'2': 'utilization',
'3': 'usage',
'4': 'free',
'5': 'used',
'6': 'total',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if int(base[1]) != self.__gpu_id:
continue
data = status_data.get(id, {})
data[keys.get(base[0])] = oid['value']
status_data[id] = data
if 0 == len(status_data):
self.__status_builder.unknown(
Output(
f'GPU "{self.__gpu_id}" either does not exist or not accessible'
))
self.__status_builder.exit()
for status_data_id in status_data:
data = status_data[status_data_id]
if 1 == data['supported']:
output = Output(f"GPU \"{self.__gpu_id}\" is unsupported")
self.__status_builder.unknown(output)
continue
if None is self.__warning:
perfdata = [
Perfdata(f'{self.__gpu_id}',
data['used'],
min=0,
max=data['total']),
]
else:
perfdata = [
Perfdata(f'{self.__gpu_id}',
data['used'],
warning=self.__warning / 100 * data['total'],
critical=self.__critical / 100 * data['total'],
min=0,
max=data['total']),
]
output = Output(f"GPU \"{self.__gpu_id}\"", perfdata)
if None is self.__warning:
self.__status_builder.success(output)
else:
if self.__critical <= data['usage']:
self.__status_builder.critical(output)
elif self.__warning <= data['usage']:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)
def run(self):
oids = self.__snmp_executor.run()
status_data = {}
keys = {
'2': 'name',
'3': 'totalSwap',
'4': 'availableSwap',
'5': 'totalReal',
'6': 'availableReal',
'7': 'totalSwapTXT',
'8': 'availableSwapTXT',
'9': 'totalRealTXT',
'10': 'availableRealTXT',
'11': 'totalFree',
'12': 'minSwap',
'13': 'shared',
'14': 'buffer',
'15': 'cached',
'16': 'usedSwapTXT',
'17': 'usedRealTXT',
'100': 'swapError',
'101': 'swapErrorMsg',
}
for oid in oids:
base = oid['oid'].split('.')
id = int(base[1])
if int(base[1]) != self.__memory_id:
continue
data = status_data.get(id, {})
data[keys.get(base[0])] = oid['value']
status_data[id] = data
if 0 == len(status_data):
self.__status_builder.unknown(
Output(
f'Memory "{self.__memory_id}" either does not exist or not accessible'
))
self.__status_builder.exit()
for status_data_id in status_data:
data = status_data[status_data_id]
self.__check_data(data, 'Swap', 'Swap', self.__warning_swap,
self.__critical_swap, self.__check_swap)
self.__check_data(data, 'SwapTXT', 'Swap txt',
self.__warning_swap_txt,
self.__critical_swap_txt, self.__check_swap_txt)
self.__check_data(data, 'Real', 'Real', self.__warning_real,
self.__critical_real, self.__check_real)
self.__check_data(data, 'RealTXT', 'Real txt',
self.__warning_real_txt,
self.__critical_real_txt, self.__check_real_txt)
total = data.get('totalSwap', 0) + data.get(
'totalSwapTXT', 0) + data.get('totalReal', 0) + data.get(
'totalRealTXT', 0)
self.__check_data(
{
'totalTotal': total,
'availableTotal': total - data['totalFree'],
'name': data['name']
}, 'Total', 'Total', self.__warning_total,
self.__critical_total, self.__check_total)
self.__check_value('shared', 'Shared', data, self.__warning_shared,
self.__critical_shared, self.__check_shared)
self.__check_value('buffer', 'Buffer', data, self.__warning_buffer,
self.__critical_buffer, self.__check_buffer)
self.__check_value('cached', 'Cached', data, self.__warning_cache,
self.__critical_cache, self.__check_cache)
self.__check_value('minSwap', 'Min SWAP', data,
self.__warning_min_swap,
self.__critical_min_swap, self.__check_min_swap)
if 0 != data['swapError']:
self.__status_builder.critical(
Output(
f'Got an unexpected SWAP error "{data["swapErrorMessage"]}" '
f'(code {data["swapError"]})'))
def __check_data(self, data, suffix, name, warning, critical, check):
if not check:
return
self.__logger.debug(f'Check memory {suffix}')
total = data.get('total' + suffix, None)
available = data.get('available' + suffix, None)
perfdata = [
Perfdata(f'{suffix}',
0,
unit='B',
warning=0,
critical=0,
min=0,
max=0),
]
if total is None:
self.__status_builder.unknown(
Output(
f"Couldn't check {name} because it either not exist or is not accessible "
f"(total value not found).", perfdata))
return
if available is None:
self.__status_builder.unknown(
Output(
f"Couldn't check {name} because it either not exist or is not accessible "
f"(available value not found).", perfdata))
return
used = total - available
if None is warning:
perfdata = [
Perfdata(f'{suffix}',
used,
unit='B',
warning=0,
critical=0,
min=0,
max=total),
]
else:
perfdata = [
Perfdata(f'{suffix}',
used,
unit='B',
warning=warning / 100 * total,
critical=critical / 100 * total,
min=0,
max=total),
]
output = Output(f"Memory \"{name}\"", perfdata)
if None is warning:
self.__status_builder.success(output)
else:
usage = used / total * 100
if critical <= usage:
self.__status_builder.critical(output)
elif self.__warning_total <= usage:
self.__status_builder.warning(output)
else:
self.__status_builder.success(output)