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"))