101 lines
3.6 KiB
Python
101 lines
3.6 KiB
Python
import paho.mqtt.client as mqtt
|
|
import time
|
|
from DecisionSystem.messages import Message, CommanderWill, RequestVote
|
|
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, timeout = 60):
|
|
'''
|
|
Initial/default waiting time is 1 minute for votes to come in.
|
|
'''
|
|
self.timeout = timeout
|
|
# Default configuration file for testing.
|
|
cfg = None
|
|
with open('config.json') as json_config:
|
|
cfg = json.load(json_config)
|
|
self._cfg = cfg
|
|
|
|
self.client = mqtt.Client()
|
|
self.client.connect(cfg["mqtt"]["host"], cfg["mqtt"]["port"], cfg["mqtt"]["host"])
|
|
|
|
self.client.subscribe("swarm1/commander")
|
|
# 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.
|
|
self.client.publish("swarm1/voters", CommanderWill(self.client._client_id))
|
|
|
|
def make_decision(self):
|
|
# Should change this to follow strategy pattern, for different implementations of
|
|
# making a decision on the votes.
|
|
votes = self._votes
|
|
dif_votes = {}
|
|
|
|
for vote in votes:
|
|
# Get the count of different votes.
|
|
if str(vote) in dif_votes:
|
|
dif_votes[str(vote)] = dif_votes[str(vote)] + 1
|
|
else:
|
|
dif_votes[str(vote)] = 1
|
|
|
|
max_vote = None
|
|
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]
|
|
|
|
return max_vote
|
|
|
|
def get_votes(self):
|
|
# Should consider abstracting these messages to another class for portability.
|
|
self._taking_votes = True
|
|
# Publish a message that votes are needed.
|
|
self.client.publish("swarm1/voters", RequestVote(self.client._client_id))
|
|
time.sleep(self.timeout)
|
|
self._taking_votes = False
|
|
self.make_decision()
|
|
|
|
def on_message(self, client, userdata, message):
|
|
messageD = None
|
|
try:
|
|
messageD = Message().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":
|
|
# Voter just connected/reconnnected.
|
|
if not messageD["client"] in self._connectedVoters:
|
|
self._connectedVoters.append(messageD["client"])
|
|
elif messageD.type == "vote":
|
|
# Voter is sending in their vote.
|
|
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] = messageD.data["vote"]
|
|
|
|
elif messageD.type == "disconnected":
|
|
self._connectedVoters.remove(messageD.sender)
|
|
|
|
def on_connect(self, client, userdata, flags, rc):
|
|
self.client.subscribe("swarm1/commander")
|
|
|
|
def get_participants(self):
|
|
|
|
self.client.publish("swarm1/voters") |