def iter_encr(self, data_len, key_storage):
data = ''.join(random.choice(string.letters) for i in xrange(data_len))
ks = FileBasedSecurityManager(key_storage, PASSWD)
print 'Data block len: %s' % len(data)
encdec = ks.get_encoder(data_len)
encrypted = encdec.encrypt(data)
print 'Encrypted data block len: %s' % len(encrypted)
encdec = ks.get_encoder(data_len)
decrypted = encdec.decrypt(encrypted)
print 'Decrypted data block len: %s' % len(decrypted)
self.assertEqual(decrypted, data)
def iter_encr(self, data_len, key_storage):
data = ''.join(random.choice(string.letters) for i in xrange(data_len))
ks = FileBasedSecurityManager(key_storage, PASSWD)
print 'Data block len: %s'%len(data)
encdec = ks.get_encoder(data_len)
encrypted = encdec.encrypt(data)
print 'Encrypted data block len: %s'%len(encrypted)
encdec = ks.get_encoder(data_len)
decrypted = encdec.decrypt(encrypted)
print 'Decrypted data block len: %s'%len(decrypted)
self.assertEqual(decrypted, data)
def test_inc_encode_decode(self):
ks = FileBasedSecurityManager(CLIENT_KS_1024_PATH, PASSWD)
key = ks.get_client_cert_key()
self.assertEqual(key, 63)
data = ''.join(random.choice(string.letters) for i in xrange(1024))
TEST_LEN = 10000
encdec = ks.get_encoder(TEST_LEN)
or_data = ''
dc_data = ''
for i in xrange(TEST_LEN/100):
data = ''.join(random.choice(string.letters) for i in xrange(100))
or_data += data
dc_data += encdec.encrypt(data)
self.assertEqual(len(dc_data), encdec.get_expected_data_len())
encdec = ks.get_encoder(TEST_LEN)
data = ''
for i in xrange(TEST_LEN/1000):
data += encdec.decrypt(dc_data[i*1000:(i+1)*1000])
data += encdec.decrypt(dc_data[(i+1)*1000:])
self.assertEqual(data, or_data)
def test_data_block(self):
ks = FileBasedSecurityManager(CLIENT_KS_1024_PATH, PASSWD)
DataBlock.SECURITY_MANAGER = ks
DB_PATH = tmp('test_data_block.kst')
DATA_LEN = 10
if os.path.exists(DB_PATH):
os.remove(DB_PATH)
db = DataBlock(DB_PATH, DATA_LEN, force_create=True)
checksum = hashlib.sha1()
for i in xrange(DATA_LEN / 10):
data = ''.join(
random.choice(string.letters)
for i in xrange(DATA_LEN / (DATA_LEN / 10)))
checksum.update(data)
db.write(data)
db.close()
db.close() #should be OK
or_checksum = checksum.hexdigest()
enc_checksum = db.checksum()
db = DataBlock(DB_PATH, DATA_LEN)
ret_data = ''
checksum = hashlib.sha1()
while True:
data = db.read(100)
if not data:
break
ret_data += data
checksum.update(data)
self.assertEqual(or_checksum, checksum.hexdigest())
self.assertEqual(db.checksum(), enc_checksum)
db = DataBlock(DB_PATH, DATA_LEN)
raw = db.read_raw()
self.assertEqual(db.checksum(), enc_checksum)
db = DataBlock(DB_PATH, DATA_LEN)
raw = db.read()
self.assertEqual(ret_data, raw)
app_db = DataBlock(DB_PATH)
app_db.write('The end!')
app_db.finalize()
app_db.close()
db = DataBlock(DB_PATH, actsize=True)
raw = db.read()
self.assertEqual(ret_data + 'The end!', raw)
db.close()
def test_inc_encode_decode(self):
ks = FileBasedSecurityManager(CLIENT_KS_1024_PATH, PASSWD)
key = ks.get_client_cert_key()
self.assertEqual(key, 63)
data = ''.join(random.choice(string.letters) for i in xrange(1024))
TEST_LEN = 10000
encdec = ks.get_encoder(TEST_LEN)
or_data = ''
dc_data = ''
for i in xrange(TEST_LEN / 100):
data = ''.join(random.choice(string.letters) for i in xrange(100))
or_data += data
dc_data += encdec.encrypt(data)
self.assertEqual(len(dc_data), encdec.get_expected_data_len())
encdec = ks.get_encoder(TEST_LEN)
data = ''
for i in xrange(TEST_LEN / 1000):
data += encdec.decrypt(dc_data[i * 1000:(i + 1) * 1000])
data += encdec.decrypt(dc_data[(i + 1) * 1000:])
self.assertEqual(data, or_data)
def test01_nibbler_init(self):
remove_dir(tmp('client_base_test'))
os.makedirs(tmp('client_base_test/dynamic_cache'))
os.makedirs(tmp('client_base_test/static_cache'))
security_manager = FileBasedSecurityManager(CLIENT_KS_PATH, PASSWD)
nibbler = Nibbler('127.0.0.1',
security_manager,
cache_dir=tmp('client_base_test'))
nibbler.fabnet_gateway.fri_client = MockedFriClient()
BaseNibblerTest.NIBBLER_INST = nibbler
with self.assertRaises(NoJournalFoundException):
nibbler.start()
self.assertEqual(nibbler.is_registered(), False)
nibbler.register_user()
nibbler.start()
def test_journal(self):
ks = FileBasedSecurityManager(CLIENT_KS_PATH, PASSWD)
DataBlock.SECURITY_MANAGER = ks
tmp_journal = tmp('test_nimbusfs_journal')
if os.path.exists(tmp_journal):
os.remove(tmp_journal)
journal = Journal('%040x' % 23453, tmp_journal, MockedFabnetGateway())
try:
dir_name = 'Test directory'
dir_id = 235532
parent_dir_id = 345
dir_md = DirectoryMD(name=dir_name,
item_id=dir_id,
parent_dir_id=parent_dir_id)
journal.append(Journal.OT_APPEND, dir_md)
for record_id, operation_type, item_md in journal.iter():
self.assertEqual(record_id, 1)
self.assertEqual(operation_type, Journal.OT_APPEND)
self.assertEqual(item_md.item_id, dir_id)
self.assertEqual(item_md.parent_dir_id, parent_dir_id)
self.assertEqual(item_md.name, dir_name)
dir_name = 'new directory name'
dir_md.dir_name = dir_name
journal.append(Journal.OT_UPDATE, dir_md)
for record_id, operation_type, item_md in journal.iter(2):
self.assertEqual(record_id, 2)
self.assertEqual(operation_type, Journal.OT_UPDATE)
self.assertEqual(item_md.item_id, dir_id)
self.assertEqual(item_md.parent_dir_id, parent_dir_id)
self.assertEqual(item_md.name, dir_name)
journal.append(Journal.OT_REMOVE, dir_md)
finally:
journal.close()
journal = Journal('%040x' % 23453, tmp_journal, MockedFabnetGateway())
cnt = 0
for record_id, operation_type, item_md in journal.iter():
cnt += 1
journal.close()
self.assertEqual(cnt, 3)
def test_parallel_read_write(self):
ks = FileBasedSecurityManager(CLIENT_KS_1024_PATH, PASSWD)
DataBlock.SECURITY_MANAGER = ks
writers = []
readers = []
NUM = 25
for i in xrange(NUM):
path = tmp('parallel_read_write_db.%s' % i)
flen = random.randint(10, 10000)
dbw = DBWriter(path, flen)
dbr = DBReader(path, flen)
writers.append(dbw)
readers.append(dbr)
for writer in writers:
writer.start()
for reader in readers:
reader.start()
for i, writer in enumerate(writers):
writer.join()
readers[i].join()
self.assertEqual(writer.get_checksum(), readers[i].get_checksum(),
'Num=%s, len=%s' % (i, writer.f_len))
def test00_base(self):
ks = FileBasedSecurityManager(CLIENT_KS_PATH, PASSWD)
DataBlock.SECURITY_MANAGER = ks
DataBlock.LOCK_MANAGER = DBLocksManager()
remove_dir(tmp('smart_file_test'))
os.makedirs(tmp('smart_file_test/dynamic_cache'))
os.makedirs(tmp('smart_file_test/static_cache'))
db_cache = DataBlockCache(tmp('smart_file_test'), user_id=sha1('test').hexdigest())
md = MetadataFile(db_cache.get_static_cache_path('test_md.bin'))
tr_manager = None
try:
tr_manager = TransactionsManager(md, db_cache)
p_queue = tr_manager.get_upload_queue()
g_queue = tr_manager.get_download_queue()
SmartFileObject.setup_transaction_manager(tr_manager)
e_file = SmartFileObject('/empty_file', for_write=True)
e_file.close()
e_file = SmartFileObject('/empty_file')
data = e_file.read()
self.assertEqual(data, '')
e_file.close()
test_file = SmartFileObject('/test.file', for_write=True)
test_file.write('this is test message for one data block!')
test_file.close()
put_obj = p_queue.get(False)
transaction, seek = put_obj
self.assertEqual(seek, 0)
data_block, next_seek, _ = transaction.get_data_block(seek, noclone=True)
self.assertNotEqual(data_block, None)
self.assertEqual(next_seek, None)
data_block.close()
tr_manager.update_transaction(transaction.get_id(), seek, is_failed=False, foreign_name='%040x'%123456)
self.assertEqual(transaction.get_status(), Transaction.TS_FINISHED)
db_path = '%s.%s'%(transaction.get_id(), seek)
self.assertFalse(DataBlock.is_locked(db_cache.get_cache_path(db_path)))
test_file = SmartFileObject('/test.file')
data = test_file.read(4)
self.assertEqual(data, 'this')
self.assertTrue(DataBlock.is_locked(db_cache.get_cache_path(db_path)))
data = test_file.read()
self.assertEqual(data, ' is test message for one data block!')
test_file.close()
self.assertFalse(DataBlock.is_locked(db_cache.get_cache_path(db_path)))
with self.assertRaises(Empty):
get_obj = g_queue.get(False)
mgt = MockedGetThread(g_queue)
mgt.start()
open(db_cache.get_cache_path(db_path), 'w').write('invalid data') #failed local data block
test_file = SmartFileObject('/test.file')
data = test_file.read()
self.assertEqual(data, 'this is test message for one data block!')
test_file.close()
db_cache.clear_all()
test_file = SmartFileObject('/test.file')
data = test_file.read()
self.assertEqual(data, 'this is test message for one data block!')
test_file.close()
self.assertFalse(DataBlock.is_locked(db_cache.get_cache_path('%040x'%123456)))
finally:
if tr_manager:
g_queue.put((None,None))
tr_manager.close()
md.close()
db_cache.stop()
