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(), [self.simulation_bus.add_interface("fetchtool1")])
self.fetch_tool2 = Fetch("rsu2", None, 255, self.encoder_type(), [self.simulation_bus.add_interface("fetchtool2")])
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 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 setUp(self):
self.encoder_type = SimpleStringEncoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type)
chunk_size = 8192
self.chunkifyer = SimpleContentChunkifyer(chunk_size)
# Initialize two cars
self.cars = []
self.fetch_tool_cars = []
self.mgmt_client_cars = []
for i in range(2):
self.cars.append(
ICNForwarder(
0,
encoder=self.encoder_type,
routing=True,
interfaces=[self.simulation_bus.add_interface(f"car{i}")]))
self.fetch_tool_cars.append(
Fetch(f"car{i}",
None,
255,
self.encoder_type,
interfaces=[
self.simulation_bus.add_interface(f"ftcar{i}")
]))
self.mgmt_client_cars.append(
MgmtClient(self.cars[i].mgmt.mgmt_sock.getsockname()[1]))
self.cars[i].icnlayer.cs.set_cs_timeout(40)
# Initialize RSUs
self.rsus = []
self.fetch_tools = []
self.mgmt_clients = []
for i in range(3):
self.rsus.append(
NFNForwarderData(
0,
encoder=self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"rsu{i}")],
chunk_size=chunk_size,
num_of_forwards=1,
ageing_interval=10))
self.fetch_tools.append(
Fetch(f"rsu{i}",
None,
255,
self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"ft{i}")
]))
self.rsus[i].nfnlayer.optimizer = EdgeComputingOptimizer(
self.rsus[i].icnlayer.cs, self.rsus[i].icnlayer.fib,
self.rsus[i].icnlayer.pit, self.rsus[i].linklayer.faceidtable)
self.mgmt_clients.append(
MgmtClient(self.rsus[i].mgmt.mgmt_sock.getsockname()[1]))
self.fetch_tools[i].timeoutpreventionlayer.timeout_interval = 40
self.rsus[i].icnlayer.cs.set_cs_timeout(60)
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 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 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 _setup_mobile_nodes(self):
"""configure the mobile nodes"""
for node in self._mobile_nodes:
node.forwarder = ICNForwarder(
0,
encoder=SimpleStringEncoder(),
routing=True,
interfaces=[
self._simulation_bus.add_interface(f"car{node.node_id}")
])
node.fetch = Fetch(
f"car{node.node_id}",
None,
255,
SimpleStringEncoder(),
interfaces=[
self._simulation_bus.add_interface(f"ftcar{node.node_id}")
])
node.mgmt_tool = MgmtClient(
node.forwarder.mgmt.mgmt_sock.getsockname()[1])
for stationary_node in self._stationary_nodes:
car_face_id = node.forwarder.linklayer.faceidtable.get_or_create_faceid(
AddressInfo(f"rsu{stationary_node.node_id}", 0))
self.to_rsu_faces[stationary_node.node_id][
node.node_id] = car_face_id
rsu_face_id = node.forwarder.linklayer.faceidtable.get_or_create_faceid(
AddressInfo(f"car{stationary_node.node_id}", 0))
self.to_car_faces[stationary_node.node_id][
node.node_id] = rsu_face_id
def setUp(self):
self.encoder = self.get_encoder()
self.forwarder1 = NFNForwarder(0,
encoder=self.get_encoder(),
log_level=255,
use_thunks=True)
self.forwarder2 = NFNForwarder(0,
encoder=self.get_encoder(),
log_level=255,
use_thunks=True)
self.forwarder3 = NFNForwarder(0,
encoder=self.get_encoder(),
log_level=255,
use_thunks=True)
self.forwarder1_port = self.forwarder1.linklayer.interfaces[
0].get_port()
self.forwarder2_port = self.forwarder2.linklayer.interfaces[
0].get_port()
self.forwarder3_port = self.forwarder3.linklayer.interfaces[
0].get_port()
self.forwarder1.icnlayer.pit.set_pit_timeout(10)
self.forwarder1.icnlayer.pit.set_pit_retransmits(10)
self.client = Fetch("127.0.0.1", self.forwarder1_port, 255,
self.get_encoder())
self.mgmt1 = MgmtClient(self.forwarder1_port)
self.mgmt2 = MgmtClient(self.forwarder2_port)
self.mgmt3 = MgmtClient(self.forwarder3_port)
self.forwarder1.start_forwarder()
self.forwarder2.start_forwarder()
self.forwarder3.start_forwarder()
self.mgmt1.add_face("127.0.0.1", self.forwarder2_port, 0)
self.mgmt1.add_face("127.0.0.1", self.forwarder3_port, 0)
self.mgmt1.add_forwarding_rule(Name("/dat"), [0])
self.mgmt1.add_forwarding_rule(Name("/fct"), [1])
self.content1 = "This is our test content object" * 20
self.function1 = "PYTHON\nf\ndef f(a):\n return a.upper()"
self.mgmt2.add_new_content(Name("/dat/data/d1"), self.content1)
self.mgmt3.add_new_content(Name("/fct/f1"), self.function1)
def setUp(self):
self.encoder_type = SimpleStringEncoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type)
chunk_size = 4
self.chunkifyer = SimpleContentChunkifyer(chunk_size)
self.car = ICNForwarder(
0,
encoder=self.encoder_type,
routing=True,
interfaces=[self.simulation_bus.add_interface("car")])
self.fetch_tool_car = Fetch(
"car",
None,
255,
self.encoder_type,
interfaces=[self.simulation_bus.add_interface("ftcar")])
self.mgmt_client_car = MgmtClient(
self.car.mgmt.mgmt_sock.getsockname()[1])
self.rsus = []
self.fetch_tools = []
self.mgmt_clients = []
for i in range(4):
self.rsus.append(
NFNForwarderData(
0,
encoder=self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"rsu{i}")],
chunk_size=chunk_size,
num_of_forwards=0))
self.fetch_tools.append(
Fetch(f"rsu{i}",
None,
255,
self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"ft{i}")
]))
self.rsus[i].nfnlayer.optimizer = EdgeComputingOptimizer(
self.rsus[i].icnlayer.cs, self.rsus[i].icnlayer.fib,
self.rsus[i].icnlayer.pit, self.rsus[i].linklayer.faceidtable)
self.mgmt_clients.append(
MgmtClient(self.rsus[i].mgmt.mgmt_sock.getsockname()[1]))
self.fetch_tools[i].timeoutpreventionlayer.timeout_interval = 30
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)
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 _setup_stationary_nodes(self):
"""configure the NFN com. stack at the stationary nodes"""
for node in self._stationary_nodes:
# install the NFN forwarder and the mgmt client tool at the stationary node
if self._forwarder == "NFNForwarder":
node.nfn_forwarder = NFNForwarder(
0,
encoder=SimpleStringEncoder(),
interfaces=[
self._simulation_bus.add_interface(
f"rsu{node.node_id}")
],
ageing_interval=10)
elif self._forwarder == "NFNForwarderData":
node.nfn_forwarder = NFNForwarderData(
0,
encoder=SimpleStringEncoder(),
interfaces=[
self._simulation_bus.add_interface(
f"rsu{node.node_id}")
],
chunk_size=self._chunk_size,
num_of_forwards=1,
ageing_interval=10)
else:
self.logger.error(
"Forwarder: " + self._forwarder +
" is not supported! Use 'NFNForwarder' or 'NFNForwarderData'!"
)
# install the optimizer
if self._optimizer == "ToDataFirstOptimizer":
node.nfn_forwarder.nfnlayer.optimizer = ToDataFirstOptimizer(
node.nfn_forwarder.icnlayer.cs,
node.nfn_forwarder.icnlayer.fib,
node.nfn_forwarder.icnlayer.pit,
node.nfn_forwarder.linklayer.faceidtable)
elif self._optimizer == "EdgeComputingOptimizer":
node.nfn_forwarder.nfnlayer.optimizer = EdgeComputingOptimizer(
node.nfn_forwarder.icnlayer.cs,
node.nfn_forwarder.icnlayer.fib,
node.nfn_forwarder.icnlayer.pit,
node.nfn_forwarder.linklayer.faceidtable)
# install the mgmt client tool at the node
node.mgmt_tool = MgmtClient(
node.nfn_forwarder.mgmt.mgmt_sock.getsockname()[1])
node.nfn_forwarder.icnlayer.cs.set_cs_timeout(60)
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 setup_network(self):
"""configure a network according to the configuration"""
#create RSUs and RSU mgmt tools
self.rsus = []
self.mgmt_rsu = []
for i in range(0, self.number_of_rsus):
rsu = NFNForwarderData(0, encoder=self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"rsu{i}")],
chunk_size=self.chunk_size, num_of_forwards=1, ageing_interval=10)
rsu.nfnlayer.optimizer = self.optimizer(rsu.icnlayer.cs, rsu.icnlayer.fib, rsu.icnlayer.pit,
rsu.linklayer.faceidtable)
mgmt_client = MgmtClient(rsu.mgmt.mgmt_sock.getsockname()[1])
self.rsus.append(rsu)
self.mgmt_rsu.append(mgmt_client)
self.rsus[i].icnlayer.cs.set_cs_timeout(60)
#setup connections
for i in range(1, self.number_of_rsus-1):
#setup connections between rsus
faceid_rsu_l = self.rsus[i].linklayer.faceidtable.get_or_create_faceid(AddressInfo("rsu" + str(i-1), 0))
faceid_rsu_r = self.rsus[i].linklayer.faceidtable.get_or_create_faceid(AddressInfo("rsu" + str(i+1), 0))
self.rsus[i].icnlayer.fib.add_fib_entry(Name("/nL"), [faceid_rsu_l])
self.rsus[i].icnlayer.fib.add_fib_entry(Name("/nR"), [faceid_rsu_r])
#setup first and last rsu
faceid_rsu_1st = self.rsus[0].linklayer.faceidtable.get_or_create_faceid(AddressInfo("rsu" + str(1), 0))
faceid_rsu_last = self.rsus[self.number_of_rsus-1].linklayer.faceidtable.get_or_create_faceid(AddressInfo("rsu" + str(self.number_of_rsus-2), 0))
self.rsus[0].icnlayer.fib.add_fib_entry(Name("/nR"), [faceid_rsu_1st])
self.rsus[self.number_of_rsus-1].icnlayer.fib.add_fib_entry(Name("/nL"), [faceid_rsu_last])
#add function
for i in range(0, self.number_of_rsus):
for n in zip(self.named_functions.keys(), self.named_functions.values()):
add_msg = self.rsus[i].icnlayer.cs.add_content_object(Content(Name(n[0]), n[1]), static=True)
#setup cars
self.car_forwarders = []
self.car_fetch = []
self.car_mgmt = []
for i in range (0, self.number_of_cars):
self.car_forwarders.append(ICNForwarder(0, encoder=self.encoder_type, routing=True,
interfaces=[self.simulation_bus.add_interface(f"car{i}")]))
self.car_fetch.append(Fetch(f"car{i}", None, 255, self.encoder_type,
interfaces=[self.simulation_bus.add_interface(f"ftcar{i}")]))
mgmt_client_car = MgmtClient(self.car_forwarders[i].mgmt.mgmt_sock.getsockname()[1])
self.car_mgmt.append(mgmt_client_car)
for j in range(0, self.number_of_rsus):
car_face_id = self.car_forwarders[i].linklayer.faceidtable.get_or_create_faceid(AddressInfo(f"rsu{j}", 0))
self.to_rsu_faces[j][i] = car_face_id
rsu_face_id = self.rsus[j].linklayer.faceidtable.get_or_create_faceid(AddressInfo(f"car{i}", 0))
self.to_car_faces[j][i] = rsu_face_id
#Starting nodes
for i in range(0, self.number_of_rsus):
self.rsus[i].start_forwarder()
for i in range(0, self.number_of_cars):
self.car_forwarders[i].start_forwarder()
self.simulation_bus.start_process()
from PiCN.Packets import Content, Interest, Name
simulation_bus = SimulationBus(packetencoder=NdnTlvEncoder())
nfn_fwd0 = NFNForwarder(port=0,
encoder=NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("nfn0")],
log_level=255,
ageing_interval=1)
nfn_fwd1 = NFNForwarder(port=0,
encoder=NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("nfn1")],
log_level=255,
ageing_interval=1)
mgmt_client0 = MgmtClient(nfn_fwd0.mgmt.mgmt_sock.getsockname()[1])
mgmt_client1 = MgmtClient(nfn_fwd1.mgmt.mgmt_sock.getsockname()[1])
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])
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 setUp(self):
self.simulation_bus = SimulationBus(packetencoder=NdnTlvEncoder())
self.fetch_tool1 = Fetch(
"nfn0",
None,
255,
NdnTlvEncoder(),
interfaces=[self.simulation_bus.add_interface("fetchtoo11")])
self.nfn0 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[self.simulation_bus.add_interface("nfn0")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
self.nfn0.executors["PYTHONSTREAM"].initialize_executor(
self.nfn0.nfnlayer.queue_to_lower,
self.nfn0.nfnlayer.queue_from_lower, self.nfn0.nfnlayer.cs, False)
self.nfn0.icnlayer.pit.ageing = self.ageing
self.nfn0.timeoutpreventionlayer.ageing = self.ageing
self.nfn1 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[self.simulation_bus.add_interface("nfn1")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
self.nfn1.executors["PYTHONSTREAM"].initialize_executor(
self.nfn1.nfnlayer.queue_to_lower,
self.nfn1.nfnlayer.queue_from_lower, self.nfn1.nfnlayer.cs, False)
self.nfn1.icnlayer.pit.ageing = self.ageing
self.nfn1.timeoutpreventionlayer.ageing = self.ageing
self.nfn12 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[self.simulation_bus.add_interface("nfn12")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
self.nfn12.executors["PYTHONSTREAM"].initialize_executor(
self.nfn12.nfnlayer.queue_to_lower,
self.nfn12.nfnlayer.queue_from_lower, self.nfn12.nfnlayer.cs,
False)
self.nfn12.icnlayer.pit.ageing = self.ageing
self.nfn12.timeoutpreventionlayer.ageing = self.ageing
self.repo1 = ICNDataRepository(
"/tmp/repo1",
Name("/repo/r1"),
0,
255,
NdnTlvEncoder(),
False,
False,
interfaces=[self.simulation_bus.add_interface("repo1")])
self.mgmt_client0 = MgmtClient(
self.nfn0.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client1 = MgmtClient(
self.nfn1.mgmt.mgmt_sock.getsockname()[1])
self.mgmt_client01 = MgmtClient(
self.nfn12.mgmt.mgmt_sock.getsockname()[1])
def setUp(self):
self.encoder_type = self.get_encoder()
self.simulation_bus = SimulationBus(packetencoder=self.encoder_type())
self.fetch_tool1 = Fetch(
"distributor",
None,
255,
self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("fetchtool1")])
self.distributor = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("distributor")],
log_level=255,
ageing_interval=3)
self.nfn1 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn1")],
log_level=255,
ageing_interval=3)
self.nfn2 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn2")],
log_level=255,
ageing_interval=3)
self.nfn3 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn3")],
log_level=255,
ageing_interval=3)
self.nfn4 = NFNForwarder(
port=0,
encoder=self.encoder_type(),
interfaces=[self.simulation_bus.add_interface("nfn4")],
log_level=255,
ageing_interval=3)
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(50)
self.nfn1.icnlayer.cs.set_cs_timeout(0)
self.nfn2.icnlayer.pit.set_pit_timeout(50)
self.nfn2.icnlayer.cs.set_cs_timeout(0)
self.nfn3.icnlayer.pit.set_pit_timeout(50)
self.nfn3.icnlayer.cs.set_cs_timeout(0)
self.nfn4.icnlayer.pit.set_pit_timeout(50)
self.nfn4.icnlayer.cs.set_cs_timeout(0)
self.mgmt_client0 = MgmtClient(
self.distributor.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 setup(dummy):
dummy.simulation_bus = SimulationBus() # Use BasicStringEncoder
dummy.icn_repo0 = ICNDataRepository(
port=0,
prefix=Name("/test/t1"),
foldername=None,
interfaces=[dummy.simulation_bus.add_interface("repo0")],
log_level=255) # Initialize repository 0
dummy.icn_repo1 = ICNDataRepository(
port=0,
prefix=Name("/test/t2"),
foldername=None,
interfaces=[dummy.simulation_bus.add_interface("repo1")],
log_level=255) # Initialize repository 1 (this one has sessions)
dummy.icn_forwarder0 = ICNForwarder(
port=0,
log_level=255,
interfaces=[dummy.simulation_bus.add_interface("fw0")
]) # Initialize forwarder 0
dummy.icn_forwarder1 = ICNForwarder(
port=0, interfaces=[dummy.simulation_bus.add_interface("fw1")
]) # Initialize forwarder 1
dummy.mgmt_client0 = MgmtClient(
dummy.icn_repo0.mgmt.mgmt_sock.getsockname()
[1]) # Mgmt client for repository 0
dummy.mgmt_client1 = MgmtClient(
dummy.icn_repo1.mgmt.mgmt_sock.getsockname()
[1]) # Mgmt client for repository 1
dummy.mgmt_client2 = MgmtClient(
dummy.icn_forwarder0.mgmt.mgmt_sock.getsockname()
[1]) # Mgmt client for forwarder 0
dummy.mgmt_client3 = MgmtClient(
dummy.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?
dummy.fetch_tool = Fetch("fw0",
None,
log_level=255,
interfaces=[
dummy.simulation_bus.add_interface("fetcht0")
]) # Initialize a client (fetch tool)
dummy.icn_repo0.start_repo()
dummy.icn_repo1.start_repo()
dummy.icn_forwarder0.start_forwarder()
dummy.icn_forwarder1.start_forwarder()
dummy.simulation_bus.start_process()
dummy.mgmt_client2.add_face(
"repo0", None, 0) # Add a connection between fw0 and repo0 interface
dummy.mgmt_client2.add_forwarding_rule(Name("/test/t1"), [
0
]) # Add a rule to forward packages with this prefix to this forwarder.
# dummy.mgmt_client0.add_forwarding_rule(Name("/test/t1"), [0]) # Add
dummy.mgmt_client3.add_face(
"repo1", None,
0) # Add a network interface to forwarder 0 and give it ip and port
dummy.mgmt_client3.add_forwarding_rule(Name("/test/t2"), [0]) # Add
# dummy.mgmt_client0.add_face("repo0", None, 0) # Add a network interface to forwarder 0 and give it ip and port
# dummy.mgmt_client0.add_forwarding_rule(Name("/test/t1"), [0]) # Add
# dummy.mgmt_client1.add_face("repo1", None, 0) # Add a network interface to forwarder 0 and give it ip and port
# dummy.mgmt_client1.add_forwarding_rule(Name("/test/t2"), [0]) # Add
dummy.icn_repo0.repolayer._repository.add_content(
Name("/test/t1/content_object"), "This is just a test for repo0.")
dummy.mgmt_client1.add_new_content(Name("/test/t2/session_connector"),
"This shouldn't be needed.")
interest0 = Name("/test/t1/content_object")
interest1 = Name("/test/t2/session_connector")
res0 = dummy.fetch_tool.fetch_data(interest0, timeout=20)
#res1 = dummy.fetch_tool.fetch_data(interest1, timeout=20)
print(res0)
interfaces=[simulation_bus.add_interface('fw0')],
node_name='forwarder0')
fw1 = ICNForwarder(port=0,
log_level=0,
interfaces=[simulation_bus.add_interface('fw1')],
node_name='forwarder1')
fw2 = ICNForwarder(port=0,
log_level=0,
interfaces=[simulation_bus.add_interface('fw2')],
node_name='forwarder2')
fw3 = ICNForwarder(port=0,
log_level=0,
interfaces=[simulation_bus.add_interface('fw3')],
node_name='forwarder3')
mgmt_repo0 = MgmtClient(repo0.mgmt.mgmt_sock.getsockname()[1])
mgmt_fw0 = MgmtClient(fw0.mgmt.mgmt_sock.getsockname()[1])
mgmt_fw1 = MgmtClient(fw1.mgmt.mgmt_sock.getsockname()[1])
mgmt_fw2 = MgmtClient(fw2.mgmt.mgmt_sock.getsockname()[1])
mgmt_fw3 = MgmtClient(fw3.mgmt.mgmt_sock.getsockname()[1])
repo0.start_repo()
fw0.start_forwarder()
fw1.start_forwarder()
fw2.start_forwarder()
fw3.start_forwarder()
simulation_bus.start_process()
mgmt_fw0.add_face('fw3', None, 0)
mgmt_fw0.add_forwarding_rule(Name('/unibas/sim1'), [0])
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])
port=0,
prefix=Name('/test/t2'),
foldername=None,
interfaces=[simulation_bus.add_interface('repo1')],
log_level=0) # Initialize repository 1 (this one has sessions)
fw0 = ICNForwarder(port=0,
log_level=255,
interfaces=[simulation_bus.add_interface('fw0')],
node_name='forwarder0') # Initialize forwarder 0
fw1 = ICNForwarder(port=0,
log_level=0,
interfaces=[simulation_bus.add_interface('fw1')],
node_name='forwarder1') # Initialize forwarder 1
mgmt_repo0 = MgmtClient(
repo0.mgmt.mgmt_sock.getsockname()[1]) # Mgmt client for repository 0
mgmt_repo1 = MgmtClient(
repo1.mgmt.mgmt_sock.getsockname()[1]) # Mgmt client for repository 1
mgmt_fw0 = MgmtClient(
fw0.mgmt.mgmt_sock.getsockname()[1]) # Mgmt client for forwarder 0
mgmt_fw1 = MgmtClient(
fw1.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?
fetch0 = Fetch('fw0',
None,
log_level=255,
interfaces=[simulation_bus.add_interface('fetcht0')],
name='fetch0')
fetch1 = FetchSessions(
'fw1',
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)
if __name__ == "__main__":
simulation_bus = SimulationBus(log_level=0) # Use BasicStringEncoder
repo0 = ICNDataRepositorySession(
port=0,
prefix=Name('/unibas/sim1'),
foldername=None,
interfaces=[simulation_bus.add_interface('repo0')],
log_level=0)
fw0 = ICNForwarder(port=0,
log_level=0,
interfaces=[simulation_bus.add_interface('fw0')],
node_name='forwarder0')
mgmt_repo0 = MgmtClient(repo0.mgmt.mgmt_sock.getsockname()[1])
mgmt_fw0 = MgmtClient(fw0.mgmt.mgmt_sock.getsockname()[1])
fetch0 = FetchSessions(
'fw0',
None,
log_level=0,
interfaces=[simulation_bus.add_interface('fetcht0')],
name='fetch0')
repo0.start_repo()
fw0.start_forwarder()
simulation_bus.start_process()
mgmt_fw0.add_face('repo0', None, 0)
mgmt_fw0.add_face('fw0', None, 0)
def simulation(classic, amount_of_parts):
generateExampleFiles("../InputFiles/exampleInputFile", amount_of_parts)
simulation_bus = SimulationBus(packetencoder=NdnTlvEncoder())
nfn_fwd0 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("nfn0")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
nfn_fwd0.executors["PYTHONSTREAM"].initialize_executor(
nfn_fwd0.nfnlayer.queue_to_lower, nfn_fwd0.nfnlayer.queue_from_lower,
nfn_fwd0.nfnlayer.cs, classic)
nfn_fwd0.icnlayer.pit.ageing = ageing
nfn_fwd0.timeoutpreventionlayer.ageing = ageing
nfn_fwd1 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("nfn1")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
nfn_fwd1.executors["PYTHONSTREAM"].initialize_executor(
nfn_fwd1.nfnlayer.queue_to_lower, nfn_fwd1.nfnlayer.queue_from_lower,
nfn_fwd1.nfnlayer.cs, classic)
nfn_fwd1.icnlayer.pit.ageing = ageing
nfn_fwd1.timeoutpreventionlayer.ageing = ageing
nfn_fwd2 = NFNForwarder(
port=0,
encoder=NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("nfn2")],
log_level=255,
executors={"PYTHONSTREAM": NFNPythonExecutorStreaming()},
ageing_interval=1)
nfn_fwd2.executors["PYTHONSTREAM"].initialize_executor(
nfn_fwd2.nfnlayer.queue_to_lower, nfn_fwd2.nfnlayer.queue_from_lower,
nfn_fwd2.nfnlayer.cs, classic)
nfn_fwd2.icnlayer.pit.ageing = ageing
nfn_fwd2.timeoutpreventionlayer.ageing = ageing
repo = ICNDataRepository("../InputFiles",
Name("/repo/r1"),
0,
255,
NdnTlvEncoder(),
False,
False,
interfaces=[simulation_bus.add_interface("repo")])
repo.start_repo()
mgmt_client0 = MgmtClient(nfn_fwd0.mgmt.mgmt_sock.getsockname()[1])
mgmt_client1 = MgmtClient(nfn_fwd1.mgmt.mgmt_sock.getsockname()[1])
mgmt_client2 = MgmtClient(nfn_fwd2.mgmt.mgmt_sock.getsockname()[1])
fetch_tool = Fetch("nfn0",
None,
255,
NdnTlvEncoder(),
interfaces=[simulation_bus.add_interface("fetchtoo1")])
nfn_fwd0.start_forwarder()
nfn_fwd1.start_forwarder()
nfn_fwd2.start_forwarder()
simulation_bus.start_process()
mgmt_client0.add_face("nfn1", None, 0)
mgmt_client0.add_forwarding_rule(Name("/lib"), [0])
mgmt_client1.add_face("nfn2", None, 0)
mgmt_client1.add_forwarding_rule(Name("/lib"), [0])
mgmt_client2.add_face("repo", None, 0)
mgmt_client2.add_forwarding_rule(Name("/repo/r1"), [0])
mgmt_client0.add_new_content(
Name("/lib/node0"),
"PYTHONSTREAM\ngetnext_on_writeout\ndef getnext_on_writeout(arg):\n print('Start dritte')\n res = ''\n a = get_next(arg)\n while a != None:\n res = res + a\n a = get_next(arg)\n print('Ende dritte')\n return res"
)
mgmt_client1.add_new_content(
Name("/lib/node1"),
"PYTHONSTREAM\nwriteout_on_getnext\ndef writeout_on_getnext(arg):\n print('Start zweite')\n a = get_next(arg)\n while a and check_end_streaming(a) is False:\n a = a.upper()\n sleep(1)\n write_out(a)\n a = get_next(arg)\n last_write_out()\n return print('Ende zweite')\n"
)
mgmt_client2.add_new_content(
Name("/lib/node2"),
"PYTHONSTREAM\nwriteout_on_getnext\ndef writeout_on_getnext(arg):\n print('Start erste')\n write_out_on_get_next(arg)\n return print('Ende erste')\n"
)
scenario_node_2 = Name("/lib/node2")
scenario_node_2 += "#(=/repo/r1/exampleInputFile=)"
scenario_node_2 += "NFN"
scenario_node_1 = Name("/lib/node1")
scenario_node_1 += "#(=" + str(scenario_node_2) + "=)"
scenario_node_1 += "NFN"
scenario_node_0 = Name("/lib/node0")
scenario_node_0 += '_("' + str(scenario_node_1) + '")'
scenario_node_0 += "NFN"
start_time = time.perf_counter()
res = fetch_tool.fetch_data(scenario_node_0, timeout=60)
end_time = time.perf_counter()
time_needed = end_time - start_time
if res.startswith("CONTENT OF NAME"):
print("Time:", time_needed, res)
return time_needed
else:
print("Something went wrong")
None
