def SendData(self, data: chat.Data, context):
if data.connect is True:
if doesSessionExist(data, self.reqMap) is True:
return chat.Empty()
self.chats[data.sender].appendData(data)
send_to = [data.receiver]
if data.group is not '':
send_to = server_config['groups'][data.group]
# Add it to the chat queue
for usr in send_to:
if usr not in self.chats:
self.chats.update({usr: UserChat()})
try:
for usr in send_to:
if usr == data.sender:
continue
# self.chats[data.sender].applyRateLimit()
data.receiver = usr
self.chats[usr].appendData(data)
except:
print('Too many requests...message not sent.')
pass
return chat.Empty()
def SendMessage(self, request, context):
response = chat.ChatRequest()
response.name = request.name
response.message = request.message
print(f"{request.name}: {request.message}")
self.messages.append(response)
return chat.Empty()
def receive_message(self, chat_stub):
'''
This method will be ran in a separate thread as the main/ui thread, because the for-in call is blocking
when waiting for new messages
'''
for message in chat_stub.ReceiveMsg(chat.Empty()):
print("[{}] {}".format(self.encrypt.decrypt(message.name), self.encrypt.decrypt(message.note)))
def RefreshTabuleiro(self):
if not self.stub:
return None
print("[REFRESH TABULEIRO]")
for message in self.stub.RefreshTabuleiro(chat_pb2.Empty()):
if self.ui != None:
self.ui.renderTabuleiro()
def TabuleiroAtual(self):
print("[TABULEIRO ATUAL]")
response = self.stub.TabuleiroAtual(chat_pb2.Empty())
tabuleiro = [
response.line1, response.line2, response.line3, response.line4,
response.line5, response.line6, response.line7, response.line8
]
return tabuleiro
def PostMessage(self, request, context):
logging.info('PostMessage(): nick="{0}", text="{1}"'\
.format(request.nick, request.text))
with self.lock:
for queue in self.queues:
message = chat_pb2.Message(nick=request.nick,
text=request.text)
queue.put(message)
return chat_pb2.Empty()
def ChangeTabuleiro(self, request, context):
print("[CHANGE TABULEIRO]")
pos = request.pos
color = request.cor
self.tabuleiro[pos[0]][pos[1]] = color
self.refresh.append(chat_pb2.Empty())
self.refresh_index = 0
return chat_pb2.Status(status=True)
def _get_messages(self):
empty = chat_pb2.Empty()
while self.running:
self.messages = self.stub.GetMessages(empty)
try:
for message in self.messages:
self.recv_queue.put(message)
except grpc.RpcError as e:
if not e.cancelled():
logging.error('RPC error: {0}'.format(e))
self.messages = None
def receive_messages(self):
if not self.stub:
return None
print("[RECEIVE MESSAGE]")
for message in self.stub.ReceiveMessage(chat_pb2.Empty()):
print("Chat client received: " + message.name + " " +
message.message)
if self.ui != None:
self.ui.renderChatMessages(message.name + " " +
message.message)
def SendMessage(self, request: chat.Message, context):
message = self.message_decrypted(request)
if (self.encrypt.decrypt(message.to) == 'server'):
if (self.encrypt.decrypt(message.method) == 'add_user'):
self.user_stub.AddUser(message.user.name)
elif (self.encrypt.decrypt(message.method) == 'remove_user'):
self.user_stub.RemoveUser(message.user.name)
elif (self.encrypt.decrypt(message.method) == 'get_users'):
self.user_stub.GetUsers()
print('[{}] {}'.format(message.user.name, message.user.note))
return chat.Empty()
def get_users(self, chat_stub, user_stub):
self.userslist = []
for _usr in user_stub.GetUsers(chat.Empty()):
self.userslist.append(self.encrypt.decrypt(_usr.name))
message = chat.Message()
message.name = self.encrypt.encrypt('Spartan')
print_string = 'User list:'
for usr in self.userslist:
print_string += '{},'.format(usr)
message.note = self.encrypt.encrypt(print_string[:-1])
chat_stub.SendMsg(message)
def SendNote(self, request: chat_pb2.ChatNote, context):
self.chats.append(request)
print("[{}] {} {}".format(request.name, request.message, request.receiver))
# Add it to the chat history
self.chats_message.append(request.message)
self.receiver.append(request.receiver)
self.LruDict.append(request.message)
if len(self.LruDict)>5:
self.LruDict.pop()
print(self.LruDict)
return chat_pb2.Empty()
def SendMsg(self, request: chat.Message, context):
"""
This method is called when a clients sends a Note to the server.
:param request:
:param context:
:return:
"""
print("[{}] {}".format(self.encrypt.decrypt(request.name),
self.encrypt.decrypt(request.note)))
# Add it to the chat history
self.chats.append(request)
return chat.Empty()
def SendNote(self, request: chat.Note, context):
"""
This method is called when a clients sends a Note to the server.
:param request:
:param context:
:return:
"""
self.sending.publish(
'chat',
json.dumps({
'message': request.message,
'user': request.name,
'timestamp': str(datetime.datetime.now())
}))
return chat.Empty()
def __listen_for_messages(self):
for note in self.conn.ChatStream(chat.Empty()):
print("R[{}] {}".format(note.name, note.message))
self.chat_list.insert(END, "[{}] {}\n".format(note.name, note.message))
def TurnoAtual(self):
print("[TURNO ATUAL]")
response = self.stub.TurnoAtual(chat_pb2.Empty())
return response.cor
def run(self, user_stub, chat_stub):
for message in chat_stub.ReceiveMsg(chat.Empty()):
if(message.to == 'client'):
if(message.method == 'list_users'):
def recive(self):
for note in self.conn.ChatStream(chat.Empty(
)): # this line will wait for new messages from the server!
if note.name and note.name != self.username:
print("{} : {}\n".format(note.name, note.message))
def SendMessage(self, request, context):
print("[SEND MESSAGE]")
self._history.append(request)
self.last_index = 0
return chat_pb2.Empty()
def cores_disponiveis(self):
print("[CORES DISPONIVEIS]")
response = self.stub.CoresDisponiveis(chat_pb2.Empty())
return response.data