class BGPListener(object): def __init__(self): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin in client.py, # which is routed to server.py via port 6000, # which is routed to here via receiver_queue. try: route = self.server.receiver_queue.get(True, 1) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = (waiting + 1) % 30 continue waiting = 0 route = json.loads(route) logger.debug("Got route from ExaBGP: %s", route) # Received BGP route advertisement from ExaBGP try: advertise_ip = route['neighbor']['ip'] except KeyError: continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send(route) def send(self, announcement): self.server.sender_queue.put(announcement) def stop(self): logger.info("Stopping BGPListener.") self.run = False
def __init__(self, config_file): logger.info("Initializing the Route Server.") # Init the Route Server self.server = None self.ah_socket = None self.participants = {} # Several useful mappings self.port_2_participant = {} self.participant_2_port = {} self.portip_2_participant = {} self.participant_2_portip = {} self.portmac_2_participant = {} self.participant_2_portmac = {} self.asn_2_participant = {} self.participant_2_asn = {} ## Parse Config self.parse_config(config_file) # Initialize a XRS Server self.server = Server(logger) self.run = True """ Start the announcement Listener which will receive announcements from participants's controller and put them in XRS's sender queue. """ self.set_announcement_handler()
def __init__(self, as_num): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True self.route_id = 0 self.start_time = 0 self.end_time = 0 self.as_num = int(as_num) self.stop_counts = 0
def __init__(self,event_queue,ready_queue,sdx): self.event_queue = event_queue self.ready_queue = ready_queue self.server = Server() self.sdx = sdx self.sdx.server = self.server participants_ports_list = get_participants_ports_list(sdx.participants) ''' Create and assign participant RIBs ''' for participant_name in sdx.participants: self.sdx.participants[participant_name].rs_client = Peer(participants_ports_list[participant_name])
def __init__(self, event_queue, ready_queue, sdx): self.event_queue = event_queue self.ready_queue = ready_queue self.server = Server() self.sdx = sdx self.sdx.server = self.server participants_ports_list = get_participants_ports_list(sdx.participants) ''' Create and assign participant RIBs ''' for participant_name in sdx.participants: self.sdx.participants[participant_name].rs_client = Peer( participants_ports_list[participant_name])
def __init__(self, swift_config): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True #Get Bpa parameters from sdg_global config file self.win_size = swift_config["win_size"] self.nb_withdrawals_burst_start = swift_config[ "nb_withdrawals_burst_start"] self.nb_withdrawals_burst_end = swift_config[ "nb_withdrawals_burst_end"] self.min_bpa_burst_size = swift_config["min_bpa_burst_size"] self.fm_freq = swift_config["fm_freq"] self.p_w = swift_config["p_w"] self.r_w = swift_config["r_w"] self.bpa_algo = swift_config["Bpa Algorithm"] self.max_depth = swift_config["max_depth"] self.nb_bits_aspath = swift_config["nb_bits_aspath"] self.run_encoding_threshold = swift_config["run_encoding_threshold"] self.silent = swift_config["silent"]
class route_server(): def __init__(self,event_queue,ready_queue,sdx): self.event_queue = event_queue self.ready_queue = ready_queue self.server = Server() self.sdx = sdx self.sdx.server = self.server participants_ports_list = get_participants_ports_list(sdx.participants) ''' Create and assign participant RIBs ''' for participant_name in sdx.participants: self.sdx.participants[participant_name].rs_client = Peer(participants_ports_list[participant_name]) def start(self): self.server.start() while True: route = self.server.receiver_queue.get() route = json.loads(route) # TODO: check the RIB update flow with others ... # At the moment, I am updating the RIB and will attach next-hop to the announcement at the end updates = [] route_list = None # Update RIBs for participant_name in self.sdx.participants: route_list = self.sdx.participants[participant_name].rs_client.update(route) if route_list: break # Best Path Selection algorithm for route_item in route_list: updates.extend(decision_process(self.sdx.participants,route_item)) # Check for withdraw routes for route in route_list: if (route is None): continue elif 'withdraw' in route: for VNH in self.sdx.VNH_2_pfx: if(route['withdraw']['prefix'] in list(self.sdx.VNH_2_pfx[VNH])): self.server.sender_queue.put(withdraw_route(route['withdraw'],self.sdx.VNH_2_IP[VNH])) break # Trigger policy updates bgp_trigger_update(self.event_queue,self.ready_queue) # Check for announced routes #if (route_list): # TODO: need to correct this glue logic if hasattr(self.sdx, 'VNH_2_pfx'): for VNH in self.sdx.VNH_2_pfx: for prefix in list(self.sdx.VNH_2_pfx[VNH]): for paticipant_name in self.sdx.participants: route = self.sdx.participants[paticipant_name].rs_client.get_route('local',prefix) if route: self.server.sender_queue.put(announce_route(route,self.sdx.VNH_2_IP[VNH])) break
class route_server(object): def __init__(self, config_file): logger.info("Initializing the Route Server.") # Init the Route Server self.server = None self.ah_socket = None self.participants = {} # Several useful mappings self.port_2_participant = {} self.participant_2_port = {} self.portip_2_participant = {} self.participant_2_portip = {} self.portmac_2_participant = {} self.participant_2_portmac = {} self.asn_2_participant = {} self.participant_2_asn = {} ## Parse Config self.parse_config(config_file) # Initialize a XRS Server self.server = Server(logger) self.run = True """ Start the announcement Listener which will receive announcements from participants's controller and put them in XRS's sender queue. """ self.set_announcement_handler() def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin try: route = self.server.receiver_queue.get(True, 1) route = json.loads(route) waiting = 0 logger.debug("Got route from ExaBGP. " + str(route) + ' ' + str(type(route))) # Received BGP route advertisement from ExaBGP for id, peer in self.participants.iteritems(): # Apply the filtering logic advertiser_ip = route['neighbor']['ip'] if advertiser_ip in self.portip_2_participant: advertise_id = self.portip_2_participant[advertiser_ip] if id in self.participants[ advertise_id].peers_out and advertise_id in self.participants[ id].peers_in: # Now send this route to participant `id`'s controller' self.send_update(id, route) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = 1 else: waiting = (waiting % 30) + 1 if waiting == 30: logger.debug("Waiting for BGP update...") def parse_config(self, config_file): # loading config file logger.debug("Begin parsing config...") config = json.load(open(config_file, 'r')) self.ah_socket = tuple(config["Route Server"]["AH_SOCKET"]) for participant_name in config["Participants"]: participant = config["Participants"][participant_name] iname = int(participant_name) # adding asn and mappings asn = participant["ASN"] self.asn_2_participant[participant["ASN"]] = iname self.participant_2_asn[iname] = participant["ASN"] self.participant_2_port[iname] = [] self.participant_2_portip[iname] = [] self.participant_2_portmac[iname] = [] for port in participant["Ports"]: self.port_2_participant[port['Id']] = iname self.portip_2_participant[port['IP']] = iname self.portmac_2_participant[port['MAC']] = iname self.participant_2_port[iname].append(port['Id']) self.participant_2_portip[iname].append(port['IP']) self.participant_2_portmac[iname].append(port['MAC']) # adding ports and mappings ports = [{ "ID": port['Id'], "MAC": port['MAC'], "IP": port['IP'] } for port in participant["Ports"]] peers_out = [peer for peer in participant["Peers"]] # TODO: Make sure this is not an insane assumption peers_in = peers_out addr, port = participant["EH_SOCKET"] eh_socket = (str(addr), int(port)) # create peer and add it to the route server environment self.participants[iname] = XRSPeer(asn, ports, peers_in, peers_out, eh_socket) logger.debug("Done parsing config") def set_announcement_handler(self): '''Start the listener socket for BGP Announcements''' logger.info("Starting the announcement handler...") self.listener_eh = Listener(self.ah_socket, authkey=None) ps_thread = Thread(target=self.start_ah) ps_thread.daemon = True ps_thread.start() def start_ah(self): '''Announcement Handler ''' logger.info("Announcement Handler started.") while True: conn_ah = self.listener_eh.accept() tmp = conn_ah.recv() logger.debug("Received an announcement.") announcement = json.loads(tmp) self.server.sender_queue.put(announcement) reply = "Announcement processed" conn_ah.send(reply) conn_ah.close() def send_update(self, id, route): # TODO: Explore what is better, persistent client sockets or # new socket for each BGP update "Send this BGP route to participant id's controller" logger.debug("Sending a route update to participant " + str(id)) conn = Client(tuple(self.participants[id].eh_socket), authkey=None) conn.send(json.dumps({'bgp': route})) conn.recv() conn.close() def stop(self): logger.info("Stopping.") self.run = False
def __init__(self): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True
class BGPListener(object): def __init__(self): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin in client.py, # which is routed to server.py via port 6000, # which is routed to here via receiver_queue. try: route = self.server.receiver_queue.get(True, 1) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = (waiting+1) % 30 continue waiting = 0 route = json.loads(route) logger.debug("Got route from ExaBGP: %s", route) # Received BGP route advertisement from ExaBGP try: advertise_ip = route['neighbor']['ip'] except KeyError as e: logger.debug("KEY ERROR " + str(e.msg)) continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: logger.debug(str(participants)) continue logger.debug("PARTICIPANTS_SIZE " + str(len(participants))) for id, peer in participants.iteritems(): logger.debug("ADVDEBUG advertising %s to neighbor" % str(route)) # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' logger.debug("SENDROUTETOPEER " + str(route)) logger.info("PEERISOFTYPE: " + str(peer)) peer.send(route) def send(self, announcement): logger.info("CRITICALQUEUEDEBUG " + str(self.server.sender_queue.qsize())) self.server.sender_queue.put(announcement) def stop(self): logger.info("Stopping BGPListener.") self.run = False
class BGPListener(object): def __init__(self, swift_config): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True #Get Bpa parameters from sdg_global config file self.win_size = swift_config["win_size"] self.nb_withdrawals_burst_start = swift_config[ "nb_withdrawals_burst_start"] self.nb_withdrawals_burst_end = swift_config[ "nb_withdrawals_burst_end"] self.min_bpa_burst_size = swift_config["min_bpa_burst_size"] self.fm_freq = swift_config["fm_freq"] self.p_w = swift_config["p_w"] self.r_w = swift_config["r_w"] self.bpa_algo = swift_config["Bpa Algorithm"] self.max_depth = swift_config["max_depth"] self.nb_bits_aspath = swift_config["nb_bits_aspath"] self.run_encoding_threshold = swift_config["run_encoding_threshold"] self.silent = swift_config["silent"] def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() self.peer_swift_dict = {} self.peer_queue_dict = {} self.peer_queue = Queue.Queue() self.FR_queue = Queue.Queue() self.waiting = 0 route_server_listener_thread = Thread( target=self.Route_server_listener) route_server_sender_thread = Thread(target=self.Route_server_sender) route_server_sender_thread.start() route_server_listener_thread.start() def send(self, announcement): self.server.sender_queue.put(announcement) def stop(self): logger.info("Stopping BGPListener.") self.run = False def Route_server_listener(self): while self.run: try: route = self.server.receiver_queue.get(True, 1) except Queue.Empty: if self.waiting == 0: logger.debug("Waiting for BGP update...") self.waiting = (self.waiting + 1) % 30 continue self.waiting = 0 route = json.loads(route) logger.info("Got route from ExaBGP: %s", route) logger.debug("Got route from ExaBGP: %s", route) # Received BGP route advertisement from ExaBGP try: advertise_ip = route['neighbor']['ip'] except KeyError: print "KEYERROR", route logger.debug("KEYERROR" + str(route)) continue with participantsLock: try: advertise_id = portip2participant[advertise_ip] except KeyError: continue route_list = self.route_2_bgp_updates(route) if len(route_list) == 1: if 'down' in route_list[0]: logger.debug("down route received" + str(route_list[0])) self.peer_queue.put(route_list[0]) continue #@TODO: when no more links to participant are active stop its siwft process if advertise_id not in self.peer_queue_dict: print "launching swift for peer_id:", advertise_id self.peer_queue_dict[advertise_id] = Queue.Queue() with participantsLock: self.peer_swift_dict[advertise_id] = Thread(target=run_peer, \ args=(logger, self.peer_queue_dict[advertise_id], self.peer_queue, self.FR_queue, self.win_size,advertise_id, self.nb_withdrawals_burst_start, \ self.nb_withdrawals_burst_end, self.min_bpa_burst_size, "bursts", self.max_depth, self.fm_freq, self.p_w, \ self.r_w, self.bpa_algo, self.nb_bits_aspath, self.run_encoding_threshold, \ self.silent)) self.peer_swift_dict[advertise_id].start() for route in route_list: self.peer_queue_dict[advertise_id].put(route) for thread in self.peer_swift_dict.items(): thread.stop() def Route_server_sender(self): while self.run: route = None try: route = self.FR_queue.get(False) except Queue.Empty: pass if route is None: try: route = self.peer_queue.get(False) except Queue.Empty: continue if 'FR' in route: peer_id = route['FR']['peer_id'] found = [] with participantsLock: try: peers_out = participants[peer_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and peer_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send_FR(route) elif 'down' in route: try: advertise_ip = route['down'] except KeyError: print "KEYERROR", route logger.debug("KEYERROR" + str(route)) continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send_FR(route) else: if 'announce' in route: try: advertise_ip = route['announce'].neighbor except KeyError: print "KEYERROR", route logger.debug("KEYERROR" + str(route)) continue if 'withdraw' in route: try: advertise_ip = route['withdraw'].neighbor except KeyError: print "KEYERROR", route logger.debug("KEYERROR" + str(route)) continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send(route) def route_2_bgp_updates(self, route): origin = None as_path = None as_path_vmac = None med = None atomic_aggregate = None communities = None route_list = [] if 'state' in route['neighbor'] and route['neighbor'][ 'state'] == 'down': print "state down update received from:", route['neighbor']['ip'] down_ip = route['neighbor']['ip'] route_list.append({'down': down_ip}) return route_list # Extract out neighbor information in the given BGP update neighbor = route["neighbor"]["ip"] if 'message' in route['neighbor']: if 'update' in route['neighbor']['message']: time = route['time'] if 'attribute' in route['neighbor']['message']['update']: attribute = route['neighbor']['message']['update'][ 'attribute'] origin = attribute[ 'origin'] if 'origin' in attribute else '' as_path = attribute[ 'as-path'] if 'as-path' in attribute else [] as_path_vmac = attribute[ 'as_path_vmac'] if 'as_path_vmac' in attribute else None med = attribute['med'] if 'med' in attribute else '' community = attribute[ 'community'] if 'community' in attribute else '' communities = '' for c in community: communities += ':'.join(map(str, c)) + " " atomic_aggregate = attribute[ 'atomic-aggregate'] if 'atomic-aggregate' in attribute else '' if 'announce' in route['neighbor']['message']['update']: announce = route['neighbor']['message']['update'][ 'announce'] if 'ipv4 unicast' in announce: for next_hop in announce['ipv4 unicast'].keys(): for prefix in announce['ipv4 unicast'][ next_hop].keys(): announced_route = BGPRoute( prefix, neighbor, next_hop, origin, as_path, as_path_vmac, communities, med, atomic_aggregate) route_list.append({ 'announce': announced_route, 'time': time }) elif 'withdraw' in route['neighbor']['message']['update']: withdraw = route['neighbor']['message']['update'][ 'withdraw'] if 'ipv4 unicast' in withdraw: next_hop = None for prefix in withdraw['ipv4 unicast'].keys(): withdrawn_route = BGPRoute( prefix, neighbor, next_hop, origin, as_path, as_path_vmac, communities, med, atomic_aggregate, ) route_list.append({ 'withdraw': withdrawn_route, 'time': time }) return route_list
class BGPListener(object): def __init__(self, as_num): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True self.route_id = 0 self.start_time = 0 self.end_time = 0 self.as_num = int(as_num) self.stop_counts = 0 def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin in client.py, # which is routed to server.py via port 6000, # which is routed to here via receiver_queue. try: route = self.server.receiver_queue.get(True, 1) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = (waiting + 1) % 30 continue if self.start_time == 0: self.start_time = time.time() waiting = 0 logger.debug( "\n BGPListener: Got original route from ExaBGP: %s\n", route) route = json.loads(route) if 'stop' in route: logger.info("BGPListener: stop signal received from ExaBGP") peers = participants.values() for peer in peers: peer.send([]) continue self.route_id = route["route_id"] # Received BGP route advertisement from ExaBGP try: advertise_ip = route['neighbor']['ip'] except KeyError: continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send(route) self.end_time = time.time() self.server.stop() def send(self, announcement): self.end_time = time.time() #self.server.sender_queue.put(announcement) def stop(self): logger.info("Stopping BGPListener.") self.run = False
class route_server(): def __init__(self, event_queue, ready_queue, sdx): self.event_queue = event_queue self.ready_queue = ready_queue self.server = Server() self.sdx = sdx self.sdx.server = self.server participants_ports_list = get_participants_ports_list(sdx.participants) ''' Create and assign participant RIBs ''' for participant_name in sdx.participants: self.sdx.participants[participant_name].rs_client = Peer( participants_ports_list[participant_name]) def start(self): self.server.start() while True: route = self.server.receiver_queue.get() route = json.loads(route) # TODO: check the RIB update flow with others ... # At the moment, I am updating the RIB and will attach next-hop to the announcement at the end updates = [] route_list = None # Update RIBs for participant_name in self.sdx.participants: route_list = self.sdx.participants[ participant_name].rs_client.update(route) if route_list: break # Best Path Selection algorithm for route_item in route_list: updates.extend( decision_process(self.sdx.participants, route_item)) # Check for withdraw routes for route in route_list: if (route is None): continue elif 'withdraw' in route: for VNH in self.sdx.VNH_2_pfx: if (route['withdraw']['prefix'] in list(self.sdx.VNH_2_pfx[VNH])): self.server.sender_queue.put( withdraw_route(route['withdraw'], self.sdx.VNH_2_IP[VNH])) break # Trigger policy updates bgp_trigger_update(self.event_queue, self.ready_queue) # Check for announced routes #if (route_list): # TODO: need to correct this glue logic if hasattr(self.sdx, 'VNH_2_pfx'): for VNH in self.sdx.VNH_2_pfx: for prefix in list(self.sdx.VNH_2_pfx[VNH]): for paticipant_name in self.sdx.participants: route = self.sdx.participants[ paticipant_name].rs_client.get_route( 'local', prefix) if route: self.server.sender_queue.put( announce_route(route, self.sdx.VNH_2_IP[VNH])) break
class BGPListener(object): def __init__(self): logger.info('Initializing the BGPListener') # Initialize XRS Server self.server = Server(logger) self.run = True def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin in client.py, # which is routed to server.py via port 6000, # which is routed to here via receiver_queue. try: route = self.server.receiver_queue.get(True, 1) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = (waiting+1) % 30 continue waiting = 0 route = json.loads(route) if 'state' in route['neighbor']: logger.debug("Got route state from ExaBGP: %s", route) if 'down' not in route['neighbor']['state']: continue logger.debug("Got route from ExaBGP: %s", route) # Received BGP route advertisement from ExaBGP try: advertise_ip = route['neighbor']['ip'] except KeyError: continue found = [] with participantsLock: try: advertise_id = portip2participant[advertise_ip] peers_out = participants[advertise_id].peers_out except KeyError: continue for id, peer in participants.iteritems(): # Apply the filtering logic if id in peers_out and advertise_id in peer.peers_in: found.append(peer) for peer in found: # Now send this route to participant `id`'s controller' peer.send(route) def send(self, announcement): self.server.sender_queue.put(announcement) def stop(self): logger.info("Stopping BGPListener.") self.run = False
class route_server(object): def __init__(self, config_file): logger.info("Initializing the Route Server.") # Init the Route Server self.server = None self.ah_socket = None self.participants = {} # Several useful mappings self.port_2_participant = {} self.participant_2_port = {} self.portip_2_participant = {} self.participant_2_portip = {} self.portmac_2_participant = {} self.participant_2_portmac = {} self.asn_2_participant = {} self.participant_2_asn = {} ## Parse Config self.parse_config(config_file) # Initialize a XRS Server self.server = Server(logger) self.run = True """ Start the announcement Listener which will receive announcements from participants's controller and put them in XRS's sender queue. """ self.set_announcement_handler() def start(self): logger.info("Starting the Server to handle incoming BGP Updates.") self.server.start() waiting = 0 while self.run: # get BGP messages from ExaBGP via stdin try: route = self.server.receiver_queue.get(True, 1) route = json.loads(route) waiting = 0 logger.debug("Got route from ExaBGP. "+str(route)+' '+str(type(route))) # Received BGP route advertisement from ExaBGP for id, peer in self.participants.iteritems(): # Apply the filtering logic advertiser_ip = route['neighbor']['ip'] if advertiser_ip in self.portip_2_participant: advertise_id = self.portip_2_participant[advertiser_ip] if id in self.participants[advertise_id].peers_out and advertise_id in self.participants[id].peers_in: # Now send this route to participant `id`'s controller' self.send_update(id, route) except Queue.Empty: if waiting == 0: logger.debug("Waiting for BGP update...") waiting = 1 else: waiting = (waiting % 30) + 1 if waiting == 30: logger.debug("Waiting for BGP update...") def parse_config(self, config_file): # loading config file logger.debug("Begin parsing config...") config = json.load(open(config_file, 'r')) self.ah_socket = tuple(config["Route Server"]["AH_SOCKET"]) for participant_name in config["Participants"]: participant = config["Participants"][participant_name] iname = int(participant_name) # adding asn and mappings asn = participant["ASN"] self.asn_2_participant[participant["ASN"]] = iname self.participant_2_asn[iname] = participant["ASN"] self.participant_2_port[iname] = [] self.participant_2_portip[iname] = [] self.participant_2_portmac[iname] = [] for port in participant["Ports"]: self.port_2_participant[port['Id']] = iname self.portip_2_participant[port['IP']] = iname self.portmac_2_participant[port['MAC']] = iname self.participant_2_port[iname].append(port['Id']) self.participant_2_portip[iname].append(port['IP']) self.participant_2_portmac[iname].append(port['MAC']) # adding ports and mappings ports = [{"ID": port['Id'], "MAC": port['MAC'], "IP": port['IP']} for port in participant["Ports"]] peers_out = [peer for peer in participant["Peers"]] # TODO: Make sure this is not an insane assumption peers_in = peers_out addr, port = participant["EH_SOCKET"] eh_socket = (str(addr), int(port)) # create peer and add it to the route server environment self.participants[iname] = XRSPeer(asn, ports, peers_in, peers_out, eh_socket) logger.debug("Done parsing config") def set_announcement_handler(self): '''Start the listener socket for BGP Announcements''' logger.info("Starting the announcement handler...") self.listener_eh = Listener(self.ah_socket, authkey=None) ps_thread = Thread(target=self.start_ah) ps_thread.daemon = True ps_thread.start() def start_ah(self): '''Announcement Handler ''' logger.info("Announcement Handler started.") while True: conn_ah = self.listener_eh.accept() tmp = conn_ah.recv() logger.debug("Received an announcement.") announcement = json.loads(tmp) self.server.sender_queue.put(announcement) reply = "Announcement processed" conn_ah.send(reply) conn_ah.close() def send_update(self, id, route): # TODO: Explore what is better, persistent client sockets or # new socket for each BGP update "Send this BGP route to participant id's controller" logger.debug("Sending a route update to participant "+str(id)) conn = Client(tuple(self.participants[id].eh_socket), authkey = None) conn.send(json.dumps({'bgp': route})) conn.recv() conn.close() def stop(self): logger.info("Stopping.") self.run = False