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)
class MapReduceSimulation(unittest.TestCase):
"""Simulate a Map Reduce Scenario where timeout prevention is required."""
@abc.abstractmethod
def get_encoder(self) -> BasicEncoder:
return SimpleStringEncoder
def setUp(self):
self.encoder_type = self.get_encoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type())
self.fetch_tool1 = Fetch(
"nfn0",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool1")])
self.nfn0 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn0")],
log_level=255,
ageing_interval=1)
self.nfn1 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn1")],
log_level=255,
ageing_interval=1)
self.nfn2 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn2")],
log_level=255,
ageing_interval=1)
self.nfn3 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn3")],
log_level=255,
ageing_interval=1)
self.nfn4 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn4")],
log_level=255,
ageing_interval=1)
self.repo1 = ICNDataRepository(
"/tmp/repo1", Name("/repo/r1"), 0, 255, self.encoder_type(), False,
False, [self.simulation_bus.add_interface("repo1")])
self.repo2 = ICNDataRepository(
"/tmp/repo2", Name("/repo/r2"), 0, 255, self.encoder_type(), False,
False, [self.simulation_bus.add_interface("repo2")])
self.repo3 = ICNDataRepository(
"/tmp/repo3", Name("/repo/r3"), 0, 255, self.encoder_type(), False,
False, [self.simulation_bus.add_interface("repo3")])
self.repo4 = ICNDataRepository(
"/tmp/repo4", Name("/repo/r4"), 0, 255, self.encoder_type(), False,
False, [self.simulation_bus.add_interface("repo4")])
self.nfn1.icnlayer.pit.set_pit_timeout(0)
self.nfn1.icnlayer.cs.set_cs_timeout(30)
self.nfn2.icnlayer.pit.set_pit_timeout(0)
self.nfn2.icnlayer.cs.set_cs_timeout(30)
self.nfn3.icnlayer.pit.set_pit_timeout(0)
self.nfn3.icnlayer.cs.set_cs_timeout(30)
self.nfn4.icnlayer.pit.set_pit_timeout(0)
self.nfn4.icnlayer.cs.set_cs_timeout(30)
self.nfn0.nfnlayer.optimizer = MapReduceOptimizer(
self.nfn0.icnlayer.cs, self.nfn0.icnlayer.fib,
self.nfn0.icnlayer.pit, self.nfn0.linklayer.faceidtable)
self.nfn1.nfnlayer.optimizer = MapReduceOptimizer(
self.nfn1.icnlayer.cs, self.nfn1.icnlayer.fib,
self.nfn1.icnlayer.pit, self.nfn1.linklayer.faceidtable)
self.nfn2.nfnlayer.optimizer = MapReduceOptimizer(
self.nfn2.icnlayer.cs, self.nfn2.icnlayer.fib,
self.nfn2.icnlayer.pit, self.nfn2.linklayer.faceidtable)
self.nfn3.nfnlayer.optimizer = MapReduceOptimizer(
self.nfn3.icnlayer.cs, self.nfn3.icnlayer.fib,
self.nfn3.icnlayer.pit, self.nfn3.linklayer.faceidtable)
self.nfn4.nfnlayer.optimizer = MapReduceOptimizer(
self.nfn4.icnlayer.cs, self.nfn4.icnlayer.fib,
self.nfn4.icnlayer.pit, self.nfn4.linklayer.faceidtable)
self.mgmt_client0 = MgmtClient(
self.nfn0.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client1 = MgmtClient(
self.nfn1.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client2 = MgmtClient(
self.nfn2.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client3 = MgmtClient(
self.nfn3.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client4 = MgmtClient(
self.nfn4.mgmt.mgmt_sock.getsockname()[1])
def tearDown(self):
self.nfn0.stop_forwarder()
self.nfn1.stop_forwarder()
self.nfn2.stop_forwarder()
self.nfn3.stop_forwarder()
self.nfn4.stop_forwarder()
self.repo1.stop_repo()
self.repo2.stop_repo()
self.repo3.stop_repo()
self.repo4.stop_repo()
self.fetch_tool1.stop_fetch()
self.simulation_bus.stop_process()
self.tearDown_repo()
def setup_faces_and_connections(self):
self.nfn0.start_forwarder()
self.nfn1.start_forwarder()
self.nfn2.start_forwarder()
self.nfn3.start_forwarder()
self.nfn4.start_forwarder()
self.repo1.start_repo()
self.repo2.start_repo()
self.repo3.start_repo()
self.repo4.start_repo()
self.simulation_bus.start_process()
time.sleep(3)
# setup forwarding rules
self.mgmt_client0.add_face("nfn1", None, 0)
self.mgmt_client0.add_forwarding_rule(Name("/lib/func1"), [0])
self.mgmt_client0.add_face("nfn2", None, 0)
self.mgmt_client0.add_forwarding_rule(Name("/lib/func2"), [1])
self.mgmt_client0.add_face("nfn3", None, 0)
self.mgmt_client0.add_forwarding_rule(Name("/lib/func3"), [2])
self.mgmt_client0.add_face("nfn4", None, 0)
self.mgmt_client0.add_forwarding_rule(Name("/lib/func4"), [3])
self.mgmt_client1.add_face("repo1", None, 0)
self.mgmt_client1.add_forwarding_rule(Name("/repo/r1"), [0])
self.mgmt_client2.add_face("repo2", None, 0)
self.mgmt_client2.add_forwarding_rule(Name("/repo/r2"), [0])
self.mgmt_client3.add_face("repo3", None, 0)
self.mgmt_client3.add_forwarding_rule(Name("/repo/r3"), [0])
self.mgmt_client4.add_face("repo4", None, 0)
self.mgmt_client4.add_forwarding_rule(Name("/repo/r4"), [0])
self.mgmt_client1.add_face("nfn0", None, 0)
self.mgmt_client1.add_forwarding_rule(Name("/lib"), [1])
#setup function code
self.mgmt_client0.add_new_content(
Name("/lib/reduce4"),
"PYTHON\nreduce4\ndef reduce4(a,b,c,d):\n return a+b+c+d")
self.mgmt_client1.add_new_content(
Name("/lib/func1"),
"PYTHON\nf\ndef f(a):\n for i in range(0,100000000):\n a.upper()\n return a.upper()"
)
self.mgmt_client2.add_new_content(
Name("/lib/func2"),
"PYTHON\nf\ndef f(a):\n for i in range(0,100000000):\n a.upper()\n return a.upper()"
)
self.mgmt_client3.add_new_content(
Name("/lib/func3"),
"PYTHON\nf\ndef f(a):\n for i in range(0,100000000):\n a.upper()\n return a.upper()"
)
self.mgmt_client4.add_new_content(
Name("/lib/func4"),
"PYTHON\nf\ndef f(a):\n for i in range(0,100000000):\n a.upper()\n return a.upper()"
)
def setup_repo(self):
for i in range(1, 5):
self.path = "/tmp/repo" + str(i)
try:
os.stat(self.path)
except:
os.mkdir(self.path)
with open(self.path + "/data" + str(i), 'w+') as content_file:
content_file.write("data" + str(i))
def tearDown_repo(self):
try:
shutil.rmtree(self.path)
os.remove("/tmp/repo")
except:
pass
def test_simple_map_reduce(self):
"""Simple map reduce test with input data as string parameter"""
self.setup_faces_and_connections()
name = Name("/lib/reduce4")
name += '_(/lib/func1("helloworld1"),/lib/func2("helloworld2"),/lib/func3("helloworld3"),/lib/func4("helloworld4"))'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=0)
time.sleep(3)
print(res)
self.assertEqual("HELLOWORLD1HELLOWORLD2HELLOWORLD3HELLOWORLD4", res)
def test_simple_map_reduce_data_from_repo(self):
"""Simple map reduce test with input data from repo"""
self.setup_repo()
self.setup_faces_and_connections()
name = Name("/lib/reduce4")
name += '_(/lib/func1(/repo/r1/data1),/lib/func2(/repo/r2/data2),/lib/func3(/repo/r3/data3),/lib/func4(/repo/r4/data4))'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=0)
time.sleep(3)
print(res)
self.assertEqual("DATA1DATA2DATA3DATA4", res)
def test_simple_map_reduce_data_from_repo_to_data(self):
"""Simple map reduce test with input data from repo forwarding to data"""
self.setup_repo()
self.setup_faces_and_connections()
name = Name("/repo/r1/data1")
name += '/lib/reduce4(/lib/func1(_),/lib/func2(/repo/r2/data2),/lib/func3(/repo/r3/data3),/lib/func4(/repo/r4/data4))'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=0)
time.sleep(3)
print(res)
self.assertEqual("DATA1DATA2DATA3DATA4", res)
# Send content from fetch to repo over session. The repo will print out the content on the logger
fetch1.send_content(
(fetch1.get_session_name(Name('/test/t2')), 'Hello, is this repo1?'))
# Send content from repo over session. The receive loop will print out the content
repo1.repolayer.send_content(
content='Whatever I want, whenever I want it.')
# Test reconnecting sessions after repository has moved to another forwarder
faces = repo1.linklayer.faceidtable.get_faceids(
) # This is a little cheat, in the future we want to get the connected faceids from the repo itself.
repo1.repolayer.reconnect(initial_faces=faces, sid=None, max_hops=2)
# -------------------
# Stop the simulation
time.sleep(
1
) # Be safe and wait for all messages to trickle in before shutting down everything
fw0.stop_forwarder()
fw1.stop_forwarder()
fetch0.stop_fetch()
fetch1.stop_fetch()
simulation_bus.stop_process()
mgmt_repo0.shutdown()
mgmt_repo1.shutdown()
mgmt_fw0.shutdown()
mgmt_fw1.shutdown()
exit(0)
class cases_ICNDataRepository(object):
"""Test the ICN Data Repository using fetch"""
@abc.abstractmethod
def get_encoder(self):
"""returns the encoder to be used """
def setUp(self):
self.data1 = "data1"
self.data2 = 'A' * 5000
self.data3 = 'B' * 5000 + 'C' * 5000 + 'DE' * 5000
self.encoder = self.get_encoder()
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' * 5000 + 'C' * 5000 + 'DE' * 5000)
self.ICNRepo: ICNDataRepository = ICNDataRepository("/tmp/repo_unit_test", Name("/test/data"), 0,
encoder=self.get_encoder(), log_level=255)
self.repo_port = self.ICNRepo.linklayer.interfaces[0].get_port()
self.fetch = Fetch("127.0.0.1", self.repo_port, encoder=self.get_encoder())
def tearDown(self):
try:
shutil.rmtree(self.path)
os.remove("/tmp/repo_unit_test")
except:
pass
self.ICNRepo.stop_repo()
self.fetch.stop_fetch()
def test_fetch_single_data(self):
"""Test fetching a single data object without chunking"""
self.ICNRepo.start_repo()
content = self.fetch.fetch_data(Name("/test/data/f1"))
self.assertEqual(content, self.data1)
def test_fetch_small_data(self):
"""Test fetching a small data object with little chunking"""
self.ICNRepo.start_repo()
content = self.fetch.fetch_data(Name("/test/data/f2"))
self.assertEqual(content, self.data2)
def test_fetch_big_data(self):
"""Test fetching a big data object with lot of chunking"""
self.ICNRepo.start_repo()
content = self.fetch.fetch_data(Name("/test/data/f3"))
self.assertEqual(content, self.data3)
def test_fetch_nack(self):
"""Test fetching content which is not available and get nack"""
self.ICNRepo.start_repo()
content = self.fetch.fetch_data(Name("/test/data/f4"))
self.assertEqual(content, "Received Nack: " + NackReason.NO_CONTENT.value)
class EdgeComputingSimpleSimulation1(unittest.TestCase):
"""run the simple Edge Computing Scenario Simulation"""
@abc.abstractmethod
def get_encoder(self) -> BasicEncoder:
return SimpleStringEncoder
def setUp(self):
self.encoder_type = self.get_encoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type())
self.fetch_tool1 = Fetch(
"rsu1",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool1")])
self.fetch_tool2 = Fetch(
"rsu2",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool2")])
self.fetch_tool3 = Fetch(
"rsu3",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool3")])
self.rsu1 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("rsu1")],
log_level=255,
ageing_interval=1)
self.rsu2 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("rsu2")],
log_level=255,
ageing_interval=1)
self.rsu3 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("rsu3")],
log_level=255,
ageing_interval=1)
self.rsu1.icnlayer.pit.set_pit_timeout(0)
self.rsu1.icnlayer.cs.set_cs_timeout(30)
self.rsu2.icnlayer.pit.set_pit_timeout(0)
self.rsu2.icnlayer.cs.set_cs_timeout(30)
self.rsu3.icnlayer.pit.set_pit_timeout(0)
self.rsu3.icnlayer.cs.set_cs_timeout(30)
self.rsu1.nfnlayer.optimizer = EdgeComputingOptimizer(
self.rsu1.icnlayer.cs, self.rsu1.icnlayer.fib,
self.rsu1.icnlayer.pit, self.rsu1.linklayer.faceidtable)
self.rsu2.nfnlayer.optimizer = EdgeComputingOptimizer(
self.rsu2.icnlayer.cs, self.rsu2.icnlayer.fib,
self.rsu2.icnlayer.pit, self.rsu2.linklayer.faceidtable)
self.rsu3.nfnlayer.optimizer = EdgeComputingOptimizer(
self.rsu3.icnlayer.cs, self.rsu3.icnlayer.fib,
self.rsu3.icnlayer.pit, self.rsu3.linklayer.faceidtable)
self.mgmt_client1 = MgmtClient(
self.rsu1.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client2 = MgmtClient(
self.rsu2.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client3 = MgmtClient(
self.rsu3.mgmt.mgmt_sock.getsockname()[1])
def tearDown(self):
self.rsu1.stop_forwarder()
self.rsu2.stop_forwarder()
self.rsu3.stop_forwarder()
self.fetch_tool1.stop_fetch()
self.fetch_tool2.stop_fetch()
self.fetch_tool3.stop_fetch()
self.simulation_bus.stop_process()
def setup_faces_and_connections(self):
self.rsu1.start_forwarder()
self.rsu2.start_forwarder()
self.rsu3.start_forwarder()
self.simulation_bus.start_process()
#setup rsu1
self.mgmt_client1.add_face("rsu2", None, 0)
self.mgmt_client1.add_forwarding_rule(Name("/rsu"), [0])
self.mgmt_client1.add_new_content(
Name("/rsu/func/f1"),
"PYTHON\nf\ndef f(a):\n for i in range(0,20000000):\n a.upper()\n return a.upper() + ' RSU1'"
)
#setup rsu2
self.mgmt_client2.add_face("rsu1", None, 0)
self.mgmt_client2.add_face("rsu3", None, 0)
self.mgmt_client2.add_forwarding_rule(Name("/rsu"), [0, 1])
self.mgmt_client2.add_new_content(
Name("/rsu/func/f1"),
"PYTHON\nf\ndef f(a):\n for i in range(0,30000000):\n a.upper()\n return a.upper() + ' RSU2'"
)
#setup rsu3
self.mgmt_client3.add_face("rsu2", None, 0)
self.mgmt_client3.add_forwarding_rule(Name("/rsu"), [0])
self.mgmt_client3.add_new_content(
Name("/rsu/func/f1"),
"PYTHON\nf\ndef f(a):\n for i in range(0,40000000):\n a.upper()\n return a.upper() + ' RSU3'"
)
def test_without_data_from_client(self):
"""execute a simple function on the rsus"""
self.setup_faces_and_connections()
name = Name("/rsu/func/f1")
name += '_("helloworld")'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=5)
self.assertEqual(res, "HELLOWORLD RSU1")
print("Result at RSU1:", res)
time.sleep(5)
res = self.fetch_tool2.fetch_data(name, timeout=5)
print("Result as fetched via RSU2:", res)
self.assertEqual(res, "HELLOWORLD RSU1")
def test_inner_call_without_data_from_client(self):
"""execute one function on the first node and another function on the second node"""
self.setup_faces_and_connections()
self.mgmt_client2.add_new_content(
Name("/rsu/func/f2"), "PYTHON\nf\ndef f(a):\n return a[::-1]")
name1 = Name("/rsu/func/f1")
name1 += '_("helloworld")'
name1 += "NFN"
name2 = Name("/rsu/func/f2")
name2 += '_(/rsu/func/f1("helloworld"))'
name2 += "NFN"
res1 = self.fetch_tool1.fetch_data(name1, timeout=20)
print(res1)
time.sleep(6)
res2 = self.fetch_tool2.fetch_data(name2, timeout=20)
print(res2)
def test_result_placement_using_names(self):
"""execute one function on a node where the client will be, when the computation is finished"""
self.setup_faces_and_connections()
self.mgmt_client3.add_new_content(
Name("/rsu/id3/func/f2"),
"PYTHON\nf\ndef f(a):\n for i in range(0,20000000):\n a.upper()\n return a.upper() + ' PLACED ON RSU3'"
)
name1 = Name("/rsu/id3/func/f2")
name1 += '_("helloworld")'
name1 += "NFN"
res1 = self.fetch_tool1.fetch_data(name1, timeout=10)
print(res1)
res2 = self.fetch_tool3.fetch_data(name1, timeout=10)
print(res2)
class TimeoutPreventionSimulation(unittest.TestCase):
"""Simulate a Scenario where timeout prevention is required"""
@abc.abstractmethod
def get_encoder(self) -> BasicEncoder:
return SimpleStringEncoder
def setUp(self):
self.encoder_type = self.get_encoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type())
self.fetch_tool1 = Fetch(
"nfn1",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool1")])
self.nfn1 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn1")],
log_level=255,
ageing_interval=1)
self.nfn2 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn2")],
log_level=255,
ageing_interval=1)
self.simulation_bus.add_interface("deadend")
self.nfn1.icnlayer.pit.set_pit_timeout(0)
self.nfn1.icnlayer.cs.set_cs_timeout(30)
self.nfn2.icnlayer.pit.set_pit_timeout(0)
self.nfn2.icnlayer.cs.set_cs_timeout(30)
self.nfn1.nfnlayer.optimizer = ToDataFirstOptimizer(
self.nfn1.icnlayer.cs, self.nfn1.icnlayer.fib,
self.nfn1.icnlayer.pit, self.nfn1.linklayer.faceidtable)
self.nfn2.nfnlayer.optimizer = ToDataFirstOptimizer(
self.nfn2.icnlayer.cs, self.nfn2.icnlayer.fib,
self.nfn2.icnlayer.pit, self.nfn2.linklayer.faceidtable)
self.mgmt_client1 = MgmtClient(
self.nfn1.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client2 = MgmtClient(
self.nfn2.mgmt.mgmt_sock.getsockname()[1])
def tearDown(self):
self.nfn1.stop_forwarder()
self.nfn2.stop_forwarder()
self.fetch_tool1.stop_fetch()
self.simulation_bus.stop_process()
def setup_faces_and_connections(self):
self.nfn1.start_forwarder()
self.nfn2.start_forwarder()
self.simulation_bus.start_process()
# setup nfn1
self.mgmt_client1.add_face("nfn2", None, 0)
self.mgmt_client1.add_forwarding_rule(Name("/lib"), [0])
self.mgmt_client1.add_new_content(Name("/test/data/string"),
"This is a String")
# setup nfn2
self.mgmt_client1.add_face("nfn1", None, 0)
self.mgmt_client1.add_forwarding_rule(Name("/test"), [0])
self.mgmt_client2.add_new_content(
Name("/lib/func/f1"),
"PYTHON\nf\ndef f(a):\n for i in range(0,100000000):\n a.upper()\n return a.upper() + ' WITHOUT TIMEOUT'"
)
def test_simple_timeout_prevention(self):
"""Simple test to see if timeout prevention works"""
self.setup_faces_and_connections()
name = Name("/lib/func/f1")
name += '_("helloworld")'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=0)
time.sleep(3)
self.assertEqual("HELLOWORLD WITHOUT TIMEOUT", res)
print(res)
def test_timeout_prevention_if_no_comp(self):
"""Simple test to see if timeout prevention works if no computation is available and no fwd rule"""
self.setup_faces_and_connections()
name = Name("/lib/func/f2")
name += '_("helloworld")'
name += "NFN"
res = self.fetch_tool1.fetch_data(name, timeout=0)
self.assertEqual(
"Received Nack: one or many input data (function or data) is unavailable",
res)
time.sleep(3)
print(res)
def test_timeout_prevention_if_no_comp_no_data_fwd(self):
"""Simple test to see if timeout prevention works if no computation is available and no data are replied"""
self.setup_faces_and_connections()
name = Name("/lib/func/f2")
name += '_("helloworld")'
name += "NFN"
self.mgmt_client2.add_face("deadend", None, 0)
self.mgmt_client2.add_forwarding_rule(Name("/lib"), [0])
res = self.fetch_tool1.fetch_data(name, timeout=0)
self.assertEqual(
"Received Nack: one or many input data (function or data) is unavailable",
res)
time.sleep(3)
print(res)
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()
class cases_Simulation():
"""Test the PiCN Simulation System"""
@abc.abstractmethod
def get_encoder(self) -> BasicEncoder:
pass
def setUp(self):
self.encoder_type = self.get_encoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type())
self.fetchiface = self.simulation_bus.add_interface("fetch")
self.encoder = self.encoder_type()
self.icn_forwarder1 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd1")], log_level=255)
self.icn_forwarder2 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd2")], log_level=255)
#self.simulation_bus.start_process()
def tearDown(self):
try:
self.simulation_bus.stop_process()
self.icn_forwarder1.stop_forwarder()
self.icn_forwarder2.stop_forwarder()
except:
self.icn_forwarder2.stop_repo()
pass
def test_send_single_packet(self):
"""Test fetching a single content object over the simulation bus"""
self.icn_forwarder1.start_forwarder()
self.icn_forwarder2.start_forwarder()
self.simulation_bus.start_process()
fid1 = self.icn_forwarder1.linklayer.faceidtable.get_or_create_faceid(AddressInfo("icnfwd2", 0))
self.icn_forwarder1.icnlayer.fib.add_fib_entry(Name("/test"), [fid1])
self.icn_forwarder2.icnlayer.cs.add_content_object(Content("/test/data", "HelloWorld"), static=True)
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"))
def test_send_single_packet_with_delay(self):
"""Test fetching a single content object over the simulation bus"""
delay_func = lambda packet: 0.5
self.fetchiface = self.simulation_bus.add_interface("fetch", delay_func=delay_func)
self.icn_forwarder1 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd1", delay_func=delay_func)])
self.icn_forwarder2 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd2", delay_func=delay_func)])
self.simulation_bus.start_process()
self.icn_forwarder1.start_forwarder()
self.icn_forwarder2.start_forwarder()
fid1 = self.icn_forwarder1.linklayer.faceidtable.get_or_create_faceid(AddressInfo("icnfwd2", 0))
self.icn_forwarder1.icnlayer.fib.add_fib_entry(Name("/test"), [fid1])
self.icn_forwarder2.icnlayer.cs.add_content_object(Content("/test/data", "HelloWorld"), static=True)
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"))
def test_send_single_packet_with_packet_loss(self):
"""Test fetching a single content object over the simulation bus"""
packet_loss_func = lambda packet: True
self.fetchiface = self.simulation_bus.add_interface("fetch", packet_loss_func=packet_loss_func)
self.icn_forwarder1 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd1", packet_loss_func=packet_loss_func)])
self.icn_forwarder2 = ICNForwarder(port=0, encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("icnfwd2", packet_loss_func=packet_loss_func)])
self.simulation_bus.start_process()
self.icn_forwarder1.start_forwarder()
self.icn_forwarder2.start_forwarder()
fid1 = self.icn_forwarder1.linklayer.faceidtable.get_or_create_faceid(AddressInfo("icnfwd2", 0))
self.icn_forwarder1.icnlayer.fib.add_fib_entry(Name("/test"), [fid1])
self.icn_forwarder2.icnlayer.cs.add_content_object(Content("/test/data", "HelloWorld"), static=True)
interest = Interest("/test/data")
wire_data = self.encoder.encode(interest)
self.fetchiface.send(wire_data, "icnfwd1")
try:
self.fetchiface.receive(timeout=4)
except queue.Empty:
pass
else:
self.fail()
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 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_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_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_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()
class test_RoutingLayerFullStack(unittest.TestCase):
def setUp(self):
self.f9000 = ICNForwarder(9000, encoder=NdnTlvEncoder(), routing=True,
peers=[('127.0.0.1', 9001), ('127.0.0.1', 9002), ('127.0.0.1', 9090)])
self.f9001 = ICNForwarder(9001, encoder=NdnTlvEncoder(), routing=True,
peers=[('127.0.0.1', 9000), ('127.0.0.1', 9002), ('127.0.0.1', 9003),
('127.0.0.1', 9004)])
self.f9002 = ICNForwarder(9002, encoder=NdnTlvEncoder(), routing=True,
peers=[('127.0.0.1', 9000), ('127.0.0.1', 9001), ('127.0.0.1', 9004)])
self.f9003 = ICNForwarder(9003, encoder=NdnTlvEncoder(), routing=True,
peers=[('127.0.0.1', 9001), ('127.0.0.1', 9004)])
self.f9004 = ICNForwarder(9004, encoder=NdnTlvEncoder(), routing=True,
peers=[('127.0.0.1', 9001), ('127.0.0.1', 9002), ('127.0.0.1', 9003)])
os.makedirs('/tmp/test_repo', exist_ok=True)
f = open('/tmp/test_repo/helloworld', 'w')
f.write('Hello, World!\n')
f.close()
self.repo = ICNDataRepository('/tmp/test_repo', Name('/testrepo'), port=9090, encoder=NdnTlvEncoder())
self.fetch = Fetch('127.0.0.1', 9004, encoder=NdnTlvEncoder())
# Create RIB entry for the repository (with Python weirdness)
repo_fid: int = self.f9000.linklayer.faceidtable.get_or_create_faceid(AddressInfo(('127.0.0.1', 9090), 0))
rib: BaseRoutingInformationBase = self.f9000.routinglayer.rib
rib.insert(Name('/testrepo'), repo_fid, distance=1, timeout=None)
def tearDown(self):
self.f9000.stop_forwarder()
self.f9001.stop_forwarder()
self.f9002.stop_forwarder()
self.f9003.stop_forwarder()
self.f9004.stop_forwarder()
self.repo.stop_repo()
self.fetch.stop_fetch()
shutil.rmtree('/tmp/test_repo')
def test_network(self):
"""
C
|
F[9004] -- F[9003]
/ \ /
/ \ /
/ \ /
F[9002] -- F[9001]
\ /
\ /
\ /
F[9000]
|
R
"""
self.f9000.start_forwarder()
self.f9001.start_forwarder()
self.f9002.start_forwarder()
self.f9003.start_forwarder()
self.f9004.start_forwarder()
self.repo.start_repo()
hw: str = ''
until = datetime.utcnow() + timedelta(seconds=20)
while hw != 'Hello, World!\n' and datetime.utcnow() < until:
try:
hw = self.fetch.fetch_data(Name('/testrepo/helloworld'), timeout=1.0)
except queue.Empty:
pass
self.assertEqual('Hello, World!\n', hw)
until = datetime.utcnow() + timedelta(seconds=20)
hw = ''
start = datetime.utcnow()
end = start
while hw != 'Hello, World!\n' and datetime.utcnow() < until:
try:
hw = self.fetch.fetch_data(Name('/testrepo/helloworld'), timeout=1.0)
end = datetime.utcnow()
except queue.Empty:
pass
self.assertEqual('Hello, World!\n', hw)
self.assertLess(end-start, timedelta(seconds=4))
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,1000):
name = "/f" + str(i)
with open(self.path + name, 'w+') as content_file:
content_file.write(self.data3)
for i in range(1,1000):
fname = "/f" + str(i)
icn_name = "/test/data" + name
content = self.fetch.fetch_data(Name(icn_name))
self.assertEqual(content, self.data3)