From d4dd00f58a502c9ca4b63e36ce6bc7a9945dc63c Mon Sep 17 00:00:00 2001 From: Federico Ceratto Date: Tue, 27 Mar 2018 22:28:21 +0100 Subject: New upstream version 1.10.0+dfsg --- python.d/isc_dhcpd.chart.py | 249 ++++++++++++++++++++++++-------------------- 1 file changed, 138 insertions(+), 111 deletions(-) (limited to 'python.d/isc_dhcpd.chart.py') diff --git a/python.d/isc_dhcpd.chart.py b/python.d/isc_dhcpd.chart.py index 60995342c..eb6338452 100644 --- a/python.d/isc_dhcpd.chart.py +++ b/python.d/isc_dhcpd.chart.py @@ -2,165 +2,192 @@ # Description: isc dhcpd lease netdata python.d module # Author: l2isbad -from time import mktime, strptime, gmtime, time -from os import stat, access, R_OK -from os.path import isfile -try: - from ipaddress import ip_network, ip_address - HAVE_IPADDRESS = True -except ImportError: - HAVE_IPADDRESS = False +import os +import re +import time + + try: - from itertools import filterfalse + import ipaddress + HAVE_IP_ADDRESS = True except ImportError: - from itertools import ifilterfalse as filterfalse + HAVE_IP_ADDRESS = False + +from collections import defaultdict +from copy import deepcopy from bases.FrameworkServices.SimpleService import SimpleService priority = 60000 retries = 60 -update_every = 5 -ORDER = ['pools_utilization', 'pools_active_leases', 'leases_total', 'parse_time', 'leases_size'] +ORDER = ['pools_utilization', 'pools_active_leases', 'leases_total'] CHARTS = { 'pools_utilization': { - 'options': [None, 'Pools Utilization', 'used in percent', 'utilization', + 'options': [None, 'Pools Utilization', '%', 'utilization', 'isc_dhcpd.utilization', 'line'], 'lines': []}, 'pools_active_leases': { - 'options': [None, 'Active Leases', 'leases per pool', 'active leases', + 'options': [None, 'Active Leases Per Pool', 'leases', 'active leases', 'isc_dhcpd.active_leases', 'line'], 'lines': []}, 'leases_total': { - 'options': [None, 'Total All Pools', 'number', 'active leases', + 'options': [None, 'All Active Leases', 'leases', 'active leases', 'isc_dhcpd.leases_total', 'line'], - 'lines': [['leases_total', 'leases', 'absolute']]}, - 'parse_time': { - 'options': [None, 'Parse Time', 'ms', 'parse stats', - 'isc_dhcpd.parse_time', 'line'], - 'lines': [['parse_time', 'time', 'absolute']]}, - 'leases_size': { - 'options': [None, 'Dhcpd Leases File Size', 'kilobytes', - 'parse stats', 'isc_dhcpd.leases_size', 'line'], - 'lines': [['leases_size', 'size', 'absolute', 1, 1024]]}} + 'lines': [['leases_total', 'leases', 'absolute']], + 'variables': [ + ['leases_size'] + ] + } +} + + +class DhcpdLeasesFile: + def __init__(self, path): + self.path = path + self.mod_time = 0 + self.size = 0 + + def is_valid(self): + return os.path.isfile(self.path) and os.access(self.path, os.R_OK) + + def is_changed(self): + mod_time = os.path.getmtime(self.path) + if mod_time != self.mod_time: + self.mod_time = mod_time + self.size = int(os.path.getsize(self.path) / 1024) + return True + return False + + def get_data(self): + try: + with open(self.path) as leases: + result = defaultdict(dict) + for row in leases: + row = row.strip() + if row.startswith('lease'): + address = row[6:-2] + elif row.startswith('iaaddr'): + address = row[7:-2] + elif row.startswith('ends'): + result[address]['ends'] = row[5:-1] + elif row.startswith('binding state'): + result[address]['state'] = row[14:-1] + return dict((k, v) for k, v in result.items() if len(v) == 2) + except (OSError, IOError): + return None + + +class Pool: + def __init__(self, name, network): + self.id = re.sub(r'[:/.-]+', '_', name) + self.name = name + self.network = ipaddress.ip_network(address=u'%s' % network) + + def num_hosts(self): + return self.network.num_addresses - 2 + + def __contains__(self, item): + return item.address in self.network + + +class Lease: + def __init__(self, address, ends, state): + self.address = ipaddress.ip_address(address=u'%s' % address) + self.ends = ends + self.state = state + + def is_active(self, current_time): + # lease_end_time might be epoch + if self.ends.startswith('epoch'): + epoch = int(self.ends.split()[1].replace(';', '')) + return epoch - current_time > 0 + # max. int for lease-time causes lease to expire in year 2038. + # dhcpd puts 'never' in the ends section of active lease + elif self.ends == 'never': + return True + return time.mktime(time.strptime(self.ends, '%w %Y/%m/%d %H:%M:%S')) - current_time > 0 + + def is_valid(self): + return self.state == 'active' class Service(SimpleService): def __init__(self, configuration=None, name=None): SimpleService.__init__(self, configuration=configuration, name=name) - self.leases_path = self.configuration.get('leases_path', '/var/lib/dhcp/dhcpd.leases') self.order = ORDER - self.definitions = CHARTS - self.pools = dict() + self.definitions = deepcopy(CHARTS) + + lease_path = self.configuration.get('leases_path', '/var/lib/dhcp/dhcpd.leases') + self.dhcpd_leases = DhcpdLeasesFile(path=lease_path) + self.pools = list() + self.data = dict() # Will work only with 'default' db-time-format (weekday year/month/day hour:minute:second) # TODO: update algorithm to parse correctly 'local' db-time-format - # Also only ipv4 supported def check(self): - if not HAVE_IPADDRESS: - self.error('\'python-ipaddress\' module is needed') + if not HAVE_IP_ADDRESS: + self.error("'python-ipaddress' module is needed") return False - if not (isfile(self.leases_path) and access(self.leases_path, R_OK)): - self.error('Make sure leases_path is correct and leases log file is readable by netdata') + + if not self.dhcpd_leases.is_valid(): + self.error("Make sure '{path}' is exist and readable by netdata".format(path=self.dhcpd_leases.path)) return False - if not self.configuration.get('pools'): + + pools = self.configuration.get('pools') + if not pools: self.error('Pools are not defined') return False - if not isinstance(self.configuration['pools'], dict): - self.error('Invalid \'pools\' format') - return False - for pool in self.configuration['pools']: + for pool in pools: try: - net = ip_network(u'%s' % self.configuration['pools'][pool]) - self.pools[pool] = dict(net=net, num_hosts=net.num_addresses - 2) + new_pool = Pool(name=pool, network=pools[pool]) except ValueError as error: - self.error('%s removed, error: %s' % (self.configuration['pools'][pool], error)) + self.error("'{pool}' was removed, error: {error}".format(pool=pools[pool], error=error)) + else: + self.pools.append(new_pool) - if not self.pools: - return False self.create_charts() - return True + return bool(self.pools) - def _get_raw_data(self): - """ - Parses log file - :return: tuple( - [ipaddress, lease end time, ...], - time to parse leases file - ) - """ - try: - with open(self.leases_path) as leases: - time_start = time() - part1 = filterfalse(find_lease, leases) - part2 = filterfalse(find_ends, leases) - result = dict(zip(part1, part2)) - time_end = time() - file_parse_time = round((time_end - time_start) * 1000) - return result, file_parse_time - except (OSError, IOError) as error: - self.error("Failed to parse leases file:", str(error)) - return None - - def _get_data(self): + def get_data(self): """ :return: dict """ - raw_data = self._get_raw_data() - if not raw_data: - return None + if not self.dhcpd_leases.is_changed(): + return self.data - raw_leases, parse_time = raw_data[0], raw_data[1] + raw_leases = self.dhcpd_leases.get_data() + if not raw_leases: + self.data = dict() + return None - # Result: {ipaddress: end lease time, ...} - active_leases, to_netdata = list(), dict() - current_time = mktime(gmtime()) + active_leases = list() + current_time = time.mktime(time.gmtime()) - for ip, lease_end_time in raw_leases.items(): - # Result: [active binding, active binding....]. (Expire time (ends date;) - current time > 0) - if binding_active(lease_end_time=lease_end_time[7:-2], - current_time=current_time): - active_leases.append(ip_address(u'%s' % ip[6:-3])) + for address in raw_leases: + try: + new_lease = Lease(address, **raw_leases[address]) + except ValueError: + continue + else: + if new_lease.is_active(current_time) and new_lease.is_valid(): + active_leases.append(new_lease) for pool in self.pools: - dim_id = pool.replace('.', '_') - pool_leases_count = len([ip for ip in active_leases if ip in self.pools[pool]['net']]) - to_netdata[dim_id + '_active_leases'] = pool_leases_count - to_netdata[dim_id + '_utilization'] = float(pool_leases_count) / self.pools[pool]['num_hosts'] * 10000 + count = len([ip for ip in active_leases if ip in pool]) + self.data[pool.id + '_active_leases'] = count + self.data[pool.id + '_utilization'] = float(count) / pool.num_hosts() * 10000 + + self.data['leases_size'] = self.dhcpd_leases.size + self.data['leases_total'] = len(active_leases) - to_netdata['leases_total'] = len(active_leases) - to_netdata['leases_size'] = stat(self.leases_path)[6] - to_netdata['parse_time'] = parse_time - return to_netdata + return self.data def create_charts(self): for pool in self.pools: - dim, dim_id = pool, pool.replace('.', '_') - self.definitions['pools_utilization']['lines'].append([dim_id + '_utilization', - dim, 'absolute', 1, 100]) - self.definitions['pools_active_leases']['lines'].append([dim_id + '_active_leases', - dim, 'absolute']) - - -def binding_active(lease_end_time, current_time): - # lease_end_time might be epoch - if lease_end_time.startswith('epoch'): - epoch = int(lease_end_time.split()[1].replace(';','')) - return epoch - current_time > 0 - # max. int for lease-time causes lease to expire in year 2038. - # dhcpd puts 'never' in the ends section of active lease - elif lease_end_time == 'never': - return True - else: - return mktime(strptime(lease_end_time, '%w %Y/%m/%d %H:%M:%S')) - current_time > 0 - - -def find_lease(value): - return value[0:3] != 'lea' - - -def find_ends(value): - return value[2:6] != 'ends' + self.definitions['pools_utilization']['lines'].append([pool.id + '_utilization', pool.name, + 'absolute', 1, 100]) + self.definitions['pools_active_leases']['lines'].append([pool.id + '_active_leases', pool.name]) -- cgit v1.2.3