def __driver__(self):
Flag = True
count = 0
ip_mac = None
while True:
while Flag:
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
get_lease_object = leases.get()
ip_mac = list(
set([(x.ip, x.ethernet) for x in get_lease_object]))
time.sleep(10)
count += 1
if count == 6:
Flag = False
for x in ip_mac:
self.queue.put(x)
for x in self.active_thread:
x.join()
for x in self.workers:
make_worker = Thread(target=self.__arp__, name=x)
make_worker.start()
self.active_thread.append(make_worker)
print(bcolors.OKGREEN + str(self.active) + bcolors.ENDC + "\n")
print(bcolors.OKGREEN + str(self.blacklist) + bcolors.ENDC + "\n")
self.__print__()
time.sleep(20 * 60)
def main(self):
self.read_conf()
check_subnet = []
i = 0
print(self.iface)
timeout = time.time() + 60 * self.app_timeout
if self.app_timeout > 20:
scan = time.time() + 60 * (self.app_timeout / 5)
else:
scan = time.time() + 60 * (self.app_timeout / 2)
while True:
if time.time() <= scan:
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
get_valid = leases.get_current()
all_leases = list(
set([(value.ip, value.ethernet)
for value in get_valid.values()]))
check_subnet = list(set(filter(self.gen, all_leases)))
print(f"Discovered [{len(check_subnet)}]")
print(f"Scan Time Left ({(scan-time.time())/60} minutes)")
time.sleep(2)
else:
self.active = list(set(filter(self.arp, check_subnet)))
self.__print__()
time.sleep(5)
i += 1
if time.time() >= timeout:
break
return 0
def lookup(ip):
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
leaseList = leases.get()
for l in leaseList:
if l.ip == ip:
return l.ethernet
return None
def parse():
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
allLeases = leases.get()
for lease in allLeases:
# print('Lease ist: '+ lease.ip + ', Hostname ist:' + lease.hostname)
allIps.append(lease.ip)
for ip in allIps:
hostname = 'worker1-' + ip[8:]
allHostnames.append(hostname)
print(hostname)
def _oldGetCurrentLeases():
leases = IscDhcpLeases(DHCP_LEASES_FILENAME)
currentLeases = leases.get_current()
resultado = []
for objeto in currentLeases.values():
item = {}
item[objeto.ip] = objeto
resultado.append(item)
resultado.sort(key=ordenar)
return resultado
def get_clients(self):
clients = []
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
list = leases.get_current()
for key in list:
lease = list[key]
mac_address = lease.ethernet
ip_address = lease.ip
hostname = lease.hostname
lease_time = str(lease.end)
client = Client(mac_address, ip_address, hostname, lease_time)
clients.append(client)
return clients
def parse():
all_ips = []
all_hostnames = []
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
all_leases = leases.get()
for lease in all_leases:
all_ips.append(lease.ip)
for ip in all_ips:
hostname = 'worker1-' + ip[8:]
all_hostnames.append(hostname)
return all_ips
def proxy():
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
ips = [lease for lease in leases.get()]
with futures.ThreadPoolExecutor(max_workers=255) as executor:
futs = [(host, executor.submit(functools.partial(ping, host)))
for host in ips]
js = [{
"ip": ip.ip,
"mac": ip.ethernet,
"hostname": ip.hostname
} for ip, f in futs if f.result()]
return Response(json.dumps(js), mimetype='application/json')
def add_leases(self, fname, mock):
leases = IscDhcpLeases(fname)
for lease in leases.get_current().values():
self.set_defaults(fname, mock, lease.hostname)
ptr_addr = self.to_ptr_v4(lease.ip)
self.set_defaults(fname, mock, ptr_addr)
mock[lease.hostname]["A"].add(("A", lease.ip))
mock[lease.hostname]["ANY"].add(("A", lease.ip))
mock[ptr_addr]["PTR"].add(("PTR", lease.hostname))
mock[ptr_addr]["ANY"].add(("PTR", lease.hostname))
fqdn = lease.hostname + "." + self.config.get("local", "my_domain")
self.set_defaults(fname, mock, fqdn)
mock[fqdn]["A"].add(("A", lease.ip))
mock[fqdn]["ANY"].add(("A", lease.ip))
mock[ptr_addr]["PTR"].add(("PTR", fqdn))
mock[ptr_addr]["ANY"].add(("PTR", fqdn))
def dhcpLeases(filter='active'):
leases = IscDhcpLeases('/var/db/dhcpd/dhcpd.leases')
entries = {}
rows = []
now = datetime.utcnow()
for l in sorted(leases.get(), key=lambda l: inet_aton(l.ip)):
age = now - l.start
age = str(age).split('.')[0]
state = l.binding_state
if state == 'active' and l.end and l.end < now:
state = 'expired'
name = reverse(l.ip)
vendor = macParser.get_manuf_long(l.ethernet)
if filters[filter](l):
leaserow = LeaseRow(active=l.active,
age=age,
dns=name,
end=l.end,
ip=l.ip,
mac=l.ethernet,
name=l.hostname,
start=l.start,
state=state,
valid=l.valid,
vendor=vendor,
color=color(l.ip))
entries[leaserow.mac] = leaserow
rows.append(leaserow)
for l in arpentries():
name = reverse(l.ip)
vendor = macParser.get_manuf_long(l.mac)
if l.mac not in entries:
rows.append(
LeaseRow(active=True,
age=0,
dns=name,
end=None,
ip=l.ip,
mac=l.mac,
name='',
start=None,
state='arp',
valid=True,
vendor=vendor,
color=color(l.ip)))
return dict(extended=False,
leases=sorted(rows, key=lambda l: inet_aton(l.ip)))
def main(self):
self.read_conf()
check_subnet = []
i = 0
while True:
if i <= 30:
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
get_valid = leases.get_current()
all_leases = list(set([(value.ip, value.ethernet) for value in get_valid.values()]))
check_subnet = list(set(filter(self.gen, all_leases)))
print(i)
else:
pass
self.active = list(set(filter(self.arp, check_subnet)))
self.__print__()
time.sleep(5)
i += 1
def __init__(self, leasefile='/var/lib/dhcp/dhcpd.leases'):
print(leasefile)
netbox = 'https://netbox.minserver.dk/ipam/prefixes/?status=1&parent=&family=&q=&vrf=npflan&mask_length=&export'
data = urllib.request.urlopen(netbox).read()
reader = csv.reader(io.StringIO(data.decode()),
delimiter=',',
quotechar='|')
subnets = []
for row in reader:
if row[7].lower() == "Access".lower() or row[7].lower(
) == "Wireless".lower() or row[9].lower() == "AP-MGMT".lower():
if row[9].lower() == 'Wireless Networks'.lower():
continue
# Add networks to array
subnets.append(IPv4Network(row[0]))
self.subnets = subnets
self.leases = IscDhcpLeases(leasefile)
print("dhcpd_exporter started!")
class DhcpdCollector(object):
def __init__(self, leasefile='/var/lib/dhcp/dhcpd.leases'):
print(leasefile)
netbox = 'https://netbox.minserver.dk/ipam/prefixes/?status=1&parent=&family=&q=&vrf=npflan&mask_length=&export'
data = urllib.request.urlopen(netbox).read()
reader = csv.reader(io.StringIO(data.decode()),
delimiter=',',
quotechar='|')
subnets = []
for row in reader:
if row[7].lower() == "Access".lower() or row[7].lower(
) == "Wireless".lower() or row[9].lower() == "AP-MGMT".lower():
if row[9].lower() == 'Wireless Networks'.lower():
continue
# Add networks to array
subnets.append(IPv4Network(row[0]))
self.subnets = subnets
self.leases = IscDhcpLeases(leasefile)
print("dhcpd_exporter started!")
def collect(self):
scope_size = GaugeMetricFamily('size_per_scope',
'Size of scope',
labels=['scope'])
for network in self.subnets:
scope_size.add_metric([str(network)], network.num_addresses - 2)
yield scope_size
scope_usage = GaugeMetricFamily('usage_per_scope',
'Currently in use leases per scope',
labels=['scope'])
# TODO: Very bad from a performance perspective, needs optimization
uses = defaultdict(lambda: 0)
cur_leases = 0
total_leases = 0
for lease in self.leases.get():
total_leases = total_leases + 1
if lease.valid and lease.active:
cur_leases = cur_leases + 1
parsed = IPv4Address(lease.ip)
for network in self.subnets:
if parsed in network:
uses[network] = uses[network] + 1
break
for network, used_ips in uses.items():
scope_usage.add_metric([str(network)], used_ips)
yield scope_usage
yield GaugeMetricFamily('total_current',
'Total amount of current valid leases',
value=cur_leases)
yield GaugeMetricFamily('total_leases',
'Total amount of leases valid and invalid',
value=total_leases)
def get_address_for_ptusb_connected_device():
def command_succeeds(cmd, timeout):
try:
run_command(cmd, timeout=timeout, check=True, log_errors=False)
return True
except Exception:
return False
if interface_is_up("ptusb0"):
current_leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases').get_current().values()
current_leases = list(current_leases)
current_leases.reverse()
for lease in current_leases:
# Windows machines won't respond to ping requests by default. Using arping
# helps us on that case, but since it takes ~1.5s, it's used as a fallback
if (command_succeeds(f"ping -c1 {lease.ip}", 0.1) or
command_succeeds(f"arping -c1 {lease.ip}", 2)):
return lease.ip
return ""
def update(self):
modification_time = os.path.getmtime(self.leases_file)
if modification_time != self.last_modification_time:
self.last_modification_time = modification_time
leases_list = IscDhcpLeases(self.leases_file).get()
leases_dict = dict()
for lease in leases_list:
if lease.active:
leases_dict[lease.ethernet] = lease
self.leases = leases_dict
return True
return False
def get_leases(leases, state, pool=None, sort='ip'):
# get leases from file
leases = IscDhcpLeases(lease_file).get()
# filter leases by state
if 'all' not in state:
leases = list(filter(lambda x: x.binding_state in state, leases))
# filter leases by pool name
if pool is not None:
if config.exists_effective(
"service dhcp-server shared-network-name {0}".format(pool)):
leases = list(filter(lambda x: in_pool(x, pool), leases))
else:
print("Pool {0} does not exist.".format(pool))
sys.exit(0)
# should maybe filter all state=active by lease.valid here?
# sort by start time to dedupe (newest lease overrides older)
leases = sorted(leases, key=lambda lease: lease.start)
# dedupe by converting to dict
leases_dict = {}
for lease in leases:
# dedupe by IP
leases_dict[lease.ip] = lease
# convert the lease data
leases = list(map(get_lease_data, leases_dict.values()))
# apply output/display sort
if sort == 'ip':
leases = sorted(
leases, key=lambda lease: int(ipaddress.ip_address(lease['ip'])))
else:
leases = sorted(leases, key=lambda lease: lease[sort])
return leases
# Needs file argument
print("Needs leases file argument")
exit(-1)
# Define metrics
TOTAL_LEASES = Gauge('total_leases',
'Total amount of leases valid and invalid')
TOTAL_CURRENT = Gauge('total_current', 'Total amount of current valid leases')
USAGE_PER_SCOPE = Gauge('usage_per_scope', 'Currently in use leases per scope',
['scope'])
SIZE_PER_SCOPE = Gauge('size_per_scope', 'Size of scope', ['scope'])
dhcpd_leases = sys.argv[1]
# Instantiate and parse DHCPD leases file
leases = IscDhcpLeases(dhcpd_leases)
netbox = 'https://netbox.minserver.dk/ipam/prefixes/?status=1&parent=&family=&q=&vrf=npflan&mask_length=&export'
data = urllib.request.urlopen(netbox).read()
datafile = os.path.join(os.path.dirname(__file__), 'data.csv')
with open(datafile, 'wb+') as f:
f.write(data)
reader = csv.reader(io.StringIO(data.decode()), delimiter=',', quotechar='|')
subnets = []
for row in reader:
if row[7].lower() == "Access".lower() or row[7].lower(
) == "Wireless".lower() or row[9].lower() == "AP-MGMT".lower():
def getCurrentLeases():
leases = IscDhcpLeases(DHCP_LEASES_FILENAME)
currentLeases = leases.get_current()
resultado = []
for objeto in currentLeases.values():
dispositivo = IPObject(objeto.ip)
#
# Algunos dispositivos no registran su nombre en el servidor DHCP
# así que le asignamos el nombre "Desconocido"
#
if objeto.hostname == "":
dispositivo.name = "Desconocido"
else:
dispositivo.name = objeto.hostname
dispositivo.mac = objeto.ethernet.upper()
dispositivo.pool = 3
dispositivo.poolName = 'DHCP'
dispositivo.endDate = objeto.end
resultado.append(dispositivo)
# Ya tengo las direcciones de leases DHCP
#
# toca unir los resultados a las fijas y estáticas
cnx = util.openDDBB()
cursor = cnx.cursor()
txtQuery = "select Descripcion from Dispositivos where Mac = %s"
for objeto in resultado:
cursor.execute(txtQuery, (objeto.mac, ))
encontrado = False
for nombre in cursor:
encontrado = True
objeto.name = nombre[0]
objeto.known = encontrado
cursor.close()
cursor = cnx.cursor()
query = (
"select Mac, IPAddress, Descripcion, Pool, PoolName from Dispositivos where Pool in (1,2,4)"
)
cursor.execute(query)
for mac, ip, desc, pool, poolName in cursor:
dispositivo = IPObject(ip)
dispositivo.name = desc
dispositivo.mac = mac.upper()
dispositivo.pool = int(pool)
dispositivo.poolName = poolName
dispositivo.endDate = 'N/A'
dispositivo.known = True
resultado.append(dispositivo)
cursor.close()
util.closeDDBB(cnx)
resultado.sort(key=ordenar)
return resultado
def get_lease():
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
return leases.get()
def show_entries():
server = DhcpSubnet.get()
clients = DhcpClient.query.order_by(DhcpClient.hostname).all()
pnca = PnCloudAccount.get()
ansible = AnsibleConfig.get()
hostfiles = AnsibleHostsFile.query.order_by(
AnsibleHostsFile.filename.desc()).all()
servstats = service_status((DHCPD_PROC, TSHARK_PROC, LOGCATUI_PROC))
assets = []
products = []
activation_keys = {}
activations_by_device_id = {}
activation_key_download_times = {}
if server.server_ip:
http_base = "http://{0}:{1}".format(server.server_ip.ip,
server.server_port)
else:
http_base = ''
onie_installers = [
os.path.basename(x)
for x in glob.glob(os.path.join(WWW_ROOT, 'onie-installer-*'))
]
if os.path.islink(ONIE_INSTALLER_PATH):
current = os.path.basename(os.readlink(ONIE_INSTALLER_PATH))
else:
current = ''
pnc = PnCloud.get()
if pnc.login():
assets = pnc.assets()
products = pnc.products(download_group_ids=(1, ),
sw_pid_pattern=re.compile(r'^onie-installer-'))
for dtype in ACTIVATION_KEY_FILES:
if os.path.isfile(ACTIVATION_KEY_FILES[dtype]):
activation_keys[dtype] = re.sub(r'^.*/images/', '/images/',
ACTIVATION_KEY_FILES[dtype])
activation_key_download_times[
dtype] = datetime.datetime.fromtimestamp(
os.path.getmtime(ACTIVATION_KEY_FILES[dtype]))
else:
activation_keys[dtype] = None
activation_key_download_times[dtype] = None
for det in pnc.order_details():
for a in det['order_activations']:
activations_by_device_id[a['device_id']] = True
elif pnca and pnca.username and pnca.password:
flash("Failed to log in to PN Cloud as user \"{0}\"".format(
pnca.username))
downloaded = [x['sw_pid'] for x in products if x['__downloaded']]
uploaded = [
onie_installer_details(x) for x in onie_installers
if x not in downloaded
]
dhcp_leases = []
if os.path.isfile(LEASES_FILE):
dhcp_leases = reversed(IscDhcpLeases(LEASES_FILE).get())
services = [x for x in servstats if x['service_id'] in REPORT_SERVICES]
ts = [x['status'] for x in servstats if x['service_id'] == TSHARK_PROC]
if ts:
tshark_status = ts[0]
else:
tshark_status = 'UNKNOWN'
lc = [x['status'] for x in servstats if x['service_id'] == LOGCATUI_PROC]
if lc:
logcat_status = lc[0]
else:
logcat_status = 'UNKNOWN'
nvos_running = _nvos_status()
return render_template(
'show_entries.html',
server=server,
entries=clients,
pnca=pnca,
ansible=ansible,
hostfiles=hostfiles,
assets=assets,
products=products,
activation_keys=activation_keys,
activations_by_device_id=activations_by_device_id,
onie_installers=onie_installers,
uploaded=uploaded,
current=current,
services=services,
http_base=http_base,
dhcp_leases=dhcp_leases,
tshark_status=tshark_status,
logcat_status=logcat_status,
nvos_running=nvos_running,
activation_key_download_times=activation_key_download_times)
import csv
import json
import subprocess
import ruamel.yaml
from nornir import InitNornir
from isc_dhcp_leases import IscDhcpLeases
from nornir_netmiko.tasks import netmiko_send_config
from nornir_netmiko.tasks import netmiko_send_command
from nornir_jinja2.plugins.tasks import template_file
from nornir_utils.plugins.functions import print_result
from ruamel.yaml.scalarstring import SingleQuotedScalarString as sq
yaml = ruamel.yaml.YAML()
# Get IP addresses of booted network elements ##################################
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
current_leases = leases.get_current()
lease_ips = []
for lease in current_leases.values():
m = re.search(r'([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)', str(lease))
if m:
lease_ips.append(m.group(1))
# Generate initial inventory file ##############################################
os.chdir('/home/nornir-ztp/inventory')
hosts = {}
for index, lease_ip in enumerate(lease_ips):
router_name = 'R' + str(index + 1)
hosts[router_name] = {'hostname': lease_ip}
# Add single quoted (sq) value in YAML dumper
device_type = {'device_type': sq('cisco_ios_telnet')}
def get_vm_info(self, dom_name):
'''
Get the IP info of interfaces on the VM
Args:
dom_name (string): name of the desired domain
Returns:
eth0_ip, usrp_if (string): eth0 and USRP interface
'''
# Get XML description of domain
dom = self.conn.lookupByName(dom_name)
dom_xml = dom.XMLDesc(0)
root = ET.fromstring(dom_xml)
# Find MAC address of the VMs primary interface
for if_element in root.iter('interface'):
if if_element.attrib['type'] == 'bridge' and if_element.find(
'virtualport') is None:
outbound_if = if_element.find('mac').attrib['address']
# Find what is the IP of the bridged interface. This only makes sense
# if the VM is turned on. It will return 0.0.0.0 if the VM is off. This
# will use QEMU Agent. Need to modify the XML of the VM's to access it
# and install qemu-guest-agent on them.
if dom is None:
self.log.debug('Failed to get the domain object')
out_ip = '0.0.0.0'
try:
ifaces = dom.interfaceAddresses(
libvirt.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT, 0)
self.log.debug("The interface IP addresses:")
for name, val in ifaces.iteritems():
if val['addrs']:
for ipaddr in val['addrs']:
if ipaddr['type'] == libvirt.VIR_IP_ADDR_TYPE_IPV4:
self.log.debug("iface name: " + str(name) +
" Addr: " + ipaddr['addr'] +
" VIR_IP_ADDR_TYPE_IPV4")
if '192.168.0' in ipaddr['addr']:
out_ip = ipaddr['addr']
return out_ip
elif ipaddr['type'] == libvirt.VIR_IP_ADDR_TYPE_IPV6:
self.log.debug("iface name: " + str(name) +
" Addr: " + ipaddr['addr'] +
" VIR_IP_ADDR_TYPE_IPV6")
except Exception as e:
self.log.debug("ERROR trying to obtain VM IP: " + str(e))
self.log.debug('repr(e): ' + str(repr(e)))
# Find out the IP by collecting the MAC address and searching
# for it on the DHCP
interfaces = []
if dom.isActive():
try:
leases = IscDhcpLeases(DHCP_LEASES_PATH)
vm_lease = leases.get_current()[outbound_if]
out_ip = vm_lease.ip
except Exception:
self.log.debug("Could not get IP of VM: " + str(dom_name))
return out_ip
def main():
fastd_sockets = (
('0', '/run/fastd-ffda-vpn.sock'),
('1', '/run/fastd-ffda-vpn1.sock'),
)
device_name_mapping = {
'freifunk': 'ffda-br',
'bat0': 'ffda-bat',
'mesh-vpn': 'ffda-vpn'
}
device_whitelist = [
'eth0',
'tun-ffrl-ber',
'tun-ffrl-dus',
'tun-ffrl-fra',
'tun-ffda-gw01',
'tun-ffda-gw02',
'tun-ffda-gw03',
'tun-ffda-gw04',
'ffda-vpn',
'ffda-bat',
'ffda-br',
'icvpn',
'ffda-transport',
'services',
]
fields = [
'bytes', 'packets', 'errs', 'drop', 'fifo',
'frame', 'compressed', 'multicast',
]
field_format = '(?P<{direction}_{field}>\d+)'
pattern = re.compile(
'^\s*(?P<device_name>[\w-]+):\s+' + '\s+'.join(
itertools.chain.from_iterable((field_format.format(direction=direction, field=field)
for field in fields) for direction in ['rx', 'tx'])
)
)
update = {}
with open('/proc/net/dev') as fh:
lines = fh.readlines()
for line in lines:
m = pattern.match(line)
if m:
groupdict = m.groupdict()
device_name = groupdict.pop('device_name')
device_name = device_name_mapping.get(device_name, device_name)
if device_name in device_whitelist or device_name.endswith('-vpn') or \
device_name.endswith('-bat') or \
device_name.endswith('-br') or \
device_name.endswith('-transport'):
for key, value in groupdict.items():
direction, metric = key.split('_')
update['%s.%s.%s' % (device_name, direction, metric)] = value
with open('/proc/loadavg', 'r') as fh:
line = fh.read()
values = line.split(' ', 3)
update['load.15'] = values[0]
update['load.5'] = values[1]
update['load.1'] = values[2]
for key in ['count', 'max']:
try:
with open('/proc/sys/net/netfilter/nf_conntrack_%s' % key, 'r') as fh:
update['netfilter.%s' % key] = fh.read().strip()
except IOError as e:
pass
with open('/proc/net/snmp6', 'r') as fh:
for line in fh.readlines():
key, value = line.split(' ', 1)
value = value.strip()
update['ipv6.%s' % key] = value
with open('/proc/net/snmp', 'r') as fh:
for heading, values in pairwise(fh.readlines()):
section, headings = heading.split(':')
headings = headings.strip().split(' ')
_, values = values.split(':')
values = values.strip().split(' ')
for key, value in zip(headings, values):
update['ipv4.%s.%s' % (section, key)] = value
with open('/proc/stat', 'r') as fh:
for line in fh.readlines():
key, value = line.split(' ', 1)
if key == 'ctxt':
update['context_switches'] = value.strip()
break
for name, filename in fastd_sockets:
if not os.path.exists(filename):
continue
data = read_from_fastd_socket(filename)
if len(data) > 0:
update.update({'fastd.%s.%s' % (name, key): value for (key, value) in data.items()})
fastd_drops = get_fastd_process_stats()
if fastd_drops:
update['fastd.drops'] = fastd_drops
if IscDhcpLeases:
try:
isc_leases = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
update['dhcp_leases'] = len(isc_leases.get())
update['dhcp_leases_valid'] = len(isc_leases.get_current())
update['dhcp_leases_active'] = len([1 for lease in isc_leases.get() if lease.valid])
except Exception:
pass
#pprint.pprint(update)
write_to_graphite(update)
return leases.get_current()
latest = {}
for lease in leases.get():
latest[lease.ethernet] = lease
return latest
parser = argparse.ArgumentParser()
parser.add_argument('leases_file',
nargs='?',
default='/var/lib/dhcp/dhcpd.leases')
parser.add_argument('--json', action='store_true', help='output JSON format')
parser.add_argument('--all',
action='store_true',
help='include some expired leases (latest for any MAC)')
args = parser.parse_args()
leases = IscDhcpLeases(args.leases_file)
lease_data = get_leases(leases, args)
if args.json:
data = {}
for key, lease in lease_data.items():
data[key] = lease_as_dict(lease)
print(json.dumps(data, indent=2))
else:
for lease in lease_data.values():
print(lease, lease.sets.get('vendor-class-identifier', ''))
parts = mac.split(":")
# modify parts to match IPv6 value
parts.insert(3, "ff")
parts.insert(4, "fe")
parts[0] = "%x" % (int(parts[0], 16) ^ 2)
# format output
ipv6Parts = []
for i in range(0, len(parts), 2):
ipv6Parts.append("".join(parts[i:i + 2]))
ipv6 = "fe80::%s" % (":".join(ipv6Parts))
return ipv6
leases = IscDhcpLeases('/var/lib/dhcp/dhcpd6.leases')
#print(leases.get_current())
l = []
for mac in leases.get_current():
lease = leases.get_current().get(mac)
#print(lease)
ip = lease.ip
if not ip in l:
output = subprocess.Popen(['ping', '-c', '2', ip],
stdout=subprocess.PIPE).communicate()[0]
#print(output.decode('utf-8'))
#if (not "Destination unreachable" in output.decode('utf-8')) and (not "Request timed out" in output.decode('utf-8')):
if ", 0% packet loss" in output.decode('utf-8'):
l.append(ip)
print(ip)
#print(output.decode('utf-8'))
import datetime, calendar, os, sys, json
from time import sleep
config_path = os.path.abspath(os.path.dirname(sys.argv[0]) + '/config.json')
if not (os.path.exists(config_path)):
sys.stderr.write("Cannot find config file " + config_path + "\n")
sys.exit(1)
with open(config_path) as data:
config = json.load(data)
data.close()
mqtt_host = config['mqtt']['host']
mqtt_topic = config['mqtt']['topic_prefix']
# Initialise
reader = IscDhcpLeases('/var/lib/dhcp/dhcpd.leases')
leases = []
messages = []
for lease in reader.get_current():
mac = str(lease).replace(':', '')
leases.append(mac)
while True:
sleep(10)
new_leases = []
messages = []
for lease in reader.get_current():
mac = str(lease).replace(':', '')
new_leases.append(mac)
for mac in new_leases:
def __init__(self, lease_file_path):
self.leases = IscDhcpLeases(lease_file_path)
