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)