def setUp(self): synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() faceidtable = synced_data_struct_factory.manager.faceidtable() interface = UDP4Interface(0) self.linklayer = BasicLinkLayer([interface], faceidtable) self.linklayerport = self.linklayer.interfaces[0].get_port() self.q1 = multiprocessing.Queue() self.linklayer.queue_from_higher = self.q1 self.mgmt = Mgmt(cs, fib, pit, self.linklayer, self.linklayerport) self.testMgmtSock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.testMgmtSock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.testMgmtSock3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.mgmt_client = MgmtClient(self.linklayerport)
class ICNPushRepository(object): """A Push Repository using PiCN""" def __init__(self, database_path, port=9000, log_level=255, encoder: BasicEncoder = None, flush_database=False): # debug level logger = Logger("PushRepo", log_level) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level=log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStorePersistentExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs(db_path=database_path + "/pushrepo.db") if flush_database: cs.delete_all() faceidtable = synced_data_struct_factory.manager.faceidtable() # default interface interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer(self.encoder, log_level=log_level) self.repolayer = PushRepositoryLayer(log_level=log_level) self.lstack: LayerStack = LayerStack([ self.repolayer, self.packetencodinglayer, self.linklayer ]) self.repolayer.cs = cs # mgmt self.mgmt = Mgmt(cs, None, None, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level) def start_forwarder(self): # start processes self.lstack.start_all() self.mgmt.start_process() def stop_forwarder(self): # Stop processes self.lstack.stop_all() # close queues file descriptors if self.mgmt.process: self.mgmt.stop_process() self.lstack.close_all()
class test_Mgmt(unittest.TestCase): def setUp(self): synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() faceidtable = synced_data_struct_factory.manager.faceidtable() interface = UDP4Interface(0) self.linklayer = BasicLinkLayer([interface], faceidtable) self.linklayerport = self.linklayer.interfaces[0].get_port() self.q1 = multiprocessing.Queue() self.linklayer.queue_from_higher = self.q1 self.mgmt = Mgmt(cs, fib, pit, self.linklayer, self.linklayerport) self.testMgmtSock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.testMgmtSock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.testMgmtSock3 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.mgmt_client = MgmtClient(self.linklayerport) def tearDown(self): self.linklayer.stop_process() self.mgmt.stop_process() self.testMgmtSock1.close() self.testMgmtSock2.close() self.testMgmtSock3.close() def test_mgmt_new_face(self): """Test the mgmt interace to create a new face""" self.linklayer.start_process() self.mgmt.start_process() self.testMgmtSock1.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock1.send( "GET /linklayer/newface/127.0.0.1:9000:0 HTTP/1.1\r\n\r\n".encode( )) data = self.testMgmtSock1.recv(1024) self.testMgmtSock1.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newface OK:0\r\n" ) self.assertEqual(self.linklayer.faceidtable.get_num_entries(), 1) self.assertEqual( self.linklayer.faceidtable.get_face_id( AddressInfo(("127.0.0.1", 9000), 0)), 0) self.assertEqual(self.linklayer.faceidtable.get_address_info(0), AddressInfo(("127.0.0.1", 9000), 0)) def test_mgmt_multiple_new_face(self): """Test the mgmt interace to create multiple new faces with deduplication""" self.linklayer.start_process() self.mgmt.start_process() self.testMgmtSock1.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock1.send( "GET /linklayer/newface/127.0.0.1:9000:0 HTTP/1.1\r\n\r\n".encode( )) data = self.testMgmtSock1.recv(1024) self.testMgmtSock1.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newface OK:0\r\n" ) self.testMgmtSock2.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock2.send( "GET /linklayer/newface/127.0.0.1:8000:0 HTTP/1.1\r\n\r\n".encode( )) data = self.testMgmtSock2.recv(1024) self.testMgmtSock2.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newface OK:1\r\n" ) self.testMgmtSock3.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock3.send( "GET /linklayer/newface/127.0.0.1:9000:0 HTTP/1.1\r\n\r\n".encode( )) data = self.testMgmtSock3.recv(1024) self.testMgmtSock3.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newface OK:0\r\n" ) self.assertEqual(self.linklayer.faceidtable.get_num_entries(), 2) self.assertEqual( self.linklayer.faceidtable.get_face_id( AddressInfo(("127.0.0.1", 9000), 0)), 0) self.assertEqual( self.linklayer.faceidtable.get_face_id( AddressInfo(("127.0.0.1", 8000), 0)), 1) def test_mgmt_add_forwaring_rule(self): """Test adding Forwarding rules""" self.linklayer.start_process() self.mgmt.start_process() self.testMgmtSock1.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock1.send( "GET /icnlayer/newforwardingrule/%2Ftest%2Fdata:2 HTTP/1.1\r\n\r\n" .encode()) data = self.testMgmtSock1.recv(1024) self.testMgmtSock1.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newforwardingrule OK:2\r\n" ) time.sleep(1) self.testMgmtSock2.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock2.send( "GET /icnlayer/newforwardingrule/%2Fdata%2Ftest:3 HTTP/1.1\r\n\r\n" .encode()) data = self.testMgmtSock2.recv(1024) self.testMgmtSock2.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newforwardingrule OK:3\r\n" ) self.assertEqual( self.mgmt.fib.find_fib_entry(Name("/test/data")).faceid, [2]) self.assertEqual( self.mgmt.fib.find_fib_entry(Name("/data/test")).faceid, [3]) def test_mgmt_add_content(self): """Test adding content""" self.linklayer.start_process() self.mgmt.start_process() self.testMgmtSock1.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock1.send( "GET /icnlayer/newcontent/%2Ftest%2Fdata:HelloWorld HTTP/1.1\r\n\r\n" .encode()) data = self.testMgmtSock1.recv(1024) self.testMgmtSock1.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newcontent OK\r\n" ) time.sleep(1) self.testMgmtSock2.connect(("127.0.0.1", self.linklayerport)) self.testMgmtSock2.send( "GET /icnlayer/newcontent/%2Fdata%2Ftest:GoodBye HTTP/1.1\r\n\r\n". encode()) data = self.testMgmtSock2.recv(1024) self.testMgmtSock2.close() self.assertEqual( data.decode(), "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newcontent OK\r\n" ) self.assertEqual( self.mgmt.cs.find_content_object( Name("/test/data")).content.content, "HelloWorld") self.assertEqual( self.mgmt.cs.find_content_object( Name("/data/test")).content.content, "GoodBye") def test_add_face_mgmt_client(self): """Test adding a face using the mgmtclient""" self.linklayer.start_process() self.mgmt.start_process() data = self.mgmt_client.add_face("127.0.0.1", 9000, 0) self.assertEqual( data, "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newface OK:0\r\n" ) self.assertEqual(self.linklayer.faceidtable.get_num_entries(), 1) self.assertEqual(self.linklayer.faceidtable.get_address_info(0), AddressInfo(("127.0.0.1", 9000), 0)) self.assertEqual( self.linklayer.faceidtable.get_face_id( AddressInfo(("127.0.0.1", 9000), 0)), 0) def test_add_forwarding_rule_mgmt_client(self): """Test adding forwarding rule using MgmtClient""" self.linklayer.start_process() self.mgmt.start_process() data = self.mgmt_client.add_forwarding_rule(Name("/test/data"), [2]) self.assertEqual( "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newforwardingrule OK:2\r\n", data) time.sleep(1) data = self.mgmt_client.add_forwarding_rule(Name("/data/test"), [3]) self.assertEqual( data, "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newforwardingrule OK:3\r\n" ) self.assertEqual( self.mgmt.fib.find_fib_entry(Name("/test/data")).faceid, [2]) self.assertEqual( self.mgmt.fib.find_fib_entry(Name("/data/test")).faceid, [3]) def test_mgmt_add_content_mgmt_client(self): """Test adding content using MgmtClient""" self.linklayer.start_process() self.mgmt.start_process() data = self.mgmt_client.add_new_content(Name("/test/data"), "HelloWorld") self.assertEqual( data, "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newcontent OK\r\n" ) time.sleep(1) data = self.mgmt_client.add_new_content(Name("/data/test"), "GoodBye") self.assertEqual( data, "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n newcontent OK\r\n" ) self.assertEqual( self.mgmt.cs.find_content_object( Name("/test/data")).content.content, "HelloWorld") self.assertEqual( self.mgmt.cs.find_content_object( Name("/data/test")).content.content, "GoodBye") def test_mgmt_shutdown_mgmt_client(self): """Test adding content""" self.linklayer.start_process() self.mgmt.start_process() data = self.mgmt_client.shutdown() self.assertEqual( data, "HTTP/1.1 200 OK \r\n Content-Type: text/html \r\n\r\n shutdown\r\n" )
def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, interfaces: List[BaseInterface] = None, executors: BaseNFNExecutor = None, ageing_interval: int = 3, use_thunks=False): # debug level logger = Logger("NFNForwarder", log_level) logger.info("Start PiCN NFN Forwarder on port " + str(port)) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.register("computation_table", NFNComputationList) synced_data_struct_factory.register("timeoutprevention_dict", TimeoutPreventionMessageDict) if use_thunks: synced_data_struct_factory.register("thunktable", ThunkList) synced_data_struct_factory.register("plantable", PlanTable) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() faceidtable = synced_data_struct_factory.manager.faceidtable() self.parser = DefaultNFNParser() if use_thunks: thunktable = synced_data_struct_factory.manager.thunktable() plantable = synced_data_struct_factory.manager.plantable( self.parser) #setup chunkifier self.chunkifier = SimpleContentChunkifyer() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.chunklayer = BasicChunkLayer(self.chunkifier, log_level=log_level) # setup nfn self.icnlayer._interest_to_app = True if executors is None: self.executors = {"PYTHON": NFNPythonExecutor()} else: self.executors = executors self.r2cclient = TimeoutR2CHandler() comp_table = synced_data_struct_factory.manager.computation_table( self.r2cclient, self.parser) self.nfnlayer = BasicNFNLayer(cs, fib, pit, faceidtable, comp_table, self.executors, self.parser, self.r2cclient, log_level=log_level) if use_thunks: self.thunk_layer = BasicThunkLayer(cs, fib, pit, faceidtable, thunktable, plantable, self.parser, log_level=log_level) self.nfnlayer.optimizer = ThunkPlanExecutor( cs, fib, pit, faceidtable, plantable) timeoutprevention_dict = synced_data_struct_factory.manager.timeoutprevention_dict( ) self.timeoutpreventionlayer = BasicTimeoutPreventionLayer( timeoutprevention_dict, comp_table, pit=pit, log_level=log_level) if use_thunks: self.lstack: LayerStack = LayerStack([ self.nfnlayer, self.chunklayer, self.timeoutpreventionlayer, self.thunk_layer, self.icnlayer, self.packetencodinglayer, self.linklayer ]) else: self.lstack: LayerStack = LayerStack([ self.nfnlayer, self.chunklayer, self.timeoutpreventionlayer, self.icnlayer, self.packetencodinglayer, self.linklayer ]) self.icnlayer.cs = cs self.icnlayer.fib = fib self.icnlayer.pit = pit # mgmt self.mgmt = Mgmt(self.icnlayer.cs, self.icnlayer.fib, self.icnlayer.pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level)
def __init__(self, port=9000, log_level=255, encoder: ExtendedNdnTlvEncoder = None, interfaces: List[BaseInterface] = None): # debug level logger = Logger("ICNForwarder", log_level) # packet encoder if encoder is None: self.encoder = () else: encoder.set_log_level(log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("face_id_table", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit(pit_timeout=60) face_id_table = synced_data_struct_factory.manager.face_id_table() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.link_layer = BasicLinkLayer(interfaces, face_id_table, log_level=log_level) self.packet_encoding_layer = HeartbeatPacketEncodingLayer( self.encoder, log_level=log_level) self.icn_layer = HeartbeatNetworkLayer(log_level=log_level) self.lstack: LayerStack = LayerStack( [self.icn_layer, self.packet_encoding_layer, self.link_layer]) self.icn_layer.cs = cs self.icn_layer.fib = fib self.icn_layer.pit = pit # mgmt self.mgmt = Mgmt(cs, fib, pit, self.link_layer, mgmt_port, self.stop_forwarder, log_level=log_level)
def __init__(self, foldername: Optional[str], prefix: Name, port=9000, log_level=255, encoder: BasicEncoder = None, autoconfig: bool = False, autoconfig_routed: bool = False, interfaces: List[BaseInterface] = None, use_thunks=False): """ :param foldername: If None, use an in-memory repository. Else, use a file system repository. """ logger = Logger("ICNRepoSession", log_level) logger.info("Start PiCN Data Repository with Sessions") # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder # chunkifyer self.chunkifyer = SimpleContentChunkifyer() # repo manager = multiprocessing.Manager() if foldername is None: self.repo: BaseRepository = SimpleMemoryRepository(prefix, manager, logger) else: self.repo: BaseRepository = SimpleFileSystemRepository(foldername, prefix, manager, logger) # initialize layers synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("faceidtable", FaceIDDict) if use_thunks: synced_data_struct_factory.register("thunktable", ThunkList) synced_data_struct_factory.register("plantable", PlanTable) synced_data_struct_factory.create_manager() faceidtable = synced_data_struct_factory.manager.faceidtable() if use_thunks: self.parser = DefaultNFNParser() thunktable = synced_data_struct_factory.manager.thunktable() plantable = synced_data_struct_factory.manager.plantable(self.parser) if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer(self.encoder, log_level=log_level) self.chunklayer = BasicChunkLayer(self.chunkifyer, log_level=log_level) self.repolayer = SessionRepositoryLayer(self.repo, log_level=log_level) if use_thunks: self.thunklayer = BasicThunkLayer(None, None, None, faceidtable, thunktable, plantable, self.parser, self.repo, log_level=log_level) logger.info("Using Thunks") if use_thunks: self.lstack: LayerStack = LayerStack([ self.repolayer, self.chunklayer, self.thunklayer, self.packetencodinglayer, self.linklayer ]) else: self.lstack: LayerStack = LayerStack([ self.repolayer, self.chunklayer, self.packetencodinglayer, self.linklayer ]) if autoconfig: self.autoconfiglayer = AutoconfigRepoLayer(name=prefix.string_components[-1], addr='127.0.0.1', linklayer=self.linklayer, repo=self.repo, register_global=autoconfig_routed, log_level=log_level) self.lstack.insert(self.autoconfiglayer, below_of=self.chunklayer) # mgmt self.mgmt = Mgmt(None, None, None, self.linklayer, mgmt_port, self.start_repo, repo_path=foldername, repo_prfx=prefix, log_level=log_level)
def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, routing: bool = False, peers=None, autoconfig: bool = False, interfaces: List[BaseInterface] = None, ageing_interval: int = 3, node_name: str = None): # debug level logger = Logger("ICNForwarder", log_level) # FIXME: Why isn't this self.logger??? self._node_name = node_name # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level=log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterestTableMemoryExact) synced_data_struct_factory.register("rib", TreeRoutingInformationBase) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() rib = None if routing: rib = synced_data_struct_factory.manager.rib() faceidtable = synced_data_struct_factory.manager.faceidtable() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.lstack: LayerStack = LayerStack( [self.icnlayer, self.packetencodinglayer, self.linklayer]) if autoconfig: self.autoconfiglayer: AutoconfigServerLayer = AutoconfigServerLayer( linklayer=self.linklayer, address='127.0.0.1', registration_prefixes=[(Name('/testnetwork/repos'), True)], log_level=log_level) self.lstack.insert(self.autoconfiglayer, below_of=self.icnlayer) if routing: self.routinglayer = BasicRoutingLayer(self.linklayer, peers=peers, log_level=log_level) self.lstack.insert(self.routinglayer, below_of=self.icnlayer) self.icnlayer.cs = cs self.icnlayer.fib = fib # ----- by Luc # FIXME: How to pass these parameters to __init__ self.icnlayer.fib.logger = logger self.icnlayer.fib.node_name = self._node_name # ----- by Luc # FIXME: How to pass these parameters to __init__ self.icnlayer.pit = pit self.icnlayer.pit.logger = logger self.icnlayer.pit.node_name = self._node_name # ----- if autoconfig: self.autoconfiglayer.fib = fib if routing: self.routinglayer.rib = rib self.routinglayer.fib = fib # mgmt self.mgmt = Mgmt(cs, fib, pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level)
class ICNForwarder(object): """A ICN Forwarder using PiCN""" def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, routing: bool = False, peers=None, autoconfig: bool = False, interfaces: List[BaseInterface] = None, ageing_interval: int = 3): # debug level logger = Logger("ICNForwarder", log_level) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level=log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("rib", TreeRoutingInformationBase) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() if routing: rib = synced_data_struct_factory.manager.rib() faceidtable = synced_data_struct_factory.manager.faceidtable() #default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.lstack: LayerStack = LayerStack( [self.icnlayer, self.packetencodinglayer, self.linklayer]) if autoconfig: self.autoconfiglayer: AutoconfigServerLayer = AutoconfigServerLayer( linklayer=self.linklayer, address='127.0.0.1', registration_prefixes=[(Name('/testnetwork/repos'), True)], log_level=log_level) self.lstack.insert(self.autoconfiglayer, below_of=self.icnlayer) if routing: self.routinglayer = BasicRoutingLayer(self.linklayer, peers=peers, log_level=log_level) self.lstack.insert(self.routinglayer, below_of=self.icnlayer) self.icnlayer.cs = cs self.icnlayer.fib = fib self.icnlayer.pit = pit if autoconfig: self.autoconfiglayer.fib = fib if routing: self.routinglayer.rib = rib self.routinglayer.fib = fib # mgmt self.mgmt = Mgmt(cs, fib, pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level) def start_forwarder(self): # start processes self.lstack.start_all() self.icnlayer.ageing() self.mgmt.start_process() def stop_forwarder(self): # Stop processes self.lstack.stop_all() # close queues file descriptors if self.mgmt.process: self.mgmt.stop_process() self.lstack.close_all()
class NFNForwarder(object): """NFN Forwarder for PICN""" # TODO add chunking layer def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, interfaces: List[BaseInterface] = None, ageing_interval: int = 3): # debug level logger = Logger("NFNForwarder", log_level) logger.info("Start PiCN NFN Forwarder on port " + str(port)) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStoreMemoryExact) synced_data_struct_factory.register( "fib", ForwardingInformationBaseMemoryPrefix) synced_data_struct_factory.register("pit", PendingInterstTableMemoryExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.register("computation_table", NFNComputationList) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs() fib = synced_data_struct_factory.manager.fib() pit = synced_data_struct_factory.manager.pit() faceidtable = synced_data_struct_factory.manager.faceidtable() #setup chunkifier self.chunkifier = SimpleContentChunkifyer() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.chunklayer = BasicChunkLayer(self.chunkifier, log_level=log_level) # setup nfn self.icnlayer._interest_to_app = True self.executors = {"PYTHON": NFNPythonExecutor()} self.parser = DefaultNFNParser() self.r2cclient = TimeoutR2CHandler() comp_table = synced_data_struct_factory.manager.computation_table( self.r2cclient, self.parser) self.nfnlayer = BasicNFNLayer(cs, fib, pit, faceidtable, comp_table, self.executors, self.parser, self.r2cclient, log_level=log_level) self.lstack: LayerStack = LayerStack([ self.nfnlayer, self.chunklayer, self.icnlayer, self.packetencodinglayer, self.linklayer ]) self.icnlayer.cs = cs self.icnlayer.fib = fib self.icnlayer.pit = pit # mgmt self.mgmt = Mgmt(self.icnlayer.cs, self.icnlayer.fib, self.icnlayer.pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level) def start_forwarder(self): # start processes self.lstack.start_all() self.icnlayer.ageing() self.mgmt.start_process() def stop_forwarder(self): # Stop processes self.mgmt.stop_process() self.lstack.stop_all() # close queues file descriptors self.lstack.close_all()