def handle(self, input, addresses, jobs, *args, **options): self.addresses = set() # Direct addresses for a in addresses: if is_ipv4(a): self.addresses.add(a) # Read addresses from files if input: for fn in input: try: with open(fn) as f: for line in f: line = line.strip() if is_ipv4(line): self.addresses.add(line) except OSError as e: self.die("Cannot read file %s: %s\n" % (fn, e)) # Ping if config.features.use_uvlib: from tornaduv import UVLoop self.stderr.write("Using libuv\n") tornado.ioloop.IOLoop.configure(UVLoop) self.ioloop = IOLoop.current() self.ping = Ping(io_loop=self.ioloop) self.jobs = jobs self.queue = tornado.queues.Queue(self.jobs) for i in range(self.jobs): self.ioloop.spawn_callback(self.ping_worker) self.ioloop.run_sync(self.ping_task)
def execute_cli(self): r = [] v = self.cli("show lldp neighbors") for match in self.rx_local_port.finditer(v): local_interface = match.group("port") c = self.cli("show lldp neighbors interface %s" % local_interface) match1 = self.rx_remote.search(c) chassis_id = match1.group("chassis_id") if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_NETWORK_ADDRESS elif is_mac(chassis_id): chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_MAC else: chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_LOCAL port_id = match1.group("port_id") if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = LLDP_PORT_SUBTYPE_NETWORK_ADDRESS elif is_mac(port_id): port_id_subtype = LLDP_PORT_SUBTYPE_MAC else: port_id_subtype = LLDP_PORT_SUBTYPE_LOCAL neighbor = { "remote_chassis_id_subtype": chassis_id_subtype, "remote_chassis_id": chassis_id, "remote_port_subtype": port_id_subtype, "remote_port": port_id, } port_descr = match1.group("port_descr").strip() if port_descr and "-- not advertised" not in port_descr: neighbor["remote_port_description"] = port_descr r += [{ "local_interface": local_interface, "neighbors": [neighbor] }] return r
def handle(self, input, addresses, jobs, community, oid, timeout, convert, version, *args, **options): self.addresses = set() # Direct addresses for a in addresses: if is_ipv4(a): self.addresses.add(a) # Read addresses from files if input: for fn in input: try: with open(fn) as f: for line in f: line = line.strip() if is_ipv4(line): self.addresses.add(line) except OSError as e: self.die("Cannot read file %s: %s\n" % (fn, e)) # @todo: Add community oid check if not community: community = [self.DEFAULT_COMMUNITY] # Ping self.ioloop = IOLoop.current() self.jobs = jobs self.convert = convert self.version = version self.queue = tornado.queues.Queue(self.jobs) for i in range(self.jobs): self.ioloop.spawn_callback(self.poll_worker, community, oid, timeout, version) self.ioloop.run_sync(self.poll_task)
def execute(self): r = [] try: v = self.cli("show lldp neighbors") # This is strange behavior, but it helps us v = self.blank_line.sub("", v) except self.CLISyntaxError: raise self.NotSupportedError() t = parse_table(v, allow_wrap=True, allow_extend=True) for i in t: chassis_id = i[1] if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 elif is_mac(chassis_id): chassis_id_subtype = 4 else: chassis_id_subtype = 7 port_id = i[2] if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 elif is_mac(port_id): port_id_subtype = 3 else: port_id_subtype = 7 caps = 0 for c in i[4].split(","): c = c.strip() if c: caps |= { "O": 1, "P": 2, "B": 4, "W": 8, "R": 16, "T": 32, "C": 64, "S": 128 }[c] neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps, } if i[3]: neighbor["remote_system_name"] = i[3] s = self.cli("show lldp neighbors ethernet %s" % i[0]) match = self.rx_sysdescr.search(s) if match: neighbor["remote_system_description"] = match.group( "descr").strip() match = self.rx_portdescr.search(s) if match: neighbor["remote_port_description"] = match.group( "descr").strip() r += [{"local_interface": i[0], "neighbors": [neighbor]}] return r
def execute_cli(self): r = [] t = parse_table(self.cli("show lldp neighbor"), allow_wrap=True) for i in t: c = self.cli("show lldp neighbor %s" % i[0]) match = self.rx_neighbor.search(c) chassis_id = match.group("chassis_id") if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_NETWORK_ADDRESS elif is_mac(chassis_id): chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_MAC else: chassis_id_subtype = LLDP_CHASSIS_SUBTYPE_LOCAL port_id = match.group("port_id") if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = LLDP_PORT_SUBTYPE_NETWORK_ADDRESS elif is_mac(port_id): port_id_subtype = LLDP_PORT_SUBTYPE_MAC else: port_id_subtype = LLDP_PORT_SUBTYPE_LOCAL neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, } if match.group("port_descr"): port_descr = match.group("port_descr").strip() if port_descr: neighbor["remote_port_description"] = port_descr if match.group("system_name"): system_name = match.group("system_name").strip() if system_name: neighbor["remote_system_name"] = system_name if match.group("system_descr"): system_descr = match.group("system_descr").strip() if system_descr: neighbor["remote_system_description"] = system_descr caps = 0 match = self.rx_caps.search(c) if match: caps = lldp_caps_to_bits( match.group("caps").strip().split(","), { "other": LLDP_CAP_OTHER, "repeater": LLDP_CAP_REPEATER, "bridge": LLDP_CAP_BRIDGE, "access point": LLDP_CAP_WLAN_ACCESS_POINT, "router": LLDP_CAP_ROUTER, "telephone": LLDP_CAP_TELEPHONE, "cable device": LLDP_CAP_DOCSIS_CABLE_DEVICE, "station only": LLDP_CAP_STATION_ONLY, }, ) neighbor["remote_capabilities"] = caps r += [{"local_interface": i[0], "neighbors": [neighbor]}] return r
def execute(self): r = [] t = parse_table(self.cli("show lldp neighbor"), allow_wrap=True) for i in t: c = self.cli("show lldp neighbor %s" % i[0]) match = self.rx_neighbor.search(c) chassis_id = match.group("chassis_id") if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 elif is_mac(chassis_id): chassis_id_subtype = 4 else: chassis_id_subtype = 7 port_id = match.group("port_id") if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 elif is_mac(port_id): port_id_subtype = 3 else: port_id_subtype = 7 caps = 0 if match.group("caps"): for c in match.group("caps").split(","): c = c.strip() if c: caps |= { "Other": 1, "Repeater": 2, "Bridge": 4, "Access Point": 8, "Router": 16, "Telephone": 32, "Cable Device": 64, "Station only": 128 }[c] neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps } if match.group("port_descr"): port_descr = match.group("port_descr").strip() if port_descr: neighbor["remote_port_description"] = port_descr if match.group("system_name"): system_name = match.group("system_name").strip() if system_name: neighbor["remote_system_name"] = system_name if match.group("system_descr"): system_descr = match.group("system_descr").strip() if system_descr: neighbor["remote_system_description"] = system_descr r += [{"local_interface": i[0], "neighbors": [neighbor]}] return r
def execute(self): r = [] data = [] try: v = self.cli("show lldp remote-device all") except self.CLISyntaxError: raise self.NotSupportedError() v = v.replace("\n\n", "\n") for l in parse_table(v, allow_extend=True): if not l[0]: data[-1] = [s[0] + s[1] for s in zip(data[-1], l)] continue data += [l] for d in data: chassis_id = d[2] if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 else: try: MACAddressParameter().clean(chassis_id) chassis_id_subtype = 4 except ValueError: chassis_id_subtype = 7 port_id = d[3] if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 else: try: MACAddressParameter().clean(port_id) port_id_subtype = 3 except ValueError: port_id_subtype = 7 # caps = sum([self.CAPS[s.strip()] for s in d[4].split(",")]) caps = 0 if not chassis_id: continue neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps, } """ if match.group("system_name"): neighbor["remote_system_name"] = match.group("system_name") """ neighbor["remote_system_name"] = d[4] r += [{ # "local_interface": match.group("port"), "local_interface": d[0], "neighbors": [neighbor], }] return r
def execute_cli(self): r = [] data = [] try: v = self.cli("show lldp neighbors") except self.CLISyntaxError: raise self.NotSupportedError() v = v.replace("\n\n", "\n") for l in parse_table(v): if not l[0]: data[-1] = [s[0] + s[1] for s in zip(data[-1], l)] continue data += [l] for d in data: try: ifname = self.profile.convert_interface_name(d[0]) except ValueError: continue v = self.cli("show lldp neighbors %s" % ifname) match = self.rx_neighbor.search(v) chassis_id = match.group("chassis_id").strip() if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 elif is_mac(chassis_id): chassis_id_subtype = 4 else: chassis_id_subtype = 7 port_id = match.group("port_id").strip() if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 elif is_mac(port_id): port_id_subtype = 3 else: port_id_subtype = 7 capabilities = match.group("caps") caps = sum([self.CAPS[s.strip()] for s in capabilities.split(",")]) neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps, } system_name = match.group("system_name").strip() if system_name: neighbor["remote_system_name"] = system_name system_descr = match.group("system_descr").strip() if system_descr: neighbor["remote_system_description"] = system_descr port_descr = match.group("port_descr").strip() if port_descr: neighbor["remote_port_description"] = port_descr r += [{"local_interface": ifname, "neighbors": [neighbor]}] return r
def execute(self): r = [] try: v = self.cli("show lldp neighbors") # This is strange behavior, but it helps us v = self.blank_line.sub("", v) except self.CLISyntaxError: raise self.NotSupportedError() t = parse_table(v, allow_wrap=True, allow_extend=True) for i in t: chassis_id = i[1] if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 else: try: MACAddressParameter().clean(chassis_id) chassis_id_subtype = 4 except ValueError: chassis_id_subtype = 7 port_id = i[2] if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 else: try: MACAddressParameter().clean(port_id) port_id_subtype = 3 except ValueError: port_id_subtype = 7 caps = 0 for c in i[4].split(","): c = c.strip() if c: caps |= { "O": 1, "P": 2, "B": 4, "W": 8, "R": 16, "T": 32, "C": 64, "S": 128 }[c] neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps } if i[3]: neighbor["remote_system_name"] = i[3] r += [{ "local_interface": i[0], "neighbors": [neighbor] }] return r
def execute(self): r = [] try: v = self.cli("show lldp info") except self.CLISyntaxError: raise self.NotSupportedError() for match in self.rx_line.finditer(v): chassis_id = match.group("chassis_id") if is_ipv4(chassis_id) or is_ipv6(chassis_id): chassis_id_subtype = 5 elif is_mac(chassis_id): chassis_id_subtype = 4 else: chassis_id_subtype = 7 port_id = match.group("port_id") if is_ipv4(port_id) or is_ipv6(port_id): port_id_subtype = 4 elif is_mac(port_id): port_id_subtype = 3 else: port_id_subtype = 7 caps = 0 # Need more examples if "Bridge" in match.group("caps"): caps += 4 if "Router" in match.group("caps"): caps += 16 neighbor = { "remote_chassis_id": chassis_id, "remote_chassis_id_subtype": chassis_id_subtype, "remote_port": port_id, "remote_port_subtype": port_id_subtype, "remote_capabilities": caps } if match.group("system_name"): neighbor["remote_system_name"] = \ match.group("system_name").strip() if match.group("system_description"): neighbor["remote_system_description"] = \ match.group("system_description").strip() if match.group("port_description"): neighbor["remote_port_description"] = \ match.group("port_description").strip() r += [{ "local_interface": match.group("port"), "neighbors": [neighbor] }] return r
def is_static(svc): if ":" not in svc: return False p = svc.split(":") if len(p) != 2: return False return is_ipv4(p[0]) and is_int(p[1])
def loop(): sf = SocketFactory() ps4 = Ping4Socket(sf) ps6 = Ping6Socket(sf) print "Running socket factory" t = threading.Thread(target=sf.run) t.setDaemon(True) t.start() print "READY" while True: try: ip = raw_input("IP> ") except EOFError: print "%% STOP" sys.exit(0) ip = ip.strip() if not ip: continue if "*" in ip: ip, count = ip.split("*") ip = ip.strip() try: count = int(count.strip()) except ValueError: print "%% ERROR: Invald count" else: count = 1 if not is_ipv4(ip) and not is_ipv6(ip): print "%% ERROR: Invalid IP address" continue sock = ps6 if ":" in ip else ps4 for i in range(count): sock.ping(ip, count=3, callback=cb)
def get_zone(cls, name): """ Resolve name to zone object :return: """ def get_closest(n): """ Return closest matching zone """ while n: try: return DNSZone.objects.get(name=n) except DNSZone.DoesNotExist: pass n = ".".join(n.split(".")[1:]) return None if not name: return None if is_ipv4(name): # IPv4 zone n = name.split(".") n.reverse() return get_closest("%s.in-addr.arpa" % (".".join(n[1:]))) elif is_ipv6(name): # IPv6 zone d = IPv6(name).digits d.reverse() c = ".".join(d) return (get_closest("%s.ip6.arpa" % c) or get_closest("%s.ip6.int" % c)) else: return get_closest(name)
def execute(self, address, count=None, source_address=None, size=None, df=None, vrf=None): cmd = "ping" if is_ipv4(address): cmd += " ip" else: cmd += " ipv6" if vrf: cmd += " vrf %s" % vrf cmd += " %s" % address if count: cmd += " %d" % int(count) if source_address: cmd += " source address %s" % source_address if size: cmd += " data-size %d" % int(size) match = self.rx_result.search(self.cli(cmd)) if match: return { "success": match.group("success"), "count": match.group("count"), "min": match.group("min"), "avg": match.group("avg"), "max": match.group("max") } else: match = self.rx_result1.search(s) return { "success": match.group("success"), "count": match.group("count") }
def on_syslog_server(self, tokens): """ logging <server> """ h = tokens[1] if is_ipv4(h) or is_ipv6(h): self.get_sysloghost_fact(h)
def get_ns_name(cls, ns): """Add missed '.' to the end of NS name, if given as FQDN""" name = ns.name.strip() if not is_ipv4(name) and not name.endswith("."): return name + "." else: return name
def get_avail_metrics(self, metrics): if not self.credentials["path"]: return check_id = 999 check_rtt = 998 for m in metrics: if m.metric == "Check | Result": check_id = m.id if m.metric == "Check | RTT": check_rtt = m.id for ip in self.credentials["path"].split(","): if is_ipv4(ip.strip()): result = self.scripts.ping(address=ip) self.set_metric( id=check_id, metric="Check | Result", path=("ping", ip), value=bool(result["success"]), multi=True, ) if result["success"] and check_rtt != 998: self.set_metric( id=check_rtt, metric="Check | RTT", path=("ping", ip), value=bool(result["success"]), )
def execute(self, address, count=None, source_address=None, size=None, df=None, vrf=None): if is_ipv4(address): cmd = "ping ip %s" % address elif is_ipv6(address): cmd = "ping ipv6 %s" % address if count: cmd += " count %d" % int(count) if size: cmd += " size %d" % int(size) s = self.cli(cmd) match = self.rx_result1.search(s) if match: return { "success": match.group("success"), "count": match.group("count"), "min": match.group("min"), "avg": match.group("avg"), "max": match.group("max") } else: match = self.rx_result2.search(s) return { "success": match.group("success"), "count": match.group("count") }
def get_neighbor(self, n): nn = self.get_neighbor_by_hostname(n) if nn: return nn if is_ipv4(n): return self.get_neighbor_by_ip(n) elif is_mac(n): return self.get_neighbor_by_mac(n) else: return None
def interpolate_ipv4(s): p = s.split(".") if len(p) > 4: return None elif len(p) < 4: p += ["0"] * (4 - len(p)) s = ".".join(p) if not is_ipv4(s): return None return s
def execute(self, address, count=None, source_address=None, size=None): if is_ipv4(address): cmd = "ping ip %s" % address elif is_ipv6(address): cmd = "ping ipv6 %s" % address if count: cmd += " repeat %d" % int(count) if size: cmd += " size %d" % int(size) s = self.cli(cmd) match = self.rx_result.search(s) return match.groupdict()
def execute(self, address, count=None, source_address=None, size=None): if is_ipv4(address): cmd = "ping ip %s" % address elif is_ipv6(address): cmd = "ping ipv6 %s" % address if count: cmd += " count %d" % int(count) if size: cmd += " size %d" % int(size) try: s = self.cli(cmd) except self.CLISyntaxError: if is_ipv4(address): cmd = "ping" elif is_ipv6(address): cmd = "ping6 %s" if count: cmd += " -n %d" % int(count) if size: cmd += " -l %d" % int(size) cmd = "%s %s" % (cmd, address) s = self.cli(cmd) match = self.rx_result1.search(s) if match: return { "success": match.group("success"), "count": match.group("count"), "min": match.group("min"), "avg": match.group("avg"), "max": match.group("max") } else: match = self.rx_result2.search(s) return { "success": match.group("success"), "count": match.group("count") }
def clean(self, data): data = super(AddressRangeApplication, self).clean(data) afi = data["afi"] from_address = data["from_address"] to_address = data["to_address"] # Check AFI address_validator = is_ipv4 if afi == "4" else is_ipv6 if not address_validator(from_address): raise ValueError("Invalid IPv%(afi)s 'From Address'" % {"afi": afi}) if not address_validator(to_address): raise ValueError("Invalid IPv%(afi)s 'To Address'" % {"afi": afi}) # Check from address not greater than to address if IP.prefix(from_address) > IP.prefix(to_address): raise ValueError( "'To Address' must be greater or equal than 'From Address'") # Check for valid "action" combination if "fqdn_template" in data and data[ "fqdn_template"] and data["action"] != "G": raise ValueError( "'FQDN Template' must be clean for selected 'Action'") if "reverse_nses" in data and data[ "reverse_nses"] and data["action"] != "D": raise ValueError( "'Reverse NSes' must be clean for selected 'Action'") # Set range as locked for "G" and "D" actions if data["action"] != "N": data["is_locked"] = True # @todo: check FQDN template # Check reverse_nses is a list of FQDNs or IPs if "reverse_nses" in data and data["reverse_nses"]: reverse_nses = data["reverse_nses"] for ns in reverse_nses.split(","): ns = ns.strip() if not is_ipv4(ns) and not is_ipv6(ns) and not is_fqdn(ns): raise ValueError("%s is invalid nameserver" % ns) # Check no locked range overlaps another locked range if data["is_locked"]: r = [ r for r in AddressRange.get_overlapping_ranges( data["vrf"], data["afi"], data["from_address"], data["to_address"]) if r.is_locked is True and r.name != data["name"] ] if r: raise ValueError( "Locked range overlaps with ahother locked range: %s" % unicode(r[0])) return data
def parse_iproute(self, tokens): """ create iproute default 10.254.10.129 1 create iproute 10.0.0.0/255.252.0.0 null0 create iproute 10.125.0.0/255.255.255.0 10.125.0.1 1 primary """ if tokens[2] == "default": prefix = "0.0.0.0/0" else: net, mask = tokens[2].split("/") prefix = str(IPv4(net, netmask=mask)) f = self.get_static_route_fact(prefix) if is_ipv4(tokens[3]): f.next_hop = tokens[3] else: f.interface = tokens[3]
def resolve_addresses(self, addr_list, default_port): """ Parses string and returns a list of (ip,port) :param addr_list: Comma-separared list of addresses in form: * ip * ip:port * interface * interface:port :param default_port: :return: """ r = [] for x in addr_list.split(","): x = x.strip() if not x: continue if ":" in x: # Implicit port notation x, port = x.split(":", 1) if is_int(port): port = int(port) else: import socket try: port = socket.getservbyname(port) except socket.error: raise Exception("Invalid port: %s" % port) else: port = int(default_port) if port <= 0 or port > 65535: raise Exception("Invalid port: %s" % port) if is_ipv4(x): r += [(x, port)] continue if USE_NETIFACES: # Can resolve interface names try: a = netifaces.ifaddresses(x) except ValueError: raise Exception("Invalid interface '%s'" % x) try: x = a[2][0]["addr"] except (IndexError, KeyError): raise Exception("No ip address for interface: '%s' found" % x) r += [(x, port)] continue raise Exception("Cannot resolve address '%s'" % x) return r
def on_ipv4_route(self, tokens): """ ip route-static 0.0.0.0 0.0.0.0 172.20.66.30 preference 30 @todo ip route-static 10.10.10.0 255.255.254.0 Vlanif7 10.10.100.1 ip route-static vpn-instance vpn1 1.1.1.1 255.255.255.255 10.10.10.10 """ if tokens[2] == "vpn-instance": p = IPv4(tokens[4], netmask=tokens[5]) nh = tokens[6] else: p = IPv4(tokens[2], netmask=tokens[3]) nh = tokens[4] sf = self.get_static_route_fact(str(p)) # rest = tokens[3].split() # nh = rest.pop(0) if is_ipv4(nh): sf.next_hop = nh
def resolve_address(self, s): """ Resolve interface names to IP addresses :param s: Interface name or IPv4 address :return: """ if is_ipv4(s): return s if USE_NETIFACES: try: a = netifaces.ifaddresses(s) except ValueError: raise Exception("Invalid interface '%s'" % s) try: return a[2][0]["addr"] except (IndexError, KeyError): raise Exception("No ip address for interface: '%s' found" % s) raise Exception("Cannot resolve address '%s'" % s)
def resolve_expression(cls, s): """ Resolve expression to a list of object. Expression must be string or list. Elements must be one of: * string starting with @ - treated as selector name * string containing numbers - treated as object's id * string - managed object name. * string - IPv4 or IPv6 address - management address Raises ManagedObject.DoesNotExists if object is not found. Raises ManagedObjectSelector.DoesNotExists if selector is not found :param cls: :param s: :return: """ from .managedobject import ManagedObject if type(s) in (int, long, str, unicode): s = [s] if type(s) != list: raise ValueError("list required") objects = set() for so in s: if not isinstance(so, six.string_types): so = str(so) if so.startswith("@"): # Selector expression: @<selector name> o = ManagedObjectSelector.objects.get(name=so[1:]) objects |= set(o.managed_objects) else: # Search by name q = Q(name=so) if is_int(so): # Search by id q |= Q(id=int(so)) if is_ipv4(so) or is_ipv6(so): q |= Q(address=so) o = ManagedObject.objects.get(q) objects.add(o) return list(objects)
def get_neighbor_by_local(self, local): """ Try to find neighbor using arbitrary data """ # Check IPv4 if is_ipv4(local): n = self.get_neighbor_by_ip(local) if n: return n else: # Check MAC try: mac = MACAddressParameter().clean(local) n = self.get_neighbor_by_mac(mac) if n: return n except InterfaceTypeError: pass # Fallback to hostname return self.get_neighbor_by_hostname(local)
def on_ipv4_route(self, tokens): p = IPv4(tokens[0], netmask=tokens[1]) sf = self.get_static_route_fact(str(p)) rest = tokens[2].split() nh = rest.pop(0) if is_ipv4(nh): sf.next_hop = nh else: iface = self.convert_interface_name(nh) if iface.startswith("Nu"): sf.discard = True else: sf.interface = iface if rest and is_int(rest[0]): sf.distance = rest.pop(0) while rest: if rest[0] == "name": sf.description = rest[1] rest = rest[2:] elif rest[0] == "tag": sf.tag = rest[1] rest = rest[2:] else: break