python.d/isc_dhcpd.chart.py

   1 # -*- coding: utf-8 -*-
   2 # Description: isc dhcpd lease netdata python.d module
   3 # Author: l2isbad
   4
   5 from base import SimpleService
   6 from time import mktime, strptime, gmtime, time
   7 from os import stat
   8 try:
   9     from ipaddress import IPv4Address as ipaddress
  10     from ipaddress import ip_network
  11     have_ipaddress = True
  12 except ImportError:
  13     have_ipaddress = False
  14 try:
  15     from itertools import filterfalse as filterfalse
  16 except ImportError:
  17     from itertools import ifilterfalse as filterfalse
  18
  19
  20 priority = 60000
  21 retries = 60
  22 update_every = 60
  23
  24 class Service(SimpleService):
  25     def __init__(self, configuration=None, name=None):
  26         SimpleService.__init__(self, configuration=configuration, name=name)
  27         self.leases_path = self.configuration.get('leases_path', '/var/lib/dhcp/dhcpd.leases')
  28         self.pools = self.configuration.get('pools')
  29
  30         # Will work only with 'default' db-time-format (weekday year/month/day hour:minute:second)
  31         # TODO: update algorithm to parse correctly 'local' db-time-format
  32         # (epoch <seconds-since-epoch>; # <day-name> <month-name> <day-number> <hours>:<minutes>:<seconds> <year>)
  33         # Also only ipv4 supported
  34
  35     def check(self):
  36         if not self._get_raw_data():
  37             self.error('Make sure leases_path is correct and leases log file is readable by netdata')
  38             return False
  39         elif not have_ipaddress:
  40             self.error('No ipaddress module. Please install (py2-ipaddress in case of python2)')
  41             return False
  42         else:
  43             try:
  44                 self.pools = self.pools.split()
  45                 if not [ip_network(return_utf(pool)) for pool in self.pools]:
  46                     self.error('Pools list is empty')
  47                     return False
  48             except (ValueError, IndexError, AttributeError, SyntaxError) as e:
  49                 self.error('Pools configurations is incorrect', str(e))
  50                 return False
  51
  52             # Creating static charts
  53             self.order = ['parse_time', 'leases_size', 'utilization', 'total']
  54             self.definitions = {'utilization':
  55                                     {'options':
  56                                          [None, 'Pools utilization', 'used %', 'utilization', 'isc_dhcpd.util', 'line'],
  57                                      'lines': []},
  58                                  'total':
  59                                    {'options':
  60                                         [None, 'Total all pools', 'leases', 'utilization', 'isc_dhcpd.total', 'line'],
  61                                     'lines': [['total', 'leases', 'absolute']]},
  62                                'parse_time':
  63                                    {'options':
  64                                         [None, 'Parse time', 'ms', 'parse stats', 'isc_dhcpd.parse', 'line'],
  65                                     'lines': [['ptime', 'time', 'absolute']]},
  66                                'leases_size':
  67                                    {'options':
  68                                         [None, 'dhcpd.leases file size', 'kilobytes', 'parse stats', 'isc_dhcpd.lsize', 'line'],
  69                                     'lines': [['lsize', 'size', 'absolute']]}}
  70             # Creating dynamic charts
  71             for pool in self.pools:
  72                 self.definitions['utilization']['lines'].append([''.join(['ut_', pool]), pool, 'absolute'])
  73                 self.order.append(''.join(['leases_', pool]))
  74                 self.definitions[''.join(['leases_', pool])] = \
  75                     {'options': [None, 'Active leases', 'leases', 'pools', 'isc_dhcpd.lease', 'area'],
  76                      'lines': [[''.join(['le_', pool]), pool, 'absolute']]}
  77
  78             self.info('Plugin was started succesfully')
  79             return True
  80
  81     def _get_raw_data(self):
  82         """
  83         Parses log file
  84         :return: tuple(
  85                        [ipaddress, lease end time, ...],
  86                        time to parse leases file
  87                       )
  88         """
  89         try:
  90             with open(self.leases_path, 'rt') as dhcp_leases:
  91                 time_start = time()
  92                 part1 = filterfalse(find_lease, dhcp_leases)
  93                 part2 = filterfalse(find_ends, dhcp_leases)
  94                 raw_result = dict(zip(part1, part2))
  95                 time_end = time()
  96                 file_parse_time = round((time_end - time_start) * 1000)
  97         except Exception as e:
  98             self.error("Failed to parse leases file:", str(e))
  99             return None
 100         else:
 101             result = (raw_result, file_parse_time)
 102             return result
 103
 104     def _get_data(self):
 105         """
 106         :return: dict
 107         """
 108         raw_leases = self._get_raw_data()
 109         if not raw_leases:
 110             return None
 111
 112         # Result: {ipaddress: end lease time, ...}
 113         all_leases = dict([(k[6:len(k)-3], v[7:len(v)-2]) for k, v in raw_leases[0].items()])
 114
 115         # Result: [active binding, active binding....]. (Expire time (ends date;) - current time > 0)
 116         active_leases = [k for k, v in all_leases.items() if is_binding_active(all_leases[k])]
 117
 118         # Result: {pool: number of active bindings in pool, ...}
 119         pools_count = dict([(pool, len([lease for lease in active_leases if is_address_in(lease, pool)]))
 120                        for pool in self.pools])
 121
 122         # Result: {pool: number of host ip addresses in pool, ...}
 123         pools_max = dict([(pool, (2 ** (32 - int(pool.split('/')[1])) - 2))
 124                      for pool in self.pools])
 125
 126         # Result: {pool: % utilization, ....} (percent)
 127         pools_util = dict([(pool, int(round(float(pools_count[pool]) / pools_max[pool] * 100, 0)))
 128                       for pool in self.pools])
 129
 130         # Bulding dicts to send to netdata
 131         final_count = dict([(''.join(['le_', k]), v) for k, v in pools_count.items()])
 132         final_util = dict([(''.join(['ut_', k]), v) for k, v in pools_util.items()])
 133
 134         to_netdata = {'total': len(active_leases)}
 135         to_netdata.update({'lsize': int(stat(self.leases_path)[6] / 1024)})
 136         to_netdata.update({'ptime': int(raw_leases[1])})
 137         to_netdata.update(final_util)
 138         to_netdata.update(final_count)
 139
 140         return to_netdata
 141
 142
 143 def is_binding_active(binding):
 144     return mktime(strptime(binding, '%w %Y/%m/%d %H:%M:%S')) - mktime(gmtime()) > 0
 145
 146
 147 def is_address_in(address, pool):
 148     return ipaddress(return_utf(address)) in ip_network(return_utf(pool))
 149
 150
 151 def find_lease(value):
 152     return value[0:3] != 'lea'
 153
 154
 155 def find_ends(value):
 156     return value[2:6] != 'ends'
 157
 158
 159 def return_utf(s):
 160     # python2 returns "<type 'str'>" for simple strings
 161     # python3 returns "<class 'str'>" for unicode strings
 162     if str(type(s)) == "<type 'str'>":
 163         return unicode(s, 'utf-8')
 164     return s