def main(): # Make socket transport = TSocket.TSocket(sys.argv[1], int(sys.argv[2])) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() sha256 = hashlib.sha256() sha256.update(("test.txt").encode('utf-8')) filenamekey = sha256.hexdigest() node = client.findSucc(filenamekey) print("Found node for the test.txt file ", filenamekey, node) transport.close() rFileMeta = RFileMetadata("test.txt",0) rFile = RFile(rFileMeta, "This is a test file.") transport = TSocket.TSocket(node.ip, node.port) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) transport.open() client.writeFile(rFile) print("Write successful") returnedRFile = client.readFile("test.txt") print("Read successful: ", returnedRFile.meta.version, returnedRFile.meta.filename, returnedRFile.content) # Connect! transport.close() transport = TSocket.TSocket(node.ip, 9090) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) transport.open() returnedRFile = client.readFile("test.txt") print("Read successful: ", returnedRFile.meta.version, returnedRFile.meta.filename, returnedRFile.content) transport.close()
def incorrectOwnerTest(host, port_list): if len(port_list) < 2: return # Make socket transport = TSocket.TSocket(host, port_list[0]) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() meta_obj = RFileMetadata() meta_obj.filename = "book.txt" meta_obj.version = 0 meta_obj.owner = "Brad" meta_obj.contentHash = \ hashlib.sha256(("%s:%s" % (meta_obj.filename,\ meta_obj.owner)).encode("utf-8")).hexdigest() content_str = "Test String" file_obj = RFile() file_obj.meta = meta_obj file_obj.content = content_str client.writeFile(file_obj) transport.close() # Make socket transport = TSocket.TSocket(host, port_list[1]) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() try: res = client.readFile("book.txt", "Drake") except SystemException: print("Success: Incorrect owner") transport.close()
def main(): transport = TSocket.TSocket(sys.argv[1], int(sys.argv[2])) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() ## writeFile rfile = RFile() rfileMetadata = RFileMetadata( '', 0, '' ) # NOTE: structure needs to be initialised with default values. otherwise, nonetype error. rfileMetadata.filename = sys.argv[3] rfile.meta = rfileMetadata rfile.content = 'Winter Is Coming. Be Prepared.' print() try: client.writeFile(rfile) print("writeFile() called..") print() except SystemException as e: print(e) transport.close()
def findPred(self, key): if (self.fingerTable is None or len(self.fingerTable) == 0): raise ttypes.SystemException( "No finger table present for this node") if (key > self.id and key >= self.fingerTable[0].id and self.fingerTable[0].id < self.id): #This means key is between the largest node and the smallest node but it is larger than the largest node return self.node elif (key < self.id and key <= self.fingerTable[0].id and self.fingerTable[0].id < self.id): #this means key is between the largest node and the smallest node but it is smaller than the smallest node return self.node elif (key <= self.id or key > self.fingerTable[0].id): #ask the closest known pred node predNode = self.closestPred(key) if (predNode.id != self.id): #ask the pred node for the actual pred node transport = TSocket.TSocket(predNode.ip, int(predNode.port)) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() pred = client.findPred(key) transport.close() return pred else: return self.node else: return self.node
def createClient(ip, port): transport = TSocket.TSocket(ip, port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() return transport, client
def main(): transport = TSocket.TSocket(sys.argv[1], int(sys.argv[2])) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() wFile = RFile() wFileMeta = RFileMetadata() wFileMeta.filename = "sample.txt" sha256file = hashlib.sha256(wFileMeta.filename.encode()) wFileMeta.contentHash = sha256file.hexdigest() wFile.meta = wFileMeta wFile.content = "what now?" #print('dddddddddddddddd : ',sha256file.hexdigest() ) client.writeFile(wFile) rFile = RFile() rFile = client.readFile('aaa.txt') print('sha256: ', rFile.meta.contentHash) print('content: ', rFile.content) nodeID = NodeID() #nodeID = client.getNodeSucc() #keey = '69c9b6900f19eeddc1c9c99928410ddf045adb877f565487546c9cf05c9e2fd2' #nodeID = client.findPred(sha256file.hexdigest()) #print('node', nodeID) transport.close()
def getClientToCallRPC(nodeId): # print ("RPC to {}".format(nodeId.port)) transport = TSocket.TSocket(nodeId.ip, nodeId.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) return client, transport
def main(): # Make socket transport = TSocket.TSocket(sys.argv[1], int(sys.argv[2])) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() # writing to file - need object of RFileMetadata and RFile rFileMetadata = RFileMetadata() rFileMetadata.filename = 'testdp.txt' rFile = RFile() rFile.meta = rFileMetadata rFile.content = "Hi I am client" client.writeFile(rFile) # read file rFile2 = client.readFile("testdp.txt") print("\nOn Client Side received \nFile -- " + rFile2.meta.filename + "\nVersion -- " + str(rFile2.meta.version) + "\nContent -- " + str(rFile2.content) + "\nContentHash -- " + str(rFile2.meta.contentHash) + "\n") # Close! transport.close()
def findSucc(self, key): qnode = NodeID() qnode.id = self.sha256ID qnode.ip = self.ip qnode.port = self.port nNode = NodeID() nNode = self.findPred(key) #print('predNode: ', nNode.id) if qnode.id == key: return qnode else: if nNode.id == qnode.id: return self.getNodeSucc() else: ttransport = TSocket.TSocket(nNode.ip, nNode.port) ttransport.open() pprotocol = TBinaryProtocol.TBinaryProtocol(ttransport) client = FileStore.Client(pprotocol) cNode = NodeID() cNode = client.getNodeSucc() #ttransport.close() return cNode
def make_socket(ipAddress, port): transport = TSocket.TSocket(ipAddress, port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) file_store = FileStore.Client(protocol) transport.open() return file_store
def get_server_node(self, ip, port, key, is_pred): """ Parameters: - ip - port - keys - is_pred """ transport = TSocket.TSocket(ip, port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) server_node = None transport.open() if is_pred: if DEBUG: print("Connecting to Pred Node: {0}:{1}".format(ip, port)) server_node = client.findPred(key) else: if DEBUG: print("Connecting to Succ Node: {0}:{1}".format(ip, port)) server_node = client.getNodeSucc() transport.close() if DEBUG: print("Finished Connection to: {0}:{1}".format(ip, port)) return server_node
def findPred(self, key): if not self.fingerTable: raise SystemExcetion("Error: No predecessors, fingertable empty!") closest_node = None for i in range(len(self.fingerTable)-1, -1, -1): if(self.contains(int(self.fingerTable[i].id, 16),\ int(self.myNode.id, 16),\ int(key, 16))): closest_node = self.fingerTable[i] transport = TSocket.TSocket(closest_node.ip, str(closest_node.port)) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) transport.open() return client.findPred(key) break return self.myNode
def findSucc(self, key): # returns a NodeID print('%i: findSucc()' % port) if self.inRange(key, nodeID.id, self.getNodeSucc().id): return self.getNodeSucc() else: # Hop to the closest preceding node p = self.findPred(key) if p.port == nodeID.port: print('%i: Got node %i as successor' % (nodeID.port, p.port)) return nodeID # Make socket connection to the predecessor transport = TSocket.TSocket(p.ip, p.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) # Connect! print('%i: Creating connection with port %i' % (nodeID.port, p.port)) transport.open() n = client.findSucc(key) transport.close() print('%i: Got node %i as successor' % (nodeID.port, n.port)) return n
def testSucc3(): # Make socket transport = TSocket.TSocket('alpha.cs.binghamton.edu', 9002) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() res_1 = client.findSucc( "42E197B31EF421E4B7995324FD8FA7CE9F781E32002C65BA86DBABADE24AEC81") res_2 = client.findSucc( "CE5B56C3815D692CA036D6A663DCB29683481756C201B6EF50A7E8F4D8532021") res_3 = client.findSucc( "60DE97FE3C29E0EC465924E8CDE1189BF29F73D03495B1E1740A3D10A407FFDC") res_4 = client.findSucc( "445BE48D4D32D4F22B278A424A430CD533BB5E8D80F5C0B85289D1DFE6A328E9") assert res_1.port == 9000 assert res_2.port == 9001 assert res_3.port == 9002 assert res_4.port == 9003 print "findSucc() test 3 passed" transport.close()
def testReadAfterWriteError(): # Make socket transport = TSocket.TSocket('alpha.cs.binghamton.edu', 9000) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() meta_obj = RFileMetadata() meta_obj.filename = "book.txt" meta_obj.version = 0 meta_obj.owner = "Brad" meta_obj.contentHash = hashlib.sha256(meta_obj.filename +\ ":" + meta_obj.owner).hexdigest() content_str = "Knowledge Bitch!" file_obj = RFile() file_obj.meta = meta_obj file_obj.content = content_str client.writeFile(file_obj) transport.close() # Make socket transport = TSocket.TSocket('alpha.cs.binghamton.edu', 9001) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() try: res = client.readFile("book.txt", "Brad") print "Read after write error NOT succesful" except SystemException: print "Read after write error successful" transport.close()
def incorrectOwnerTest(): # Make socket transport = TSocket.TSocket('alpha.cs.binghamton.edu', 9000) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() meta_obj = RFileMetadata() meta_obj.filename = "book.txt" meta_obj.version = 0 meta_obj.owner = "Brad" meta_obj.contentHash = hashlib.sha256(meta_obj.filename +\ ":" + meta_obj.owner).hexdigest() content_str = "Test String" file_obj = RFile() file_obj.meta = meta_obj file_obj.content = content_str client.writeFile(file_obj) transport.close() # Make socket transport = TSocket.TSocket('alpha.cs.binghamton.edu', 9000) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() try: res = client.readFile("book.txt", "Drake") except SystemException: print "Success: Incorrect owner" transport.close()
def returnClientAndTransportToMakeRPCTo(node): transport = TSocket.TSocket(node.ip, node.port) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) return client, transport
def get_client_and_transport_objs(node): transport = TSocket.TSocket(node.ip.decode('utf-8'), node.port) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) return client, transport
def findPred(self, key): if not len(self.finger_table): raise SystemException("Find Pred Error - Finger table is missing") if self.NodeID >= self.finger_table[0].id: if not (key <= self.NodeID and key > self.finger_table[0].id): n = NodeID() n.id = self.NodeID n.ip = self.ip n.port = int(self.port_num) return n else: if key > self.NodeID and key <= self.finger_table[0].id: n = NodeID() n.id = self.NodeID n.ip = self.ip n.port = int(self.port_num) return n if self.NodeID >= key: for i in reversed(self.finger_table): if not (i.id <= self.NodeID and i.id > key): t = TSocket.TSocket(i.ip, i.port) t = TTransport.TBufferedTransport(t) p = TBinaryProtocol.TBinaryProtocol(t) c = FileStore.Client(p) t.open() k = c.findPred(key) t.close() return k raise SystemException("Find Pred Error - Cannot find pred 1") else: for i in reversed(self.finger_table): if i.id > self.NodeID and i.id <= key: t = TSocket.TSocket(i.ip, i.port) t = TTransport.TBufferedTransport(t) p = TBinaryProtocol.TBinaryProtocol(t) c = FileStore.Client(p) t.open() k = c.findPred(key) t.close() return k raise SystemException("Find Pred Error - Cannot find pred 2")
def create_suc_client(serv_node): ''' follows up the findSucc() function if other server is to be contacted for finding the next active node input : NodeID serv_node output: NodeID suc_node ''' transport = TSocket.TSocket(serv_node.ip, serv_node.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() return client
def test_node_addition(host, port_list, new_host, new_port): # Make socket transport = TSocket.TSocket(host, port_list[0]) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() client.addNode(host, new_port)
def _createFileStoreClient(self, ip_address, port_number): # Create Client side Apache Thrift configurations self.client_socket = TSocket.TSocket( ip_address, port_number) # Raw socket creation using Thrift API self.client_transport = TTransport.TBufferedTransport( self.client_socket) # Enable buffering in above raw socket self.client_protocol = TBinaryProtocol.TBinaryProtocol( self.client_transport ) # Client protocol to send contents as Binary (marshalling and unmarshalling) self.client_filestore = FileStore.Client( self.client_protocol) # Client to use protocol encoder self.client_transport.open( ) # Connect to specified Chord Server with above configuration
def findPred(self, key): self.curr_node = getCurrNode() if self.getNodeSucc().id == self.curr_node.id: return self.curr_node if not belongsTo(key, self.curr_node.id, self.getNodeSucc().id): curr_node = self.closeFinger(key) transport = TSocket.TSocket(curr_node.ip, curr_node.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) sockObject = FileStore.Client(protocol) transport.open() predSock = sockObject.findPred(key) transport.close() return predSock
def create_pred_client(serv_node): ''' follows up the findPred() function if other server is to be contacted for finding the suc_node input : NodeID serv_node, sha256(file_name) file_id output: NodeID pred_node ''' #print "\nin create_pred_client : "+str(serv_node)+"\n" transport = TSocket.TSocket(serv_node.ip, serv_node.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() return client
def findSucc(self, key): if not len(self.finger_table): raise SystemException("Find Succ Error - Finger table is missing") n = self.findPred(key) if not n.id == self.NodeID: t = TSocket.TSocket(n.ip, n.port) t = TTransport.TBufferedTransport(t) p = TBinaryProtocol.TBinaryProtocol(t) c = FileStore.Client(p) t.open() k = c.getNodeSucc() t.close() return k else: return self.getNodeSucc()
def findSucc(self, key): if not self.node_list: s = SystemException() s.message = "Finger Table does not exist" raise s self.curr_node = getCurrNode() self.curr_node = self.findPred(key) if self.node.ip == self.curr_node.ip and self.node.port == self.curr_node.port: return self.getNodeSucc() transport = TSocket.TSocket(self.curr_node.ip, self.curr_node.port) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) tNode = FileStore.Client(protocol) transport.open() targetNode = tNode.getNodeSucc() transport.close() return targetNode
def findSucc(self, keyIn): if (self.checkFingerTable()): predNode = self.findPred(keyIn) # print("predNode = ", predNode.id) if predNode.id == self.serverNode.id: return self.getNodeSucc() # Make socket newTransport = TSocket.TSocket(predNode.ip, predNode.port) # Buffering is critical. Raw sockets are very slow newTransport = TTransport.TBufferedTransport(newTransport) # Wrap in a protocol newProtocol = TBinaryProtocol.TBinaryProtocol(newTransport) # Create a client to use the protocol encoder newClient = FileStore.Client(newProtocol) # Connect! newTransport.open() return newClient.getNodeSucc()
def openConnection(ip, port): # Make socket transport = TSocket.TSocket(ip, port) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() return (transport, client)
def findSucc(self, key): if (self.fingerTable is None or len(self.fingerTable) == 0): raise ttypes.SystemException( "No finger table present for this node") if (key == self.id): return self.node pred = self.findPred(key) if (pred.id == self.id): return self.getNodeSucc() else: #ask pred node for its succesor and return it transport = TSocket.TSocket(pred.ip, int(pred.port)) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = FileStore.Client(protocol) transport.open() succ = client.getNodeSucc() transport.close() return succ
def testPred(query_port): # Make socket transport = TSocket.TSocket(host, query_port) # Buffering is critical. Raw sockets are very slow transport = TTransport.TBufferedTransport(transport) # Wrap in a protocol protocol = TBinaryProtocol.TBinaryProtocol(transport) # Create a client to use the protocol encoder client = FileStore.Client(protocol) # Connect! transport.open() for port in port_list: hash = hashlib.sha256(("%s:%d" % (host, port)).encode("utf-8")).hexdigest() incremented_hash_str = hex(int(hash, 16) + 1)[2:] assert client.findPred(incremented_hash_str).id == hash print("findPred(%d) test passed" % query_port) transport.close()