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)
