# Author: l2isbad
from base import SimpleService
-from re import compile
from time import mktime, strptime, gmtime, time
+from os import stat
try:
from ipaddress import IPv4Address as ipaddress
from ipaddress import ip_network
have_ipaddress = True
except ImportError:
have_ipaddress = False
+try:
+ from itertools import filterfalse as filterfalse
+except ImportError:
+ from itertools import ifilterfalse as filterfalse
+
priority = 60000
retries = 60
# TODO: update algorithm to parse correctly 'local' db-time-format
# (epoch <seconds-since-epoch>; # <day-name> <month-name> <day-number> <hours>:<minutes>:<seconds> <year>)
# Also only ipv4 supported
- self.regex = compile(r'\d+(?:\.\d+){3}')
def check(self):
if not self._get_raw_data():
else:
try:
self.pools = self.pools.split()
- if not [ip_network(pool) for pool in self.pools]:
+ if not [ip_network(return_utf(pool)) for pool in self.pools]:
self.error('Pools list is empty')
return False
- except (ValueError, IndexError, AttributeError, SyntaxError):
- self.error('Pools configurations is incorrect')
+ except (ValueError, IndexError, AttributeError, SyntaxError) as e:
+ self.error('Pools configurations is incorrect', str(e))
return False
-
- # Creating dynamic charts
- self.order = ['parse_time', 'utilization']
+
+ # Creating static charts
+ self.order = ['parse_time', 'leases_size', 'utilization', 'total']
self.definitions = {'utilization':
{'options':
- [None, 'Pools utilization', 'used %', 'Utulization', 'isc_dhcpd.util', 'line'],
+ [None, 'Pools utilization', 'used %', 'Utilization', 'isc_dhcpd.util', 'line'],
'lines': []},
+ 'total':
+ {'options':
+ [None, 'Total all pools', 'leases', 'Utilization', 'isc_dhcpd.total', 'line'],
+ 'lines': [['total', 'leases', 'absolute']]},
'parse_time':
{'options':
- [None, 'Parse time', 'ms', 'Parse statistics', 'isc_dhcpd.parse', 'line'],
- 'lines': [['ptime', 'time', 'absolute']]}}
+ [None, 'Parse time', 'ms', 'Parse stats', 'isc_dhcpd.parse', 'line'],
+ 'lines': [['ptime', 'time', 'absolute']]},
+ 'leases_size':
+ {'options':
+ [None, 'dhcpd.leases file size', 'kilobytes', 'Parse stats', 'isc_dhcpd.lsize', 'line'],
+ 'lines': [['lsize', 'size', 'absolute']]}}
+ # Creating dynamic charts
for pool in self.pools:
self.definitions['utilization']['lines'].append([''.join(['ut_', pool]), pool, 'absolute'])
self.order.append(''.join(['leases_', pool]))
self.definitions[''.join(['leases_', pool])] = \
- {'options': [None, 'Active leases', 'leases', 'Leases', 'isc_dhcpd.lease', 'area'],
+ {'options': [None, 'Active leases', 'leases', 'Pools', 'isc_dhcpd.lease', 'area'],
'lines': [[''.join(['le_', pool]), pool, 'absolute']]}
self.info('Plugin was started succesfully')
Parses log file
:return: tuple(
[ipaddress, lease end time, ...],
- length of list,
time to parse leases file
)
"""
try:
with open(self.leases_path, 'rt') as dhcp_leases:
- raw_result = []
-
time_start = time()
- for line in dhcp_leases:
- if line[0:3] == 'lea':
- raw_result.append(self.regex.search(line).group())
- elif line[2:6] == 'ends':
- raw_result.append(line[7:28])
- else:
- continue
+ part1 = filterfalse(find_lease, dhcp_leases)
+ part2 = filterfalse(find_ends, dhcp_leases)
+ raw_result = dict(zip(part1, part2))
time_end = time()
+
file_parse_time = round((time_end - time_start) * 1000)
- except Exception:
+ except Exception as e:
+ self.error("Failed to parse leases file:", str(e))
return None
else:
- raw_result_length = len(raw_result)
- result = (raw_result, raw_result_length, file_parse_time)
+ result = (raw_result, file_parse_time)
return result
def _get_data(self):
:return: dict
"""
raw_leases = self._get_raw_data()
-
if not raw_leases:
return None
# Result: {ipaddress: end lease time, ...}
- all_leases = dict(zip([raw_leases[0][_] for _ in range(0, raw_leases[1], 2)],
- [raw_leases[0][_] for _ in range(1, raw_leases[1], 2)]))
+ all_leases = dict([(k[6:len(k)-3], v[7:len(v)-2]) for k, v in raw_leases[0].items()])
# Result: [active binding, active binding....]. (Expire time (ends date;) - current time > 0)
- active_leases = [k for k, v in all_leases.items() if is_bind_active(all_leases[k])]
+ active_leases = [k for k, v in all_leases.items() if is_binding_active(all_leases[k])]
# Result: {pool: number of active bindings in pool, ...}
pools_count = {pool: len([lease for lease in active_leases if is_address_in(lease, pool)])
for pool in self.pools}
# Bulding dicts to send to netdata
- final_count = {''.join(['le_', k]): v for k, v in pools_count.items()}
- final_util = {''.join(['ut_', k]): v for k, v in pools_util.items()}
+ final_count = dict([(''.join(['le_', k]), v) for k, v in pools_count.items()])
+ final_util = dict([(''.join(['ut_', k]), v) for k, v in pools_util.items()])
- to_netdata = {'ptime': int(raw_leases[2])}
+ to_netdata = {'total': len(active_leases)}
+ to_netdata.update({'lsize': int(stat(self.leases_path)[6] / 1024)})
+ to_netdata.update({'ptime': int(raw_leases[1])})
to_netdata.update(final_util)
to_netdata.update(final_count)
-
+
return to_netdata
-
-def is_bind_active(binding):
+
+
+def is_binding_active(binding):
return mktime(strptime(binding, '%w %Y/%m/%d %H:%M:%S')) - mktime(gmtime()) > 0
+
def is_address_in(address, pool):
- return ipaddress(address) in ip_network(pool)
+ return ipaddress(return_utf(address)) in ip_network(return_utf(pool))
+
+
+def find_lease(value):
+ return value[0:3] != 'lea'
+
+
+def find_ends(value):
+ return value[2:6] != 'ends'
+
+def return_utf(s):
+ # python2 returns "<type 'str'>" for simple strings
+ # python3 returns "<class 'str'>" for unicode strings
+ if str(type(s)) == "<type 'str'>":
+ return unicode(s, 'utf-8')
+ return s
projects / netdata.git / blobdiff