def setUp(self):
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("data1")
with open(self.path + "/f2", 'w+') as content_file:
content_file.write("data2")
with open("/tmp/f3", 'w+') as content_file:
content_file.write("data3")
manager = multiprocessing.Manager()
self.repository = SimpleFileSystemRepository(self.path,
Name("/test/data"),
manager=manager)
def setUp(self):
try:
shutil.rmtree(self.path)
os.remove("/tmp/repo")
except:
pass
self.path = "/tmp/repo"
try:
os.stat(self.path)
except:
os.mkdir(self.path)
with open(self.path + "/d2", 'w+') as content_file:
content_file.write("data2")
factory = PiCNSyncDataStructFactory()
factory.register("cs", ContentStoreMemoryExact)
factory.register("fib", ForwardingInformationBaseMemoryPrefix)
factory.register("pit", PendingInterstTableMemoryExact)
factory.register("faceidtable", FaceIDDict)
factory.register("thunkTable", ThunkList)
factory.register("planTable", PlanTable)
factory.create_manager()
self.cs = factory.manager.cs()
self.fib = factory.manager.fib()
self.pit = factory.manager.pit()
self.faceidtable = factory.manager.faceidtable()
self.thunkTable = factory.manager.thunkTable()
self.parser = DefaultNFNParser()
self.planTable = factory.manager.planTable(self.parser)
self.repo = SimpleFileSystemRepository("/tmp/repo", Name("/dat/data"),
multiprocessing.Manager())
self.thunklayer = BasicThunkLayer(self.cs, self.fib, self.pit,
self.faceidtable, self.thunkTable,
self.planTable, self.parser,
self.repo)
self.thunklayer.queue_to_higher = multiprocessing.Queue()
self.thunklayer.queue_to_lower = multiprocessing.Queue()
self.thunklayer.queue_from_higher = multiprocessing.Queue()
self.thunklayer.queue_from_lower = multiprocessing.Queue()
self.thunklayer.start_process()
def setUp(self):
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("data1")
with open( self.path + "/f2", 'w+') as content_file:
content_file.write("data2")
manager = multiprocessing.Manager()
self.repository = SimpleFileSystemRepository(self.path, Name("/test/data"), manager=manager)
self.repositoryLayer = BasicRepositoryLayer(self.repository)
self.q1_from_lower = multiprocessing.Queue()
self.q1_to_lower = multiprocessing.Queue()
self.repositoryLayer.queue_from_lower = self.q1_from_lower
self.repositoryLayer.queue_to_lower = self.q1_to_lower
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)
class test_SimpleFileSystemRepository(unittest.TestCase):
"""Test the Simple File System Repository"""
def setUp(self):
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("data1")
with open(self.path + "/f2", 'w+') as content_file:
content_file.write("data2")
with open("/tmp/f3", 'w+') as content_file:
content_file.write("data3")
manager = multiprocessing.Manager()
self.repository = SimpleFileSystemRepository(self.path,
Name("/test/data"),
manager=manager)
def tearDown(self):
try:
shutil.rmtree(self.path)
os.remove("/tmp/repo_unit_test")
except:
pass
def test_content_available(self):
"""Test if the function is_content_available works correct"""
try:
os.remove("/tmp/repo_unit_test/f3") #ensure there is no f3
except:
pass
self.assertTrue(
self.repository.is_content_available(Name("/test/data/f1")))
self.assertTrue(
self.repository.is_content_available(Name("/test/data/f2")))
self.assertFalse(
self.repository.is_content_available(Name("/test/data/f3")))
def test_get_content(self):
"""test if the function get content works correct"""
c1_cmp = Content("/test/data/f1", "data1")
c1 = self.repository.get_content(Name("/test/data/f1"))
self.assertEqual(c1, c1_cmp)
c2_cmp = Content("/test/data/f2", "data2")
c2 = self.repository.get_content(Name("/test/data/f2"))
self.assertEqual(c2, c2_cmp)
c3 = self.repository.get_content(Name("/test/data/f3"))
self.assertEqual(c3, None)
def test_get_content_directory_traversal(self):
"""test if the function get content do not allow directory traversal"""
c4 = self.repository.get_content(Name("/test/data/../f3"))
self.assertEqual(c4, None)
c5 = self.repository.get_content(Name("/test/data/..%2Ff3"))
self.assertEqual(c5, None)
c6 = self.repository.get_content(Name("/test/data/..%2ff3"))
self.assertEqual(c6, None)
n1 = Name("/test/data")
n1 += "../f3"
c7 = self.repository.get_content(n1)
self.assertEqual(c7, None)
n2 = Name("/test/data")
n2 += "..%2ff3"
c8 = self.repository.get_content(n2)
self.assertEqual(c8, None)
n3 = Name("/test/data")
n3 += "..%2Ff3"
c9 = self.repository.get_content(n3)
self.assertEqual(c9, None)
def test_get_content_invalid_prefix(self):
"""test if the function get content do not return data from a invalid prefix"""
c10 = self.repository.get_content(Name("/data/test/f1"))
self.assertEqual(c10, None)
def test_get_size(self):
"""test the functionality of the get size function"""
c1 = self.repository.get_content(Name("/test/data/f1"))
size = len(c1.content)
self.assertEqual(size,
self.repository.get_data_size(Name("/test/data/f1")))