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 go_online(self):
# Colocar para os nos adicionarem o main server a sua table e requisitarem a adicao deles no main server table
if self.id != 0:
main_servers = [11904, 11936, 11968, 12000]
for serv in main_servers:
self.route_table.add_node(0, serv)
channel = grpc.insecure_channel(self.address + ':' + str(serv))
conn = rpc.ChatSServerStub(channel)
print("send", self.id, self.Request_port)
conn.AddNewNode(
chat.NewNodeReq(n_id=self.id, port=self.Request_port))
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
rpc.add_ChatSServerServicer_to_server(ChatServer(self), server)
print('Starting server, Listenning ...')
server.add_insecure_port('[::]:' + str(self.Request_port))
server.start()
server.wait_for_termination()
def AddNewNode(self, request, context):
others = self.server.AddNewNode(request, context)
for tupla in others: # each tupla is an id and a list of ports
for node in tupla[1]: # member 1 is the list of ports
try:
channel = grpc.insecure_channel(self.server.address + ':' +
str(node))
conn = rpc.ChatSServerStub(
channel) ## connection with the responsible server
conn.AddNewNode(
chat.NewNodeReq(n_id=request.n_id, port=request.port))
except:
print("Fail on AddNewNode at", node)
return chat.EmptyResponse()
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)
from concurrent import futures
import sys
sys.path.append('../')
from proto import ChatRoom_pb2_grpc as rpc
from proto import ChatRoom_pb2 as chat
import grpc
import time
from threading import Lock
from server import ChatRoom as room
import multiprocessing as mp
import os
Roomname = 'Batman'
password = 123
port = 11912
if __name__ == '__main__':
print('ChatRroom: Room process started ...')
Roomserver = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
newroom = room.ChatRoom(Roomname, password)
rpc.add_ChatRoomServicer_to_server(newroom, Roomserver)
print('ChatRoom: Starting new Chat room, listenning ...')
Port = Roomserver.add_insecure_port('[::]:' + str(port))
newroom.setport(port)
print('ChatRoom: ' + Roomname + ':' + str(Port))
Roomserver.start()
while True:
time.sleep(64 * 64 * 100)
#print('Testing Server Connection ...')
#channel = grpc.insecure_channel(address+':'+str(port))
#conn = rpc.ChatSServerStub(channel)
#print('Creating a new ChatRoom ...')
#newroom_response= conn.CreateChat(chat.CreateChatRequest(roomname = 'Teste', password = '******',nickname = 'Tester'))
#if(newroom_response.state == 'sucess'):
# newroom_port = newroom_response.Port
# print('Room created sucessfully...')
#else:
# print('Fail to create a room, aborting ...')
# exit(1)
print('Trying to connect to chatRoom ...')
room_channel = grpc.insecure_channel(address + ':' + str(newroom_port))
room_conn = rpc.ChatRoomStub(room_channel)
time.sleep(10)
def Cliente1():
print('Cliente1: Trying to Send a message')
for i in range(100):
room_conn.SendMessage(chat.Note(nickname='Tester', message=str(i)))
print('Cliente1: Message: ' + str(i) + ' sent ...')
while True:
for message in room_conn.ReceiveMessage(chat.EmptyResponse()):
print(message)
def Cliente2():
def new_channel(self):
print("Trying another server")
channel = grpc.insecure_channel(address + ':' +
str(port[self.replica]))
self.conn = rpc.ChatSServerStub(channel) ## connection with the server
self.replica = (self.replica + 1) % len(port)
def __init__(self):
channel = grpc.insecure_channel(address + ':' + str(port[0]))
self.conn = rpc.ChatSServerStub(channel) ## connection with the server
self.lock = Lock()
self.chats = [] ## lock to chats list
self.replica = 1