def mkdir(filename, directory):
inum = inode_number.get_free_inode()
i = inode_number.inode_number_to_inode(inum)
i.inode_type = FileType.directory
i.add_block()
d_inode = inode_number.inode_number_to_inode(directory)
d_block = inode_number.inode_number_to_block((d_inode.size - 1) * blockLayer._block_size, directory)
data = filename + "|" + str(inum) + ","
d_block.write(d_block.size, data, 0, len(data))
b_string = [""] * d_block.size
b_string = d_block.read(0, b_string, 0, d_block.size)
def rmdir(directory):
inum = file_name_layer.lookup(directory, path_name_layer._wd)
i = inode_number.inode_number_to_inode(inum)
if (i.inode_type == FileType.directory):
blockLayer.release_block(i.blocks[0])
inode_number.release_inode(inum)
inode_directory = inode_number.inode_number_to_inode(path_name_layer._wd)
block_directory = blockLayer.block_number_to_block(inode_directory.blocks[0])
buf = [""] * block_directory.size
buf = block_directory.read(0, buf, 0, block_directory.size)
buf = "".join(buf)
search = directory + "|" + str(inum) + ","
buf = buf.replace(search, "")
clear = "_" * 512
block_directory.write(0, clear, 0, len(clear))
block_directory.write(0, buf, 0, len(buf))
if(len(buf) == 0): # checks to see if the directory is now empty
block_directory.size = 0
else:
raise Exception("Inode %r is not of type directory." % inum)
def ls():
b = inode_number.inode_number_to_block((inode_number.inode_number_to_inode(path_name_layer._wd)).size, path_name_layer._wd)
buf = [''] * b.size
buf = b.read(0, buf, 0, b.size - 1)
d = "".join(buf)
if(0 != b.size):
dic = file_name_layer.createDict(d)
for key in dic.keys():
print "- ", key
else:
print "Empty Directory"
def rm(filename):
num = 0
inum = file_name_layer.lookup(filename, path_name_layer._wd)
i = inode_number.inode_number_to_inode(inum)
for b in i.blocks:
if (b != -1):
blockLayer.release_block(i.blocks[num])
num += 1
inode_number.release_inode(inum)
inode_directory = inode_number.inode_number_to_inode(path_name_layer._wd)
block_directory = blockLayer.block_number_to_block(inode_directory.blocks[0])
buf = [""] * block_directory.size
buf = block_directory.read(0, buf, 0, block_directory.size)
buf = "".join(buf)
search = filename + "|" + str(inum) + ","
buf = buf.replace(search, "")
clear = "_" * 512
block_directory.write(0, clear, 0, len(clear))
block_directory.write(0, buf, 0, len(buf))
if(len(buf) == 0): # checks to see if the directory is now empty
block_directory.size = 0
def lookup(filename, directory):
if(valid_filename(filename) == 0):
i = inode_number.inode_number_to_inode(directory)
if (i.inode_type != FileType.directory):
raise Exception ("Not a directory.")
offset = 0
while (offset < i.size):
b = inode_number.inode_number_to_block(offset, directory)
if (string_match(filename, b)):
return inode_num(filename, b) # may need to be returned as an int
offset = offset + blockLayer._block_size
return 0
else:
raise Exception("The filename %s is not a valid name." % filename)
def cat(filename):
num_blocks = 0
pointer = 0
count = 0
inum = file_name_layer.lookup(filename, path_name_layer._wd)
i = inode_number.inode_number_to_inode(inum)
for b in i.blocks:
if (b != -1):
num_blocks += 1
buf = [""] * (blockLayer._block_size * num_blocks)
while(pointer < num_blocks):
block = blockLayer.block_number_to_block(i.blocks[pointer])
buf = block.read(0, buf, count, block.size)
pointer += 1
count += blockLayer._block_size
buf = "".join(buf)
print buf
def append(filename, writer):
inum = file_name_layer.lookup(filename, path_name_layer._wd)
i = inode_number.inode_number_to_inode(inum)
bnum = i.blocks[i.size - 1]
blk = blockLayer.block_number_to_block(bnum)
buf = list(writer)
b_start = 0
while (b_start < len(buf)):
while (blk.size < blockLayer._block_size):
if(b_start == len(writer)):
return 0
buf_string = "".join(buf[b_start])
blk.write(blk.size, buf_string, 0, 1)
b_start += 1
if(b_start < len(buf)):
bnum = i.add_block()
blk = blockLayer.block_number_to_block(bnum)
def rmdir(name):
#first, remove every file inside the directory recursively diving down as far as possible
#open the directory
#recursively call rmdir until not directory
#repeat for all files in directory
dirInodeNum = general_path_to_inode_number(name,createOnFailure=0)
if dirInodeNum == failure:
raise Exception("Directory not found")
#parse to dict
fnDict = FileNameLayer.parseDirectory(dirInodeNum)
#go through all the files in the directory
for fn in fnDict:
if InodeNumberLayer.inode_number_to_inode(fnDict[fn]).type == FileNameLayer.FileType.directory:
rmdir(name+'/'+fn)
else:
#base case: delete the file
# print 'filename:',fn
rm(name+'/'+fn)
# print 'name:',name
rm(name,rmdir=True)
d_inode = path_name_layer.path_to_inode_number("Home", 0)
file_name_layer.create_file("test_1", d_inode)
file_name_layer.create_file("test_2", d_inode)
file_name_layer.create_file("test_3", d_inode)
file_name_layer.create_file("test_4", d_inode)
# Creates Kris directory
file_name_layer.mkdir("Kris", d_inode)
d_inode2 = path_name_layer.path_to_inode_number("Kris", d_inode)
# Creates Docs directory
file_name_layer.mkdir("Docs", d_inode2)
d_inode_docs = path_name_layer.path_to_inode_number("Docs", d_inode2)
file_name_layer.create_file("Doc_1", d_inode_docs) # I want to write to this file
inum = path_name_layer.path_to_inode_number("Doc_1", d_inode_docs)
i = inode_number.inode_number_to_inode(inum)
block = blockLayer.block_number_to_block(i.blocks[0])
s = "Testing 1... 2... 3... 4.... 5... 6.... 7...."
block.write(0, s, 0, len(s))
# Creates Pics directory
file_name_layer.mkdir("Pics", d_inode2)
d_inode_pics = path_name_layer.path_to_inode_number("Pics", d_inode2)
file_name_layer.create_file("img_1", d_inode_pics)
file_name_layer.create_file("img_2", d_inode_pics)
# Creates Music directory
file_name_layer.mkdir("Music", d_inode2)
d_inode_music = path_name_layer.path_to_inode_number("Music", d_inode2)
file_name_layer.create_file("song_1", d_inode_music)
file_name_layer.create_file("song_2", d_inode_music)
