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()
