def fitness(pop): # TODO: Add later (fairness, non_manipulablity, others) as args -> or maybe **kwargs?
""" Evaluate the fitness of the weight population by running an election
and a test of the results based on the input fairness and non-manipulability constraints """
# Profile for election
profile, profile_df, profile_matrix = create_profile(500, origin="distribution",
params="spheroid", candidates=["Adam", "Bert",
"Chad", "Derek", "Elon"])
fitness_pop = []
for weights in pop:
results = election(profile, weights)
# for result, value in results.items():
# print(f"{result}: {value}")
# Score = condorcet compliance + majority rule
condorcet_score = check_condorcet(profile, results)
majority_score = check_majority(profile_df, results)
fitness_pop.append(condorcet_score + majority_score)
# print("Is Condorcet compliant?:", check_condorcet(profile, results))
# print("Satisfies majority criterion?", check_majority(profile_df, results))
return np.array(fitness_pop)
def process(self, data, elec, user):
if elec == None:
elec = election()
f = data["ans"]
cwd = os.getcwd()
f = cwd + "\\" + f
file2 = open(f, 'rb')
new_d = pickle.load(file2)
file2.close()
elec.setVotes(new_d["votes"])
elec.setVoteActions(new_d["voteActions"])
server_data.set_user_objs(new_d["userObjs"])
return elec, user
def main(sk_filename):
global processed_txids, transaction_id
sk = SigningKey.from_pem(open(sk_filename).read())
vk = sk.get_verifying_key()
pk = str(base64.b64encode(vk.to_string()), encoding='utf8')
timestamp = str(int(time.time()-300))
leaders = db.query("SELECT * FROM leaders WHERE pk = %s AND timestamp > %s", pk, timestamp)
if not leaders:
election(sk_filename)
else:
# leader = leaders[0]
transactions = db.query("SELECT * FROM transactions WHERE id > %s ORDER BY id ASC LIMIT 20", transaction_id)
random.shuffle(transactions)
for transaction in transactions:
if transaction.txid in processed_txids:
continue
data = json.loads(transaction.data)
sender = data["transaction"]["sender"]
receiver = data["transaction"]["receiver"]
amount = data["transaction"]["amount"]
signature = data["signature"]
chain_txids = set()
sender_blocks = lastest_block(sender)
receiver_blocks = lastest_block(receiver)
if len(set(sender_blocks+receiver_blocks)) >= 1:
if len(set(sender_blocks+receiver_blocks)) == 1:
txs = db.query("SELECT * FROM graph WHERE hash = %s", (sender_blocks+receiver_blocks)[0])
else:
txs = db.query("SELECT * FROM graph WHERE hash IN %s", set(sender_blocks+receiver_blocks))
for tx in txs:
tx_data = json.loads(tx.data)
txid = tx_data["transaction"]["txid"]
chain_txids.add(txid)
processed_txids.add(txid)
if transaction.txid in chain_txids:
continue
from_block = sender_blocks[-1] if sender_blocks else sender
to_block = receiver_blocks[-1] if receiver_blocks else receiver
# query from_block and to_block
# get balance and calcuate
# update transaction's from_block and to_block
data["from_block"] = from_block
data["to_block"] = to_block
data["sender_balance"] = ""
data["receiver_balance"] = ""
data["leader_publickey"] = pk
vk2 = VerifyingKey.from_string(base64.b64decode(sender), curve=NIST384p)
assert vk2.verify(base64.b64decode(signature), json.dumps(data["transaction"]).encode('utf-8'))
# signature = sk.sign(json.dumps(transaction).encode('utf-8'))
# data = {"transaction": transaction, "signature": str(base64.b64encode(signature), encoding="utf-8")}
for nonce in range(100000000):
block_hash = hashlib.sha256((json.dumps(data) + pk + str(nonce)).encode('utf8')).hexdigest()
if block_hash < certain_value:
print("tx", nonce, block_hash)
try:
# query if any node taken from_block or to_block
db.execute("INSERT INTO graph (hash, from_block, to_block, sender, receiver, nonce, data) VALUES (%s, %s, %s, %s, %s, %s, %s)", block_hash, from_block, to_block, sender, receiver, nonce, transaction.data)
# db.execute("INSERT INTO graph (hash, from_block, to_block, sender, receiver, nonce, data, transaction_id, timestamp) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)", block_hash, from_block, to_block, sender, receiver, nonce, transaction.data, transaction.id, int(time.time()))
processed_txids.add(transaction.txid)
break
except:
pass
time.sleep(1)
transaction_id += 20
time.sleep(0.1)
from election import election
choices = ['Salad', 'Burger', 'Pizza', 'Curry', 'Pasta', 'BLT']
campaign = election(300, choices)
print('NEW ELECTION')
print(f'Number of voters is {campaign.voter_count}')
print(campaign.vote_counts)
def handle(self):
authenticated_requst=authenticate(file_server_key,self.request.recv(1024))
print "FS {}: AuthenticatedReply below".format(file_port)
print(authenticated_requst)
if ("KILL_SERVICE" in authenticated_requst):
#print ("Service killed by Client\n")
self.client_connected=False
file_server.server_alive = False
elif ("HELO" in authenticated_requst):
#print(authenticated_requst)
lines=authenticated_requst.split()
authenticated_requst = ("HELO {}\nIP:{}\nPort:{}\nStudentID:{}\n".format(lines[1], my_ip, p, studentNumber))
self.request.send(authenticated_requst)
elif("WRITE" in authenticated_requst):
#print(authenticated_requst)
write_file(self, authenticated_requst)
#if it is a primary copy then the server propagates the updated file
#to replicas, if a server can not be progagate too it is deamed failed and removed from
#the replica server list
if(file_server.primary_copy==True):
file_name=authenticated_requst.split("\n")[1]
failed_servers=propagate_write_2(file_server.server_list,file_name, auth_port)
file_server.server_list.remove(failed_servers)
elif("READ" in authenticated_requst):
if(file_server.primary_copy==True):
#send replica server info to client
self.request.send(file_server.server_list[file_server.last_replica])
#iterates to the next replica server, so that the following read requests are distributed fairly bewtween the replicas
if(len(file_server.server_list)==file_server.last_replica):
file_server.last_replica=0
else:
file_server.last_replica+=1
else:
#print(authenticated_requst)
read_file(self, authenticated_requst)
elif("Expired Ticket"):
self.request("Your can not be completed, your ticket has expired")
elif("PING" in authenticated_requst):
#if the primary copy receives a ping
#then return the serverlist
if(file_server.primary_copy==True):
string_server_list=parse_tuple_server_list(file_server.server_list)
self.request.send(string_server_list)
else:
#else send none
self.request.send(None)
elif("ELECTION" in authenticated_requst):
#checks if the id in the message is larger then mine
#id is extracted by spliting the request
#If the election requests Id is larger reply with a \n
if(int(authenticated_requst.split("\n")[1])>file_server.server_id):
self.request.send("\n")
else:
#else send dont send \n
self.request.send("Whoa, I have a bigger Id, I'm a bully")
#this server should then start an election
election(file_server.server_id,file_server.server_list, file_host,file_port,auth_port)
elif("ELECTED" in authenticated_requst):
file_server.primary_copy=parse_elected(authenticated_requst)
server_thread.daemon = True
server_thread.start()
#fileserver closes after 10 minutes
while(file_server.server_alive==True and current_min> datetime.now().minute-10):
#print datetime.now().second #if replica then ping_primary
#if replication was working then the the pings would happen here
if():#file_server.primary_copy==False and datetime.now().second==file_server.ping_interval):
print "FS {} Pinged!".format(file_port)
ping_reply=ping_primary_copy(file_server.primary_copy_address, auth_port, file_port)
#if ping fails hold, then an election
if(ping_reply==None):
election(file_server.server_id,file_server.server_list,file_host, file_port,auth_port)
pass
else:
#the Primary copy replys with the currently connected replicas
file_server.server_list=ping_reply
file_server.shutdown()
file_server.server_close()
exit()
except KeyboardInterrupt:
print("Key board interrupt \nServer Shutting Down")
file_server.shutdown()
file_server.server_close()
exit()
def process(self, data, elec, user):
dict = data
ans = dict["ans"]
elec = election()
elec.name = ans
return (elec, user)
