Viewing file:  isc_dhcpd.chart.py (8.14 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# -*- coding: utf-8 -*-
# Description: isc dhcpd lease netdata python.d module
# Author: ilyam8
# SPDX-License-Identifier: GPL-3.0-or-later
import os
import re
import time
try:
import ipaddress
HAVE_IP_ADDRESS = True
except ImportError:
HAVE_IP_ADDRESS = False
from collections import defaultdict
from copy import deepcopy
from bases.FrameworkServices.SimpleService import SimpleService
ORDER = [
'pools_utilization',
'pools_active_leases',
'leases_total',
]
CHARTS = {
'pools_utilization': {
'options': [None, 'Pools Utilization', 'percentage', 'utilization', 'isc_dhcpd.utilization', 'line'],
'lines': []
},
'pools_active_leases': {
'options': [None, 'Active Leases Per Pool', 'leases', 'active leases', 'isc_dhcpd.active_leases', 'line'],
'lines': []
},
'leases_total': {
'options': [None, 'All Active Leases', 'leases', 'active leases', 'isc_dhcpd.leases_total', 'line'],
'lines': [
['leases_total', 'leases', 'absolute']
],
'variables': [
['leases_size']
]
}
}
POOL_CIDR = "CIDR"
POOL_IP_RANGE = "IP_RANGE"
POOL_UNKNOWN = "UNKNOWN"
def detect_ip_type(ip):
ip_type = ip.split("-")
if len(ip_type) == 1:
return POOL_CIDR
elif len(ip_type) == 2:
return POOL_IP_RANGE
else:
return POOL_UNKNOWN
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.networks = list()
for network in network.split(" "):
if not network:
continue
ip_type = detect_ip_type(ip=network)
if ip_type == POOL_CIDR:
self.networks.append(PoolCIDR(network=network))
elif ip_type == POOL_IP_RANGE:
self.networks.append(PoolIPRange(ip_range=network))
else:
raise ValueError('Network ({0}) incorrect syntax, expect CIDR or IPRange format.'.format(network))
def num_hosts(self):
return sum([network.num_hosts() for network in self.networks])
def __contains__(self, item):
for network in self.networks:
if item in network:
return True
return False
class PoolCIDR:
def __init__(self, network):
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 PoolIPRange:
def __init__(self, ip_range):
ip_range = ip_range.split("-")
self.networks = list(self._summarize_address_range(ip_range[0], ip_range[1]))
@staticmethod
def ip_address(ip):
return ipaddress.ip_address(u'%s' % ip)
def _summarize_address_range(self, first, last):
address_first = self.ip_address(first)
address_last = self.ip_address(last)
return ipaddress.summarize_address_range(address_first, address_last)
def num_hosts(self):
return sum([network.num_addresses for network in self.networks])
def __contains__(self, item):
for network in self.networks:
if item.address in network:
return True
return False
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.order = ORDER
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
def check(self):
if not HAVE_IP_ADDRESS:
self.error("'python-ipaddress' package is needed")
return False
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
pools = self.configuration.get('pools')
if not pools:
self.error('Pools are not defined')
return False
for pool in pools:
try:
new_pool = Pool(name=pool, network=pools[pool])
except ValueError as error:
self.error("'{pool}' was removed, error: {error}".format(pool=pools[pool], error=error))
else:
self.pools.append(new_pool)
self.create_charts()
return bool(self.pools)
def get_data(self):
"""
:return: dict
"""
if not self.dhcpd_leases.is_changed():
return self.data
raw_leases = self.dhcpd_leases.get_data()
if not raw_leases:
self.data = dict()
return None
active_leases = list()
current_time = time.mktime(time.gmtime())
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:
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)
return self.data
def create_charts(self):
for pool in self.pools:
dim = [
pool.id + '_utilization',
pool.name,
'absolute',
1,
100,
]
self.definitions['pools_utilization']['lines'].append(dim)
dim = [
pool.id + '_active_leases',
pool.name,
]
self.definitions['pools_active_leases']['lines'].append(dim)
|