def status(self):
option = input(
"Enter 1 for Local File System status, 2 for Server status: ")
if option == 1:
print "\n", (MemoryInterface.status_MFS())
else:
print "\n", (MemoryInterface.status())
def update_inode_table(self, table_inode, inode_number):
if table_inode:
table_inode.time_modified = datetime.datetime.now(
) #TIME OF MODIFICATION
array_inode = InodeOps.InodeOperations().convert_table_to_array(
table_inode)
MemoryInterface.update_inode_table(array_inode, inode_number)
def read(self, path, offset=0, size=-1):
print(
"plz input serverNumber whose data is corrupted, if ur input >3, no server's data is corrupted"
)
serverNum = int(raw_input())
if serverNum < 4:
MemoryInterface.corruptData(serverNum)
read_buffer = interface.read(path, offset, size)
if read_buffer != -1: print(path + " : " + read_buffer)
def INODE_NUMBER_TO_INODE(self, inode_number):
array_inode = MemoryInterface.inode_number_to_inode(inode_number)
inode = InodeOps.InodeOperations().convert_array_to_table(array_inode)
if inode:
inode.time_accessed = str(
datetime.datetime.now())[:19] #TIME OF ACCESS
return inode
def INODE_NUMBER_TO_INODE(self, inode_number):
#print(inode_number)
array_inode = MemoryInterface.inode_number_to_inode(inode_number)
#print("###############")
#print(array_inode)
inode = InodeOps.InodeOperations().convert_array_to_table(array_inode)
#print(inode)
if inode: inode.time_accessed = datetime.datetime.now() #TIME OF ACCESS
return inode
def unlink(self, inode_number, parent_inode_number):
'''WRITE YOUR CODE HERE'''
error = -1
inode = self.INODE_NUMBER_TO_INODE(inode_number)
if(inode == False):
return error
parent_inode = self.INODE_NUMBER_TO_INODE(parent_inode_number)
if(parent_inode == False):
return error
#unlinking dir, make sure it is empty, dir inode can only be deleted if its empty
if inode.type == 1 and len(inode.directory) != 0:
print("ERROR: cant unlink non empty directory")
return error
#if the file is an inode decrement its links
if inode.type == 0:
inode.links -=1
if(inode.links == 0):
interface.free_data_block(inode,0)
MemoryInterface.update_inode_table(False, inode_number)
return parent_inode
if inode.type == 1:
interface.free_data_block(inode,0)
MemoryInterface.update_inode_table(False, inode_number)
return parent_inode
array_inode = InodeOps.InodeOperations().convert_table_to_array(inode)
MemoryInterface.update_inode_table(array_inode, inode_number)
return parent_inode
def read(self, inode, offset, length):
'''READING DATA'''
B = inode.ser_numbers
if (inode.type != 0):
print "ERROR: INODE TYPE NOT FILE"
return (-1)
if (offset >= inode.size
): #If the offset is greater than the size of the inode
print "ERROR: OFFSET LARGER THAN FILE SIZE."
return (-1) #Give an error and exit
if (length == -1):
length = inode.size
if (length - offset > inode.size):
print "ERROR: LENGTH GREATER THAN FILE SIZE"
bl_dat = "" #Stores data that is read
index = offset / config.BLOCK_SIZE #Index of the block thst contains the offset
abc = math.ceil(
min([offset + length, inode.size])
) / config.BLOCK_SIZE #Index of the block that contains the last charcter to be read
index1 = self.ceilings(abc)
E = index * config.BLOCK_SIZE #Stores number of characters before the index block
N = offset - E #Stores number of characters in the index block that do not have to be read
read_servers = []
if index == index1:
for i in range(index, index1 + 1):
read_servers = MemoryInterface.Read_Data_Servers(B[i])
print("\n\nData to be read resides on the following servers: ")
for i in range(0, len(read_servers)):
print read_servers[i]
MemoryInterface.Read_Server_Ack(read_servers)
for i in range(index, index1 +
1): #For number of block that have to be read from
bl_dat = bl_dat + MemoryInterface.get_data_block(
inode.blk_numbers[i],
B[i]) #Put all the data block appended togther in bl_data
inode.time_accessed = str(
datetime.datetime.now())[:19] #Update the access time
for i in range(index, index1):
read_servers = MemoryInterface.Read_Data_Servers(B[i])
print("\n\nData to be read resides on the following servers: ")
for i in range(0, len(read_servers)):
print read_servers[i]
MemoryInterface.Read_Server_Ack(read_servers)
for i in range(index,
index1): #For number of block that have to be read from
bl_dat = bl_dat + MemoryInterface.get_data_block(
inode.blk_numbers[i],
B[i]) #Put all the data block appended togther in bl_data
inode.time_accessed = str(
datetime.datetime.now())[:19] #Update the access time
data_read = bl_dat[N:N + length]
return inode, data_read #Read data is bl_data removing N characters from the index block to N+length characters
'''#IMPLEMENTS THE READ FUNCTION
def get_valid_data_block(self):
return MemoryInterface.get_valid_data_block()
def update_data_block(self, block_number, block_data, delay_sec):
MemoryInterface.update_data_block(block_number, block_data, delay_sec)
def BLOCK_NUMBER_TO_DATA_BLOCK(self, block_number, delay_sec):
return ''.join(MemoryInterface.get_data_block(block_number, delay_sec))
print "\n", (MemoryInterface.status_MFS())
else:
print "\n", (MemoryInterface.status())
if __name__ == '__main__':
#DO NOT MODIFY THIS
my_object = FileSystemOperations()
num_of_servers = input("Enter the number of servers: ")
#for i in range (0,num_of_servers):
#os.system("gnome-terminal -e 'bash -c \"/media/sf_share/server"+str(i+1)+"/ServerStub"+str(i+1)+".py; exec bash\"'")
time_t = input("Enter time t in seconds: ")
MemoryInterface.time_func(time_t)
port_num = input("Enter the first port number: ")
MemoryInterface.Init(num_of_servers, port_num)
Initialize_My_FileSystem()
Initialize_My_FileSystem_MFS()
text = []
while text != "exit":
text = raw_input(
"\nEnter input command: \nTo create a directory: 'mkdir PATH' \nTo create a file: 'create PATH' \nTo write to a file: 'write'\nTo read froma file: 'read' \nTo move a file from oldpath to newpath: 'mv OLDPATH NEWPATH' \nTo remove a file: 'rm PATH' \nTo see the status: 'status' \nTo quit: 'exit' \n$"
)
text1 = text.split(' ')
print text
if len(text1) > 1:
def write(self, inode, offset, data):
no_blocks_needed = self.ceilings(
math.ceil(len(data)) / config.BLOCK_SIZE)
B = inode.ser_numbers
if inode.blk_numbers[0] == -1:
A = inode.blk_numbers
X = []
for i in range(0, len(A)):
X = interface.get_valid_data_block()
A[i] = X[0]
B[i] = X[1]
'''TYPE ERROR'''
if (inode.type != 0):
print "ERROR: Inode type not file"
return -1
'''OFFSET ERROR'''
if (offset > inode.size):
print "ERROR: Offset greater than file size"
return -1
'''OFFSET ERROR'''
if (offset < 0):
print "ERROR: Offset less than 0"
return -1
'''TRUNCATE DATA'''
mfs = (len(inode.blk_numbers)) * config.BLOCK_SIZE
if (offset >= mfs):
print "ERROR: Offset greater than inode size" #mfs -> Maximum File Size
return -1
index = int(
offset /
config.BLOCK_SIZE) #Index block=Block number with the offset
block_data = [] #To get the data of the index block
q = 0 #To store the star
count = 0
d = mfs - inode.size
if (index == 0): #If index block is the first block
if (
len(data) - offset > mfs
): #If length of data exceeds the maximum file size Data is truncated at the end by the
data = data[0:mfs - offset] #remaining space in the file
print "Data larger than file size. Data truncated."
else: #If index block is not the first block
if (inode.size == mfs): #If inode is filled
if (offset < mfs): #But offset is lesser than the EOF
d = mfs - offset #d stores the space in which new data is to be appended before EOF
if (
len(data) > d
): #if the data is longer than the space in the file after offset
data = data[
0:
d] #Truncates the data by keeping only the length=space available
print "Data larger than file size. Data truncated."
else: #If the file is not full,
d = mfs - inode.size #d stores the space available in the inode
if (len(data) > d
): #If the length of data is more than the space in inode
data = data[
0:
d] #Truncates the data by only keeping the length=space available
print "Data larger than file size. Data truncated."
block_data = MemoryInterface.get_data_block(
inode.blk_numbers[index],
B[index]) #Gets previous data from the index block
b_d = [] #b_d stores the data in the index block
b_d = block_data.replace('\x00', "")
if index == 0: #If the index block is first block
b_d = b_d[
0:
offset] + data #data to be written=previous data upto offset+new data
else:
for i in range(0, index):
count += config.BLOCK_SIZE #If index block is not first block, for number of blocks before index block
q = offset - count #increment the offset by block size to get new offset
b_d = b_d[
0:
q] + data #Data to be written= previous data upto new offset+newdata
if (len(b_d) > config.BLOCK_SIZE):
no_blocks_needed = self.ceilings(
math.ceil(len(b_d)) / config.BLOCK_SIZE)
MemoryInterface.No_Writing_Blocks(no_blocks_needed, inode)
'''WRITING DATA'''
if len(
b_d
) > config.BLOCK_SIZE: #If len of data to be written is greater than size of 1 block
interface.free_data_block(inode.blk_numbers[index],
B[index]) #Free the first data block
interface.update_data_block(
inode.blk_numbers[index], b_d[0:config.BLOCK_SIZE], B[index]
) #Write the first (blocksize) characters of the data to be written
inode.time_accessed = str(datetime.datetime.now(
))[:19] #Update access and modification time
inode.time_modified = str(datetime.datetime.now())[:19]
a = copy.deepcopy(
config.BLOCK_SIZE
) #Copy blocksize into a & b without pointing to the same object
b = copy.deepcopy(config.BLOCK_SIZE)
x = len(b_d) / 8
for i in range(
1,
no_blocks_needed): #Executing for the rest of the blocks
y = b + a
interface.free_data_block(
inode.blk_numbers[index + i],
B[index + i]) #Free all the blocks after index block
interface.update_data_block(
inode.blk_numbers[index + i], b_d[b:y], B[index + i]
) #In block after the index bloc, write the data left after first block
inode.time_accessed = str(datetime.datetime.now())[:19]
inode.time_modified = str(datetime.datetime.now())[:19]
b = b + a
inode.size = offset + len(
data) #Increment inode size= length of the data written
else:
for i in range(
0, (inode.size / config.BLOCK_SIZE) - 1
): #If the length of the data to be written is less than the block size
interface.free_data_block(
inode.blk_numbers[index + i], B[index + i]
) #Free all the data blocks after index block and update the index block with
interface.update_data_block(inode.blk_numbers[index], b_d,
B[index + i]) #the data to be written
inode.time_accessed = str(datetime.datetime.now())[:19]
inode.time_modified = str(datetime.datetime.now())[:19]
inode.size = offset + len(data)
inode.blk_numbers = inode.blk_numbers
return (
inode
) #Updating inode.blk_numbers with the block numbers written in
def Initialize_My_FileSystem(num_servers, raid_mode):
MemoryInterface.Initialize_My_FileSystem(num_servers, raid_mode)
AbsolutePathNameLayer.AbsolutePathNameLayer().new_entry('/', 1)
for i in range(2, len(a)):
if (a[i] == ' '):
command = a[2:i]
instruction = a[i + 1:]
return command, instruction
break
if __name__ == '__main__':
#DO NOT MODIFY THIS
while True:
raid = raw_input("Choose the type of RAID (1 or 5): ")
print(raid)
if (int(raid) == 5):
print("RAID 5 Method is applied!")
MemoryInterface.RAID_5()
break
if (int(raid) == 1):
print("RAID 1 Method is applied!")
MemoryInterface.RAID_1()
break
else:
print("Wrong Number Typed. Please choose either 1 or 5.")
Initialize_My_FileSystem()
my_object = FileSystemOperations()
#=======================INITIAL START FOR RUNNING TEST=====================
#IF YOU WANT TO TYPE FROM BEGINNING, COMMENT THIS AREA
my_object.mkdir("/A")
my_object.mkdir("/B")
my_object.mkdir("/C")
def parse(cls, desc):
"""
Parse the description of this IP object from an dictionary
return a defaultdictionary built from the key-value pairs.
Arguments:
e -- An element tree element containing the description of this
object
"""
# Try to parse interfaces -- if it fails, return
d = super(GroupMemoryInterface, cls).parse(desc)
# Required Description Parameters
q = None
ifs = None
if ("quantity" in desc):
q = cls.parse_quantity(desc)
if ("interfaces" in desc):
ifs = cls.parse_interfaces(desc)
if (ifs is not None):
d["interfaces"] = ifs
d["quantity"] = len(ifs)
if (q is not None and q != len(ifs)):
# TODO: is this the right error message?
Tinker.value_error_map("quantity", q, str(len(ifs)))
if ((set(desc.keys()) - cls._C_INTERFACE_KEYS) == set()):
pass
elif (set(ifs) == (set(desc.keys()) - cls._C_INTERFACE_KEYS)):
for i in ifs:
if (desc[i]["role"] == "primary"):
d["primary"] = i
for i in ifs:
# Hack...
if (desc[i]["role"] != "primary"):
desc[i]["master"] = d["primary"]
d[i] = MemoryInterface.MemoryInterface(desc[i])
else:
sys.exit("Error! Interfaces \"%s\" were missing keys" % str(
list(set(desc.keys()) - cls._C_INTERFACE_KEYS - set(ifs))))
elif (q is not None):
d["quantity"] = q
else:
sys.exit(
"Failed to find an enumeration of memory interfaces in %s" %
str(desc))
# Optional Description Parameters
if ("role" in desc):
d["role"] = cls.parse_role(desc)
if ("burst" in desc):
d["burst"] = cls.parse_burst(desc)
if ("ratio" in desc):
d["ratio"] = cls.parse_ratio(desc)
if ("width" in desc):
d["width"] = cls.parse_width(desc)
if ("name" in desc):
d["name"] = cls.parse_name(desc)
return d
def implement(self, b):
"""
Implement the Interface described by this object using the Board
object describing the IP available on this board.
Arguments:
d -- A Description object, containing the parsed user description
of a custom board
"""
self.validate(self)
self.check_quantity(self)
if ("interfaces" in self):
self.check_interfaces(self)
else:
self["interfaces"] = []
# TODO: Check interfaces, type
ifs = b[self["type"]]["interfaces"]
q = self["quantity"]
if (q > len(ifs)):
Tinker.value_error_map("quantity", str(q),
"Range(1, %d)" % str(len(ifs)),
Tinker.tostr_dict(self))
default = b[self["type"]]["default"]
d = {"role": "primary"}
self["primary"] = default
self["interfaces"].append(default)
self[default] = MemoryInterface.MemoryInterface(d)
ifs.remove(default)
q -= 1
for i in ifs:
if (q <= 0):
break
p = b[self["type"]][i]
d = {}
if ("independent" in p["roles"]):
d["role"] = "independent"
d["master"] = default
elif ("secondary" in p["roles"] and default in p["group"]):
d["role"] = "secondary"
d["master"] = default
else:
continue
q -= 1
self[i] = MemoryInterface.MemoryInterface(d)
self["interfaces"].append(i)
if (q > 0):
print "In Key-Value Map"
print Tinker.tostr_dict(self)
sys.exit("Error! Not enough independent or capable " +
"secondary interfaces to implement memory group")
ba = 0
sz = 0
for i in self["interfaces"]:
self[i].implement(b[self["type"]][i])
self[i] = self[i]["IP"]
if ("burst" in self):
self[i].set_burst(self["burst"])
if ("ratio" in self):
self[i].set_ratio(self["ratio"])
if ("width" in self):
self[i].set_ratio(self["width"])
self.__configure()
pass
def remove_and_free_memory_inode(self, inode, inode_number): interface.free_data_block(inode,0) MemoryInterface.update_inode_table(False, inode_number)
def update_data_block(self, block_number, block_data):
MemoryInterface.update_data_block(block_number, block_data)
def get_first_four_blocks(self):
return MemoryInterface.get_first_four_blocks()
def free_data_block(self, block_number):
MemoryInterface.free_data_block(block_number)
def assign_virtual_blk_numbers(self, blk_number_list):
return MemoryInterface.assign_virtual_blk_numbers(blk_number_list)
def rf(self):
MemoryInterface.rf()
def Initialize_My_FileSystem():
MemoryInterface.Initialize_My_FileSystem()
AbsolutePathNameLayer.AbsolutePathNameLayer().new_entry('/', 1)
def Initialize_My_FileSystem():
MemoryInterface.Initialize_My_FileSystem()
def translate_virtual_blk_numbers(self, blk_number_list):
return MemoryInterface.translate_virtual_blk_numbers(blk_number_list)
# fixTest.py import datetime, config, BlockLayer, InodeOps, MemoryInterface, InodeLayer, time interface = BlockLayer.BlockLayer() inodeInt = InodeLayer.InodeLayer() print(MemoryInterface.status()) testInode = inodeInt.new_inode(0) # Indicate the running test print "\nRUNNING TEST 1:\n" # Write and print the memory interface status testInode = inodeInt.write(testInode, 0, "01234567") print(MemoryInterface.status()) time.sleep(1) # Read the file just written to testInode, testRead = inodeInt.read(testInode, 0, 8) # Print the read results print "\n" print "'" + testRead + "'" print "\n" # Indicate the running test print "\nRUNNING TEST 2:\n"
def status(self, server):
print("++++++++++++++" * 5)
print("Status for Server " + str(server))
print("++++++++++++++" * 5)
print(MemoryInterface.status(server))
def status(self):
return MemoryInterface.status()
def status(self):
print(MemoryInterface.status())
def kill_all(self):
MemoryInterface.kill_all()
