Exemple #1
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)
Exemple #2
0
    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)
Exemple #3
0
    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)
Exemple #4
0
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)
Exemple #5
0
    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()
Exemple #6
0
    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()
Exemple #7
0
    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
Exemple #8
0
    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
Exemple #9
0
    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])
Exemple #10
0
    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])
Exemple #11
0
    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()
Exemple #12
0
    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 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)
Exemple #14
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])
Exemple #15
0
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)
Exemple #16
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)
Exemple #17
0
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"
        )
Exemple #18
0
    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])
Exemple #19
0
class Initiation(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(
            "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 tearDown(self):
        self.distributor.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.distributor.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"), [0])
        self.mgmt_client0.add_face("nfn2", None, 0)
        self.mgmt_client0.add_forwarding_rule(Name("/lib"), [1])
        self.mgmt_client0.add_face("nfn3", None, 0)
        self.mgmt_client0.add_forwarding_rule(Name("/lib"), [2])
        self.mgmt_client0.add_face("nfn4", None, 0)
        self.mgmt_client0.add_forwarding_rule(Name("/lib4/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])
        self.mgmt_client2.add_face("nfn0", None, 0)
        self.mgmt_client2.add_forwarding_rule(Name("/lib"), [1])
        self.mgmt_client3.add_face("nfn0", None, 0)
        self.mgmt_client3.add_forwarding_rule(Name("/lib"), [1])
        self.mgmt_client4.add_face("nfn0", None, 0)
        self.mgmt_client4.add_forwarding_rule(Name("/lib4/func4"), [1])

        #setup function code
        #self.mgmt_client1.add_new_content(Name("/lib/func1"),"PYTHON\nf\ndef f(n):\n return n")
        self.mgmt_client1.add_new_content(
            Name("/lib/func1"),
            "PYTHON\nf\ndef f():\n  result =[]\n  x,y =0,1\n  while x<n:\n    result.append(x)\n    x,y = y, y+x\n  return result"
        )
        self.mgmt_client2.add_new_content(
            Name("/lib/func1"),
            "PYTHON\nf\ndef f(n):\n  result =[]\n  x,y =0,1\n  while x<n:\n    result.append(x)\n    x,y = y, y+x\n  return result"
        )
        # self.mgmt_client2.add_new_content(Name("/lib/func2"),"func2")
        self.mgmt_client3.add_new_content(
            Name("/lib/func1"),
            "PYTHON\nf\ndef f(n):\n  result =[]\n  x,y =0,1\n  while x<n:\n    result.append(x)\n    x,y = y, y+x\n  return result"
        )
        self.mgmt_client4.add_new_content(Name("/lib4/func4"), "func4")

        # self.mgmt_client1.add_new_content(Name("/lib/func1"),
        #                                   "PYTHON\nf\ndef f():\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_Fs(self):
        self.setup_repo()
        self.setup_faces_and_connections()
        name1 = Name("/lib/func1")
        name1 += '_()'
        name1 += "NFN"

        name2 = Name("/lib/func1")
        name2 += '_(500000)'
        name2 += "NFN"

        name3 = Name("/lib/func1")
        name3 += '_(5000)'
        name3 += "NFN"

        name4 = Name("/lib/func1")
        name4 += '_(900000000000000000)'
        name4 += "NFN"

        name5 = Name("/lib/func1")
        name5 += '_(68899455874)'
        name5 += "NFN"

        t1 = Fs_thread(name1, fetch_tool=self.fetch_tool1)
        t2 = Fs_thread(name2, fetch_tool=self.fetch_tool1)
        t3 = Fs_thread(name3, fetch_tool=self.fetch_tool1)
        t4 = Fs_thread(name4, fetch_tool=self.fetch_tool1)
        t5 = Fs_thread(name5, fetch_tool=self.fetch_tool1)

        t1.start()
        t2.start()
        t3.start()
        t4.start()
        t5.start()
        t1.join()
        t2.join()
        t3.join()
        t4.join()
        t5.join()
Exemple #20
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])
Exemple #21
0
class StreamingSimulation(unittest.TestCase):
    """Simulate a Streaming Scenario."""
    def ageing(self):
        return

    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 tearDown(self):
        self.nfn0.stop_forwarder()
        self.nfn1.stop_forwarder()
        self.nfn12.stop_forwarder()
        self.repo1.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.nfn12.start_forwarder()

        self.repo1.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("/lib0"), [0])

        self.mgmt_client0.add_face("nfn12", None, 0)
        self.mgmt_client0.add_forwarding_rule(Name("/lib1"), [1])

        self.mgmt_client01.add_face("nfn1", None, 0)
        self.mgmt_client01.add_forwarding_rule(Name("/lib1"), [0])

        self.mgmt_client1.add_face("repo1", None, 0)
        self.mgmt_client1.add_forwarding_rule(Name("/repo/r1"), [0])

        self.mgmt_client1.add_face("nfn0", None, 0)
        self.mgmt_client1.add_forwarding_rule(Name("/lib0"), [1])

        #setup function code

        #multi name
        self.mgmt_client1.add_new_content(
            Name("/lib0/multiname"),
            "PYTHONSTREAM\nmultiname\ndef multiname(arg):\n    a = get_next(arg)\n    a = a.upper()\n    b = get_next(arg)\n    b = b.upper()\n    c = get_next(arg)\n    c = c.upper()\n    d = get_next(arg)\n    d = d.upper()\n    e = get_next(arg)\n    e = e.upper()\n    f = get_next(arg)\n    f = f.upper()\n    g = get_next(arg)\n    g = g.upper()\n    h = get_next(arg)\n    h = h.upper()\n    i = get_next(arg)\n    i = i.upper()\n    j = get_next(arg)\n    j = j.upper()\n    return a + b + c + d + e + f + g + h + i + j"
        )

        #single name - two layer
        self.mgmt_client0.add_new_content(
            Name("/lib0/node0"),
            "PYTHONSTREAM\ngetnext_on_writeout\ndef getnext_on_writeout(arg):\n    print('Start äussere')\n    a = get_next(arg)\n    a = a.upper()\n    b = get_next(arg)\n    b = b.upper()\n    c = get_next(arg)\n    c = c.upper()\n    d = get_next(arg)\n    d = d.upper()\n    e = get_next(arg)\n    e = e.upper()\n    f = get_next(arg)\n    f = f.upper()\n    g = get_next(arg)\n    g = g.upper()\n    h = get_next(arg)\n    h = h.upper()\n    i = get_next(arg)\n    i = i.upper()\n    j = get_next(arg)\n    j = j.upper()\n    print('Ende äussere')\n    return a + b + c + d + e + f + g + h + i + j"
        )

        self.mgmt_client1.add_new_content(
            Name("/lib0/node1"),
            "PYTHONSTREAM\nwriteout_on_getnext\ndef writeout_on_getnext(arg):\n    print('Start innere')\n    write_out_on_get_next(arg)\n    return print('Ende innere')\n"
        )

        #single name - three layer
        self.mgmt_client0.add_new_content(
            Name("/lib1/node0"),
            "PYTHONSTREAM\ngetnext_on_writeout\ndef getnext_on_writeout(arg):\n    print('Start äussere')\n    a = get_next(arg)\n    a = a.upper()\n    b = get_next(arg)\n    b = b.upper()\n    c = get_next(arg)\n    c = c.upper()\n    d = get_next(arg)\n    d = d.upper()\n    e = get_next(arg)\n    e = e.upper()\n    f = get_next(arg)\n    f = f.upper()\n    g = get_next(arg)\n    g = g.upper()\n    h = get_next(arg)\n    h = h.upper()\n    i = get_next(arg)\n    i = i.upper()\n    j = get_next(arg)\n    j = j.upper()\n    print('Ende äussere')\n    return a + b + c + d + e + f + g + h + i + j"
        )

        self.mgmt_client01.add_new_content(
            Name("/lib1/node1"),
            "PYTHONSTREAM\nwriteout_on_getnext\ndef writeout_on_getnext(arg):\n    print('Start mittlere')\n    write_out_on_get_next(arg)\n    return print('Ende mittlere')\n"
        )

        self.mgmt_client1.add_new_content(
            Name("/lib1/node2"),
            "PYTHONSTREAM\nwriteout_on_getnext\ndef writeout_on_getnext(arg):\n    print('Start innere')\n    write_out_on_get_next(arg)\n    return print('Ende innere')\n"
        )

    def generate_name_files(self, path: str, number: int):
        with open(path + "/name" + str(number), "w") as f:
            f.write("Content of name" + str(number) + ". ")
        f.close()

    def setup_repo(self):
        self.path = "/tmp/repo1"
        try:
            os.stat(self.path)
        except:
            os.mkdir(self.path)
        with open(self.path + "/data1", 'w+') as content_file:
            content_file.write("sdo:\n")
            for i in range(1, 11):
                content_file.write("/repo/r1/name" + str(i) + "\n")
                self.generate_name_files(self.path, i)
            content_file.write("sdo:endstreaming\n")

    def tearDown_repo(self):
        try:
            shutil.rmtree(self.path)
            os.remove("/tmp/repo")
        except:
            pass

    def test_multiname(self):
        """Multiname test with input data from repo"""
        self.setup_repo()
        self.setup_faces_and_connections()

        name = Name("/lib0/multiname")
        name += '_(/repo/r1/data1)'
        name += "NFN"

        res = self.fetch_tool1.fetch_data(name, timeout=40)
        print(res)
        self.assertEqual(
            "CONTENT OF NAME1. CONTENT OF NAME2. CONTENT OF NAME3. CONTENT OF NAME4. CONTENT OF NAME5. CONTENT OF NAME6. CONTENT OF NAME7. CONTENT OF NAME8. CONTENT OF NAME9. CONTENT OF NAME10. ",
            res)

    def test_twolayer(self):
        """Singlename test over two layers with input data from repo"""
        self.setup_repo()
        self.setup_faces_and_connections()

        scenario_node_1 = Name("/lib0/node1")
        scenario_node_1 += "#(=/repo/r1/data1=)"
        scenario_node_1 += "NFN"

        scenario_node_0 = Name("/lib0/node0")
        scenario_node_0 += '_("' + str(scenario_node_1) + '")'
        scenario_node_0 += "NFN"

        res = self.fetch_tool1.fetch_data(scenario_node_0, timeout=40)
        print(res)
        self.assertEqual(
            "CONTENT OF NAME1. CONTENT OF NAME2. CONTENT OF NAME3. CONTENT OF NAME4. CONTENT OF NAME5. CONTENT OF NAME6. CONTENT OF NAME7. CONTENT OF NAME8. CONTENT OF NAME9. CONTENT OF NAME10. ",
            res)

    def test_threelayer(self):
        """Singlename test over three layers with input data from repo"""
        self.setup_repo()
        self.setup_faces_and_connections()

        scenario_node_2 = Name("/lib1/node2")
        scenario_node_2 += "#(=/repo/r1/data1=)"
        scenario_node_2 += "NFN"

        scenario_node_1 = Name("/lib1/node1")
        scenario_node_1 += "#(=" + str(scenario_node_2) + "=)"
        scenario_node_1 += "NFN"

        scenario_node_0 = Name("/lib1/node0")
        scenario_node_0 += '_("' + str(scenario_node_1) + '")'
        scenario_node_0 += "NFN"

        res = self.fetch_tool1.fetch_data(scenario_node_0, timeout=40)
        print(res)
        self.assertEqual(
            "CONTENT OF NAME1. CONTENT OF NAME2. CONTENT OF NAME3. CONTENT OF NAME4. CONTENT OF NAME5. CONTENT OF NAME6. CONTENT OF NAME7. CONTENT OF NAME8. CONTENT OF NAME9. CONTENT OF NAME10. ",
            res)
Exemple #22
0
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)
class test_NFNForwarderThunks(unittest.TestCase):
    """Test NFN Forwarder with Thunks"""

    #TODO: Add optimizer to execute the plans
    #TODO: Add REPO TO TEST

    def get_encoder(self):
        return NdnTlvEncoder()

    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 tearDown(self):
        self.forwarder1.stop_forwarder()
        self.forwarder2.stop_forwarder()
        self.forwarder3.stop_forwarder()
        self.client.stop_fetch()

    def test_simple_thunk_query(self):
        """Test a simple thunk query"""
        name = Name("/fct/f1")
        name += "_(/dat/data/d1)"
        name += "THUNK"
        name += "NFN"
        res = self.client.fetch_data(name, timeout=4)
        self.assertEqual(res, "659")
        #print(self.forwarder1.thunk_layer.planTable.get_plan(self.forwarder1.thunk_layer.removeThunkMarker(name)))
        name2 = Name("/fct/f1")
        name2 += "_(/dat/data/d1)"
        name2 += "NFN"
        res2 = self.client.fetch_data(name2)
        self.assertEqual(res2, self.content1.upper())

    def test_simple_thunk_query_additional_fwd_rule_to_fct(self):
        """Test a simple thunk query. Add additional rule to have cheap computation at data location"""
        self.mgmt2.add_face("127.0.0.1", self.forwarder3_port, 0)
        self.mgmt2.add_forwarding_rule(Name("/fct"), [0])
        name = Name("/fct/f1")
        name += "_(/dat/data/d1)"
        name += "THUNK"
        name += "NFN"
        res = self.client.fetch_data(name, timeout=4)
        self.assertEqual(res, "39")
        #print(self.forwarder1.thunk_layer.planTable.get_plan(self.forwarder1.thunk_layer.removeThunkMarker(name)))
        name2 = Name("/fct/f1")
        name2 += "_(/dat/data/d1)"
        name2 += "NFN"
        res2 = self.client.fetch_data(name2)
        self.assertEqual(res2, self.content1.upper())

    def test_simple_thunk_query_additional_fwd_rule_to_data(self):
        """Test a simple thunk query. Add additional rule to have cheap computation at fct location"""
        self.mgmt3.add_face("127.0.0.1", self.forwarder2_port, 0)
        self.mgmt3.add_forwarding_rule(Name("/dat"), [0])
        name = Name("/fct/f1")
        name += "_(/dat/data/d1)"
        name += "THUNK"
        name += "NFN"
        res = self.client.fetch_data(name, timeout=4)
        self.assertEqual(res, "620")
        #print(self.forwarder1.thunk_layer.planTable.get_plan(self.forwarder1.thunk_layer.removeThunkMarker(name)))
        name2 = Name("/fct/f1")
        name2 += "_(/dat/data/d1)"
        name2 += "NFN"
        res2 = self.client.fetch_data(name2)
        self.assertEqual(res2, self.content1.upper())

    def test_simple_thunk_query_additional_fwd_rule_to_fct_and_data(self):
        """Test a simple thunk query. Add additional rule to have cheap computation at fct and data location"""
        self.mgmt2.add_face("127.0.0.1", self.forwarder3_port, 0)
        self.mgmt2.add_forwarding_rule(Name("/fct"), [0])
        self.mgmt3.add_face("127.0.0.1", self.forwarder2_port, 0)
        self.mgmt3.add_forwarding_rule(Name("/dat"), [0])
        name = Name("/fct/f1")
        name += "_(/dat/data/d1)"
        name += "THUNK"
        name += "NFN"
        res = self.client.fetch_data(name, timeout=50)
        self.assertEqual(res, "39")
        #print(self.forwarder1.thunk_layer.planTable.get_plan(self.forwarder1.thunk_layer.removeThunkMarker(name)))
        name2 = Name("/fct/f1")
        name2 += "_(/dat/data/d1)"
        name2 += "NFN"
        res2 = self.client.fetch_data(name2)
        self.assertEqual(res2, self.content1.upper())
