def _setup_mobile_nodes(self): """configure the mobile nodes""" for node in self._mobile_nodes: node.forwarder = ICNForwarder( 0, encoder=SimpleStringEncoder(), routing=True, interfaces=[ self._simulation_bus.add_interface(f"car{node.node_id}") ]) node.fetch = Fetch( f"car{node.node_id}", None, 255, SimpleStringEncoder(), interfaces=[ self._simulation_bus.add_interface(f"ftcar{node.node_id}") ]) node.mgmt_tool = MgmtClient( node.forwarder.mgmt.mgmt_sock.getsockname()[1]) for stationary_node in self._stationary_nodes: car_face_id = node.forwarder.linklayer.faceidtable.get_or_create_faceid( AddressInfo(f"rsu{stationary_node.node_id}", 0)) self.to_rsu_faces[stationary_node.node_id][ node.node_id] = car_face_id rsu_face_id = node.forwarder.linklayer.faceidtable.get_or_create_faceid( AddressInfo(f"car{stationary_node.node_id}", 0)) self.to_car_faces[stationary_node.node_id][ node.node_id] = rsu_face_id
def _setup_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 __init__(self): """define the configuration""" self.number_of_rsus = 4 self.number_of_cars = 5 self.to_car_faces = [[0] * self.number_of_cars for i in range(self.number_of_rsus)] #rsu, car -> faceid self.to_rsu_faces = [[0] * self.number_of_cars for i in range(self.number_of_rsus)] #rsu, car -> faceid self.car_speed = [60, 60, 60, 60, 60] #in km/h self.car_direction = [1, 1 ,1 ,1 ,1] # 1 or -1, consider starting rsu by choosing direction. self.starting_rsu = [0, 0, 0, 0, 0] self.rsu_distance = 0.5 #in km, range is identical here self.computations = self.get_computations() #Store computations in here, car will randomly choose one self.named_functions ={"/rsu/func/f1": "PYTHON\nf\ndef f(a, b, c):\n return a+b+c", "/rsu/func/f2": "PYTHON\nf\ndef f(a, b, c):\n return a*b*c"} #named functions stored on the self.chunk_size = 8192 self.optimizer = EdgeComputingOptimizer #NFN resolution strategy optimizer self.encoder_type = SimpleStringEncoder() self.simulation_bus = SimulationBus(packetencoder=self.encoder_type) self.rsu_name = Name("/rsu") self.car_to_computation = [0,0,0,0,0] #index which car issues which computation self._compute_rsu_connection_time() self.setup_network()
def main(args): name_str = args.name name = None if 'NFN' in name_str and '_' not in name_str: name = parse_nfn_str(name_str) if name is None: if '[' in name_str and ']' in name_str: name = unescape_str_to_Name(args.name) else: name = Name(args.name) name = unescape_name(name) name.format = args.format log_level = 255 encoder = NdnTlvEncoder( ) if args.format == 'ndntlv' else SimpleStringEncoder() fetchTool = Fetch(ip=args.ip, port=args.port, log_level=log_level, encoder=encoder, autoconfig=args.autoconfig) content = fetchTool.fetch_data(name, timeout=10) print(content) fetchTool.stop_fetch()
def __init__(self, packetencoder: BasicEncoder = SimpleStringEncoder(), print_keep_alive=True, log_level=logging.DEBUG): super().__init__("SimulationBus", log_level) self.interfacetable: Dict[str, SimulationInterface] = {} self.packetencoder = packetencoder self.print_keep_alive = print_keep_alive
def setUp(self): self.encoder_type = SimpleStringEncoder() self.simulation_bus = SimulationBus(packetencoder=self.encoder_type) chunk_size = 8192 self.chunkifyer = SimpleContentChunkifyer(chunk_size) # Initialize two cars self.cars = [] self.fetch_tool_cars = [] self.mgmt_client_cars = [] for i in range(2): self.cars.append( ICNForwarder( 0, encoder=self.encoder_type, routing=True, interfaces=[self.simulation_bus.add_interface(f"car{i}")])) self.fetch_tool_cars.append( Fetch(f"car{i}", None, 255, self.encoder_type, interfaces=[ self.simulation_bus.add_interface(f"ftcar{i}") ])) self.mgmt_client_cars.append( MgmtClient(self.cars[i].mgmt.mgmt_sock.getsockname()[1])) self.cars[i].icnlayer.cs.set_cs_timeout(40) # Initialize RSUs self.rsus = [] self.fetch_tools = [] self.mgmt_clients = [] for i in range(3): self.rsus.append( NFNForwarderData( 0, encoder=self.encoder_type, interfaces=[self.simulation_bus.add_interface(f"rsu{i}")], chunk_size=chunk_size, num_of_forwards=1, ageing_interval=10)) self.fetch_tools.append( Fetch(f"rsu{i}", None, 255, self.encoder_type, interfaces=[self.simulation_bus.add_interface(f"ft{i}") ])) self.rsus[i].nfnlayer.optimizer = EdgeComputingOptimizer( self.rsus[i].icnlayer.cs, self.rsus[i].icnlayer.fib, self.rsus[i].icnlayer.pit, self.rsus[i].linklayer.faceidtable) self.mgmt_clients.append( MgmtClient(self.rsus[i].mgmt.mgmt_sock.getsockname()[1])) self.fetch_tools[i].timeoutpreventionlayer.timeout_interval = 40 self.rsus[i].icnlayer.cs.set_cs_timeout(60)
def main(args): # Log Level if args.logging == 'error': log_level = logging.ERROR elif args.logging == 'warning': log_level = logging.WARNING elif args.logging == 'info': log_level = logging.INFO elif args.logging == 'debug': log_level = logging.DEBUG else: log_level = 255 logger = Logger("NFNForwarder", log_level) # Info logger.info("Starting a NFN Forwarder...") logger.info("UDP Port: " + str(args.port)) logger.info("Log Level: " + args.logging) logger.info("Packet Format: " + args.format) # Packet encoder encoder = NdnTlvEncoder( log_level) if args.format == 'ndntlv' else SimpleStringEncoder( log_level) if args.optimizer == "Edge": forwarder = PiCN.ProgramLibs.NFNForwarder.NFNForwarder( args.port, log_level, encoder, ageing_interval=1) logger.info("Edge Computing Node") forwarder.icnlayer.pit.set_pit_timeout(2) forwarder.icnlayer.cs.set_cs_timeout(30) forwarder.nfnlayer.optimizer = EdgeComputingOptimizer( forwarder.icnlayer.cs, forwarder.icnlayer.fib, forwarder.icnlayer.pit, forwarder.linklayer.faceidtable) elif args.optimizer == "MapReduce": forwarder = PiCN.ProgramLibs.NFNForwarder.NFNForwarder( args.port, log_level, encoder) logger.info("Using MapReduce Optimizer") forwarder.nfnlayer.optimizer = MapReduceOptimizer( forwarder.icnlayer.cs, forwarder.icnlayer.fib, forwarder.icnlayer.pit, forwarder.linklayer.faceidtable) elif args.optimizer == "Thunks": forwarder = PiCN.ProgramLibs.NFNForwarder.NFNForwarder(args.port, log_level, encoder, use_thunks=True) logger.info("Using Thunks for Planning and Optimizing") else: forwarder = PiCN.ProgramLibs.NFNForwarder.NFNForwarder( args.port, log_level, encoder) forwarder.start_forwarder() forwarder.linklayer.process.join()
def __init__(self, ip: str, port: int, log_level=255, encoder: BasicEncoder = None, autoconfig: bool = False, interfaces=None): # create encoder and chunkifyer if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder self.chunkifyer = SimpleContentChunkifyer() # initialize layers synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() faceidtable = synced_data_struct_factory.manager.faceidtable() if interfaces is None: interfaces = [UDP4Interface(0)] else: interfaces = interfaces # create layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.chunklayer = BasicChunkLayer(self.chunkifyer, log_level=log_level) self.lstack: LayerStack = LayerStack( [self.chunklayer, self.packetencodinglayer, self.linklayer]) self.autoconfig = autoconfig if autoconfig: self.autoconfiglayer: AutoconfigClientLayer = AutoconfigClientLayer( self.linklayer) self.lstack.insert(self.autoconfiglayer, on_top_of=self.packetencodinglayer) # setup communication if port is None: self.fid = self.linklayer.faceidtable.get_or_create_faceid( AddressInfo(ip, 0)) else: self.fid = self.linklayer.faceidtable.get_or_create_faceid( AddressInfo((ip, port), 0)) # send packet self.lstack.start_all()
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 __init__(self, database_path, port=9000, log_level=255, encoder: BasicEncoder = None, flush_database=False): # debug level logger = Logger("PushRepo", log_level) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level=log_level) self.encoder = encoder # setup data structures synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("cs", ContentStorePersistentExact) synced_data_struct_factory.register("faceidtable", FaceIDDict) synced_data_struct_factory.create_manager() cs = synced_data_struct_factory.manager.cs(db_path=database_path + "/pushrepo.db") if flush_database: cs.delete_all() faceidtable = synced_data_struct_factory.manager.faceidtable() # default interface interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer(self.encoder, log_level=log_level) self.repolayer = PushRepositoryLayer(log_level=log_level) self.lstack: LayerStack = LayerStack([ self.repolayer, self.packetencodinglayer, self.linklayer ]) self.repolayer.cs = cs # mgmt self.mgmt = Mgmt(cs, None, None, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level)
def main(args): prefix = Name(args.icnprefix) log_level = logging.DEBUG if args.format == "ndntlv": encoder = NdnTlvEncoder() else: encoder = SimpleStringEncoder(log_level=log_level) repo = ICNDataRepository(args.datapath, prefix, args.port, log_level, encoder=encoder, autoconfig=args.autoconfig) repo.start_repo() repo.linklayer.process.join()
def main(args): # Packet encoder encoder = NdnTlvEncoder( ) if args.format == 'ndntlv' else SimpleStringEncoder() # Generate interest packet interest: Interest = Interest(args.name) encoded_interest = encoder.encode(interest) # Send interest packet sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.settimeout(args.timeout) sock.bind(("0.0.0.0", 0)) try: resolved_hostname = socket.gethostbyname(args.ip) except: print("Resolution of hostname failed.") sys.exit(-2) sock.sendto(encoded_interest, (resolved_hostname, args.port)) # Receive content object try: wire_packet, addr = sock.recvfrom(8192) except: print("Timeout.") sys.exit(-1) # Print if args.plain is False: printer = NdnTlvPrinter(wire_packet) printer.formatted_print() else: encoder = NdnTlvEncoder() if encoder.is_content(wire_packet): sys.stdout.buffer.write(encoder.decode_data(wire_packet)[1]) else: sys.exit(-2)
def __init__(self, packetencoder: BasicEncoder = SimpleStringEncoder()): self.interfacetable: Dict[SimulationInterface] = {} self.packetencoder = packetencoder
def setUp(self): self.encoder1 = SimpleStringEncoder()
def get_encoder(self): return SimpleStringEncoder()
class test_SimpleStringEncoder(unittest.TestCase): """Test the SimpleStringEncoder""" def setUp(self): self.encoder1 = SimpleStringEncoder() def tearDown(self): pass def test_Encoder_encode_interest_equal(self): """Test the interest encoding of Encoder: equal""" i = Interest("/test/data") ei = self.encoder1.encode(i) self.assertEqual(ei.decode(), "I:/test/data:") def test_Encoder_encode_interest_not_equal(self): """Test the interest encoding of Encoder: not equal""" i = Interest("/data/test") ei = self.encoder1.encode(i) self.assertNotEqual(ei.decode(), "I:/test/data:") def test_Encoder_decode_interest_equal(self): """Test the interest decoding of Encoder: equal""" data = "I:/test/data:".encode() di = self.encoder1.decode(data) cmp_interest = Interest("/test/data") self.assertTrue(di == cmp_interest) def test_Encoder_decode_interest_equal(self): """Test the interest decoding of Encoder: not equal""" data = "I:/data/test:".encode() di = self.encoder1.decode(data) cmp_interest = Interest("/test/data") self.assertFalse(di == cmp_interest) def test_Encoder_encode_decode_interest(self): """Test the interest decoding of Encoder: equal""" i = Interest("/data/test") ei = self.encoder1.encode(i) di = self.encoder1.decode(ei) self.assertTrue(i == di) def test_Encoder_decode_content_equal(self): """Test the Content decoding of Encoder: equal""" data = "C:/data/test::HelloWorld".encode() dc = self.encoder1.decode(data) cmp_interest = Content("/data/test", "HelloWorld") self.assertTrue(dc == cmp_interest) def test_Encoder_decode_content_not_equal(self): """Test the Content decoding of Encoder: not equal""" data = "C:/data/test::HelloWorld2".encode() dc = self.encoder1.decode(data) cmp_interest = Content("/data/test", "HelloWorld") self.assertFalse(dc == cmp_interest) def test_Encoder_encode_decode_content(self): """Test the content decoding of Encoder""" c = Content("/data/test", "HelloWorld") ec = self.encoder1.encode(c) dc = self.encoder1.decode(ec) self.assertTrue(c == dc) def test_Encoder_encode_decode_nack(self): """Test the nack decoding of Encoder""" interest = Interest("/data/test") n = Nack("/data/test", NackReason.NO_CONTENT, interest=interest) en = self.encoder1.encode(n) dn = self.encoder1.decode(en) self.assertTrue(n == dn)
def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, interfaces: List[BaseInterface] = None, executors: BaseNFNExecutor = None, ageing_interval: int = 3, use_thunks=False): # debug level logger = Logger("NFNForwarder", log_level) logger.info("Start PiCN NFN Forwarder on port " + str(port)) # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder # setup data structures 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.register("computation_table", NFNComputationList) synced_data_struct_factory.register("timeoutprevention_dict", TimeoutPreventionMessageDict) if use_thunks: synced_data_struct_factory.register("thunktable", ThunkList) synced_data_struct_factory.register("plantable", PlanTable) 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() self.parser = DefaultNFNParser() if use_thunks: thunktable = synced_data_struct_factory.manager.thunktable() plantable = synced_data_struct_factory.manager.plantable( self.parser) #setup chunkifier self.chunkifier = SimpleContentChunkifyer() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.chunklayer = BasicChunkLayer(self.chunkifier, log_level=log_level) # setup nfn self.icnlayer._interest_to_app = True if executors is None: self.executors = {"PYTHON": NFNPythonExecutor()} else: self.executors = executors self.r2cclient = TimeoutR2CHandler() comp_table = synced_data_struct_factory.manager.computation_table( self.r2cclient, self.parser) self.nfnlayer = BasicNFNLayer(cs, fib, pit, faceidtable, comp_table, self.executors, self.parser, self.r2cclient, log_level=log_level) if use_thunks: self.thunk_layer = BasicThunkLayer(cs, fib, pit, faceidtable, thunktable, plantable, self.parser, log_level=log_level) self.nfnlayer.optimizer = ThunkPlanExecutor( cs, fib, pit, faceidtable, plantable) timeoutprevention_dict = synced_data_struct_factory.manager.timeoutprevention_dict( ) self.timeoutpreventionlayer = BasicTimeoutPreventionLayer( timeoutprevention_dict, comp_table, pit=pit, log_level=log_level) if use_thunks: self.lstack: LayerStack = LayerStack([ self.nfnlayer, self.chunklayer, self.timeoutpreventionlayer, self.thunk_layer, self.icnlayer, self.packetencodinglayer, self.linklayer ]) else: self.lstack: LayerStack = LayerStack([ self.nfnlayer, self.chunklayer, self.timeoutpreventionlayer, self.icnlayer, self.packetencodinglayer, self.linklayer ]) self.icnlayer.cs = cs self.icnlayer.fib = fib self.icnlayer.pit = pit # mgmt self.mgmt = Mgmt(self.icnlayer.cs, self.icnlayer.fib, self.icnlayer.pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level)
def __init__(self, packetencoder: BasicEncoder = SimpleStringEncoder(), print_keep_alive=True): self.interfacetable: Dict[str, SimulationInterface] = {} self.packetencoder = packetencoder self.print_keep_alive = print_keep_alive
def __init__(self, run_id: int, mobile_nodes: List[MobileNode], stationary_nodes: List[StationaryNode], stationary_node_distance: float, named_functions: dict, function_names: list, forwarder: str = "NFNForwarder", optimizer: str = "ToDataFirstOptimizer", use_distribution_helper: bool = False, log_level=logging.DEBUG): """ Configuration of the mobility simulation :param run_id the identifier of the simulation run :param mobile_nodes a list of mobile nodes part of the simulation :param stationary_nodes a list of stationary nodes forming the infrastructure :param stationary_node_distance the distance between the stationary nodes :param named_functions a dictionary of named function definitions used to be executed :param function_names a list of function names to be assigned to the mobile nodes :param forwarder the NFN forwarder to be used :param optimizer the NFN resolution strategy optimizer to be used in the simulation :param use_distribution_helper A flag indicating if the default distribution helper (ZipfMandelbrotDistribution) shall be used or not; default = False :param log_level the log level of the logger to be used; default: logging.DEBUG """ self._run_id = run_id self._forwarder = forwarder self._optimizer = optimizer self._mobile_nodes = mobile_nodes self._stationary_nodes = stationary_nodes self._stationary_node_distance = stationary_node_distance self.logger = Logger("MobilitySimulation", log_level) self.to_car_faces = [[0] * len(self._mobile_nodes) for i in range(len(self._stationary_nodes)) ] # rsu, car -> faceid self.to_rsu_faces = [[0] * len(self._mobile_nodes) for i in range(len(self._stationary_nodes)) ] # rsu, car -> faceid self._velocities = [] self._heading_directions = [] self._starting_points = [] for node in self._mobile_nodes: self._velocities.append(node.speed) self._heading_directions.append(node.direction) self._starting_points.append(node.spawn_point) self._is_running = False # flag indicating if the simulation is running or not self._function_names = function_names # list of function names to be invoked by the nodes self._named_functions = named_functions # a dict of function definitions to be invoked self._chunk_size = 8192 self._simulation_bus = SimulationBus( packetencoder=SimpleStringEncoder()) self._stationary_node_name_prefix = Name("/rsu") self._mobile_node_to_computation = [0] * len( mobile_nodes) # index which mobile node issues which computation if use_distribution_helper: # TODO in the future support more distribution types, e.g., uniform, gaussian, etc. dist_array = ZipfMandelbrotDistribution.create_zipf_mandelbrot_distribution( len(self._function_names), 0.7, 0.7) for i in range(0, len(mobile_nodes)): self._mobile_node_to_computation[i] = ZipfMandelbrotDistribution.\ get_next_zipfmandelbrot_random_number(dist_array, len(self._function_names)) - 1 # get_next_zipfmandelbrot_random_number(dist_array, len(self._function_names), run_id) - 1 self._compute_rsu_connection_time() self._setup_simulation_network()
def __init__(self, foldername: Optional[str], prefix: Name, port=9000, log_level=255, encoder: BasicEncoder = None, autoconfig: bool = False, autoconfig_routed: bool = False, interfaces: List[BaseInterface] = None, use_thunks=False): """ :param foldername: If None, use an in-memory repository. Else, use a file system repository. """ logger = Logger("ICNRepoSession", log_level) logger.info("Start PiCN Data Repository with Sessions") # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level) self.encoder = encoder # chunkifyer self.chunkifyer = SimpleContentChunkifyer() # repo manager = multiprocessing.Manager() if foldername is None: self.repo: BaseRepository = SimpleMemoryRepository(prefix, manager, logger) else: self.repo: BaseRepository = SimpleFileSystemRepository(foldername, prefix, manager, logger) # initialize layers synced_data_struct_factory = PiCNSyncDataStructFactory() synced_data_struct_factory.register("faceidtable", FaceIDDict) if use_thunks: synced_data_struct_factory.register("thunktable", ThunkList) synced_data_struct_factory.register("plantable", PlanTable) synced_data_struct_factory.create_manager() faceidtable = synced_data_struct_factory.manager.faceidtable() if use_thunks: self.parser = DefaultNFNParser() thunktable = synced_data_struct_factory.manager.thunktable() plantable = synced_data_struct_factory.manager.plantable(self.parser) if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer(self.encoder, log_level=log_level) self.chunklayer = BasicChunkLayer(self.chunkifyer, log_level=log_level) self.repolayer = SessionRepositoryLayer(self.repo, log_level=log_level) if use_thunks: self.thunklayer = BasicThunkLayer(None, None, None, faceidtable, thunktable, plantable, self.parser, self.repo, log_level=log_level) logger.info("Using Thunks") if use_thunks: self.lstack: LayerStack = LayerStack([ self.repolayer, self.chunklayer, self.thunklayer, self.packetencodinglayer, self.linklayer ]) else: self.lstack: LayerStack = LayerStack([ self.repolayer, self.chunklayer, self.packetencodinglayer, self.linklayer ]) if autoconfig: self.autoconfiglayer = AutoconfigRepoLayer(name=prefix.string_components[-1], addr='127.0.0.1', linklayer=self.linklayer, repo=self.repo, register_global=autoconfig_routed, log_level=log_level) self.lstack.insert(self.autoconfiglayer, below_of=self.chunklayer) # mgmt self.mgmt = Mgmt(None, None, None, self.linklayer, mgmt_port, self.start_repo, repo_path=foldername, repo_prfx=prefix, log_level=log_level)
def __init__(self, port=9000, log_level=255, encoder: BasicEncoder = None, routing: bool = False, peers=None, autoconfig: bool = False, interfaces: List[BaseInterface] = None, ageing_interval: int = 3, node_name: str = None): # debug level logger = Logger("ICNForwarder", log_level) # FIXME: Why isn't this self.logger??? self._node_name = node_name # packet encoder if encoder is None: self.encoder = SimpleStringEncoder(log_level=log_level) else: encoder.set_log_level(log_level=log_level) self.encoder = encoder # setup data structures 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", PendingInterestTableMemoryExact) synced_data_struct_factory.register("rib", TreeRoutingInformationBase) 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() rib = None if routing: rib = synced_data_struct_factory.manager.rib() faceidtable = synced_data_struct_factory.manager.faceidtable() # default interface if interfaces is not None: self.interfaces = interfaces mgmt_port = port else: interfaces = [UDP4Interface(port)] mgmt_port = interfaces[0].get_port() # initialize layers self.linklayer = BasicLinkLayer(interfaces, faceidtable, log_level=log_level) self.packetencodinglayer = BasicPacketEncodingLayer( self.encoder, log_level=log_level) self.icnlayer = BasicICNLayer(log_level=log_level, ageing_interval=ageing_interval) self.lstack: LayerStack = LayerStack( [self.icnlayer, self.packetencodinglayer, self.linklayer]) if autoconfig: self.autoconfiglayer: AutoconfigServerLayer = AutoconfigServerLayer( linklayer=self.linklayer, address='127.0.0.1', registration_prefixes=[(Name('/testnetwork/repos'), True)], log_level=log_level) self.lstack.insert(self.autoconfiglayer, below_of=self.icnlayer) if routing: self.routinglayer = BasicRoutingLayer(self.linklayer, peers=peers, log_level=log_level) self.lstack.insert(self.routinglayer, below_of=self.icnlayer) self.icnlayer.cs = cs self.icnlayer.fib = fib # ----- by Luc # FIXME: How to pass these parameters to __init__ self.icnlayer.fib.logger = logger self.icnlayer.fib.node_name = self._node_name # ----- by Luc # FIXME: How to pass these parameters to __init__ self.icnlayer.pit = pit self.icnlayer.pit.logger = logger self.icnlayer.pit.node_name = self._node_name # ----- if autoconfig: self.autoconfiglayer.fib = fib if routing: self.routinglayer.rib = rib self.routinglayer.fib = fib # mgmt self.mgmt = Mgmt(cs, fib, pit, self.linklayer, mgmt_port, self.stop_forwarder, log_level=log_level)
def main(args): logger = Logger( "ICNPushRepo", logging.DEBUG) # note: set later according to cli/config arguments logger.info("Starting a Push Repository...") # Parse Configuration file conf = None if args.config != "none": try: conf = ConfigParser(args.config) logger.info("Successfully parsed configuration file.") except CouldNotOpenConfigError: conf = None logger.warning( "Could not open configuration file. Proceed with command line arguments or default values." ) except CouldNotParseError: logger.warning( "Could not parse configuration file. Proceed with command line arguments or default values." ) except MalformedConfigurationError as e: logger.warning( "Invalid configuration file. Proceed with command line arguments or default values. Hint: " + str(e)) # Choose command line arguments before config file arguments before default values if not args.port: if conf and conf.udp_port: args.port = conf.udp_port else: args.port = default_port if not args.format: if conf and conf.format: args.format = conf.format else: args.format = default_format if not args.logging: if conf and conf.logging: args.logging = conf.logging else: args.logging = default_logging # Log Level if args.logging == 'error': log_level = logging.ERROR elif args.logging == 'warning': log_level = logging.WARNING elif args.logging == 'info': log_level = logging.INFO elif args.logging == 'debug': log_level = logging.DEBUG else: log_level = 255 logger.setLevel(log_level) # Info logger.info("UDP Port: " + str(args.port)) logger.info("Log Level: " + args.logging) logger.info("Packet Format: " + args.format) logger.info("Database: " + args.database_path) logger.info("Flush DB: " + str(args.flush_database)) # Packet encoder encoder = NdnTlvEncoder( log_level) if args.format == 'ndntlv' else SimpleStringEncoder( log_level) # Start forwarder = PiCN.ProgramLibs.ICNPushRepository.ICNPushRepository( args.database_path, args.port, log_level, encoder, args.flush_database) forwarder.start_forwarder() forwarder.linklayer.process.join()