def deleteUpdate(nodeID, path, session): try: print "Node " + str( nodeID) + " has successfully deleted " + str(path) if path in self.reg.data: if session.finished(): print "Deletion complete!" rec = self.reg.data.pop(path) response = ClientResponse(type=ClientRequestType.rm, output="Deletion Success", success=True) session.clientsocket.send(response.toJson()) session.clientsocket.close() session.mutex.release() print "All filenodes have deleted " + path + " -- Disconnecting from client" if path in self.sessions: del self.sessions[path] else: session.mutex.release() else: raise DFSError("Deletion update for " + str(path) + \ ", which does not exist on master.") except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/deleteUpdate")
def readJSONFromSock(sock, addr): data = '' timeout_seconds = 60 wait_until = datetime.datetime.now() + timedelta(seconds=timeout_seconds) while True: try: data += sock.recv(BUFSIZE) obj = json.loads(data) break except socket.error as ex: print "Error reading from socket -- connection may have broken." sock.close() raise DFSError("Socket broken in readJSONFromSock.") return except Exception as ex: if wait_until < datetime.datetime.now(): print "READ TIMED OUT." sock.close() return time.sleep(WAIT_INTERVAL) continue if not data: raise DFSError("No data recieved in readJSONFromSock") # print str(obj) return obj
def handleConnection(self, sock, address): try: request = readJSONFromSock(sock, address) except: print "Error getting data from " + str(address) + " in 'handleConnection'" print "Closing socket." sock.close() # handle request try: if not 'type' in request: raise DFSError("Bad request to filenode recieved from " + str(address)) type = request['type'] if type is ReqType.store: self.handleFileStore(sock, address, request) elif type is ReqType.retrieve: self.handleFileRetrieve(sock, address, request) elif type is ReqType.delete: self.handleFileDelete(sock, address, request) elif type is ReqType.copy: self.handleFileCopy(sock, address, request) elif type is ReqType.n2ncopy: self.handleExternalFileCopy(sock, address, request) elif type is ReqType.rename: self.handleRename(sock, address, request) elif type is ReqType.m2n_kill: self.handleKill(sock, address, request) elif type is ReqType.ping: self.handleStatusCheck(sock, address, request) else: raise DFSError("Invalid request to file node from " + str(address)) except Exception as ex: print "An exception in 'handleConnection' with name \n" + str(ex) + \ "\n was raised. Closing socket...\n" sock.close() return
def uploadUpdate(nodeID, path, session): try: if path not in self.reg.data: session.dir.files.add(path.split('/')[-1]) rec = DataRecord(path, [nodeID], session.checksum) self.reg.addFile(rec) else: self.reg.data[path].nodeIDList.append(nodeID) print "Node " + str( nodeID) + " has received " + path + " successfully." if session.finished(): print "All filenodes have received " + path + "\nDisconnecting from client." response = ClientResponse(type=ClientRequestType.upload, output="Upload Success", success=True) session.clientsocket.send(response.toJson()) session.clientsocket.close() session.mutex.release() if path in self.sessions: del self.sessions[path] else: session.mutex.release() except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/uploadUpdate")
def handleFileDelete(self, socket, address, request): print "FILE DELETE: " + str(request) try: if 'path' in request: path = request['path'] hashpath = self.hashForPath(path) socket.close() rawfpath = self.dirpath + '/' + hashpath + RAWFILE_EXT metapath = self.dirpath + '/' + hashpath + META_EXT if os.path.isfile(rawfpath) and os.path.isfile(metapath): os.remove(rawfpath) os.remove(metapath) req = Request(ReqType.n2m_update, data = self.nodeID, path = path, status = True) print "Deletion success for " + str(path) else: print "Deletion failure for " + str(path) self.failureUpdate() msock.close() return msock = self.reqToMaster(req.toJson()) msock.close() else: print "Request to delete sent with malformed request." print "Closing socket." except Exception as ex: raise DFSError("Error in 'handleFileDelete'" + " with value " + str(ex)) socket.close()
def uploadToNode(self, hashed_path, plaintext_path, node_address): def connectToNode(node_address): s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(node_address) return s def messageSocket(s, message): s.send(message.toJson()) return readJSONFromSock(s, str(s.getpeername())) with io.open(hashed_path, 'rb') as file: size = os.path.getsize(hashed_path) s = connectToNode(node_address) res = messageSocket(s, Request(ReqType.store, path = plaintext_path, length = size)) print "Sending data transfer request to filenode..." if res and 'type' in res and res['type'] is ResType.ok: pass else: print "Did not receive ack from filenode" raise DFSError("No ack from filenode in 'handleExternalFileCopy'") print "Sending data to filenode..." while True: data = file.read(setup.BUFSIZE) if data: s.send(data) else: break s.close()
def reqToMaster(self, request): try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(setup.MASTER_NODE_ADDR) sock.send(request) except socket.error as e: raise DFSError("Socket error in 'reqToMaster'" + \ " with value " + str(e) + " in function 'reqToMaster'.") return sock
def handleCopyRequest(self, socket, newpath, oldpath): pass try: command = ['cd', path] output = viewer.process(len(command), command) if output != None: command = 'mkdir ' + dirname self.handleViewerRequest(socket, viewer, command) except Exception as e: raise DFSError("Exception raised in 'handleCopyRequest': \n" + str(ex))
def __init__(self, filepath, nodeIDList, dataChecksum): try: self.filepath = filepath self.nodeIDList = nodeIDList self.dataChecksum = dataChecksum self.timecreated = time.time() self.timemodified = self.timecreated self.timeaccessed = self.timecreated self.checksum = dataChecksum except Exception as e: raise DFSError("Error initializing DataRecord for file " + str(filepath) + " with exception " + str(e))
def handleClientRequest(self, socket, address): viewer = Viewer(self.root) while True: try: data = socket.recv(setup.BUFSIZE) if data: request = json.loads(data) if 'type' in request: # print "Raw Client Request: \n " + str(request) self.processClientRequest(socket, request, request['type'], viewer) else: raise DFSError("Invalid Client Request") else: raise DFSError("Client disconnected") except Exception as ex: print "Exception raised in 'handleClientRequest': \n" + str(ex) print "Disconnecting client." socket.close() return
def handleFileRetrieve(self, socket, address, request): # get file from storage # send it in chunks that won't be too big for ram try: path = request['path'] print "Received download request for " + path pathHashStr = self.hashForPath(path) chunkFilename = self.dirpath + '/' + pathHashStr + RAWFILE_EXT print chunkFilename # TODO: Convert path to filenode file scheme to get the file, then send to client with open(chunkFilename, 'rb') as file: size = os.path.getsize(chunkFilename) ack = Response(ResType.ok, path=path, length=size) socket.send(ack.toJson()) res = readJSONFromSock(socket, address) if res and 'type' in res and res['type'] is ResType.ok: pass else: raise DFSError("Did not receive ack from client") self.log.insert(0, SessionLog('download', size)) print "Sending data to client" while True: data = file.read(setup.BUFSIZE) if data: socket.send(data) else: break except Exception as ex: raise DFSError("Socket error in 'handleFileRetrieve'" + \ " with value " + str(ex) + " in function 'handleFileRetrieve'.") socket.close()
def confirmDeletion(sock): while True: print "Waiting for deletion confirmation from Master..." res = readJSONFromSock(s, 'masternode') if 'type' not in res or res['type'] is not ClientRequestType.rm: raise DFSError("Recieved response of incorrect type from Master.") if 'success' in res and res['success']: print "File deletion completed with message: " + str(res['output']) sys.exit() else: print "File deletion unsuccessful. Retrying..." addrs = zip(res['address'], res['port']) [deleteFromNode(address, server_file_path) for address in addrs]
def handleExternalFileCopy(self, socket, address, request): try: if 'path' in request and 'data' in request: plainpath = request['path'] addrs = request['data'] if 'address' in addrs and 'port' in addrs: ips = addrs['address'] ports = addrs['port'] else: self.failureUpdate(plainpath) socket.close() return print "Performing external file copy of " + str(plainpath) + " to " + str(addrs) hashpath = self.hashForPath(plainpath) rawfpath = self.dirpath + '/' + hashpath + RAWFILE_EXT if os.path.isfile(rawfpath): target = self.uploadToNode adds = [pair for pair in zip(ips, ports)] for ad in adds: args = [rawfpath, plainpath, ad] uploadThread = Thread(target = target, args = args) uploadThread.start() # wait for server to tell you that it worked. if not, # resend the file while True: res = readJSONFromSock(socket, setup.MASTER_NODE_ADDR) if res: print res['output'] if res['success']: break else: address = (res['address'], res['port']) args = [rawfpath, plainpath, address] uploadThread = Thread(target = target, args = args) uploadThread.start() else: self.failureUpdate(plainpath) else: self.failureUpdate('unknown_path') except Exception as e: raise DFSError("Error in 'handleExternalFileCopy' with value " + str(e)) socket.close()
def deleteRetry(nodeID, path, session): try: print "Node " + str(nodeID) + " failed to delete " + str(path) +\ "\n File was already deleted." if session.finished(): session.mutex.release() del self.sessions[path] response = ClientResponse(ClientRequestType.rm, output="File deleted: " + str(path), success=True) session.clientsocket.send(response.toJson()) else: session.mutex.release() except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/deleteRetry")
def stat(server_file_path): try: req = ClientRequest(type = ClientRequestType.stat, serverPath = server_file_path, name = '') s = connect_to_master() s.send(req.toJson()) res = readJSONFromSock(s, 'masternode') if 'success' in res and res['success'] and 'output' in res: print res['output'] elif not res['success']: print "STAT Failure." if 'output' in res: print res['output'] except Exception as e: DFSError("Error raised in 'stat' due to exception \n" + str(ex) + "\nShutting down.") sys.exit()
def rm(server_file_path): def deleteFromNode(address, server_file_path): filenodesock = connect_to_node(address) req = FileRequest(FileRequestType.delete, path = server_file_path) filenodesock.send(req.toJson()) def confirmDeletion(sock): while True: print "Waiting for deletion confirmation from Master..." res = readJSONFromSock(s, 'masternode') if 'type' not in res or res['type'] is not ClientRequestType.rm: raise DFSError("Recieved response of incorrect type from Master.") if 'success' in res and res['success']: print "File deletion completed with message: " + str(res['output']) sys.exit() else: print "File deletion unsuccessful. Retrying..." addrs = zip(res['address'], res['port']) [deleteFromNode(address, server_file_path) for address in addrs] try: req = ClientRequest(ClientRequestType.rm, serverPath = server_file_path, name = '') s = connect_to_master() s.send(req.toJson()) res = readJSONFromSock(s, 'mastenode') if 'success' in res and res['success']: addrs = zip(res['address'], res['port']) [deleteFromNode(address, server_file_path) for address in addrs] confirmDeletion(s) else: output = res['output'] if 'output' in res else None print output raise DFSError("RM failed due to failure response from server with value: " + str(output)) except Exception as e: print "Error in RM while trying to remove " + str(server_file_path) + " because: " print str(e) print "Aborting..." sys.exit()
def handleFileDeleteRequest(self, socket, path, name): # find all active nodes with file # open sessions for file removal # tell client to send remove signals to those files try: fullpath = path + name if self.validPath(fullpath): nids = self.reg.data[fullpath].nodeIDList nids = [n for n in nids if n in self.reg.activenodes] ips = [self.reg.activenodes[n].address[0] for n in nids] ports = [self.reg.activenodes[n].address[1] for n in nids] self.waitForSessionClose(fullpath) session = Session(path=fullpath, type='delete', nodeIDs=nids, clientsocket=socket, dir=self.root.cd(fullpath[1:].split('/'))) self.sessionmutex.acquire() self.sessions[fullpath] = session self.sessionmutex.release() res = ClientResponse(ClientRequestType.rm, output='Delete Request for ' + str(fullpath) + ' received', success=True, address=ips, port=ports) print "Delete request for existing file " + str(fullpath) + \ " recieved. Directing client to delete on nodes " + str(nids) else: res = ClientResponse(ClientRequestType.rm, output='Error removing ' + str(fullpath) + '. File not found.', success=False) print "Remove request failed. File " + str( fullpath) + " not found." socket.send(res.toJson()) except Exception as e: raise DFSError( ("Exception raised in 'handleFileDeleteRequest: \n" + str(e)))
def wakeup(self): dirs = os.walk(NODE_FILEPATH).next()[1] # list of directories if self.mode == 'fresh': ids = [] else: ids = [int(re.findall('\d+', d).pop()) for d in dirs] data = {'ids': ids, 'port': self.server.port} request = Request(ReqType.n2m_wakeup, data).toJson() clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: clientsocket.connect(setup.MASTER_NODE_ADDR) clientsocket.send(request) print "ID REQUEST: " + request response = readJSONFromSock(clientsocket, setup.MASTER_NODE_ADDR) if not 'type' in response: raise DFSError("Master sent bad response.") if response['type'] is ResType.m2n_wakeres: nodeID = int(response['data']) elif response['type'] is ResType.m2n_kill: print "Recieved shutdown signal from masternode. Shutting down." sys.exit() else: print "Recieved invalid response type from masternode." sys.exit() except Exception, ex: print "Unable to obtain filenode ID becuase exception \n" + \ str(ex) + "\n" + " was raised. Shutting down." sys.exit()
def uploadRetry(nodeID, path, session): try: print "Node " + str(nodeID) + " failed the upload for " + path if session.nTriesLeft > 0: node = self.reg.activenodes[nodeID] response = ClientResponse(type=ClientRequestType.upload, output="Retrying Upload...", success=False, address=node.address[0], port=node.address[1]) session.nTriesLeft = session.nTriesLeft - 1 session.clientsocket.send(response.toJson()) session.mutex.release() else: print "Upload out of tries." if path in self.reg.data: print "File " + str(path) + " under replicated." response = ClientResponse( type=ClientRequestType.upload, output="Upload soft failure. " + str(path) + " under-replicated.", success=True) session.clientsocket.send(response.toJson()) else: print "File " + str( path) + " not stored in filesystem." response = ClientResponse( type=ClientRequestType.upload, output="UPLOAD " + str(path) + "ABORTED.", success=True) session.clientsocket.send(response.toJson()) session.mutex.release() del self.sessions[path] except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/uploadRetry")
def handleUploadRequest(self, socket, path, filesize, filename, checksum): def error(message): response = ClientResponse(ClientRequestType.upload, message, False) socket.send(response.toJson()) tprint("Upload Failed: " + message) tprint("Received Request to upload " + filename + " (" + str(filesize) + ") to " + str(path)) if path[0] == '/': dir = self.root.cd(path[1:].split('/')) if dir: try: tprint("Sending upload ACK to client") nodes = self.priorityQueue()[:setup.NODES_PER_FILE] for node in nodes: node.hits += 1 addrs = [node.address[0] for node in nodes] ports = [node.address[1] for node in nodes] response = ClientResponse(type=ClientRequestType.upload, output="Initiating Upload...", success=True, address=addrs, port=ports) tprint( "Sending upload info to client for the following nodes:" ) for node in nodes: print node.address serverFile = path + '/' + filename if path[ -1] != '/' else path + filename ids = [node.id for node in nodes] session = Session(path=serverFile, type='upload', nodeIDs=ids, clientsocket=socket, dir=dir, checksum=checksum) self.waitForSessionClose( serverFile) # to avoid session overlap self.sessionmutex.acquire() self.sessions[serverFile] = session self.sessionmutex.release() socket.send(response.toJson()) tprint("Upload info sent to client.") if serverFile in self.reg.data: del self.reg.data[serverFile] except Exception as ex: raise DFSError( "Exception raised in 'handleUploadRequest': \n" + str(ex)) else: response = ClientResponse(type=ClientRequestType.upload, output="Invalid directory path", success=False) socket.send(response.toJson()) error("Directory path was not found") else: error("Directory must start with '/'")
def failureUpdate(self, path, sock): raise DFSError("Failure when performing an action on " + str(path))
def handleNodeUpdate(self, socket, request): def uploadUpdate(nodeID, path, session): try: if path not in self.reg.data: session.dir.files.add(path.split('/')[-1]) rec = DataRecord(path, [nodeID], session.checksum) self.reg.addFile(rec) else: self.reg.data[path].nodeIDList.append(nodeID) print "Node " + str( nodeID) + " has received " + path + " successfully." if session.finished(): print "All filenodes have received " + path + "\nDisconnecting from client." response = ClientResponse(type=ClientRequestType.upload, output="Upload Success", success=True) session.clientsocket.send(response.toJson()) session.clientsocket.close() session.mutex.release() if path in self.sessions: del self.sessions[path] else: session.mutex.release() except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/uploadUpdate") def deleteUpdate(nodeID, path, session): try: print "Node " + str( nodeID) + " has successfully deleted " + str(path) if path in self.reg.data: if session.finished(): print "Deletion complete!" rec = self.reg.data.pop(path) response = ClientResponse(type=ClientRequestType.rm, output="Deletion Success", success=True) session.clientsocket.send(response.toJson()) session.clientsocket.close() session.mutex.release() print "All filenodes have deleted " + path + " -- Disconnecting from client" if path in self.sessions: del self.sessions[path] else: session.mutex.release() else: raise DFSError("Deletion update for " + str(path) + \ ", which does not exist on master.") except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/deleteUpdate") def uploadRetry(nodeID, path, session): try: print "Node " + str(nodeID) + " failed the upload for " + path if session.nTriesLeft > 0: node = self.reg.activenodes[nodeID] response = ClientResponse(type=ClientRequestType.upload, output="Retrying Upload...", success=False, address=node.address[0], port=node.address[1]) session.nTriesLeft = session.nTriesLeft - 1 session.clientsocket.send(response.toJson()) session.mutex.release() else: print "Upload out of tries." if path in self.reg.data: print "File " + str(path) + " under replicated." response = ClientResponse( type=ClientRequestType.upload, output="Upload soft failure. " + str(path) + " under-replicated.", success=True) session.clientsocket.send(response.toJson()) else: print "File " + str( path) + " not stored in filesystem." response = ClientResponse( type=ClientRequestType.upload, output="UPLOAD " + str(path) + "ABORTED.", success=True) session.clientsocket.send(response.toJson()) session.mutex.release() del self.sessions[path] except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/uploadRetry") def deleteRetry(nodeID, path, session): try: print "Node " + str(nodeID) + " failed to delete " + str(path) +\ "\n File was already deleted." if session.finished(): session.mutex.release() del self.sessions[path] response = ClientResponse(ClientRequestType.rm, output="File deleted: " + str(path), success=True) session.clientsocket.send(response.toJson()) else: session.mutex.release() except Exception as e: raise DFSError("Exception with name " + str(e) + " raised in handleNodeUpdate/deleteRetry") try: if 'data' not in request or 'path' not in request or 'chksum' not in request or 'status' not in request: raise DFSError("Bad update from filenode sent to Master.") nodeID = request['data'] path = request['path'] checksum = request['chksum'] status = request['status'] if path in self.sessions: session = self.sessions[path] session.mutex.acquire() else: raise DFSError( "Got Node Update for file that is not in session.") if status and session.verify(checksum, nodeID): session.nodeIDs.remove(nodeID) if session.type is 'upload': uploadUpdate(nodeID, path, session) elif session.type is 'delete': deleteUpdate(nodeID, path, session) elif session.type is 'upload': uploadRetry(nodeID, path, session) elif session.type is 'delete': deleteRetry(nodeID, path, session) except Exception, ex: print "An exception in 'handleNodeUpdate' with name \n" + str(ex) + \ "\n was raised. Sending shutdown signal to filenode."
def handleFileStore(self, clientSocket, address, request): try: if not ('len' in request and 'path' in request): raise DFSError("Incorrect fields present in STORE JSON.") elif request['len'] is None or request['path'] is None: raise DFSError("Len and path fields initialized to None in STORE JSON") nBytesExpected = request['len'] if not isinstance(nBytesExpected, int): raise DFSError("Len field is not an integer in STORE request from " + str(address)) # hash filepath to get file handle path = request['path'] pathHashStr = self.hashForPath(path) chunkFilename = self.dirpath + '/' + pathHashStr + RAWFILE_EXT metaFilename = self.dirpath + '/' + pathHashStr + META_EXT res = Response(ResType.ok) clientSocket.send(res.toJson()) # read in the file nRecvd = 0 h = hashlib.md5() with io.open(chunkFilename, 'wb') as cFile: while nRecvd < nBytesExpected: newBytes = clientSocket.recv(setup.BUFSIZE) nRecvd = nRecvd + len(newBytes) print "Received " + str(nRecvd) + " of " + str(nBytesExpected) + " bytes" encodedBytes = bytearray(newBytes) n = cFile.write(encodedBytes) h.update(encodedBytes) dataChecksum = h.hexdigest() with io.open(metaFilename, 'wb') as mFile: metadata = {'checksum': dataChecksum} mFile.write(str(metadata)) print "Done writing file " + str(path) + " to disk..." # Log new file download self.log.insert(0, SessionLog('upload', nBytesExpected)) # send a hash of the new file to the server to confirm integrity request = Request(ReqType.n2m_update, data = self.nodeID, path = path, status = True, chksum = dataChecksum).toJson() # wait for verification response mastersock = self.reqToMaster(request) mastersock.close() clientSocket.close() except Exception as ex: print "An exception in 'handleFileStore' with name \n" + str(ex) + \ "\n was raised. Closing socket...\n" clientSocket.close() try: request = Request(ReqType.n2m_update, data = self.nodeID, path = path, status = False, chksum = dataChecksum).toJson() # wait for verification response mastersock = self.reqToMaster(request) mastersock.close() except Exception as ex: raise DFSError("Error sending failure update to master in " + \ "handleFileStore")
def processClientRequest(self, socket, request, type, viewer): if type is ClientRequestType.viewer: if 'command' in request: command = request['command'] self.handleViewerRequest(socket, viewer, command) else: raise DFSError( ("Exception raised in 'processClientRequest/viewer': \n" + str(ex))) elif type is ClientRequestType.download: try: path = request['serverPath'] self.handleDownloadRequest(socket, path) except Exception as ex: raise DFSError(( "Exception raised in 'processClientRequest/download': \n" + str(ex))) elif type is ClientRequestType.upload: try: path = request['serverPath'] size = request['filesize'] name = request['name'] checksum = request['checksum'] self.handleUploadRequest(socket, path, size, name, checksum) except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/upload': \n" + str(ex))) elif type is ClientRequestType.rm: # 3-way w/ filenode try: path = request['serverPath'] name = request['name'] self.handleFileDeleteRequest(socket, path, name) except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/rm': \n" + str(ex))) elif type is ClientRequestType.mv: # 3-way w/ filenode try: oldpath = request['serverPath'] newpath = request['name'] self.handleMVRequest(socket, newpath, oldpath) except: raise DFSError( ("Exception raised in 'processClientRequest/mv': \n" + str(ex))) elif type is ClientRequestType.rmdir: # 3-way with filenode if recursive data deletion try: path = request['serverPath'] dirname = request['name'] handleDirDeleteRequest(socket, path, dirname) except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/rmdir': \n" + str(ex))) elif type is ClientRequestType.mkdir: try: path = request['serverPath'] dirname = request['name'] wd = self.root.cd(path) wd.mkdir(dirname) res = ClientResponse(type=mkdir, output="New directory: " + str(path + dirname), success=True) socket.send(res.toJson()) socket.close() except Exception as ex: try: res = ClientResponse( type=mkdir, output="Error creating new directory.", success=False) socket.send(res.toJson()) socket.close() except: raise DFSError( ("Exception raised in 'processClientRequest/mkdir': \n" + str(ex))) print "Failure to make new directory in MasterNode->processClientRequest->mkdir." print "Disconnecting client." socket.close() elif type == ClientRequestType.cp: # 3-way with filenode try: path = request['serverPath'] filename = request['name'] except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/cp': \n" + str(ex))) # # I didn't want to create a merge conflict, but I think this will work # # It just creatively reuses code from the viewer class # try: # path = request['serverPath'] # dirname = request['name'] # command = ['cd', path] # output = viewer.process(len(command), command) # if output != None: # command = 'mkdir ' + dirname # self.handleViewerRequest(socket, viewer, command) elif type == ClientRequestType.rmdir: # 3-way with filenode if recursive data deletion try: path = request['serverPath'] name = request['name'] except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/rmdir': \n" + str(ex))) elif type == ClientRequestType.stat: try: path = request['serverPath'] name = request['name'] fullpath = path + name if fullpath in self.reg.data: filedata = self.reg.data[fullpath] res = ClientResponse(type=type, output=filedata, success=True) else: errmsg = "Error: " + str(fullpath) + " does not exist." res = ClientResponse(type=type, output=errmsg, success=False) socket.send(res.toJson()) socket.close() except Exception as ex: raise DFSError( ("Exception raised in 'processClientRequest/stat': \n" + str(ex))) else: raise error("Invalid Type Request")