def handle_1a(self, msg_1a):
logging.debug("Acceptor {}, Instance {}\n\tReceived message 1A from Proposer {} c_rnd={}".format(self.id,
msg_1a.instance_num,
msg_1a.sender_id,
msg_1a.c_rnd))
instance = msg_1a.instance_num
if instance > self.greatest_instance:
self.greatest_instance = instance
if not instance in self.state: # check if instance already exists
# start logging new instance
self.state[instance] = hp.Instance(instance, self.id)
instance_state = self.state[instance]
if msg_1a.c_rnd > instance_state.rnd:
instance_state.rnd = msg_1a.c_rnd
# msg_1b = hp.create_message(instance_num=instance ,sender_id=self.id, phase="PHASE1B", rnd=instance_state.rnd, v_rnd=instance_state.v_rnd, v_val=instance_state.v_val)
msg_1b = hp.Message.create_1b(instance, self.id, instance_state.rnd, instance_state.v_rnd, instance_state.v_val)
self.writeSock.sendto(msg_1b, hp.send_to_role("proposers"))
logging.debug("Acceptor {}, Instance {}\n\tSent message 1B to Proposer {} rnd={} v_rnd={} v_val={}".format(self.id, instance, msg_1a.sender_id, instance_state.rnd, instance_state.v_rnd, instance_state.v_val))
return
def get_greatest_instance(self):
logging.debug(f"Proposer {self.id} \n\tSent message INSTANCEREQ")
msg_greatestinstance = hp.Message.create_instancereq(self.id)
self.writeSock.sendto(msg_greatestinstance,
hp.send_to_role("acceptors"))
return
def handle_instancereq(self, msg_instancereq):
logging.debug(f"Acceptor {self.id} \n\tReceived message INSTANCEREQ from Proposer {msg_instancereq.sender_id}")
msg_instancerepl = hp.Message.create_instancerepl(self.greatest_instance, self.id)
self.writeSock.sendto(msg_instancerepl, hp.send_to_role("proposers"))
logging.debug(f"Acceptor {self.id} \n\tSent message INSTANCEREPL to Proposer {msg_instancereq.sender_id} with instance {self.greatest_instance}")
return
def catchup_request(self, catchup_instance):
logging.debug("Time {}\tLearner {} \n\tSending CATCHUPREQ for instance {}".format(int(time.time()), self.id,
catchup_instance))
msg_catchupreq = hp.Message.create_catchuprequest(catchup_instance, self.id)
self.writeSock.sendto(msg_catchupreq, hp.send_to_role("proposers"))
return
def leader_send_alive(self):
if self.is_leader():
# logging.debug("Time {}\tLeader {} \n\tSending LEADERALIVE".format(int(time.time()),self.id))
# send LEADERALIVE adding the last instance this leader has started
msg_alive = hp.Message.create_leaderalive(self.last_instance,
self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
return
def catchup_request(self):
if self.catching_up:
logging.debug("Time {}\tLearner {} \n\tSending CATCHUPREQ".format(
int(time.time()), self.id))
self.catchup_instance += 1
msg_catchupreq = hp.Message.create_catchuprequest(
self.catchup_instance, self.id)
self.writeSock.sendto(msg_catchupreq, hp.send_to_role("acceptors"))
self.catchup_store = []
return
def run(self):
logging.debug("I'm {} and my address is ({})".format(self.role, self.multicast_group))
while True:
if args["values"] is not None:
# open input values file
working_directory = os.getcwd()
file_path = working_directory + args["values"]
f = open(file_path, "r")
if f.mode == "r":
contents = f.read().splitlines()
for value in contents:
msg_proposal = hp.Message.create_proposal(self.id, value)
self.writeSock.sendto(msg_proposal, hp.send_to_role("proposers"))
logging.debug("Client {} \n\tSent PROPOSAL {} to Proposers".format(self.id, value))
args["values"] = None # don't loop forever sending values from file
else:
value = input('\nEnter value to send to proposer:')
msg_proposal = hp.Message.create_proposal(self.id, value)
self.writeSock.sendto(msg_proposal, hp.send_to_role("proposers"))
logging.debug("Client {} \n\tSent PROPOSAL {} to Proposers".format(self.id, value))
def handle_1b(self, msg_1b):
# only look at messages addressed to me and for current round
# if msg_1b["sender_id"] != self.id or msg_1b["rnd"] != self.c_rnd:
# return
if self.is_leader():
logging.debug(
"Proposer {}, Instance {} \n\tReceived message 1B from Acceptor {} rnd={} v_rnd={} v_val={}"
.format(self.id, msg_1b.instance_num, msg_1b.sender_id,
msg_1b.rnd, msg_1b.v_rnd, msg_1b.v_val))
instance = msg_1b.instance_num
instance_state = self.state[instance]
if instance_state.c_rnd == msg_1b.rnd:
instance_state.quorum_1b += 1
# save largest (v_rnd, v_val) tuple
if msg_1b.v_rnd >= instance_state.largest_v_rnd:
instance_state.largest_v_rnd = msg_1b.v_rnd
instance_state.largest_v_val = msg_1b.v_val
# if we have enough messages
if instance_state.quorum_1b >= hp.QUORUM_SIZE:
# send the client's value if not previous values are present
if instance_state.largest_v_rnd == 0:
v = instance_state.v
else:
# send largest v_val received in this instance
v = instance_state.largest_v_val
msg_2a = hp.Message.create_2a(instance, self.id,
instance_state.c_rnd, v)
self.writeSock.sendto(msg_2a, hp.send_to_role("acceptors"))
logging.debug(
"Proposer {}, Instance {} \n\tSent message 2A to Acceptors c_rnd={} c_val={}"
.format(self.id, instance, instance_state.c_rnd, v))
return
def handle_2a(self, msg_2a):
logging.debug("Acceptor {}, Instance {} \n\tReceived message 2A from Proposer {} c_rnd={} c_val={}".format(self.id, msg_2a.instance_num, msg_2a.sender_id, msg_2a.c_rnd, msg_2a.c_val))
instance = msg_2a.instance_num
instance_state = self.state[instance]
if instance > self.greatest_instance:
self.greatest_instance = instance
# discard old proposals
if msg_2a.c_rnd >= instance_state.rnd:
instance_state.v_rnd = msg_2a.c_rnd
instance_state.v_val = msg_2a.c_val
msg_2b = hp.Message.create_2b(instance, self.id, instance_state.v_rnd, instance_state.v_val)
self.writeSock.sendto(msg_2b, hp.send_to_role("proposers"))
logging.debug("Acceptor {}, Instance {} \n\tSent message 2B to Proposer {} v_rnd={} v_val={}".format(self.id, instance, msg_2a.sender_id, instance_state.v_rnd, instance_state.v_val))
return
def handle_proposal(self, msg_prop):
# start new instance with c_rnd=my_id*instance_number and v as proposal
self.state[self.last_instance] = hp.Instance(self.last_instance,
self.id, None,
msg_prop.v_val)
logging.debug(
"Proposer {} \n\tReceived message PROPOSAL from Client {} v_val={}"
.format(self.id, msg_prop.sender_id, msg_prop.v_val))
if self.is_leader() and self.instance_received:
msg_1a = hp.Message.create_1a(self.last_instance, self.id,
self.state[self.last_instance].c_rnd)
self.writeSock.sendto(msg_1a, hp.send_to_role("acceptors"))
logging.debug(
"Proposer {}, Instance {} \n\tSent message 1A to Acceptors c_rnd={}"
.format(self.id, self.last_instance,
self.state[self.last_instance].c_rnd))
self.last_instance += 1
return
def handle_catchupreq(self, msg_catchupreq):
logging.debug(
f"Proposer {self.id} \n\tReceived message CATCHUPREQ from Learner {msg_catchupreq.sender_id} for instance {msg_catchupreq.instance_num}"
)
# create instance or overwrite it
old_c_rnd = self.state[msg_catchupreq.instance_num].c_rnd
self.state[msg_catchupreq.instance_num] = hp.Instance(
msg_catchupreq.instance_num, self.id, old_c_rnd + hp.NUM_PROPOSERS,
None)
if self.is_leader() and self.instance_received:
msg_1a = hp.Message.create_1a(msg_catchupreq.instance_num, self.id,
old_c_rnd + hp.NUM_PROPOSERS)
self.writeSock.sendto(msg_1a, hp.send_to_role("acceptors"))
logging.debug(
f"Proposer {self.id}, Instance {msg_catchupreq.instance_num} \n\tSent message 1A to Acceptors c_rnd={old_c_rnd + hp.NUM_PROPOSERS}"
)
return
def handle_2b(
self, msg_2b
): # TODO anche se non è leader deve registrarsi l'ultima istanza per rimanere sincronizzato
# only look at messages addressed to me and for current round
# if msg_2b["sender_id"] != self.id:
# return
if self.is_leader():
logging.debug(
"Proposer {}, Instance {} \n\tReceived message 2B from Acceptor {} v_rnd={} v_val={}"
.format(self.id, msg_2b.instance_num, msg_2b.sender_id,
msg_2b.v_rnd, msg_2b.v_val))
instance = msg_2b.instance_num
instance_state = self.state[instance]
# record messages in this round
instance_state.quorum_2b.append(msg_2b)
# if we have a quorum of messages with v_rnd = c_rnd then we can decide
if sum(instance_state.c_rnd == item.v_rnd
for item in instance_state.quorum_2b) >= hp.QUORUM_SIZE:
# find the first element with c_rnd = v_rnd to get its v_val
v = next((x for x in instance_state.quorum_2b
if x.v_rnd == instance_state.c_rnd), None)
msg_decision = hp.Message.create_decision(
instance, self.id, v.v_val)
self.writeSock.sendto(msg_decision,
hp.send_to_role("learners"))
logging.debug(
"Proposer {}, Instance {} \n\tSent message DECISION to Learners v_val={}"
.format(self.id, instance, v.v_val))
return
def leader_check_alive(self):
# check if the current leader has received enough instance messages
if self.is_leader() and not self.instance_received:
self.get_greatest_instance()
# If I never received a LEADERALIVE then proposer 4 was never started or crashed so I elect myself
if self.last_leader_alive_msg == None:
if not self.is_leader():
logging.debug(
"Time {}\tProposer {} \n\tNo current leader".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
self.get_greatest_instance()
self.leader_print_flag = True
msg_alive = hp.Message.create_leaderalive(
self.last_instance, self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
return
# if last LEADERALIVE message is older than 3s I elect myself as leader
if hp.Message.has_timedout(self.last_leader_alive_msg, 3):
if not self.is_leader():
logging.debug("Time {}\tProposer {} \n\tLeader timeout".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
self.get_greatest_instance()
self.leader_print_flag = True
msg_alive = hp.Message.create_leaderalive(
self.last_instance, self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
return
else:
# if last LEADERALIVE sender has smaller ID than me I elect myself
if self.id > self.last_leader_alive_msg.sender_id:
if not self.is_leader():
logging.debug(
"Time {}\tProposer {} \n\tI'm largest proposer".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
self.get_greatest_instance()
self.leader_print_flag = True
msg_alive = hp.Message.create_leaderalive(
self.last_instance, self.id)
self.writeSock.sendto(msg_alive,
hp.send_to_role("proposers"))
else:
if not self.is_leader():
if self.leader_print_flag:
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader"
.format(int(time.time()), self.id,
self.last_leader_alive_msg.sender_id))
self.leader_print_flag = False
self.last_leader = self.last_leader_alive_msg.sender_id
return
def leader_check_alive(self):
# If I never received a LEADERALIVE then proposer 1 was never started or crashed so I elect myself
if self.last_leader_alive_msg == None:
if not self.is_leader():
logging.debug(
"Time {}\tProposer {} \n\tNo current leader".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
msg_alive = hp.Message.create_leaderalive(self.last_instance,
self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
return
leader_timeout = time.time(
) - self.last_leader_alive_msg.time # check time passed since last LEADERALIVE
# if last LEADERALIVE message is older than 3s I elect myself as leader
if leader_timeout > 3:
if not self.is_leader():
logging.debug("Time {}\tProposer {} \n\tLeader timeout".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
msg_alive = hp.Message.create_leaderalive(self.last_instance,
self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
return
else:
# if last LEADERALIVE sender has smaller ID than me I elect myself
if self.id > self.last_leader_alive_msg.sender_id:
if not self.is_leader():
logging.debug(
"Time {}\tProposer {} \n\tI'm largest proposer".format(
int(time.time()), self.id, self.last_leader))
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id, self.id))
self.last_leader = self.id # elect myself as new leader
msg_alive = hp.Message.create_leaderalive(
self.last_instance, self.id)
self.writeSock.sendto(msg_alive, hp.send_to_role("proposers"))
else:
if not self.is_leader():
logging.debug(
"Time {}\tProposer {} \n\tProposer {} is now leader".
format(int(time.time()), self.id,
self.last_leader_alive_msg.sender_id))
self.last_leader = self.last_leader_alive_msg.sender_id
return
print("I'm {} and my address is ({})".format(sys.argv[1], multicast_group))
message = 'very important data'
dict = {}
dict["command"] = "comando1"
dict["param"] = "param1"
dict["optional"] = "opt"
try:
# Send data to the specified multicast group
print('sending {!r}'.format(dict))
# sent = writeSock.sendto(message.encode(), hp.send_to_role("clients"))
sent = writeSock.sendto(
json.dumps(dict).encode(), hp.send_to_role("clients"))
# Look for responses from all recipients
while True:
print('waiting to receive ack')
try:
data, server = readSock.recvfrom(1024)
except socket.timeout:
print('timed out, no more responses')
break
else:
# print('received {!r} from {}'.format(data.decode(), server))
print('received {!r} from {}'.format(json.loads(data.decode()),
server))
break
from Paxos_v3 import helper as hp
import sys
import json
# get command-line arguments
role = sys.argv[1]
readSock, multicast_group, writeSock = hp.init(role)
print("I'm {} and my address is ({})".format(sys.argv[1], multicast_group))
# Receive/respond loop
while True:
print('\nwaiting to receive message')
data, address = readSock.recvfrom(1024)
print('received {} bytes from {}'.format(len(data), address))
print(json.loads(data.decode()))
# print(data.decode())
print('sending acknowledgement to', hp.send_to_role("acceptors"))
writeSock.sendto(json.dumps('ack').encode(), hp.send_to_role("acceptors"))