async def test_get_inode(filesystem):
# non existed inode eval to False
assert not Inode(MD5)
# existed inode has correct content, ref_count and mime
inode = await Inode.create(gen_content(CONTENT), MIME)
inode = Inode(inode.md5)
await assert_inode(inode)
def stat(self, filename):
inode_no = self.search_dir(filename)
if inode_no is None:
raise Exception("file or directory does not exist")
inode_block = inodemap.inodemap.lookup(inode_no)
inode = Inode(data=segment.segman.block_read(inode_block))
return inode.filesize, inode.isdir
def getInode (self, ino, vice=None):
if self.inodes.has_key (ino):
inode= self.inodes[ino]
else:
self.debug (1, "not found ino %d" % (ino), 2)
inode= Inode (ino, self, vice=vice, policy=self.policy)
self.inodes[ino]= inode
return inode
def createInodeList(self, inodeTotalNumber, fsimg, offset, size):
inodeList = []
offsetInt = offset
for i in range(inodeTotalNumber):
inodeList.append(Inode())
inodeList[i].createFromBytes(fsimg, offsetInt, size)
offsetInt += size
return inodeList
def sync(self):
(serialized,
imap_num) = inodemap.inodemap.save_inode_map(get_max_inode())
special_inode = Inode()
special_inode.write(0, serialized)
imap_loc = inodemap.inodemap.lookup(special_inode.id)
segment.segman.update_imap_postion(imap_loc, imap_num)
segment.segman.flush()
async def test_ref_unref(filesystem):
# ref should increase the ref count
inode = await Inode.create(gen_content(CONTENT), MIME)
await assert_inode(inode)
inode.ref()
await assert_inode(Inode(inode.md5), ref_count=2)
inode.ref()
await assert_inode(Inode(inode.md5), ref_count=3)
# unref should decrease the ref count
inode.unref()
await assert_inode(Inode(inode.md5), ref_count=2)
inode.unref()
await assert_inode(Inode(inode.md5), ref_count=1)
# last unref should remove the inode
inode.unref()
assert not inode
assert not Inode(inode.md5)
def create(self, filename, isdir=False):
inode_no = self.search_dir(filename)
if inode_no is not None:
raise Exception("file already exists")
inode = Inode(isdir=isdir)
parent_dir = find_parent(filename)
parent_inode_no = self.search_dir(parent_dir)
if parent_inode_no is None:
raise Exception("parent direntory does not exist")
parent_inode_block = inodemap.inodemap.lookup(parent_inode_no)
parent_inode = Inode(
data=segment.segman.block_read(parent_inode_block))
self.append_entry(parent_inode, find_filename(filename), inode)
if isdir:
return Directory(inode.id)
else:
return File(inode.id)
def unlink(self, path):
filename = find_filename(path)
parent_inode_no = self.search_dir(find_parent(path))
parent_inode_block = inodemap.inodemap.lookup(parent_inode_no)
parent_inode = Inode(
data=segment.segman.block_read(parent_inode_block))
parent_old_size = parent_inode.filesize
parent_dir = Directory(parent_inode_no)
found_entry = False
entries = []
for (name, inode) in parent_dir.enumerate():
if found_entry:
entries.append((name, inode))
if name == filename:
fount = True
position = parent_dir.position - (FILENAMELEN + 4)
for (name, inode) in entries:
parent_inode.write(position,
struct.pack("%dsI" % FILENAMELEN, name, inode))
position += (FILENAMELEN + 4)
parent_inode.filesize = parent_old_size - (FILENAMELEN + 4)
inodemap.inodemap.update_inode(parent_inode_no,
parent_inode.serialize())
def inode(self) -> typing.Optional[Inode]:
inode_id = self.meta.get('inode_md5')
return Inode(inode_id) if inode_id else None
def inode(self):
inode_id = self.meta.get('inode')
return Inode(inode_id) if inode_id else None
from inode import Inode, Tree
from api.functions import splitFile, upload_to_vk, download_from_vk, upload_main_inode
from cache import LRUCache
if __name__ == "__main__":
# Inode test
a = Inode(size=8, blocks={1: range(11200, 11210), 2: range(11200, 11210), 3: range(11200, 11210)})
b = Inode(size=30, blocks={1: range(11200, 11210), 2: range(11200, 11210), 3: range(11200, 11210)})
c = Inode(size=12, blocks={1: range(11200, 11210), 2: range(11200, 11210), 3: range(11200, 11210)})
c1 = Inode(size=15, blocks={1: range(11200, 11210), 2: range(11200, 11210), 3: range(11200, 11210)})
d = Inode(size=2, blocks={1: range(11200, 11210), 2: range(11200, 11210), 3: range(11200, 11210)})
# Tree test
tree = Tree()
#upload_main_inode(tree.marshal())
# tree.mkdir('/home')
# tree.mkdir('/home/horn')
# tree.mkdir('/home/test')
# tree.mkdir('/dom')
# tree.mkdir('/home/test/dir1')
#
# tree.inodes['/']['home']['test'].update({'1.jpg': a})
# tree.inodes['/']['home'].update({'2.jpg': b})
# tree.inodes['/']['home'].update({'3.jpg': c})
# tree.inodes['/']['home'].update({'3.jpg': d})
# print tree
# serialization
#f = open('tree', 'wb')
def restore(self):
imap_loc = segment.segman.locate_lastest_imap()
iminode = Inode(data=disk.disk.block_read(imap_loc))
imdata = iminode.read(0, 10000000)
set_max_inode(inodemap.inodemap.restore_imap(imdata))
async def test_set_mime(filesystem):
# mime can be changed afterwards
inode = await Inode.create(gen_content(CONTENT), MIME)
await assert_inode(inode)
inode.mime = MIME2
await assert_inode(Inode(inode.md5), mime=MIME2)
def get_inode(self):
inode_block_no = inodemap.inodemap.lookup(self.inode_no)
#print inode_block_no
inode = Inode(data=segment.segman.block_read(inode_block_no))
return inode
