def test_fetch_single_data_from_repo_over_forwarder_native_code(self): """Test fetch data from repo over forwarder using native code""" if platform.system() != 'Darwin': self.skipTest("Test only for OSX available") execs = {"PYTHON": NFNPythonExecutor(), "x86": x86Executor()} self.forwarder1 = NFNForwarder(0, log_level=255, encoder=self.get_encoder(), executors=execs) self.fwd_port1 = self.forwarder1.linklayer.interfaces[0].get_port() self.fetch = Fetch("127.0.0.1", self.fwd_port1, encoder=self.get_encoder()) self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() nfnfile = open('NFN-x86-file-osx', 'r') content_obj = nfnfile.read() self.forwarder1.icnlayer.cs.add_content_object(Content("/func/native/test", content_obj)) #self.mgmtClient1.add_new_content(Name("/func/native/test"), content_obj) time.sleep(5) fetch_name = Name("/func/native/test") fetch_name += '_("hello")' fetch_name += 'NFN' try: content = None while content is None or content == 'Received Nack: no forwarding rule': content = self.fetch.fetch_data(fetch_name, timeout=20) except: self.fail self.assertEqual("5", content)
def __init__(self): self._language = "PYTHONSTREAM" self._sandbox = NFNPythonExecutor()._init_sandbox() self._sandbox["check_end_streaming"] = self.check_end_streaming self._sandbox["get_next"] = self.get_next self._sandbox["write_out"] = self.write_out self._sandbox["last_write_out"] = self.last_write_out self._sandbox["write_out_on_get_next"] = self.write_out_on_get_next self._sandbox["print"] = print self._sandbox["sleep"] = time.sleep self.get_next_buffer: dict = {} self.sent_interests: dict = {} self.name_list_single: list = None self.name_list_multiple: list = None self.pos_name_list_multiple: int = 0 self.queue_to_lower: multiprocessing.Queue = None self.queue_from_lower: multiprocessing.Queue = None self.cs: BaseContentStore = None self.packetid: int = None self.comp_name: str = None self.get_next_part_counter: int = 0 self.write_out_part_counter: int = -1 self.classic: bool = False
def setUp(self): #setup icn_layer 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("computation_table", NFNComputationList) 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() self.r2cclient = TimeoutR2CHandler() parser = DefaultNFNParser() comp_table = synced_data_struct_factory.manager.computation_table( self.r2cclient, parser) self.executor = {"PYTHON": NFNPythonExecutor()} self.nfn_layer = BasicNFNLayer(cs, fib, pit, faceidtable, comp_table, self.executor, parser, self.r2cclient, log_level=255) self.nfn_layer.queue_to_lower = multiprocessing.Queue() self.nfn_layer.queue_from_lower = multiprocessing.Queue()
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 setUp(self): self.executor = NFNPythonExecutor()
class test_NFNPythonExecutor(unittest.TestCase): """Tests for the NFNPythonExecutor""" def setUp(self): self.executor = NFNPythonExecutor() def tearDown(self): pass def test_single_simple_function_call(self): """Test a very simple function code with no Parameter""" NF = \ """PYTHON f def f(): return 3 """ res = self.executor.execute(NF, []) self.assertEqual(res, 3) def test_single_function_call(self): """Test a very simple function code with Parameter""" NF = \ """PYTHON f def f(a, b): return a*b """ res = self.executor.execute(NF, [2, 3]) self.assertEqual(res, 6) def test_single_function_call_library_function(self): """Test a very simple function code with library call""" NF = \ """PYTHON f def f(a, b): return max(a,b) """ res = self.executor.execute(NF, [2, 3]) self.assertEqual(res, 3) def test_single_function_call_forbitten_library_function(self): """Test a very simple function code forbitten libary call""" NF = \ """PYTHON f def f(a): return open(a) """ res = self.executor.execute(NF, ["data.txt"]) self.assertEqual(res, None) def test_multiple_function_call(self): """Test a very simple function code with second function""" NF = \ """PYTHON f def g(b): return b*b def f(a): return g(a*a) """ res = self.executor.execute(NF, [2]) self.assertEqual(res, 16) def test_multiple_function_call_libray_name(self): """Test a very simple function code second function with library name""" NF = \ """PYTHON f def open(b): return 2 def f(a): return open(a) """ res = self.executor.execute(NF, ['test.txt']) self.assertEqual(res, 2) def test_single_function_call(self): """Test a loop function code """ NF = \ """PYTHON f def f(a): res = 0 for i in range(0,a): res = res + i return res """ res = self.executor.execute(NF, [4]) self.assertEqual(res, 6) def test_class(self): """Test with a class""" NF = \ """PYTHON f class TestClass(object): def __init___(self): self.a = 0 def f(a): res = 0 x = TestClass() for i in range(0,a): res = res + i return res """ res = self.executor.execute(NF, [4]) self.assertEqual(res, None)