client.da

#!/usr/bin/python
import sys
import os
import time
import random
import string
from utils import Utils
from datetime import datetime
from operation import Operation
config(channel is {fifo,reliable}, clock is lamport)

class Client(process):
	def setup(olympus, clientId, olympusPublicKey, workload_for_client, clientPrivateKey, client_timeout):
		self.olympus = olympus
		self.clientId = clientId
		self.olympusPublicKey = olympusPublicKey
		self.replicaPublicKeys = []
		self.workload_for_client = workload_for_client
		self.clientPrivateKey = clientPrivateKey
		self.head = None
		self.tail = None
		self.client_timeout = client_timeout
		self.requestId = -1
		self.replicas = None
		self.isValidConfigPresent = False
		self.completedRequests = {}
		self.requestToResult = {}
		self.runningstate = {}
		self.utils = Utils()
		self.someRequestOutputFailed = False
		self.periodic_interval = 2
		self.errorresponsecode = False
		self.distinct_replicas = []


	def getResult(operation, key, value):
		output = "None"
		if operation == "put" :
			self.runningstate[key] = value
			output = "OK"
		elif operation == "get":
			if key in self.runningstate:
				output = self.runningstate[key]
			else:
				output = ""
		elif operation == "slice":
			if key in self.runningstate:
				(i,j) = value.split(':')
				val = self.runningstate[key]
				if int(j)<len(val) and int(i)>=0:
					self.runningstate[key] = val[int(i):int(j)]
					output = "OK"
				else:
					output = "Fail"
		elif operation == "append":
			if key in self.runningstate:
				self.runningstate[key]+=str(value)
				output = "OK"
			else:
				output = "Fail"
		return output

	def retry_for_current_configuration():
		send(('Get Current Config', self.clientId), to = olympus)
		await(some(received(('Config Response', _,_,_,_,_), from_ = olympus)))
		while not self.isValidConfigPresent:
			if await(self.isValidConfigPresent):
				break
			elif timeout(self.periodic_interval):
				output("Client " + str(self) + "Periodically checking olympus if there is any new configuration")
				send(('Get Current Config', self.clientId), to = olympus)
				await(some(received(('Config Response', _,_,_,_,_), from_ = olympus)))

	def execute_workload(operation, key, requestIdFinal, workload):

		##Operation object created
		operation_object = Operation()
		operation_object.requestId = requestIdFinal
		operation_object.command = operation
		tempRequestId = requestIdFinal
		output("-------------------------------------------------------------------------------------")
		output("Executing New workoad from Client: " + str(self) + " for RequestId: " + requestIdFinal)
		signed_workload = utils.getSignedStatement(self.clientPrivateKey, str(workload.replace(' ', '').strip()))
		if len(key) == 1:
			self.requestToResult[requestIdFinal] = getResult(operation, key[0], None)
			operation_object.key = key[0]
			operation_object.value = ""
			send(('Execute Operation Of Client', operation_object , self, signed_workload), to = head)
			if await(tempRequestId in self.completedRequests):
				pass
			elif timeout(client_timeout):
				self.isValidConfigPresent = False
				output("Client Timeout occured: " + str(self) + " for requestid: " + requestIdFinal)
				self.distinct_replicas = []
				retry_for_current_configuration()
				send(('Retransmit Request To Replicas', operation_object, self, signed_workload), to = self.replicas)
				while True:		#await(some(received(('Retransmitted Response',_,_,_,_,_), from_ = p)))
					if await(tempRequestId in self.completedRequests):
						self.distinct_replicas = []
						break
					elif timeout(client_timeout):
						self.distinct_replicas = []
						retry_for_current_configuration()
						send(('Retransmit Request To Replicas', operation_object, self, signed_workload), to = self.replicas)
		else:
			self.requestToResult[requestIdFinal] = getResult(operation, key[0], key[1])
			operation_object.key = key[0]
			operation_object.value = key[1]
			send(('Execute Operation Of Client', operation_object, self, signed_workload), to = head)
			if await(tempRequestId in self.completedRequests):
				pass
			elif timeout(client_timeout):
				self.isValidConfigPresent = False
				output("Client Timeout occured: " + str(self) + " for requestid: " + requestIdFinal)
				self.distinct_replicas = []
				retry_for_current_configuration()
				send(('Retransmit Request To Replicas', operation_object, self, signed_workload), to = self.replicas)
				while True:		#await(some(received(('Retransmitted Response',_,_,_,_,_), from_ = p)))
					if await(tempRequestId in self.completedRequests):
						self.distinct_replicas = []
						break
					elif timeout(client_timeout):
						self.distinct_replicas = []
						retry_for_current_configuration()
						send(('Retransmit Request To Replicas', operation_object, self, signed_workload), to = self.replicas)

	def execute_pseudorandom_workloads(seed, workload_count):
		random.seed(seed)
		op = ['put', 'get', 'slice', 'append']
		opp = ['get', 'slice', 'append']
		workloads = []
		keys = []
		values = []
		maxlength = 0
		for i in range(workload_count):
			temp = ''.join(random.choices(string.ascii_lowercase , k=random.randint(2,7)) + random.choices(string.ascii_uppercase , k=random.randint(3,7)))
			values.append(temp)
			maxlength = max(maxlength, len(temp))
		putKeys = []
		put_counts = 0
		if workload_count%3==0:
			put_counts = int(workload_count/3)
		else:
		 	put_counts = int(workload_count/3) + 1
		for i in range(int(put_counts)):
			key = ''.join(random.choices(string.ascii_uppercase , k=random.randint(3,8)) + random.choices(string.ascii_lowercase , k=random.randint(2,6)))
			value = random.SystemRandom().choices(values)[0]
			workloads.append("put(\'"+key+"\',\'"+value+"\')")
			putKeys.append(key)
		other_count = workload_count - put_counts
		for i in range(int(other_count)):
			operation = random.SystemRandom().choice(opp)
			key = random.SystemRandom().choices(putKeys)[0]
			value = random.SystemRandom().choices(values)[0]
			if operation == "get":
				workloads.append("get(\'"+key+"\')")
			elif operation == "append":
				workloads.append("append(\'"+key+"\',\'"+value+"\')")
			elif operation == "slice":
				start = random.randint(0,maxlength)
				end = random.randint(start, maxlength)
				workloads.append("slice(\'"+key+"\',\'"+str(start)+":"+str(end)+"\')")
		for workload in workloads:
			retry_for_current_configuration()
			workload = workload.strip().replace("'","")
			self.errorresponsecode = False
			requestIdFinal = clientId+":"+str(self.requestId)
			operation = workload.split('(')[0]
			key_value = workload[workload.find('(')+1:workload.find(')')]
			key = key_value.split(',')
			execute_workload(operation, key, requestIdFinal, workload)
			self.requestId += 1

	def run():
		output("********Starting Client" + str(self)+ "*****")
		start_time = datetime.now()
		output("Client " + str(self) + "Started: ", start_time.second)
		workloads = workload_for_client.split(';')
		output("Client " + str(self) + " workload ->" + str(workloads))
		for workload in workloads:
			retry_for_current_configuration()
			workload = workload.strip().replace("'","")
			self.errorresponsecode = False
			self.requestId += 1
			requestIdFinal = clientId+":"+str(self.requestId)
			operation = workload.split('(')[0]
			key_value = workload[workload.find('(')+1:workload.find(')')]
			if operation == "pseudorandom":
				key = key_value.split(',')
				execute_pseudorandom_workloads(int(key[0]), int(key[1]))
			else:
				key = key_value.split(',')
				execute_workload(operation, key, requestIdFinal, workload)
		output("Checking Expected Dictionary Content at completion of all workloads for " + str(self) + ".........")
		checkFlag = True
		for key, value in self.requestToResult.items():
			if key in self.completedRequests:
				if value != self.completedRequests[key][0]:
					checkFlag = False
					self.someRequestOutputFailed = True
					output("Workload with requestId: " + str(key) + " Failed for Client: " + str(self) + "Expected value is: " + str(value) + "Actual value is: " + str(self.completedRequests[key][0]))
			else:
				checkFlag = False
				self.someRequestOutputFailed = True
				output("Workload with requestId: " + str(key) + " Failed for Client: " + str(self) + "Expected value is: " + str(value))
		if checkFlag == True:
			output("Client " + str(self) + " finised executing all workloads successfully.")
		else:
		   	output("Client " + str(self) + " finised with some request failed.")
		await(some(received(('Done'), from_ = tail)))

	def receive(msg = ('Forward Result to Client', result, result_proof, reqId), from_ = tail):
		output("Received result [" + result + "] at client " + str(self) + " from tail " + str(tail) + " for requestId = " + reqId)
		if check_validity_of_result_proof(result, result_proof) == False:
			output("Proof of Misbehaviour detected at client "+ str(self) + " because of invalid result proof of request: " + reqId)
			output("Sending Reconfiguration Request to Olympus from Client: " + str(self))
			send(('Reconfiguration request from client', result, result, result_proof, self), to = olympus)
		else:
			if self.requestToResult[reqId] == result:
				if reqId not in self.completedRequests:
					self.completedRequests[reqId] = (result, tail)
			else:
				output("Proof of Misbehaviour detected at client "+ str(self) + " because of invalid result of request: " + reqId)
				output("Sending Reconfiguration Request to Olympus from Client: " + str(self))
				send(('Reconfiguration request from client', self.requestToResult[reqId], result, result_proof, self), to = olympus)

	def check_validity_of_result_proof(result, result_proof):
		result_statements = result_proof
		for i in range(0, len(self.replicas)):
			try:
				statement = utils.verifySignature(result_statements[i] , replicaPublicKeys[i])
				hash = statement.decode('UTF-8').split(';')[-1]
				if utils.verifyHash(result, hash.encode('utf-8')) == False:
					return False
			except:
				return False
		return True

	def receive(msg = ('Config Response', replicas, head, tail, isValidConfigPresent, replicaPublicKeys), from_ = olympus):
		output("Received configuration -> [ replicas:"+ str(replicas) + ", head:" + str(head) + ", tail:"+ str(tail) +"] from the olympus at the client " + str(self) + " with flag " + str(isValidConfigPresent))
		self.head = head
		self.tail = tail
		self.replicas = replicas
		self.replicaPublicKeys = replicaPublicKeys
		self.isValidConfigPresent = isValidConfigPresent

	def receive(msg = ('Retransmitted Response', result, operation_object, result_proof, replica, responseCode, signed_workload), from_ = p):
		reqId = operation_object.requestId
		output("Received retried operation response for RequestId [" + reqId + "] and result [" + str(result) +"] from the replica " + str(p) + " at the client " + str(self))
		#if reqId not in self.completedRequests:
		if responseCode == "VALID":
			if result_proof != None:
				if check_validity_of_result_proof(result, result_proof) == False:
					output("Proof of Misbehaviour detected at client "+ str(self) + " because of invalid result proof of request: " + reqId)
					output("Sending Reconfiguration Request to Olympus from Client: " + str(self))
					send(('Reconfiguration request from client', result, result, result_proof, self), to = olympus)
				else:
					if self.requestToResult[reqId] == result:
						if replica not in self.distinct_replicas:
							self.distinct_replicas.append(replica)
						if len(self.distinct_replicas) > len(self.replicas)/2:
								if reqId not in self.completedRequests:
									output("Got Response from Quorum of Replicas for Retransmitted Response for RequestId" + str(reqId))
									self.completedRequests[reqId] = (result, replica)
					else:
						output("Proof of Misbehaviour detected at client "+ str(self) + " because of invalid result of request: " + reqId)
						output("Sending Reconfiguration Request to Olympus from Client: " + str(self))
						send(('Reconfiguration request from client', self.requestToResult[reqId], result, result_proof, self), to = olympus)
		elif responseCode == "ERROR":
			if self.errorresponsecode == False:
				self.errorresponsecode = True
				retry_for_current_configuration()
				send(('Execute Operation Of Client', operation_object, self, signed_workload), to = head)

	def receive(msg = ('Result from olympus', result, reqId), from_ = olympus):
		output("Received result [" + result + "] at client " + str(self) + " from olympus " + str(olympus) + " for requestId = " + reqId)
		if reqId not in self.completedRequests:
            		self.completedRequests[reqId] = (result, olympus)