def __call__(self, hostname):
remote_ip = get_hostname_ip(hostname)
sock = socket.socket(socket.AF_INET, tcp)
sock.settimeout(0.2)
result = sock.connect_ex((remote_ip, self.port))
if result == 0:
return State(OK)
return State(CRITICAL)
def get_state(self, cmd_exec):
state = OK
if not cmd_exec.file_exists(self.cmd_line):
print '%s not found ! Can not check for update !' % self.cmd_line
return State(UNKNOWN, 'smartctl not found !')
devices = self._get_devices(cmd_exec)
for devicename in devices:
nb_error = self._get_device_nb_errors(cmd_exec, devicename)
if nb_error:
state = WARNING
return State(state)
def get_state(self, cmd_exec):
updates = self._get_update_availables(cmd_exec)
if updates is None:
return State(UNKNOWN, 'apt-check not found!')
messages = []
if updates['normal']:
messages.append('Normal: %s' % updates['normal'])
if updates['security'] > 0:
messages.append('Security: %s' % updates['security'])
state = OK
if updates['security'] > 0:
state = CRITICAL
elif updates['normal'] > 0:
state = WARNING
return State(state, '\n'.join(messages))
def get_state(self, cmd_exec):
loads = self._get_loads(cmd_exec)
state_5m = loads[1]
state = WARNING
if state_5m < 1:
state = OK
return State(state, ' - '.join(['%.2f' % l for l in loads]))
def __call__(self, hostname):
remote_ip = get_hostname_ip(hostname)
sock = socket.socket(socket.AF_INET, udp)
sock.settimeout(0.2)
result = sock.connect_ex((remote_ip, self.port))
try:
sock.send('')
sock.recv(10)
is_open = False
except socket.timeout:
is_open = True
except socket.error:
is_open = False
sock.close()
if is_open:
return State(OK)
return State(CRITICAL)
def get_state(self, cmd_exec):
state = OK
mount_usages = self._get_mount_usages(cmd_exec)
for mount_name, mount_usage in mount_usages.iteritems():
free_ratio = mount_usage['free_space'] / float(mount_usage['size'])
if free_ratio <= 0.1:
state = CRITICAL
elif free_ratio <= 0.2:
state = WARNING
return State(state, self._str_data(mount_usages))
def get_state(self, cmd_exec):
state = OK
raid_status = self._get_raid_status(cmd_exec)
msgs = []
for raid_name in raid_status:
raid_s = raid_status[raid_name]
if raid_s['msg']:
msgs.append('%s: %s' % (raid_name, raid_s['msg']))
state = WARNING
for disk_state in raid_s['status']:
if disk_state != 'U':
state = CRITICAL
break
return State(state, '\n'.join(msgs))
def get_state(self, cmd_exec):
data = self._get_version_details(cmd_exec)
if data is None:
return State(UNKNOWN, 'lsb_release not found !')
if 'Description' not in data:
return State(UNKNOWN, 'Version not found !')
message = data['Description']
if 'Distributor ID' not in data or 'Release' not in data or 'Codename' not in data:
return State(UNKNOWN, message)
distribution = data['Distributor ID']
release = data['Release']
codename = data['Codename']
if distribution not in self.version_validity:
return State(UNKNOWN, message)
version_validities = self.version_validity[distribution]
validity = None
for version_validity in version_validities:
if 'version' in version_validity:
if version_validity['version'] != release:
continue
validity = version_validity['validity']
break
if 'codename' in version_validity:
if version_validity['codename'] != codename:
continue
validity = version_validity['validity']
break
if validity is None:
return State(UNKNOWN, message)
message = '%s [%s]' % (message, validity)
if validity == 'expired':
return State(CRITICAL, message)
validity_date = datetime.datetime.strptime(validity[:7],
'%Y-%m').date()
today = datetime.date.today()
if validity_date <= today:
return State(CRITICAL, message)
if (validity_date - today).days < self.warning_below_days:
return State(WARNING, message)
return State(OK, message)
def get_state(self, cmd_exec):
details = self._get_memory_details(cmd_exec)
def get_amount(txt):
return int(txt.split(' ', 1)[0])
def human_readable(amount):
i = 0
while float(amount) / (1000**i) > 1:
i += 1
units = ['kB', 'MB', 'GB', 'TB', 'EB']
if i > 0:
i -= 1
float(amount) / (1000**i)
return '%i%s' % (int(float(amount) / (1000**i)), units[i])
mem_total = get_amount(details['MemTotal'])
mem_free = get_amount(details['MemFree'])
mem_cached = get_amount(details['Cached'])
mem_buffer = get_amount(details['Buffers'])
mem_used = mem_total - mem_free - mem_cached - mem_buffer
pc_used = mem_used / float(mem_total)
swap_total = get_amount(details['SwapTotal'])
swap_free = get_amount(details['SwapFree'])
swap_used = swap_total - swap_free
all_total = mem_total + swap_total
all_used = mem_used + swap_used
if swap_total > 0:
pc_swap_used = swap_used / float(swap_total)
state = OK
if pc_used > 0.9 or ((all_used / float(all_total)) > 0.8):
state = CRITICAL
elif pc_used > 0.7:
state = WARNING
message = 'Mem: % 3i%% %s' % (round(
pc_used * 100), human_readable(mem_total))
if swap_total > 0:
message += '\nSwap: % 3i%% %s' % (round(
pc_swap_used * 100), human_readable(swap_total))
return State(state, message)
def __call__(self):
for hostname in self.hostnames:
if ping.__call__(self, hostname) == OK:
return State(OK)
return State(CRITICAL)
def __call__(self, hostname):
remote_ip = get_hostname_ip(hostname)
response = os.system("ping -c 1 " + remote_ip + " > /dev/null")
if response == 0:
return State(OK)
return State(CRITICAL)
def get_state(self, cmd_exec):
if cmd_exec.file_exists('/var/run/reboot-required'):
return State(WARNING)
return State(OK)
def _parse_result(self, result):
if len(result.split('\n')) > 3:
return State(OK)
return State(CRITICAL)