def test_single_interest_repo_fetch(self): """Test simulation by requesting data from a repo using the fetch program lib and chunking""" self.path = "/tmp/repo_unit_test" try: os.stat(self.path) except: os.mkdir(self.path) with open(self.path + "/f1", 'w+') as content_file: content_file.write("A" * 50000) self.icn_forwarder2 = ICNDataRepository(self.path, Name("/test/data"), 0, log_level=255, encoder=self.encoder_type(), interfaces=[self.simulation_bus.add_interface("icnfwd2")]) self.fetchtool = Fetch("icnfwd1", None, 255, encoder=self.encoder_type(), interfaces=[self.simulation_bus.add_interface("fetchtool")]) self.icn_forwarder1.start_forwarder() self.icn_forwarder2.start_repo() self.simulation_bus.start_process() mgmt_client1 = MgmtClient(self.icn_forwarder1.mgmt.mgmt_sock.getsockname()[1]) mgmt_client1.add_face("icnfwd2", None, 0) mgmt_client1.add_forwarding_rule(Name("/test"), [0]) res = self.fetchtool.fetch_data(Name("/test/data/f1"), 3) self.assertEqual("A"*50000, res) mgmt_client1.shutdown() self.fetchtool.stop_fetch()
def test_singl_interest_repo(self): """Test simulation by requesting data from a repo""" self.path = "/tmp/repo_unit_test" try: os.stat( self.path) except: os.mkdir( self.path) with open( self.path + "/f1", 'w+') as content_file: content_file.write("A"*20000) self.icn_forwarder2 = ICNDataRepository(self.path, Name("/test/data"), 0, log_level=255, encoder=self.encoder_type(), interfaces=[self.simulation_bus.add_interface("icnfwd2")]) self.icn_forwarder1.start_forwarder() self.icn_forwarder2.start_repo() self.simulation_bus.start_process() mgmt_client1 = MgmtClient(self.icn_forwarder1.mgmt.mgmt_sock.getsockname()[1]) mgmt_client1.add_face("icnfwd2", None, 0) mgmt_client1.add_forwarding_rule(Name("/test"), [0]) interest = Interest("/test/data/f1") wire_data = self.encoder.encode(interest) self.fetchiface.send(wire_data, "icnfwd1") res, src = self.fetchiface.receive() self.assertEqual(src, "icnfwd1") c = self.encoder.decode(res) self.assertEqual(c, Content(interest.name, "mdo:20000:/test/data/f1/c0;/test/data/f1/c1;/test/data/f1/c2;/test/data/f1/c3:/test/data/f1/m1")) mgmt_client1.shutdown()
def test_single_nfn_interest(self): """Test simulation with NFN nodes and a single packet """ self.icn_forwarder1 = NFNForwarder(port=0, encoder=self.encoder_type(), interfaces=[self.simulation_bus.add_interface("icnfwd1")]) self.icn_forwarder2 = NFNForwarder(port=0, encoder=self.encoder_type(), interfaces=[self.simulation_bus.add_interface("icnfwd2")]) self.icn_forwarder1.start_forwarder() self.icn_forwarder2.start_forwarder() self.simulation_bus.start_process() mgmt_client1 = MgmtClient(self.icn_forwarder1.mgmt.mgmt_sock.getsockname()[1]) mgmt_client1.add_face("icnfwd2", None, 0) mgmt_client1.add_forwarding_rule(Name("/test"), [0]) mgmt_client1.add_new_content(Name("/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") mgmt_client2 = MgmtClient(self.icn_forwarder2.mgmt.mgmt_sock.getsockname()[1]) mgmt_client2.add_new_content(Name("/test/data"), "HelloWorld") mgmt_client2.add_face("icnfwd1", None, 0) mgmt_client2.add_forwarding_rule(Name("/func"), [0]) interest = Interest("/test/data") interest.name += "/func/f1(_)" interest.name += "NFN" wire_data = self.encoder.encode(interest) self.fetchiface.send(wire_data, "icnfwd1") res, src = self.fetchiface.receive() self.assertEqual(src, "icnfwd1") c = self.encoder.decode(res) self.assertEqual(c, Content(interest.name, "HELLOWORLD")) mgmt_client1.shutdown() mgmt_client2.shutdown()
def test_bandwidth_limit(self): #TODO better test here """Simple Test for checking the bandwidth limit""" self.icn_forwarder1 = ICNForwarder(port=0, encoder=self.encoder_type(), interfaces=[ self.simulation_bus.add_interface("icnfwd1", max_bandwidth=1)]) self.icn_forwarder2 = ICNForwarder(port=0, encoder=self.encoder_type(), interfaces=[ self.simulation_bus.add_interface("icnfwd2", max_bandwidth=1)]) self.icn_forwarder1.start_forwarder() self.icn_forwarder2.start_forwarder() self.simulation_bus.start_process() mgmt_client1 = MgmtClient(self.icn_forwarder1.mgmt.mgmt_sock.getsockname()[1]) mgmt_client1.add_face("icnfwd2", None, 0) mgmt_client1.add_forwarding_rule(Name("/test"), [0]) mgmt_client2 = MgmtClient(self.icn_forwarder2.mgmt.mgmt_sock.getsockname()[1]) mgmt_client2.add_new_content(Name("/test/data"), "HelloWorld") interest = Interest("/test/data") wire_data = self.encoder.encode(interest) self.fetchiface.send(wire_data, "icnfwd1") res, src = self.fetchiface.receive() self.assertEqual(src, "icnfwd1") c = self.encoder.decode(res) self.assertEqual(c, Content("/test/data", "HelloWorld")) mgmt_client1.shutdown() mgmt_client2.shutdown()
def test_creation_of_simulation_face_mgmt(self): """Test the creation of a simulation face using a mgmt client""" self.icn_forwarder1.start_forwarder() self.icn_forwarder2.start_forwarder() self.simulation_bus.start_process() mgmt_client1 = MgmtClient(self.icn_forwarder1.mgmt.mgmt_sock.getsockname()[1]) mgmt_client1.add_face("icnfwd2", None, 0) mgmt_client1.add_forwarding_rule(Name("/test"), [0]) mgmt_client2 = MgmtClient(self.icn_forwarder2.mgmt.mgmt_sock.getsockname()[1]) mgmt_client2.add_new_content(Name("/test/data"), "HelloWorld") interest = Interest("/test/data") wire_data = self.encoder.encode(interest) self.fetchiface.send(wire_data, "icnfwd1") res, src = self.fetchiface.receive() self.assertEqual(src, "icnfwd1") c = self.encoder.decode(res) self.assertEqual(c, Content("/test/data", "HelloWorld")) mgmt_client1.shutdown() mgmt_client2.shutdown()
def main(args, help_string): mgmt_client = MgmtClient(args.port) data = None if args.command == "shutdown": try: mgmt_client.shutdown() print("Shutdown command sent.") except ConnectionRefusedError: print("Connection Refused. Repo not running?") elif args.command == "getrepoprefix": try: data = mgmt_client.get_repo_prefix() print(data) except ConnectionRefusedError: print("Connection Refused. Repo not running?") elif args.command == "getrepopath": try: data = mgmt_client.get_repo_path() print(data) except ConnectionRefusedError: print("Connection Refused. Repo not running?") elif args.command == "newface": try: resolved_hostname = socket.gethostbyname(args.parameters.split(":")[0]) except: print("Resolution of hostname failed.") sys.exit(-2) try: data = mgmt_client.add_face(resolved_hostname, int(args.parameters.split(":")[1]), int(args.parameters.split(":")[2])) except: print(help_string) elif args.command == "newforwardingrule": try: data = mgmt_client.add_forwarding_rule(Name(args.parameters.split(":")[0]), args.parameters.split(":")[1]) except ConnectionRefusedError: print("Connection Refused. Forwarder not running?") except: print(help_string) elif args.command == "newcontent" or args.command == 'addcontent': try: data = mgmt_client.add_new_content(Name(args.parameters.split(":", 1)[0]), args.parameters.split(":", 1)[1]) except ConnectionRefusedError: print("Connection Refused. Forwarder not running?") except: print(help_string) if data: print(data)
class cases_Fetch(object): @abc.abstractmethod def get_encoder(self): """get the packet encoder to be used""" def setUp(self): self.data1 = "data1" self.data2 = 'A' * 5000 self.data3 = 'B' * 20000 self.path = "/tmp/repo_unit_test" try: os.stat(self.path) except: os.mkdir(self.path) with open(self.path + "/f1", 'w+') as content_file: content_file.write(self.data1) with open(self.path + "/f2", 'w+') as content_file: content_file.write(self.data2) with open(self.path + "/f3", 'w+') as content_file: content_file.write('B' * 20000) self.ICNRepo: ICNDataRepository = ICNDataRepository("/tmp/repo_unit_test", Name("/test/data"), port=0, encoder=self.get_encoder(), log_level=255) self.forwarder: ICNForwarder = ICNForwarder(port=0, encoder=self.get_encoder(), log_level=255) self.repo_port = self.ICNRepo.linklayer.interfaces[0].get_port() self.forwarder_port = self.forwarder.linklayer.interfaces[0].get_port() self.fetch = Fetch("127.0.0.1", self.forwarder_port, encoder=self.get_encoder()) def add_face_and_forwadingrule(self): #create new face self.mgmtClient = MgmtClient(self.forwarder_port) self.mgmtClient.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient.add_forwarding_rule(Name("/test"), faceid=[0]) def tearDown(self): try: shutil.rmtree(self.path) os.remove(self.path) except: pass self.mgmtClient.shutdown() self.ICNRepo.stop_repo() self.forwarder.stop_forwarder() self.fetch.stop_fetch() time.sleep(0.5) def test_fetch_single_data_over_forwarder(self): """Test fetching a single data object over a forwarder without chunking""" self.ICNRepo.start_repo() self.forwarder.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() content = self.fetch.fetch_data(Name("/test/data/f1")) self.assertEqual(content, self.data1) def test_fetch_small_data_over_forwarder(self): """Test fetching a small data object over a forwarder with little chunking""" self.ICNRepo.start_repo() self.forwarder.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() content = self.fetch.fetch_data(Name("/test/data/f2")) self.assertEqual(content, self.data2) def test_fetch_large_data_over_forwarder(self): """Test fetching a large data object over a forwarder with more chunking""" self.ICNRepo.start_repo() self.forwarder.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() content = self.fetch.fetch_data(Name("/test/data/f3")) self.assertEqual(content, self.data3) def test_fetching_content_from_second_repo_after_nack(self): """Test sending an interest to forwarder with no matching content, choose second route to fetch content""" self.forwarder2: ICNForwarder = ICNForwarder(0, encoder=self.get_encoder(), log_level=255) self.ICNRepo.start_repo() self.forwarder.start_forwarder() self.forwarder2.start_forwarder() #check for nack on first route self.mgmtClient = MgmtClient(self.forwarder_port) self.mgmtClient.add_face("127.0.0.1", self.forwarder2.linklayer.interfaces[0].get_port(), 0) data = self.mgmtClient.add_forwarding_rule(Name("/test/data"), [0]) nack = self.fetch.fetch_data(Name("/test/data/f3")) self.assertEqual(nack, "Received Nack: " + NackReason.NO_ROUTE.value) time.sleep(0.1) #install second forwarding rule and check for result. data = self.mgmtClient.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient.add_forwarding_rule(Name("/test"), [2]) time.sleep(0.1) fetch2 = Fetch("127.0.0.1", self.forwarder_port) content = self.fetch.fetch_data(Name("/test/data/f3")) self.assertEqual(content, self.data3) self.forwarder2.stop_forwarder() def test_fetching_a_lot_of_packets(self): """sending a lot of packets using a forwarder and chunking""" self.ICNRepo.start_repo() self.forwarder.start_forwarder() self.add_face_and_forwadingrule() self.path = "/tmp/repo_unit_test" try: os.stat(self.path) except: os.mkdir(self.path) for i in range(1,10): name = "/f" + str(i) with open(self.path + name, 'w+') as content_file: content_file.write(self.data3) time.sleep(2) for i in range(1,10): fname = "/f" + str(i) icn_name = "/test/data" + name content = self.fetch.fetch_data(Name(icn_name), timeout=10) self.assertEqual(content, self.data3)
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" )
class cases_FetchNFN(object): @abc.abstractmethod def get_encoder(self): """get the packet encoder to be used""" def setUp(self): self.data1 = "data1" self.data2 = 'a' * 5000 self.data3 = 'b' * 20000 self.path = "/tmp/repo_unit_test" try: os.stat(self.path) except: os.mkdir(self.path) with open(self.path + "/d1", 'w+') as content_file: content_file.write(self.data1) with open(self.path + "/d2", 'w+') as content_file: content_file.write(self.data2) with open(self.path + "/d3", 'w+') as content_file: content_file.write('b' * 20000) self.ICNRepo: ICNDataRepository = ICNDataRepository( "/tmp/repo_unit_test", Name("/test/data"), 0, encoder=self.get_encoder(), log_level=255) self.forwarder1: NFNForwarder = NFNForwarder( 0, log_level=255, encoder=self.get_encoder()) self.forwarder2: NFNForwarder = NFNForwarder( 0, log_level=255, encoder=self.get_encoder()) self.repo_port = self.ICNRepo.linklayer.interfaces[0].get_port() self.fwd_port1 = self.forwarder1.linklayer.interfaces[0].get_port() self.fwd_port2 = self.forwarder2.linklayer.interfaces[0].get_port() self.fetch = Fetch("127.0.0.1", self.fwd_port1, encoder=self.get_encoder()) def add_face_and_forwadingrule(self): #create new face self.mgmtClient1 = MgmtClient(self.fwd_port1) self.mgmtClient1.add_face("127.0.0.1", self.fwd_port2, 0) self.mgmtClient1.add_forwarding_rule(Name("/lib"), 0) self.mgmtClient1.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient1.add_forwarding_rule(Name("/test"), 0) self.mgmtClient2 = MgmtClient(self.fwd_port2) self.mgmtClient2.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient2.add_forwarding_rule(Name("/test"), 0) def tearDown(self): try: shutil.rmtree(self.path) os.remove(self.path) except: pass self.mgmtClient1.shutdown() self.mgmtClient2.shutdown() self.ICNRepo.stop_repo() self.forwarder1.stop_forwarder() self.forwarder2.stop_forwarder() self.fetch.stop_fetch() def test_fetch_single_data_from_repo_over_forwarder(self): """Test fetch data from repo over forwarder""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() fetch_name = "/test/data/d1" try: content = self.fetch.fetch_data(fetch_name, timeout=15.0) except: self.fail self.assertEqual(self.data1, content) def test_fetch_chunked_data_from_repo_over_forwarder(self): """Test fetch chunked data from repo over forwarder""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() fetch_name = "/test/data/d3" content = self.fetch.fetch_data(fetch_name, timeout=15.0) self.assertEqual(self.data3, content) def test_compute_on_single_data_over_forwarder(self): """Test fetch result with single input data""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() self.mgmtClient1.add_new_content(Name("/test/data/d1"), self.data1) self.mgmtClient2.add_new_content( Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d1)" fetch_name += "NFN" try: content = self.fetch.fetch_data(fetch_name, timeout=15.0) except: self.fail() self.assertEqual(self.data1.upper(), content) def test_compute_on_single_data_over_forwarder_data_from_repo(self): """Test fetch result with single input data from repo""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() self.mgmtClient2.add_new_content( Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d1)" fetch_name += "NFN" try: content = self.fetch.fetch_data(fetch_name, timeout=10.0) except: self.fail() self.assertEqual(self.data1.upper(), content) def test_compute_on_large_data_over_forwarder_data_from_repo(self): """Test fetch result with large input data from repo""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() self.mgmtClient2.add_new_content( Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d3)" fetch_name += "NFN" try: content = self.fetch.fetch_data(fetch_name, timeout=10.0) except: self.fail() self.assertEqual(self.data3.upper(), content) def test_compute_on_large_data_over_forwarder_data_from_repo_to_data_prefix( self): """Test fetch result with large input data from repo with a to data prefix""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(0.1) self.add_face_and_forwadingrule() self.mgmtClient2.add_new_content( Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/test/data/d3") fetch_name += "/lib/func/f1(_)" fetch_name += "NFN" try: content = self.fetch.fetch_data(fetch_name, timeout=10.0) except: self.fail() self.assertEqual(self.data3.upper(), content)
class ICNSessionSimulation(unittest.TestCase): """Simulate a Scenario where timeout prevention is required""" def setUp(self): self.simulation_bus = SimulationBus( log_level=0) # Use BasicStringEncoder self.icn_repo0 = ICNDataRepository( port=0, prefix=Name('/test/t1'), foldername=None, interfaces=[self.simulation_bus.add_interface('repo0')], log_level=255) # Initialize repository 0 self.icn_repo1 = ICNDataRepositorySession( port=0, prefix=Name('/test/t2'), foldername=None, interfaces=[self.simulation_bus.add_interface('repo1')], log_level=0) # Initialize repository 1 (this one has sessions) self.icn_forwarder0 = ICNForwarder( port=0, log_level=255, interfaces=[self.simulation_bus.add_interface('fw0') ]) # Initialize forwarder 0 self.icn_forwarder1 = ICNForwarder( port=0, log_level=255, interfaces=[self.simulation_bus.add_interface('fw1') ]) # Initialize forwarder 1 self.mgmt_client0 = MgmtClient( self.icn_repo0.mgmt.mgmt_sock.getsockname() [1]) # Mgmt client for repository 0 self.mgmt_client1 = MgmtClient( self.icn_repo1.mgmt.mgmt_sock.getsockname() [1]) # Mgmt client for repository 1 self.mgmt_client2 = MgmtClient( self.icn_forwarder0.mgmt.mgmt_sock.getsockname() [1]) # Mgmt client for forwarder 0 self.mgmt_client3 = MgmtClient( self.icn_forwarder1.mgmt.mgmt_sock.getsockname() [1]) # Mgmt client for forwarder 1 # This is unintuitive. Why does the fetch tool add its own face, but the other components don't? self.fetch0 = Fetch('fw0', None, log_level=255, interfaces=[ self.simulation_bus.add_interface('fetcht0') ]) # Initialize a client (fetch tool) self.fetch1 = FetchSessions( 'fw0', None, log_level=255, interfaces=[self.simulation_bus.add_interface('fetcht1')]) self.icn_repo0.start_repo() self.icn_repo1.start_repo() self.icn_forwarder0.start_forwarder() self.icn_forwarder1.start_forwarder() self.simulation_bus.start_process() time.sleep(1) # Be safe and wait for all processes to start self.mgmt_client2.add_face( 'repo0', None, 0) # Add new interface to forwarder 0, index has to be 0. self.mgmt_client2.add_face( 'fw1', None, 0) # # Add new interface to forwarder 0, index has to be 0. self.mgmt_client2.add_forwarding_rule( Name('/test/t1'), [0]) # Add a forward-rule this prefix to interface with index 0. self.mgmt_client2.add_forwarding_rule( Name('/test/t2'), [1]) # Add a forward-rule this prefix to interface with index 1. self.mgmt_client3.add_face( 'repo1', None, 0) # Add new interface to forwarder 1, index has to be 0. self.mgmt_client3.add_forwarding_rule( Name('/test/t2'), [0]) # Add a forward-rule this prefix to interface with index 0. # Repositories do not need a forwarding rule or an interface. All done in constructor. self.test_content = 'This is just a test for repo0.' self.icn_repo0.repo.add_content( Name('/test/t1/content_object'), self.test_content ) # TODO: Create add_new_content command for DataRepository in ManagementClient print(self.icn_forwarder0.icnlayer.fib) print(self.icn_forwarder1.icnlayer.fib) def tearDown(self): time.sleep( 1 ) # Be safe and wait for all messages to trickle in before shutting down everything self.icn_forwarder0.stop_forwarder() self.icn_forwarder1.stop_forwarder() self.fetch0.stop_fetch() self.fetch1.stop_fetch() self.simulation_bus.stop_process() self.mgmt_client0.shutdown() self.mgmt_client1.shutdown() self.mgmt_client2.shutdown() self.mgmt_client3.shutdown() def test_simple_interest(self): interest = Name( '/test/t1/content_object') # Test routing, no new features. res = self.fetch0.fetch_data(interest, timeout=20) print(f"Return value: {res}") self.assertEqual(self.test_content, res, 'The content matches.') def test_simple_session_initiation(self): interest = Name( "/test/t2/session_connector" ) # Test session connection string. This should return 16bits res = self.fetch1.fetch_data(interest, timeout=20) print(f"Return value : {res}") self.assertEqual(self.icn_repo1.repolayer._pending_sessions[0], self.fetch1._session_keys[0], 'The session keys match.')
simple_interest = Name('/unibas/sim1/trailer.mp4') session_interest = Name('/unibas/sim1/session_connector') simple_response = fetch0.fetch_data(simple_interest, timeout=20) assert simple_response == content, f"The response should be: '{content}'. Got: '{simple_response}' instead." session_response = fetch0.fetch_data(session_interest, timeout=20) assert len( session_response ) == 11, f"The response should be of length 11. Got length {len(session_response)} instead." # Send content from fetch to repo over session. The repo will print out the content on the logger fetch0.send_content((fetch0.get_session_name(Name('/unibas/sim1')), 'Hello, please store my thesis. Thank you.')) # Send content from repo over session. The receive loop will print out the content repo0.repolayer.send_content(content='Test. Test. Test. 1-2-3') # ------------------- # Stop the simulation time.sleep( 1 ) # Be safe and wait for all messages to trickle in before shutting down everything fw0.stop_forwarder() fetch0.stop_fetch() simulation_bus.stop_process() mgmt_repo0.shutdown() mgmt_fw0.shutdown() exit(0)
class cases_FetchNFN(object): @abc.abstractmethod def get_encoder(self): """get the packet encoder to be used""" def setUp(self): self.data1 = "data1" self.data2 = 'a' * 5000 self.data3 = 'b' * 20000 self.path = "/tmp/repo_unit_test" try: os.stat(self.path) except: os.mkdir(self.path) with open(self.path + "/d1", 'w+') as content_file: content_file.write(self.data1) with open(self.path + "/d2", 'w+') as content_file: content_file.write(self.data2) with open(self.path + "/d3", 'w+') as content_file: content_file.write('b' * 20000) self.ICNRepo: ICNDataRepository = ICNDataRepository("/tmp/repo_unit_test", Name("/test/data"), 0, encoder=self.get_encoder(), log_level=255) self.forwarder1: NFNForwarder = NFNForwarder(0, log_level=255, encoder=self.get_encoder()) self.forwarder2: NFNForwarder = NFNForwarder(0, log_level=255, encoder=self.get_encoder()) self.repo_port = self.ICNRepo.linklayer.interfaces[0].get_port() self.fwd_port1 = self.forwarder1.linklayer.interfaces[0].get_port() self.fwd_port2 = self.forwarder2.linklayer.interfaces[0].get_port() self.fetch = Fetch("127.0.0.1", self.fwd_port1, encoder=self.get_encoder()) def add_face_and_forwadingrule(self): #create new face self.mgmtClient1 = MgmtClient(self.fwd_port1) self.mgmtClient1.add_face("127.0.0.1", self.fwd_port2, 0) self.mgmtClient1.add_forwarding_rule(Name("/lib"), [0]) self.mgmtClient1.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient1.add_forwarding_rule(Name("/test"), [0]) self.mgmtClient2 = MgmtClient(self.fwd_port2) self.mgmtClient2.add_face("127.0.0.1", self.repo_port, 0) self.mgmtClient2.add_forwarding_rule(Name("/test"), [0]) def tearDown(self): try: shutil.rmtree(self.path) os.remove(self.path) except: pass try: self.mgmtClient1.shutdown() self.mgmtClient2.shutdown() self.ICNRepo.stop_repo() self.forwarder1.stop_forwarder() self.forwarder2.stop_forwarder() self.fetch.stop_fetch() except: pass def test_fetch_single_data_from_repo_over_forwarder(self): """Test fetch data from repo over forwarder""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) fetch_name = "/test/data/d1" 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(self.data1, content) def test_fetch_chunked_data_from_repo_over_forwarder(self): """Test fetch chunked data from repo over forwarder""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) fetch_name = "/test/data/d3" content = None while content is None or content == 'Received Nack: no forwarding rule': content = self.fetch.fetch_data(fetch_name, timeout=20) self.assertEqual(self.data3, content) def test_compute_on_single_data_over_forwarder(self): """Test fetch result with single input data""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) self.mgmtClient1.add_new_content(Name("/test/data/d1"), self.data1) self.mgmtClient2.add_new_content(Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d1)" 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(self.data1.upper(), content) def test_compute_on_single_data_over_forwarder_data_from_repo(self): """Test fetch result with single input data from repo""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) self.mgmtClient2.add_new_content(Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d1)" fetch_name += "NFN" try: content = self.fetch.fetch_data(fetch_name, timeout=20) except: self.fail() self.assertEqual(self.data1.upper(), content) def test_compute_on_large_data_over_forwarder_data_from_repo(self): """Test fetch result with large input data from repo""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) self.mgmtClient2.add_new_content(Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/lib/func/f1") fetch_name += "_(/test/data/d3)" fetch_name += "NFN" time.sleep(1) content = None try: 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(self.data3.upper(), content) def test_compute_on_large_data_over_forwarder_data_from_repo_to_data_prefix(self): """Test fetch result with large input data from repo with a to data prefix""" self.ICNRepo.start_repo() self.forwarder1.start_forwarder() self.forwarder2.start_forwarder() time.sleep(2) self.add_face_and_forwadingrule() time.sleep(5) self.mgmtClient2.add_new_content(Name("/lib/func/f1"), "PYTHON\nf\ndef f(a):\n return a.upper()") fetch_name = Name("/test/data/d3") fetch_name += "/lib/func/f1(_)" fetch_name += "NFN" time.sleep(1) content = None try: 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(self.data3.upper(), content) 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)
fetch_tool = Fetch("nfn0", None, 255, NdnTlvEncoder(), interfaces=[simulation_bus.add_interface("fetchtool1")]) nfn_fwd0.start_forwarder() nfn_fwd1.start_forwarder() simulation_bus.start_process() mgmt_client0.add_face("nfn1", None, 0) mgmt_client0.add_forwarding_rule(Name("/data"), [0]) mgmt_client0.add_new_content( Name("/func/combine"), "PYTHON\nfunc\ndef func(a, b):\n return a + b") mgmt_client1.add_new_content(Name("/data/obj1"), "World") name = Name("/func/combine") name += '_("Hello",/data/obj1)' name += "NFN" res = fetch_tool.fetch_data(name, timeout=20) print(res) nfn_fwd0.stop_forwarder() nfn_fwd1.stop_forwarder() fetch_tool.stop_fetch() simulation_bus.stop_process() mgmt_client0.shutdown() mgmt_client1.shutdown()