Exemple #24
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
Exemple #25
0
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)
Exemple #26
0
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.')
Exemple #27
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
        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)
Exemple #28
0
    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)
Exemple #29
0
    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()
Exemple #30
0
class TestDisconnections(unittest.TestCase):
    """Run the data-offloading simulation"""
    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 tearDown(self):
        self.car.stop_forwarder()
        self.fetch_tool_car.stop_fetch()

        for rsu in self.rsus:
            rsu.stop_forwarder()

        for fetch_tool in self.fetch_tools:
            fetch_tool.stop_fetch()

        self.simulation_bus.stop_process()

    def setup_faces_and_connections(self):
        self.car.start_forwarder()

        for rsu in self.rsus:
            rsu.start_forwarder()

        self.simulation_bus.start_process()

        function = "PYTHON\nf\ndef f(a):\n return a + ' World'"

        # Setup rsu0
        self.mgmt_clients[0].add_face("car", None, 0)
        self.mgmt_clients[0].add_face("rsu1", None, 0)
        self.mgmt_clients[0].add_forwarding_rule(Name("/car"), [0])
        self.mgmt_clients[0].add_forwarding_rule(Name("/nR"), [1])
        self.mgmt_clients[0].add_new_content(Name("/rsu/func/f1"), function)

        # Setup rsu1
        self.mgmt_clients[1].add_face("car", None, 0)
        self.mgmt_clients[1].add_face("rsu0", None, 0)
        self.mgmt_clients[1].add_face("rsu2", None, 0)
        self.mgmt_clients[1].add_forwarding_rule(Name("/car"), [0])
        self.mgmt_clients[1].add_forwarding_rule(Name("/nL"), [1])
        self.mgmt_clients[1].add_forwarding_rule(Name("/nR"), [2])
        self.mgmt_clients[1].add_new_content(Name("/rsu/func/f1"), function)

        # Setup rsu2
        self.mgmt_clients[2].add_face("car", None, 0)
        self.mgmt_clients[2].add_face("rsu1", None, 0)
        self.mgmt_clients[2].add_face("rsu3", None, 0)
        self.mgmt_clients[2].add_forwarding_rule(Name("/car"), [0])
        self.mgmt_clients[2].add_forwarding_rule(Name("/nL"), [1])
        self.mgmt_clients[2].add_forwarding_rule(Name("/nR"), [2])
        self.mgmt_clients[2].add_new_content(Name("/rsu/func/f1"), function)

        # Setup rsu3
        self.mgmt_clients[3].add_face("car", None, 0)
        self.mgmt_clients[3].add_face("rsu2", None, 0)
        self.mgmt_clients[3].add_forwarding_rule(Name("/car"), [0])
        self.mgmt_clients[3].add_forwarding_rule(Name("/nL"), [1])
        self.mgmt_clients[3].add_new_content(Name("/rsu/func/f1"), function)

        # Setup car
        self.mgmt_client_car.add_face("rsu0", None, 0)
        self.mgmt_client_car.add_face("rsu1", None, 0)
        self.mgmt_client_car.add_face("rsu2", None, 0)
        self.mgmt_client_car.add_forwarding_rule(Name("/rsu"), [0])

        self.d = Content(Name("/car/data/test1"), "Test" * 10)
        self.meta_data, self.data = self.chunkifyer.chunk_data(self.d)

        for md in self.meta_data[:]:
            self.car.icnlayer.cs.add_content_object(md)

        # Only load first 6 chunks to car to simulate car getting out of each while uploading
        for d in self.data[:5]:
            self.mgmt_client_car.add_new_content(d.name, d.content)

    def test_two_disconnections(self):
        self.setup_faces_and_connections()

        name = Name("/rsu/func/f1")
        name += '_(/car/data/test1)'
        name += "NFN"

        print("RSU 0 FETCHING")
        start = time()
        res0 = self.fetch_tools[0].fetch_data(name, timeout=10)
        print(res0)

        sleep(1)
        print("\n" * 20 + "RSU 1 FETCHING")

        for d in self.data[5:-2]:
            self.mgmt_client_car.add_new_content(d.name, d.content)
        for d in self.data[:5]:
            self.car.icnlayer.cs.remove_content_object(d.name)

        res1 = self.fetch_tools[1].fetch_data(name, timeout=10)
        print(res1)

        sleep(1)
        print("\n" * 20 + "RSU 2 FETCHING")

        for d in self.data[-2:]:
            self.mgmt_client_car.add_new_content(d.name, d.content)
        for d in self.data[:-2]:
            self.car.icnlayer.cs.remove_content_object(d.name)

        res2 = self.fetch_tools[2].fetch_data(name, timeout=10)
        print(res2, time() - start)
        self.assertEqual(self.d.content + " World", res2)

    def test_skip_two_rsus(self):

        # Increase the number of forwards
        for rsu in self.rsus:
            rsu.chunklayer.set_number_of_forwards(2)

        self.setup_faces_and_connections()
        name = Name("/rsu/func/f1")
        name += '_(/car/data/test1)'
        name += "NFN"

        res0 = self.fetch_tools[0].fetch_data(name, timeout=10)
        print(res0)

        sleep(1)
        print("\n" * 20 + "RSU 4 STARTING")

        for d in self.data[5:]:
            self.mgmt_client_car.add_new_content(d.name, d.content)
        for d in self.data[:5]:
            self.car.icnlayer.cs.remove_content_object(d.name)

        res1 = self.fetch_tools[3].fetch_data(name, timeout=10)
        print(res1)
        self.assertEqual(self.d.content + " World", res1)