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