def in_client():
try:
client.login = in_window.LogLogin.text()
client.password = in_window.LogPassw.text()
mes = client.get_passw()
send_message(client.sock, mes)
resp = get_message(client.sock)
if resp[RESPONSE] == OK:
code = client.sock.recv(32)
messege = client.hash_resp(code)
client.sock.send(messege)
responce = get_message(client.sock)
responce = client.translate_response(responce)
if responce[RESPONSE] == OK:
in_window.LogText.addItem("You're welcome")
print(1)
open_chat()
print(2)
in_window.close()
else:
in_window.LogText.addItem("Wrong password")
else:
in_window.LogText.addItem("Wrong login")
except Exception as e:
window.CrText.addItem(e)
def create_message(self, sock, name_from, name_to, message):
"""
Метод создающий словарь с сообщением
:param sock: socket (Клиентский сокет)
:param name_from: str (Имя отправителя)
:param name_to: str (Имя получателя)
:param message: str (Сообщение)
:return: None
"""
message_dict = {
ACTION: MESSAGE,
SENDER: name_from,
DESTINATION: name_to,
TIME: self.__get_time(),
MESSAGE_TEXT: message
}
client_logger.debug(f'Сформирован словарь сообщения:\n{message_dict}')
try:
send_message(sock, message_dict)
client_logger.info(
f'Отправлено сообщение для пользователя {name_to}')
except (OSError, ConnectionError, ConnectionAbortedError,
ConnectionResetError, KeyboardInterrupt, json.JSONDecodeError):
client_logger.critical('Потеряно соединение с сервером.')
exit(1)
def listen_forever(self):
self.sock_server.listen(15)
self.sock_server.settimeout(0.2)
while True:
try:
conn, addr = self.sock_server.accept(
) # Принять запрос на соединение
presence = get_message(conn)
print('<presence>:', presence)
responce = presence_response(presence)
send_message(conn, responce)
except OSError as e:
pass
else:
print('Получен запрос на соеденение: %s' % str(addr))
self.clients.append(conn)
print('<client_list>:', self.clients)
finally:
# Проверить наличие событий ввода-вывода
wait = 0
r = []
w = []
try:
r, w, e = select.select(self.clients, self.clients, [],
wait)
except:
pass # Ничего не делать, если какой-то клиент отключился
requests = self.handler.read_requests(
r, self.clients) # Получаем входные сообщения
self.handler.write_responses(
requests, w,
self.clients) # Выполним отправку входящих сообщений
def __process_message(message, names, listen_sockets):
if message[DESTINATION] in names and names[
message[DESTINATION]] in listen_sockets:
send_message(names[message[DESTINATION]], message)
elif message[DESTINATION] in names and names[
message[DESTINATION]] not in listen_sockets:
raise ConnectionError
def send_message(self, jsonmsg, group=None):
""" Отправляет сообщения на сервер.
:param jsonmsg: отправляемое сообщение
:return: длина отправленного сообщения (для тестирования)
"""
utils.send_message(self.s, jsonmsg, group)
return len(jsonmsg)
def send_crypto(self, to, pub_key):
try:
message = JimMessageCrypto(to, self.login, pub_key)
send_message(self.sock, message.to_dict())
print("send_crypto: Сообщение отправлено! {}".format(
message.to_dict()))
except Exception as e:
print("Ошибка в функции client.send_crypto:", e)
def get_contacts(self):
jimmessage = JimGetContacts(self.login)
send_message(self.sock, jimmessage.to_dict())
response = self.request_queue.get()
response.quantity
massege = self.request_queue.get()
contacts = massege.user_id
return contacts
def del_contact(self, username):
# будем удалять контакт
message = JimDelContact(self.login, username)
send_message(self.sock, message.to_dict())
# получаем ответ от сервера
#response = get_message(self.sock)
#response = Jim.from_dict(response)
response = self.request_queue.get()
return response
def write_messages(self, service):
"""Клиент пишет сообщение в бесконечном цикле"""
while True:
# Вводим сообщение с клавиатуры
text = input(':)>')
# Создаем jim сообщение
message = self.create_message('#all', text)
# отправляем на сервер
send_message(service, message)
def send_get(self, message):
try:
send_message(self.sock, message)
resp = get_message(self.sock)
# resp = self.translate_message(resp)
print('Ответ сервера: ', resp)
return resp
except Exception as e:
print(e)
def write_messages(client):
"""Клиент пишет сообщение в бесконечном цикле"""
while True:
# Вводим сообщение с клавиатуры
text = input(':)>')
# Создаем jim сообщение
message = create_message('to all', text)
#print(client)
# отправляем на сервер
send_message(client, message)
def get_client_contacts(self):
get_contacts_msg = JIMMsg(action='get_contacts').msg
utils.send_message(self.client.s, get_contacts_msg)
accept = utils.get_message(self.client.s)
contacts = utils.get_message(self.client.s)['message']
# if accept['quantity']:
# print('Ваши контакты: ')
# for i in range(accept['quantity']):
# print(utils.get_message(self.client.s)['user']['account_name'])
return contacts
def change_avatar(self, avatar_path):
message = {
ACTION: 'change_avatar',
TIME: time.time(),
ACCOUNT_NAME: self.login,
AVATAR: avatar_path
}
send_message(self.sock, message)
rsp_ch_avatar = self.request_queue.get()
return rsp_ch_avatar
def test_send_message(monkeypatch):
# подменяем настоящий сокет нашим классом заглушкой
monkeypatch.setattr("socket.socket", ClientSocket)
# зоздаем сокет, он уже был подменен
sock = socket.socket()
# т.к. возвращаемого значения нету, можно просто проверить, что метод отрабатывает без ошибок
assert send_message(sock, {'test': 'test'}) is None
# и проверяем, чтобы обязательно передавали словарь на всякий пожарный
with raises(TypeError):
send_message(sock, 'test')
def write_responses(self, messages, w_clients, all_clients):
for sock in w_clients:
for message in messages:
try:
send_message(sock, message)
except:
print('Клиент {} {} отключился'.format(
sock.fileno(), sock.getpeername()))
sock.close()
all_clients.remove(sock)
def create_del_contact(self, nickname):
message = {
ACTION: 'del_contact',
TIME: time.time(),
ACCOUNT_NAME: self.login,
USER_ID: nickname
}
send_message(self.sock, message)
resp1 = self.request_queue.get()
print(resp1)
return resp1
def mainloop(self):
"""
Основной цикл обработки запросов клиентов
:return:
"""
try:
while True:
try:
# Принимаю соединения
client, address = self._sock.accept()
# accept() - блокирует приложение до тех пор, пока не придет сообщение от клиента.
# Функция возвращает кортеж из двух параметров – объект самого соединения и адрес клиента.
# Сохраняю адрес клиента для протоколов идентификации
self.client_info = address
except OSError as e:
pass
else:
print("Получен запрос на соединение от {}".format(address))
# Принимаю сообщение о присутствии от клиента
presence = get_message(client)
# публикую в консоль сервера данные о присутствии клиента
print(self.past_time_to_dict(presence))
# Формирую ответ-подтвердение регистрации присутствия клиента
response = self.presence_response(presence)
# Отправляю ответ клиенту
send_message(client, response)
# добавляю информацию о присоединевшемся клиента в список
self._clients.append(client)
finally:
# Список read-клиентов
r = []
# Список write-клиентов
w = []
try:
# Функция опроса устройств
r, w, e = select.select(self._clients, self._clients,
[], 0)
except Exception as e:
pass
# проверка списка читающих клиентов
for client in r:
# от появившихся принять сообщение и сохранить на сервере
self.read(client)
# Если есть сохраненные сообщения
if self._requests:
# collections.popleft() - удаляет и возвращает первый элемент очереди
requests = self._requests.popleft()
# проверка списка пишущих клиентов
for client in w:
# всем в списке разослать сохраненное сообщение
self.write(client, requests)
except KeyboardInterrupt:
pass
def send_messange():
try:
current_item = ui.listWidgetContacts.currentItem()
username = current_item.text()
text = ui.lineEditMsg.text()
if text:
send_message(client.sock, create_message(username, login, text))
msg = '{} >> {}'.format(login, text)
ui.listWidgetChat.addItem(msg)
ui.lineEditMsg.clear()
except Exception as e:
print(e)
def write(self, client, requests):
"""
Метод пересылает сообщение read-клиентам
:param client: сокеты read-клиентов
:param requests: сообщение от write-клиента
:return:
"""
try:
# Отправляю сообщение
send_message(client, requests)
# При разрыве соедиения с клиентом исключить из общего списка
except (ConnectionResetError, BrokenPipeError):
if client in self._clients:
self._clients.remove(client)
def send_person(self):
while True:
self.create_person()
presence = self.create_presence()
send_message(self.sock, presence)
responce = get_message(self.sock)
responce = self.translate_response(responce)
if responce['response'] == OK:
print('профиль добавлен')
break
elif responce['response'] == ACCOUNT_ERROR:
print('Такой пользователь уже есть')
else:
print(responce)
def write(self):
"""
консоль для ввода сообщений
:return:
"""
try:
while True:
# ввести сообщение
message = input('Введите текст сообщения: ')
# упаовать сообщение в словарь структуры jim
message_dict = self.add_message_to_dict(message)
# отправить сообщение на сервер
send_message(self.sock, message_dict)
except KeyboardInterrupt:
pass
def get_contacts(self):
try:
# запрос на список контактов
jimmessage = JimGetContacts(self.login)
# отправляем
send_message(self.sock, jimmessage.to_dict())
# получаем ответ
response = self.request_queue.get()
quantity = response.quantity
# получаем имена одним списком
message = self.request_queue.get()
# возвращаем список имен
contacts = message.user_id
return contacts, quantity
except Exception as e:
print("Ошибка в функции get_contacts:", e)
def connect(self):
# Соединиться с сервером
try:
#self.sock = socket(AF_INET, SOCK_STREAM)
#self.sock = ssl.wrap_socket(socket(AF_INET, SOCK_STREAM), 'server.key', 'server.crt', True)
self.sock = socket(AF_INET, SOCK_STREAM)
self.sock = ssl.wrap_socket(self.sock,
ssl_version=ssl.PROTOCOL_SSLv3)
self.sock.connect((self.addr, self.port))
# Аутентификация на сервере
client_authenticate(self.sock, secret_key)
# Создаем сообщение
presence = self.create_presence()
# Отсылаем сообщение
print(send_message(self.sock, presence))
# Получаем ответ
response = get_message(self.sock)
# Проверяем ответ
response = self.translate_response(response)
print("Ответ сервера: ", response)
return response
except ConnectionRefusedError as e:
print(e)
raise e
except Exception as e:
print("Ошибка в функции connect:", e)
def write_responses(messages):
"""
Отправка сообщений тем клиентам, которые их ждут
:param messages: список сообщений
:param w_clients: клиенты которые читают
:param all_clients: все клиенты
:return:
"""
for message, sender in messages:
if message['action'] == MSG:
# получаем кому отправить сообщение
to = message['to']
sock = names[to]
msg = message['message']
send_message(sock, message)
def listen_forever(self):
# запускаем цикл обработки событиц много клиентов
self.sock.listen(15)
self.sock.settimeout(0.2)
print('Сервер запущен')
while True:
try:
conn, addr = self.sock.accept() # Проверка подключений
# Аутентификация клиента
if not server_authenticate(conn, secret_key):
# Если не наш то закрываем соединение
conn.close()
return
else:
# получаем сообщение от клиента
presence = get_message(conn)
print("presence сообщение: ", presence)
# формируем ответ
response, client_name = self.handler.presence_response(
presence, conn)
# отправляем ответ клиенту
send_message(conn, response)
except OSError as e:
pass # timeout вышел
else:
print("Получен запрос на соединение от %s" % str(addr))
# Добавляем клиента в список
self.clients.append(conn)
self.names[client_name] = conn
print('Подключился {}'.format(client_name))
finally:
# Проверить наличие событий ввода-вывода
wait = 0
r = []
w = []
try:
r, w, e = select.select(self.clients, self.clients, [],
wait)
except:
pass # Ничего не делать, если какой-то клиент отключился
requests = self.handler.read_requests(
r, self.clients) # Получаем входные сообщения
self.handler.write_responses(
requests, self.names,
self.clients) # Выполним отправку входящих сообщений
def send_client():
try:
presence = client.create_presence()
send_message(client.sock, presence)
responce = get_message(client.sock)
responce = client.translate_response(responce)
if responce['response'] == OK:
error ='Accept'
open_chat()
in_window.close()
elif responce['response'] == ACCOUNT_ERROR:
error ='This user name already exist'
else:
error = responce
in_window.CrText.addItem(error)
except Exception as e:
in_window.CrText.addItem(e)
def log_in(self):
while True:
self.login = input('login')
self.password = input('password')
mes = self.get_passw()
print(mes)
send_message(self.sock, mes)
resp = get_message(self.sock)
if resp[RESPONSE] == OK:
code = self.sock.recv(32)
messege = self.hash_resp(code)
self.sock.send(messege)
responce = get_message(self.sock)
responce = self.translate_response(responce)
if responce[RESPONSE] == OK:
print('ok')
break
else:
print(resp[RESPONSE])
def write_responses(messages, w_clients, all_clients):
"""
Отправка сообщений тем клиентам, которые их ждут
:param messages: список сообщений
:param w_clients: клиенты которые читают
:param all_clients: все клиенты
:return:
"""
for sock in w_clients:
# Будем отправлять каждое сообщение всем
for message in messages:
try:
# Отправить на тот сокет, который ожидает отправки
send_message(sock, message)
except: # Сокет недоступен, клиент отключился
print('Клиент {} {} отключился'.format(sock.fileno(), sock.getpeername()))
sock.close()
all_clients.remove(sock)
def user_interactive(self, sock, name_from, name_to):
"""
Метод интерактивной работы с клиентом
Вывод подсказок, завершение работы скрипта и отправка сообщений
:param sock:
:param name_from:
:param name_to:
:return: None
"""
self.print_help()
while True:
message = input(f'[{name_from} (Вы)]:\n')
if message == '#help':
self.print_help()
elif message == '#exit':
send_message(sock, self.__create_exit_message(name_from))
print(f'Чат завершен, {name_from} вышел')
client_logger.info(
'Завершение работы по команде пользователя.')
time.sleep(0.5)
break
else:
self.create_message(sock, name_from, name_to, message)
def create_add_contact(self, nickname):
# Если имя не строка
if not isinstance(nickname, str):
# Генерируем ошибку передан неверный тип
raise TypeError
# Если длина имени пользователя больше 25 символов
if len(nickname) > 25:
# генерируем нашу ошибку имя пользователя слишком длинное
raise UsernameToLongError(nickname)
# формируем словарь сообщения
try:
message = {
ACTION: 'add_contact',
TIME: time.time(),
ACCOUNT_NAME: self.login,
USER_ID: nickname
}
send_message(self.sock, message)
rsp = self.request_queue.get()
print(rsp)
return rsp
except Exception as e:
print(e)