def Quit(self, request, context):
resp_node = self.server.FindResponsible(request, context)
room_name = request.roomname
resp_serv = resp_node[1][1]
if not resp_node[
0]: # Communicate with the server that might know who will respond the request
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the responsible server
result = conn.FindResponsible(
chat.FindRRequest(roomname=room_name))
resp_serv = self.Str_to_list_ports(result.port)
break
except:
print("False Error Quit at", serv)
if self.Request_port() in resp_serv:
return self.server.Quit(request, context)
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the server
return conn.Quit(
chat.QuitRequest(roomname=request.roomname,
nickname=request.nickname))
except:
print("True Error Quit at", serv)
def CreateChat(self, request, context):
print("Create chat")
resp_node = self.server.FindResponsible(
request,
context) # Fist - try to descover who will handle the request
room_name = request.roomname # the id of the room
resp_serv = resp_node[1][
1] # list of severs that will/might know who handle
print(resp_serv)
# Talvez problema devido a atribuicoa resp_serv dentro do for
if not resp_node[
0]: # Communicate with the server that might know who will respond the request
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) # connection with the responsible server
result = conn.FindResponsible(
chat.FindRRequest(roomname=room_name))
resp_serv = self.Str_to_list_ports(result.port)
break
except:
print("False Fail Create Chat at", serv)
# If this server is the one supposed to handle -----------------------------------------------------------------------------
if self.Request_port() in resp_serv:
print("I handle", request.roomname, request.password,
request.nickname)
result = self.server.CreateChat(request.roomname, request.password,
request.nickname)
print(result)
if result:
return chat.JoinResponse(state='sucess', Port=0)
else:
return chat.JoinResponse(state='fail', Port=0)
# Server knows who will handle --------------------------------------------------------------------------------------------
print("I know who will handle")
print("is : ", resp_serv)
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the responsible server
result = conn.CreateChat(
chat.CreateChatRequest(roomname=request.roomname,
password=request.password,
nickname=request.nickname))
break
except:
print("False Fail Create Chat at", serv)
return result
def ReceiveMessage(self, request, context):
print("Send it all")
resp_node = self.server.FindResponsible(request, context)
room_name = request.roomname
resp_serv = resp_node[1][1]
if not resp_node[
0]: # Communicate with the server that might know who will respond the request
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the responsible server
result = conn.FindResponsible(
chat.FindRRequest(roomname=room_name))
resp_serv = self.Str_to_list_ports(result.port)
except:
print("False Fai Receive Message at", serv)
if self.Request_port() in resp_serv:
lastindex = 0
aux = None
while not aux:
aux = self.server.Validade_User(request.roomname,
request.nickname)
if aux != None:
while True:
while lastindex < len(aux.Chats):
n = aux.Chats[lastindex]
n = chat.Note(roomname=request.roomname,
nickname=n['nickname'],
message=n['message'])
lastindex += 1
yield n
print("What")
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the server
for note in conn.ReceiveMessage(
chat.First(roomname=request.roomname,
nickname=request.nickname)):
yield note
break
except:
print("Error Receive Message at", serv)
def FindResponsible(self, request, context):
resp_node = self.server.FindResponsible(request, context)
room_name = request.roomname # the name of the room
resp_serv = resp_node[1][
1] # list of severs that will/might know who handle
if resp_node[0]:
return chat.FindRResponse(port=self.List_ports_to_str(resp_serv))
for serv in resp_serv:
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(serv))
conn = rpc.ChatSServerStub(
channel) ## connection with the responsible server
return conn.FindResponsible(
chat.FindRRequest(roomname=room_name))
except:
print("Fail FindResponsible at", serv)