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 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 write_messages(self, service):
"""Клиент пишет сообщение в бесконечном цикле"""
while True:
# Вводим сообщение с клавиатуры
text = input(':)>')
if text.startswith('list'):
# запрос на список контактов
jimmessage = JimGetContacts(self.login)
# отправляем
send_message(service, jimmessage.to_dict())
# получаем ответ
response = get_message(service)
# приводим ответ к ответу сервера
response = Jim.from_dict(response)
# там лежит количество контактов
quantity = response.quantity
# делаем цикл и получаем каждый контакт по отдельности
print('У вас ', quantity, 'друзей')
print('Вот они:')
for i in range(quantity):
message = get_message(service)
message = Jim.from_dict(message)
print(message.user_id)
else:
command, param = text.split()
if command == 'add':
# будем добавлять контакт
message = JimAddContact(self.login, param)
send_message(service, message.to_dict())
# получаем ответ от сервера
response = get_message(service)
response = Jim.from_dict(response)
if response.response == ACCEPTED:
print('Контакт успешно добавлен')
else:
print(response.error)
elif command == 'del':
# будем удалять контакт
message = JimDelContact(self.login, param)
send_message(service, message.to_dict())
# получаем ответ от сервера
response = get_message(service)
response = Jim.from_dict(response)
if response.response == ACCEPTED:
print('Контакт успешно удален')
else:
print(response.error)
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 read_requests(r_clients, all_clients):
"""
Чтение сообщений, которые будут посылать клиенты
:param r_clients: клиенты которые могут отправлять сообщения
:param all_clients: все клиенты
:return:
"""
# Список входящих сообщений
messages = []
for sock in r_clients:
try:
# Получаем входящие сообщения
message = get_message(sock)
print(message)
# Добавляем их в список
# В идеале нам нужно сделать еще проверку, что сообщение нужного формата прежде чем его пересылать!
# Пока оставим как есть, этим займемся позже
messages.append((message, sock))
except:
print('Клиент {} {} отключился'.format(sock.fileno(),
sock.getpeername()))
all_clients.remove(sock)
# Возвращаем словарь сообщений
return messages
def message_from_server(sock, my_username):
"""
Метод-обработчик сообщений других пользователей, поступающих от сервера
:param sock: socket (Сокет с сообщением)
:param my_username: str (Имя клиента, для которого сообщение)
:return: None
"""
while True:
try:
message = get_message(sock)
if ACTION in message \
and message[ACTION] == MESSAGE \
and SENDER in message \
and DESTINATION in message \
and MESSAGE_TEXT in message \
and message[DESTINATION] == my_username:
print(f'[Сообщение от "{message[SENDER]}"]:\n'
f'{message[MESSAGE_TEXT]}')
client_logger.info(
f'Получено сообщение от пользователя {message[SENDER]}:\n'
f'{message[MESSAGE_TEXT]}')
else:
client_logger.error(
f'Получено некорректное сообщение от сервера:\n{message}'
)
except IncorrectDataReceivedError:
client_logger.error(
'Не удалось декодировать полученное сообщение')
except (OSError, ConnectionError, ConnectionAbortedError,
ConnectionResetError, json.JSONDecodeError):
client_logger.critical(f'Потеряно соединение с сервером')
break
def test_get_message(monkeypatch):
# подменяем настоящий сокет нашим классом заглушкой
monkeypatch.setattr("socket.socket", ClientSocket)
# зоздаем сокет, он уже был подменен
sock = socket.socket()
# теперь можем протестировать работу метода
assert get_message(sock) == {'response': 200}
def poll(self):
self.is_alive = True
while True:
if not self.is_alive:
break
data = get_message(self.sock)
try:
# Преобразуем словарь в Jim, Это может быть action, а может быть response
jm = Jim.from_dict(data)
# Если это сообщение
if isinstance(jm, JimMessage):
self.process_message(jm)
elif isinstance(jm, JimPicture):
self.process_pictures(jm)
elif isinstance(jm, JimSendProfile):
self.process_profiles(jm)
else:
# Это либо ответ от сервера либо действия с контактами
# мы это складываем в очередь
self.request_queue.put(jm)
except Exception as e:
# Ошбики быть не должно так как сервер отправлять верные данные
# но лучше этот случай все равно обработать
# выведем ошибку, но лучше писать в будующем в log
print(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 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 read_messages(client, account_name):
"""
Клиент читает входящие сообщения в бесконечном цикле
:param client: сокет клиента
"""
while True:
# читаем сообщение
message = get_message(client)
print(message['message'])
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 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 read_messages(self, service):
"""
Клиент читает входящие сообщения в бесконечном цикле
:param client: сокет клиента
"""
while True:
# читаем сообщение
print('Читаю')
message = get_message(service)
print(message)
# там должно быть сообщение всем
print(message[MESSAGE])
async def read_requests(self, writers, clients):
responses = []
for sock in writers:
try:
messege = get_message(sock)
responses.append((messege, sock))
except:
text = 'Клиент {} {} отключился'.format(
sock.fileno(), sock.getpeername())
self.set_text(text)
clients.remove(sock)
return responses
def get_contacts(self):
message = {
ACTION: 'get_contacts',
TIME: time.time(),
ACCOUNT_NAME: self.login
}
rsp = self.send_get(message)
print('У вас : ', rsp['quantity'], 'контактов!')
print('Ваши контакты: ')
contacts = get_message(self.sock)
print(contacts['user_id'])
return contacts['user_id']
def read(self):
"""
чтение сообщений
:return:
"""
try:
while True:
# получаем сообщение сервера от пишущего клиента
message = get_message(self.sock)
# публикуем сообщение в консоли читающего клиента
print(message[cfg.TIME], message[cfg.MESSAGE])
except KeyboardInterrupt:
pass
def read_messages(self):
while True:
message = get_message(self.sock)
try:
if FROM in message:
print('{}:{}'.format(message[FROM], message[MESSAGE]))
elif RESPONSE in message:
print(message[RESPONSE])
elif CONTACT_LIST in message:
self.contacts.append(message[CONTACT_LIST])
print(message[CONTACT_LIST])
except:
print(message)
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 read_requests(self, r_clients, all_clients):
''' Чтение запросов из списка клиентов
'''
messages = []
for sock in r_clients:
try:
message = get_message(sock)
messages.append((message, sock))
except:
print('Клиент {} {} отключился'.format(sock.fileno(),
sock.getpeername()))
all_clients.remove(sock)
# print(messages)
return messages
def read_requests(self, r_clients, all_clients):
messages = []
for sock in r_clients:
try:
message = get_message(sock)
#
messages.append(message)
except:
print('Клиент {} {} отключился'.format(sock.fileno(),
sock.getpeername()))
all_clients.remove(sock)
return messages
def poll(self):
self.is_alive = True
while True:
if not self.is_alive:
break
message = get_message(self.sock)
print(message)
try:
if ACTION in message:
# print("\n>>", message)
# print('{} >> {}'.format(message[FROM], message[MESSAGE]))
self.process_message(message)
else:
self.request_queue.put(message)
except Exception as e:
print(e)
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 poll(self):
self.is_alive = True
while True:
if not self.is_alive:
break
data = get_message(self.sock)
#print("Пришли данные: ", data)
try:
jm = Jim.from_dict(data)
if isinstance(jm, JimMessage):
self.process_message(jm)
if isinstance(jm, JimMessageCrypto):
self.process_crypto(jm)
else:
self.request_queue.put(jm)
except TypeError as e:
print("Ошибка TypeError в функции Receiver.poll:", e)
except Exception as e:
print("Ошибка в функции Receiver.poll:", e)
def read(self, client):
"""
Метод получает сообщение write-клиента и сохраняет в _requests
:param client: сокет клиента
:return: выводит в консоль информацию Кто, Когда и Что отправил
"""
try:
# Получаю сообщение от клиента
message = get_message(client)
# Сохраняю сообщение в список
self._requests.append(message)
# Печатаю информацию в консоль сервера
print('[i] Сообщение от: {0}'
'\n=== Обработанно на сервере: {1}'
'\n=== Текст сообщения: {2}'.format(self.client_info, \
message[cfg.TIME], \
message[cfg.MESSAGE]))
# При разрыве соединения с клиентом исключить из общего списка
except (ConnectionResetError, BrokenPipeError):
if client in self._clients:
self._clients.remove(client)
def listen_forever(self):
# запускаем цикл обработки событиц много клиентов
self.sock.listen(15)
self.sock.settimeout(0.2)
while True:
try:
conn, addr = self.sock.accept() # Проверка подключений
# получаем сообщение от клиента
presence = get_message(conn)
# формируем ответ
response, client_name = self.handler.presence_response(presence)
# отправляем ответ клиенту
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 mainloop(self):
"""
основной цикл взаимодействия клиентов с сервером
:return:
"""
# формирую сообщение присутствия
message = self.presence_message()
# отправляюсообщение присутствия
send_message(self.sock, message)
while True:
# принимаю сообщение-ответ сервера
tm = get_message(self.sock)
# публикую сообщение-ответ сервера
print(self.decode_message(tm))
# Смотрим ключ запуска клиента
if self.type_clients() == '-r':
# запускаем клиент на прием сообщений в чате
self.read()
elif self.type_clients() == '-w':
# запускаем клиент на отправку сообщений в чате
self.write()
else:
pass
self.sock.close()
from jim.utils import send_message, get_message
from server.functions import *
if __name__ == '__main__':
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
addr = sys.argv[1]
except IndexError:
addr = ''
try:
port = int(sys.argv[2])
except IndexError:
port = 7777
except ValueError:
print('Порт должен быть целым числом')
sys.exit(0)
server.bind((addr, port))
server.listen(5)
while True:
client, addr = server.accept()
presence = get_message(client)
print(presence)
response = presence_response(presence)
send_message(client, response)
client.close()
#------------ip-адрес-----------#
# если ip-адрес указан в параметрах -p <addr>
try:
addr = sys.argv[1]
# если ip-адрес не указан в параметрах
except IndexError:
addr = 'localhost'
#--------------порт-------------#
# если порт указан в параметрах
try:
port = int(sys.argv[2])
# если порт не указан в параметрах
except IndexError:
port = 7777
# если порт - не целое число
except ValueError:
print('Порт должен быть целым числом')
sys.exit(0)
# ДАННЫЕ ПОЛУЧИЛИ -> СОЕДИНЯЕМСЯ С СЕРВЕРОМ
# Соединиться с сервером
client.connect((addr, port))
# Сформировать сообщение серверу
presence = create_presence()
# Отправить сообщение серверу
send_message(client, presence)
# Получить ответ сервера
response = get_message(client)
# Разобрать ответ сервера
response = translate_message(response)
print(response)
