def handleWalletBlock(self, wallet_block_dict):
wallet_block_dict["msg_type"] = "NEW_WALLET"
leader_ip, leader_port = self.decideLeader()
util.sendDict(wallet_block_dict, leader_ip, leader_port,
self.receivesocket)
def handleAnnouncement(self, announce_dict):
print("\n*** Announcing nyms ***\n")
#print(announce_dict["wallet_list"])
self.nym_map = announce_dict["wallet_list"]
self.final_generator = announce_dict["g"]
pm = {}
pm["nym_map"] = self.nym_map
pm["msg_type"] = "NYM_ANNOUNCE"
pm["gen_powered"] = self.final_generator
pm["g"] = self.gen
pm["p"] = self.p
for (ip, port) in self.known_servers:
util.sendDict(pm, ip, port, self.receivesocket)
# broadcast client public keys
pm = {}
pm["client_pubkeys"] = self.known_client_pubkeys
pm["msg_type"] = "CLIENT_ANNOUNCE"
for (ip, port) in self.known_servers:
util.sendDict(pm, ip, port, self.receivesocket)
self.startNextRound()
def startShuffle(self):
# signal to first server to start shuffle phase
if len(self.known_servers) == 0:
return
pm = {}
pm["msg_type"] = "SHUFFLE"
pm["wallet_list"] = self.original_reputation_map
pm["g"] = self.gen
pm["p"] = self.p
pm["server_list"] = self.known_servers
print("\n*** Starting shuffle... ***\n")
server_ip, server_port = self.known_servers[0]
util.sendDict(pm, server_ip, server_port, self.receivesocket)
def handleMessage(self, message_dict):
new_aggr_msg = {}
new_aggr_msg["text"] = message_dict["text_msg"]
new_aggr_msg["signature"] = message_dict["signatures"] # change later
new_aggr_msg["nyms"] = message_dict[
"pseudonyms"] # actually the public keys
new_aggr_msg["id"] = len(self.aggregated_messages) + 1
#print("Message from", new_aggr_msg["nyms"])
# verify signature (and send reply? don't think we need this here)
self.aggregated_messages.append(new_aggr_msg)
for server_ip, server_port in self.known_servers:
pm = new_aggr_msg
pm["msg_type"] = "MESSAGE_BROADCAST"
util.sendDict(pm, server_ip, server_port, self.receivesocket)
return
def startNextRound(self):
# finish tasks before current phase ends
self.current_phase = self.NEXT_PHASE[(self.current_phase + 1) %
len(self.NEXT_PHASE)]
if self.current_phase == SERVER_CONFIG:
print("\n*** Server Config Phase ***\n")
if self.current_phase == SPLIT:
# split phase begins here
pm = {}
pm['msg_type'] = "VOTE_END"
for server_ip, server_port in self.known_servers:
util.sendDict(pm, server_ip, server_port, self.receivesocket)
leader_ip, leader_port = self.decideLeader()
pm['msg_type'] = "GET_VOTE_COUNT"
util.sendDict(pm, leader_ip, leader_port, self.receivesocket)
# more phase handling code
# most importantly, need to signal each server that new phase has begun
# finish tasks before new phase starts
if self.current_phase == VOTE:
print("\n*** Starting voting phase ***\n")
pm = {}
pm['msg_type'] = "VOTE_START"
for server_ip, server_port in self.known_servers:
util.sendDict(pm, server_ip, server_port, self.receivesocket)
elif self.current_phase == READY_FOR_NEW_ROUND:
self.startShuffle()
def aggregateVotes(self, vote_dict):
aggr_votes = vote_dict["dict"]
vote_per_wallet = {}
for msg in self.aggregated_messages:
if str(msg["id"]) in aggr_votes:
total_votes = int(aggr_votes[str(msg["id"])])
num_nyms = len(msg["nyms"])
for (idx, nym) in enumerate(msg["nyms"]):
wallet_rep = int(total_votes / (num_nyms - idx))
if wallet_rep < -1:
wallet_rep = -1
total_votes = total_votes - wallet_rep
if nym in vote_per_wallet:
vote_per_wallet[nym] = max(
-1, vote_per_wallet[nym] + wallet_rep)
else:
vote_per_wallet[nym] = wallet_rep
for nym in self.nym_map:
if nym in vote_per_wallet:
vote_per_wallet[nym] += 1
else:
vote_per_wallet[nym] = 1
pm = {"msg_type": "VOTE_RESULT", "wallet_delta": vote_per_wallet}
# forget old pseudonyms
self.prev_original_reputation_map = self.original_reputation_map
self.original_reputation_map = {}
self.aggregated_messages = []
for (server_ip, server_port) in self.known_servers:
util.sendDict(pm, server_ip, server_port, self.receivesocket)
def handleVote(self, vote_dict):
msg_id = vote_dict["msg_id"]
vote = int(vote_dict["vote"])
lrs = vote_dict["signature"]
print("Received vote", vote, "for message", msg_id)
if (len(self.aggregated_messages) < int(msg_id)
or (vote != -1 and vote != 1)):
# invalid vote, send reply saying this
print("Invalid vote {0} for {1} received".format(vote, msg_id))
return
else:
vote_dict["msg_type"] = "NEW_VOTE"
if msg_id in self.round_votes:
self.round_votes[msg_id] += vote
else:
self.round_votes[msg_id] = vote
leader_ip, leader_port = self.decideLeader()
util.sendDict(vote_dict, leader_ip, leader_port,
self.receivesocket)
def handleServerJoin(self, server_ip, server_port):
pm = {}
next_hop_msg = {}
pm["msg_type"] = "SERVER_JOIN_REPLY"
pm["status"] = "SUCCESS"
for known_ip, known_port in self.known_servers:
if known_ip == server_ip and known_port == server_port:
pm["status"] = "INVALID"
util.sendDict(pm, server_ip, server_port, self.receivesocket)
return
self.known_servers.append((server_ip, server_port))
if len(self.known_servers) > 1:
pm["prev_hop_ip"], pm["prev_hop_port"] = self.known_servers[-2]
next_hop_msg["msg_type"] = "SERVER_NEXT_HOP_UPDATE"
pm["next_hop_ip"], pm["next_hop_port"] = self.known_servers[-1]
prev_ip, prev_port = self.known_servers[-2]
util.sendDict(next_hop_msg, prev_ip, prev_port, self.receivesocket)
util.sendDict(pm, server_ip, server_port, self.receivesocket)
print("New server joined: ", server_ip, server_port)
def broadcastLedger(self, ledger_dict, sender_ip, sender_port):
for (ip, port) in self.known_servers:
if not (ip == sender_ip and port == sender_port):
util.sendDict(ledger_dict, ip, port, self.receivesocket)
def sendtocoordinator(self, data):
util.sendDict(data, self.MY_IP, COORDINATOR_PORT, self.receivesocket)
def sendall(self, data):
for port in ALL_PORTS:
if port != self.MY_PORT:
util.sendDict(data, self.MY_IP, port, self.receivesocket)
def send(self, data, ip_addr, port):
util.sendDict(data, ip_addr, port, self.receivesocket)
