def get_available_peers(self): # Not linked to PeeringDB, cannot determine peers if not self.peeringdb_id: return None # Get the IX LAN we are belonging to api = PeeringDB() network_ixlan = api.get_ix_network(self.peeringdb_id) # Get all peering sessions currently existing existing_sessions = self.get_peering_sessions() ipv4_sessions = [] ipv6_sessions = [] for session in existing_sessions: ip = ipaddress.ip_address(session.ip_address) if ip.version == 6: ipv6_sessions.append(str(ip)) elif ip.version == 4: ipv4_sessions.append(str(ip)) else: self.logger.debug('peering session with strange ip: %s', ip) # Find all peers belonging to the same IX and order them by ASN # Exclude our own ASN and already existing sessions return PeerRecord.objects.all().filter( Q(network_ixlan__ix_id=network_ixlan.ixlan_id) & ~Q(network__asn=settings.MY_ASN) & (~Q(network_ixlan__ipaddr6__in=ipv6_sessions) | ~Q(network_ixlan__ipaddr4__in=ipv4_sessions))).order_by( 'network__asn')
def get_available_peers(self): peers = [] # Not linked to PeeringDB, cannot determine peers if not self.peeringdb_id: return peers # Get the LAN that we are attached to and retrieve the peers api = PeeringDB() lan = api.get_ix_network(self.peeringdb_id) peeringdb_peers = api.get_peers_for_ix(lan.ix_id) known_peerings = [] # Grab all addresses we are connected to for session in self.peeringsession_set.all(): known_peerings.append(ipaddress.ip_address(session.ip_address)) # Check if peers addresses are in the list of addresses we are already # connected to. for peeringdb_peer in peeringdb_peers: peeringdb_peer['has_ipv6'] = True if peeringdb_peer[ 'network_ixlan'].ipaddr6 else None peeringdb_peer['has_ipv4'] = True if peeringdb_peer[ 'network_ixlan'].ipaddr4 else None peeringdb_peer['peering6'] = peeringdb_peer[ 'has_ipv6'] and ipaddress.ip_address( peeringdb_peer['network_ixlan'].ipaddr6) in known_peerings peeringdb_peer['peering4'] = peeringdb_peer[ 'has_ipv4'] and ipaddress.ip_address( peeringdb_peer['network_ixlan'].ipaddr4) in known_peerings peeringdb_peer['internet_exchange'] = self peers.append(peeringdb_peer) return peers
def handle(self, *args, **options): self.logger.info("Syncing networks with PeeringDB...") api = PeeringDB() api.update_local_database(api.get_last_sync_time()) self.logger.info("Syncing AS details with PeeringDB...") autonomous_systems = AutonomousSystem.objects.all() for autonomous_system in autonomous_systems: autonomous_system.synchronize_with_peeringdb()
def get_common_internet_exchanges(self): internet_exchanges = {} # Get common IX networks between us and this AS common = PeeringDB().get_common_ix_networks_for_asns(settings.MY_ASN, self.asn) for us, peer in common: ix = None if us.ixlan_id not in internet_exchanges: try: ix = InternetExchange.objects.get(peeringdb_id=us.id) except InternetExchange.DoesNotExist: # If we don't know this IX locally but we do in PeeringDB # Ignore it continue internet_exchanges[us.ixlan_id] = { 'internet_exchange': ix, 'missing_peering_sessions': [] } # Keep record of missing peering sessions if (peer.ipaddr6 and not PeeringSession.does_exist( internet_exchange=ix, autonomous_system=self, ip_address=peer.ipaddr6)): internet_exchanges[us.ixlan_id]['missing_peering_sessions'].append( peer.ipaddr6) if (peer.ipaddr4 and not PeeringSession.does_exist( internet_exchange=ix, autonomous_system=self, ip_address=peer.ipaddr4)): internet_exchanges[us.ixlan_id]['missing_peering_sessions'].append( peer.ipaddr4) return internet_exchanges
def sync_with_peeringdb(self): """ Synchronize AS properties with those found in PeeringDB. """ peeringdb_info = PeeringDB().get_autonomous_system(self.asn) # No record found, nothing to sync if not peeringdb_info: return False # Always synchronize the name self.name = peeringdb_info.name # Sync other properties if we are told to do so if self.irr_as_set_peeringdb_sync: self.irr_as_set = peeringdb_info.irr_as_set if self.ipv6_max_prefixes_peeringdb_sync: self.ipv6_max_prefixes = peeringdb_info.info_prefixes6 if self.ipv4_max_prefixes_peeringdb_sync: self.ipv4_max_prefixes = peeringdb_info.info_prefixes4 # Save the new AS self.save() return True
def get_common_internet_exchanges(self): """ Return all IX we have in common with the AS. """ # Get common IX networks between us and this AS common = PeeringDB().get_common_ix_networks_for_asns(settings.MY_ASN, self.asn) return InternetExchange.objects.all().filter( peeringdb_id__in=[us.id for us, _ in common])
def get_peeringdb_id(self): """ Retrieves the PeeringDB ID for this IX based on the IP addresses that have been recorded. The ID of the PeeringDB record will be returned on success. In any other cases 0 will be returned. """ network_ixlan = PeeringDB().get_ix_network_by_ip_address( ipv6_address=self.ipv6_address, ipv4_address=self.ipv4_address) return network_ixlan.id if network_ixlan else 0
def get_objects(self): objects = [] known_objects = [] api = PeeringDB() for ix in InternetExchange.objects.all(): if ix.peeringdb_id: known_objects.append(ix.peeringdb_id) ix_networks = api.get_ix_networks_for_asn(settings.MY_ASN) or [] for ix_network in ix_networks: if ix_network.id not in known_objects: objects.append({ 'peeringdb_id': ix_network.id, 'name': ix_network.name, 'slug': slugify(ix_network.name), 'ipv6_address': ix_network.ipaddr6, 'ipv4_address': ix_network.ipaddr4, }) return objects
def sync_with_peeringdb(self): peeringdb_info = PeeringDB().get_autonomous_system(self.asn) if not peeringdb_info: return False self.name = peeringdb_info.name self.ipv6_max_prefixes = peeringdb_info.info_prefixes6 self.ipv4_max_prefixes = peeringdb_info.info_prefixes4 self.save() return True
def is_peeringdb_valid(self): """ Tells if the PeeringDB ID for this IX is still valid. This function will return true if the PeeringDB record for this IX is valid or if this IX does not have a Peering DB ID set. In any other cases, the return value will be false. """ if self.peeringdb_id: peeringdb_record = PeeringDB().get_ix_network(self.peeringdb_id) if not peeringdb_record: return False return True
def get_missing_peering_sessions(self, internet_exchange): """ Returns a tuple of IP address lists. The first element of the tuple is the IPv6 address list. The second element of the tuple is the IPv4 address list. Each IP address of the lists is the address of a missing peering session with the current AS. """ if not internet_exchange: return None # Get common IX networks between us and this AS common = PeeringDB().get_common_ix_networks_for_asns( settings.MY_ASN, self.asn) # Divide sessions based on the IP versions ipv6_sessions = [] ipv4_sessions = [] # For each common networks take a look at it for us, peer in common: # We only care about networks matching the IX we want if us.id == internet_exchange.peeringdb_id: # Check on the IPv6 address if peer.ipaddr6: try: ip_address = ipaddress.IPv6Address(peer.ipaddr6) if not InternetExchangePeeringSession.does_exist( internet_exchange=internet_exchange, autonomous_system=self, ip_address=str(ip_address), ): ipv6_sessions.append(ip_address) except ipaddress.AddressValueError: continue # Check on the IPv4 address if peer.ipaddr4: try: ip_address = ipaddress.IPv4Address(peer.ipaddr4) if not InternetExchangePeeringSession.does_exist( internet_exchange=internet_exchange, autonomous_system=self, ip_address=str(ip_address), ): ipv4_sessions.append(ip_address) except ipaddress.AddressValueError: continue return (ipv6_sessions, ipv4_sessions)
def find_potential_ix_peering_sessions(self): """ Saves an IP address list. Each IP address of the list is the address of a potential peering session with the current AS on an Internet Exchange. """ # Get common IX networks between us and this AS common = PeeringDB().get_common_ix_networks_for_asns(settings.MY_ASN, self.asn) # For each common networks take a look at it for us, peer in common: peering_sessions = [] if peer.ipaddr6: try: peering_sessions.append(str(ipaddress.IPv6Address(peer.ipaddr6))) except ipaddress.AddressValueError: continue if peer.ipaddr4: try: peering_sessions.append(str(ipaddress.IPv4Address(peer.ipaddr4))) except ipaddress.AddressValueError: continue # Get all known sessions for this AS on the given IX known_sessions = InternetExchangePeeringSession.objects.filter( autonomous_system=self, ip_address__in=peering_sessions ) # Check if peer IP addresses are known sessions for peering_session in peering_sessions: # Consider the IP as not known at first known = False for known_session in known_sessions: if peering_session == known_session.ip_address: # If the IP is found, stop looking for the info and mark # it as known known = True break # If the IP address is used in any peering sessions append it, # keep an eye on it if not known: self.potential_internet_exchange_peering_sessions.append( peering_session ) self.save()
def create_from_peeringdb(asn): peeringdb_network = PeeringDB().get_autonomous_system(asn) if not peeringdb_network: return None try: return AutonomousSystem.objects.get(asn=peeringdb_network.asn) except AutonomousSystem.DoesNotExist: values = { 'asn': peeringdb_network.asn, 'name': peeringdb_network.name, 'irr_as_set': peeringdb_network.irr_as_set, 'ipv6_max_prefixes': peeringdb_network.info_prefixes6, 'ipv4_max_prefixes': peeringdb_network.info_prefixes4, } autonomous_system = AutonomousSystem(**values) autonomous_system.save() return autonomous_system
def handle(self, *args, **options): self.logger.info("Syncing networks with PeeringDB...") api = PeeringDB() api.update_local_database(api.get_last_sync_time())
def get_prefixes(self): """ Returns a list of prefixes found in PeeringDB for this IX. """ return PeeringDB().get_prefixes_for_ix_network(self.peeringdb_id)
def handle(self, *args, **options): self.logger.info("Indexing peer records...") api = PeeringDB() api.force_peer_records_discovery()
def get_prefixes(self): return PeeringDB().get_prefixes_for_ix_network(self.peeringdb_id) or []
def get_prefixes(self): return [] if not self.peeringdb_id else PeeringDB( ).get_prefixes_for_ix_network(self.peeringdb_id)