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()
