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)
def __init__(self):
self._language = "PYTHONSTREAM"
self._sandbox = NFNPythonExecutor()._init_sandbox()
self._sandbox["check_end_streaming"] = self.check_end_streaming
self._sandbox["get_next"] = self.get_next
self._sandbox["write_out"] = self.write_out
self._sandbox["last_write_out"] = self.last_write_out
self._sandbox["write_out_on_get_next"] = self.write_out_on_get_next
self._sandbox["print"] = print
self._sandbox["sleep"] = time.sleep
self.get_next_buffer: dict = {}
self.sent_interests: dict = {}
self.name_list_single: list = None
self.name_list_multiple: list = None
self.pos_name_list_multiple: int = 0
self.queue_to_lower: multiprocessing.Queue = None
self.queue_from_lower: multiprocessing.Queue = None
self.cs: BaseContentStore = None
self.packetid: int = None
self.comp_name: str = None
self.get_next_part_counter: int = 0
self.write_out_part_counter: int = -1
self.classic: bool = False
def setUp(self):
#setup icn_layer
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("computation_table",
NFNComputationList)
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()
self.r2cclient = TimeoutR2CHandler()
parser = DefaultNFNParser()
comp_table = synced_data_struct_factory.manager.computation_table(
self.r2cclient, parser)
self.executor = {"PYTHON": NFNPythonExecutor()}
self.nfn_layer = BasicNFNLayer(cs,
fib,
pit,
faceidtable,
comp_table,
self.executor,
parser,
self.r2cclient,
log_level=255)
self.nfn_layer.queue_to_lower = multiprocessing.Queue()
self.nfn_layer.queue_from_lower = multiprocessing.Queue()
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 setUp(self):
self.executor = NFNPythonExecutor()
class test_NFNPythonExecutor(unittest.TestCase):
"""Tests for the NFNPythonExecutor"""
def setUp(self):
self.executor = NFNPythonExecutor()
def tearDown(self):
pass
def test_single_simple_function_call(self):
"""Test a very simple function code with no Parameter"""
NF = \
"""PYTHON
f
def f():
return 3
"""
res = self.executor.execute(NF, [])
self.assertEqual(res, 3)
def test_single_function_call(self):
"""Test a very simple function code with Parameter"""
NF = \
"""PYTHON
f
def f(a, b):
return a*b
"""
res = self.executor.execute(NF, [2, 3])
self.assertEqual(res, 6)
def test_single_function_call_library_function(self):
"""Test a very simple function code with library call"""
NF = \
"""PYTHON
f
def f(a, b):
return max(a,b)
"""
res = self.executor.execute(NF, [2, 3])
self.assertEqual(res, 3)
def test_single_function_call_forbitten_library_function(self):
"""Test a very simple function code forbitten libary call"""
NF = \
"""PYTHON
f
def f(a):
return open(a)
"""
res = self.executor.execute(NF, ["data.txt"])
self.assertEqual(res, None)
def test_multiple_function_call(self):
"""Test a very simple function code with second function"""
NF = \
"""PYTHON
f
def g(b):
return b*b
def f(a):
return g(a*a)
"""
res = self.executor.execute(NF, [2])
self.assertEqual(res, 16)
def test_multiple_function_call_libray_name(self):
"""Test a very simple function code second function with library name"""
NF = \
"""PYTHON
f
def open(b):
return 2
def f(a):
return open(a)
"""
res = self.executor.execute(NF, ['test.txt'])
self.assertEqual(res, 2)
def test_single_function_call(self):
"""Test a loop function code """
NF = \
"""PYTHON
f
def f(a):
res = 0
for i in range(0,a):
res = res + i
return res
"""
res = self.executor.execute(NF, [4])
self.assertEqual(res, 6)
def test_class(self):
"""Test with a class"""
NF = \
"""PYTHON
f
class TestClass(object):
def __init___(self):
self.a = 0
def f(a):
res = 0
x = TestClass()
for i in range(0,a):
res = res + i
return res
"""
res = self.executor.execute(NF, [4])
self.assertEqual(res, None)