def work(self): while True: if self._quit: self.close_connection() read_sockets, _, exeption_sockets = select.select( self._sockets, [], self._sockets) for notified_socket in read_sockets: if notified_socket == self._socket: # it's the first message that is sent from this socket client_socket, client_address = self._socket.accept() message = recieve_message(client_socket) print(message) if message is False: continue self._sockets.append(client_socket) this_user_id = message.split("|")[0] self._num_of_connected += 1 self._client_sockets[this_user_id] = client_socket mes = Message('med', this_user_id, "SYN-ACK", '', 0, message.split("|")[-2]) send_message(client_socket, mes) else: message = recieve_message(notified_socket) waiting_time = randint(0, self._delta) self._pending.append((message, time.time(), waiting_time)) if message is False: self._sockets.remove(notified_socket) continue for notified_socket in exeption_sockets: self._sockets.remove(notified_socket)
def deliver_message(self, message): # print(message) if message == False: return message_source, message_target, message_type, message_content, message_view, message_world, message_lock = message.split( "|") # case this message isn't to the mediator if message_target != 'med': if message_target in self._client_sockets.keys( ) and message_target not in self._recieve_omission and message_source not in self._send_omission: target_socket = self._client_sockets[message_target] # here the omission fauilure comes into play # todo: as this is an asynchrnous, delay messages from time to time via clock - signals and uniform random delay DONE send_message( target_socket, Message(message_source, message_target, message_type, message_content, message_view, message_world, message_lock))
def message_driven(self, mes): # retrieve mes message_source, message_target, message_type, message_content, message_view, message_world, message_lock = mes.split( "|") message_world = int(message_world) message_view = int(message_view) if message_type == "SYN-ACK" and message_source == "med": if self._id == "*": self._id = int(message_target) self._values[self._id] = self._id self._stage = "SEND" self.logit("Server " + str(self._id) + "is connected to the Med!") if self._stage == "VC": self.vc_handler(message_type, message_view, message_world, message_content, message_lock) # echo message if message_type.startswith("echo"): if message_view >= self._locks[message_world]: self._values[message_world] = message_content self._locks[message_world] = message_view self._views[message_world] = message_view self._heard[message_world] = True # ack message elif message_type.startswith("ack"): self.ack_handler(message_content, message_view, message_world) elif message_type.startswith("done"): self._done_counter += 1 elif message_type.startswith('value'): # recieved this message from the primary of some world i if int(message_lock) >= self._locks[message_world]: # lock this value self._values[message_world] = message_content self._locks[message_world] = int(message_lock) self._views[message_world] = message_view for i in range(N): # echo to all send_message(self._mediator_socket, Message(self._id, i, 'echo ', message_content, message_view, message_world, message_lock)) # ack the primary send_message(self._mediator_socket, Message(self._id, message_world, 'ack ', message_content, message_view, message_world))
def state_driven(self): if self._stage == "SEND": self.logit("SENDING") for i in range(N): send_message(self._mediator_socket, Message(self._id, i, "value", self._values[self._id], self._views[self._id], self._id, self._locks[self._id])) self._stage = "ACK" if self._ack_messages_in_my_world >= N - F and self._stage == "ACK": self.logit('world ' + str(self._id) + ' done ' + 'with value ' + str(self._values[self._id])) for i in range(N): send_message(self._mediator_socket, Message(self._id, i, "done", self._values[self._id], self._views[self._id], self._id)) self._stage = "DONE" if self._done_counter >= N - F and self._stage == "DONE": # Leader election self._current_leader = self._ideal_functionality() self.logit("LE DONE LEADER IS " + str(self._current_leader)) self._stage = "VC" # done is sent once... # send the value that you are locked on in the leader's world type = "vc-value-gather" if self._heard[self._current_leader] else "vc-blame" for i in range(N): send_message(self._mediator_socket, Message(self._id, i, type, self._values[self._current_leader], self._views[self._current_leader], self._current_leader, self._locks[self._current_leader]))
def __init__(self, mediator_host=host, mediator_port=port, id="*", ideal___functionality=ideal_functionality): """ :param mediator_host: host name of the mediator (socket details) :param mediator_port: port of mediator socket (socket details) :param id: server's id (0,...,N-1) (protocol detail) """ # each server starts with an id self._quit = False self._id = id self._stage = "COMMUNICATION_INITIALIZATION" # value::the value i locked on world i # lock::the view that i decided value in world i # view::current view in world i self._views = [0 * i for i in range(N)] self._locks = [0 * i for i in range(N)] self._ideal_functionality = ideal___functionality self._values = [0 * i for i in range(N)] # if i heard from the leader in world i, heard[i]=True self._heard = [False] * N self._values[self._id] = self._id self._ack_messages_in_my_world = 0 # VC DataStructures self._vc_value_gather = {} self._vc_blame_gather = 0 self._vc_value_counter = 0 self._done_counter = 0 self._mediator_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: self._mediator_socket.connect((mediator_host, mediator_port)) except: self.logit("Mediator Server is Off") return self._mediator_socket.setblocking(False) self._current_leader = 0 # send first message to the mediator mes = Message(self._id, "med", "SYN", '', self._views[self._id], self._id) send_message(self._mediator_socket, mes)
def work(self): while True: value = input('Please type your value, client:') send_message( self._mediator_socket, Message('client', 'med', 'client-message', value, 0, 0))