112 lines
4.1 KiB
Python
112 lines
4.1 KiB
Python
import time
|
|
from DecisionSystem.messages import Message, CommanderWill, RequestVote, GetSwarmParticipants, deserialise
|
|
import json
|
|
import numpy as np
|
|
|
|
class Commander:
|
|
currentVote = None
|
|
|
|
# Stores voters that connect to maintain a majority.
|
|
# Voters who do not vote in latest round are removed.
|
|
_connectedVoters = []
|
|
# Dict has format: {clientId: vote}
|
|
_votes = {}
|
|
_taking_votes = False
|
|
|
|
def __init__(self, messenger, timeout = 60):
|
|
'''
|
|
Initial/default waiting time is 1 minute for votes to come in.
|
|
'''
|
|
self.timeout = timeout
|
|
|
|
self._messenger = messenger
|
|
self._messenger.add_connect(self.on_connect)
|
|
self._messenger.add_message_callback(self.on_message)
|
|
self._messenger.add_disconnect_callback(self.on_disconnect)
|
|
print('Connecting')
|
|
|
|
def make_decision(self):
|
|
# Should change this to follow strategy pattern, for different implementations of
|
|
# making a decision on the votes.
|
|
print("Making a decision")
|
|
votes = self._votes.values()
|
|
print(type(votes))
|
|
dif_votes = {}
|
|
|
|
for vote in votes:
|
|
# Get the count of different votes.
|
|
if vote in dif_votes:
|
|
dif_votes[vote] = dif_votes[vote] + 1
|
|
else:
|
|
dif_votes[vote] = 1
|
|
|
|
max_vote = ""
|
|
max_vote_num = 0
|
|
# Should try using a numpy array for this.
|
|
|
|
for vote in dif_votes.keys():
|
|
if dif_votes[vote] > max_vote_num:
|
|
max_vote = vote
|
|
max_vote_num = dif_votes[vote]
|
|
|
|
print("Made Decision!")
|
|
return max_vote
|
|
|
|
def get_votes(self):
|
|
# Should abstract messaging to another class.
|
|
print("Gathering Votes")
|
|
self._taking_votes = True
|
|
# Publish a message that votes are needed.
|
|
print("Sending request message")
|
|
self._messenger.broadcast_message(self._messenger.swarm, RequestVote(self._messenger.id).serialise())
|
|
print("published message")
|
|
time.sleep(self.timeout)
|
|
self._taking_votes = False
|
|
return self.make_decision()
|
|
|
|
def on_message(self, message):
|
|
print("Message Received")
|
|
messageD = None
|
|
try:
|
|
messageD = deserialise(message.payload)
|
|
except:
|
|
print("Incorrect Message Has Been Sent")
|
|
return
|
|
|
|
# Need to consider that a malicious message may have a type with incorrect subtypes.
|
|
if messageD.type == "connect":
|
|
print("Voter connected!")
|
|
# Voter just connected/reconnnected.
|
|
if not messageD["client"] in self._connectedVoters:
|
|
self._connectedVoters.append(messageD["client"])
|
|
elif messageD.type == "vote":
|
|
print("Received a vote!")
|
|
# Voter is sending in their vote.
|
|
print(messageD.data["vote"])
|
|
print("From: ", messageD.sender)
|
|
if self._taking_votes:
|
|
# Commander must have requested their taking votes, and the timeout
|
|
# has not occurred.
|
|
# Only add vote to list if the client has not already voted.
|
|
if messageD.sender not in self._votes:
|
|
self._votes[messageD.sender] = int(messageD.data["vote"])
|
|
|
|
elif messageD.type == "disconnected":
|
|
print("Voter disconnected :(")
|
|
self._connectedVoters.remove(messageD.sender)
|
|
|
|
def on_connect(self, rc):
|
|
# Subscribes now handled by the mqtt messenger, this is just here
|
|
# for convenience later.
|
|
pass
|
|
|
|
def get_participants(self):
|
|
self._messenger.broadcast_message(self._messenger.swarm, GetSwarmParticipants().serialise())
|
|
# Commander needs a will message too, for the decentralised version, so the
|
|
# voters know to pick a new commander.
|
|
# If using apache zookeeper this won't be needed.
|
|
# That's the wrong method for setting a will.
|
|
# self.client.publish("swarm1/voters", CommanderWill(self.client._client_id).serialise())
|
|
|
|
def on_disconnect(self, rc):
|
|
pass |