def main():
client_args = parse_client_args()
if client_args.v == 0:
LOG.setLevel(logging.INFO)
LOG.debug('create socket')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as srv_socket:
LOG.debug('connect to %(a)s:%(p)s', vars(client_args))
srv_socket.connect((client_args.a, client_args.p))
# presence надо отправить в любом случае - слушаем мы или отправляем
LOG.debug('create presence')
presence = get_jim_presence(client_args.u)
LOG.debug('send presence: %s', presence)
send_message(srv_socket, presence)
srv_msg = process_srv_msg(get_message(srv_socket))
LOG.info(srv_msg)
while True:
if client_args.s:
msg_to_srv = ''
while msg_to_srv.strip() == '':
msg_to_srv = input('Введите сообщение для отправки:')
if msg_to_srv == 'exit':
return
LOG.debug('send msg: %s', msg_to_srv)
send_message(srv_socket,
get_jim_send_msg(msg_to_srv, client_args.u, None))
else:
try:
srv_msg = process_srv_msg(get_message(srv_socket))
LOG.info(srv_msg)
except (ValueError, json.JSONDecodeError):
LOG.error('Не удалось обработать ответ сервера')
def test_get_message(self):
test_sock_ok = TestSocket(self.test_dict_receive_ok)
test_sock_error = TestSocket(self.test_dict_receive_error)
# проверка корректного получения корректного сообщения
self.assertEqual(get_message(test_sock_ok), self.test_dict_receive_ok)
# проверка корректного получения некорректного сообщения
self.assertEqual(get_message(test_sock_error),
self.test_dict_receive_error)
def test_get_message(self):
"""тест приёма"""
# создадим тестовый сокет, с разными ответами
testing_socket_with_ok = DummySocket(self.standart_answer_ok)
testing_socket_with_error = DummySocket(self.standart_answer_error)
# тестируем функцию на приём ответа
self.assertEqual(get_message(testing_socket_with_ok),
self.standart_answer_ok)
self.assertEqual(get_message(testing_socket_with_error),
self.standart_answer_error)
def main():
"""Загружаем параметы коммандной строки"""
# client.py 192.168.1.2 8079
"""Загружаем параметы коммандной строки"""
server_address, server_port, client_mode = arg_parser()
CLIENT_LOGGER.info(f'Запущен клиент с парамертами: адрес сервера: '
f'{server_address}, порт: {server_port}')
# Инициализация сокета и сообщение серверу о нашем появлении
try:
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect((server_address, server_port))
send_message(client_socket, create_new_presence())
answer = process_response_answer(get_message(client_socket))
CLIENT_LOGGER.info(f'Установлено соединение с сервером. Ответ сервера: {answer}')
print(f'Установлено соединение с сервером.')
except json.JSONDecodeError:
CLIENT_LOGGER.error('Не удалось декодировать полученную Json строку.')
sys.exit(1)
except ServerError as error:
CLIENT_LOGGER.error(f'При установке соединения сервер вернул ошибку: {error.text}')
sys.exit(1)
except ReqFieldMissingError as missing_error:
CLIENT_LOGGER.error(f'В ответе сервера отсутствует необходимое поле {missing_error.missing_field}')
sys.exit(1)
except ConnectionRefusedError:
CLIENT_LOGGER.critical(
f'Не удалось подключиться к серверу {server_address}:{server_port}, '
f'конечный компьютер отверг запрос на подключение.')
sys.exit(1)
else:
# Если соединение с сервером установлено корректно,
# начинаем обмен с ним, согласно требуемому режиму.
# основной цикл прогрммы:
if client_mode == 'send':
print('Режим работы - отправка сообщений.')
else:
print('Режим работы - приём сообщений.')
while True:
# режим работы - отправка сообщений
if client_mode == 'send':
try:
send_message(client_socket, create_message(client_socket))
except (ConnectionResetError, ConnectionError, ConnectionAbortedError):
CLIENT_LOGGER.error(f'Соединение с сервером {server_address} было потеряно.')
sys.exit(1)
# Режим работы приём:
if client_mode == 'listen':
try:
message_from_server(get_message(client_socket))
except (ConnectionResetError, ConnectionError, ConnectionAbortedError):
CLIENT_LOGGER.error(f'Соединение с сервером {server_address} было потеряно.')
sys.exit(1)
def test_get_message(self):
"""
Тест функции приёма сообщения
:return:
"""
test_sock_ok = TestSocket(self.test_dict_recv_ok)
test_sock_err = TestSocket(self.test_dict_recv_error)
# тест корректной расшифровки корректного словаря
self.assertEqual(get_message(test_sock_ok), self.test_dict_recv_ok)
# тест корректной расшифровки ошибочного словаря
self.assertEqual(get_message(test_sock_err), self.test_dict_recv_error)
def message_from_server(sock, my_username):
"""Функция - обработчик сообщений других пользователей, поступающих с сервера"""
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"\nПолучено сообщение от пользователя {message[SENDER]}:"
f"\n{message[MESSAGE_TEXT]}")
print(f"Получено сообщение от пользователя {message[SENDER]}:"
f"\n{message[MESSAGE_TEXT]}")
else:
print(f"Получено некорректное сообщение с сервера: {message}")
except IncorrectDataRecivedError:
print(f"Не удалось декодировать полученное сообщение.")
except (
OSError,
ConnectionError,
ConnectionAbortedError,
ConnectionResetError,
json.JSONDecodeError,
):
print(f"Потеряно соединение с сервером.")
break
def test_get_message(self):
test_message = {"response": "200", "alert": "test"}
test_socket = TestSocket(test_message)
self.assertEqual(get_message(test_socket, self.CONFIGS), {
'response': '200',
'alert': 'test'
})
def main():
srv_args = parse_srv_args()
if srv_args.v == 0:
LOG.setLevel(logging.INFO)
LOG.debug('create socket')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as transport:
transport.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
LOG.debug('bind socket to %(a)s:%(p)s', vars(srv_args))
transport.bind((srv_args.a, srv_args.p))
LOG.debug('start listening')
transport.listen(MAX_CONNECTIONS)
while True:
LOG.debug('waiting for client...')
client, client_addr = transport.accept()
with client:
try:
LOG.debug('get msg from %s', client)
msg_from_client = get_message(client)
LOG.info('msg: %s', msg_from_client)
LOG.debug('process_client_msg()')
response = process_client_msg(msg_from_client)
LOG.debug('send response: %s', response)
send_message(client, response)
except (ValueError, json.JSONDecodeError):
LOG.error('Принято некорректное сообщение от клиента.')
def get_users_message(user_socket, _user_name):
"""
Постоянное получение сообщений, так как для этого запускается в отдельном
потоке.
Проверка сообщений от пользователей, приходящих с сервера, на
соответствие протоколу JIM.
"""
while True:
try:
# получение сообщения из сокета
user_msg_from_server = get_message(user_socket)
# валидация
if parsing_response_of_users_message(user_msg_from_server,
_user_name):
LOGGER.debug(f'\nПолучено сообщение:'
f'{user_msg_from_server[MESSAGE_TEXT]}\n'
f' от пользователя:'
f'{user_msg_from_server[SENDER]}\n'
f'отправлено в {user_msg_from_server[TIME]}\n'
f'получено через '
f'{time.time() - user_msg_from_server[TIME]} '
f'сек.')
print(f'От:{user_msg_from_server[SENDER]} \n'
f'сообщение:{user_msg_from_server[MESSAGE_TEXT]}\n'
f'отправлено в {time.ctime(user_msg_from_server[TIME])}')
except (ConnectionError, ConnectionResetError, ConnectionRefusedError,
ConnectionAbortedError):
LOGGER.error(f'Потеря связи! Сервер '
f'{user_socket.getpeername()} '
f'не доступен.')
sys.exit(1)
def main():
'''
Загружаем параметы коммандной строки
'''
# client.py 192.168.1.2 8079
try:
server_address = sys.argv[1]
server_port = int(sys.argv[2])
if not 1023 < server_port < 65536:
LOGGER_CLIENT.critical(f'Запуск клиента с недопустимым портом {server_port} невозможен')
raise ValueError
LOGGER_CLIENT.debug(f'Клиент запущен по адресу {server_address} и порту {server_port}')
except IndexError:
server_address = DEFAULT_IP_ADDRESS
server_port = DEFAULT_PORT
LOGGER_CLIENT.debug(f'Используемся адрес {server_address} и порт {server_port} по умолчанию')
except ValueError:
LOGGER_CLIENT.info('В качестве порта может быть указано только число в диапазоне от 1024 до 65535.')
sys.exit(1)
# Инициализация сокета и обмен
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.connect((server_address, server_port))
message_to_server = create_presence()
send_message(transport, message_to_server)
LOGGER_CLIENT.debug(f'Отправили сообщение {message_to_server} на сервер')
try:
answer = process_ans(get_message(transport))
LOGGER_CLIENT.info(f'Получен ответ от сервера {answer}')
print(answer)
except (ValueError, json.JSONDecodeError):
LOGGER_CLIENT.error('Не удалось декодировать сообщение сервера.')
def run(self):
"""Метод содержащий основной цикл работы транспортного потока."""
client_logger.debug('Запущен процесс - приёмник собщений с сервера.')
while self.running:
# Отдыхаем секунду и снова пробуем захватить сокет.
# если не сделать тут задержку, то отправка может достаточно долго
# ждать освобождения сокета.
time.sleep(1)
message = None
with socket_lock:
try:
self.transport.settimeout(0.5)
message = get_message(self.transport, CONFIGS)
except OSError as err:
if err.errno:
client_logger.critical(
f'Потеряно соединение с сервером.')
self.running = False
self.connection_lost.emit()
# Проблемы с соединением
except (ConnectionError, ConnectionAbortedError,
ConnectionResetError, json.JSONDecodeError, TypeError):
client_logger.debug(f'Потеряно соединение с сервером.')
self.running = False
self.connection_lost.emit()
finally:
self.transport.settimeout(5)
# Если сообщение получено, то вызываем функцию обработчик:
if message:
client_logger.debug(
f'Принято сообщение с сервера: {message}')
self.process_server_ans(message)
def main():
parser = create_argument_parser()
namespace = parser.parse_args(sys.argv[1:])
server_address = namespace.addr
server_port = namespace.port
if not 1023 < server_port < 65536:
logging_client.critical(
f'Попытка запуска клиента с неподходящим номером порта: {server_port}.'
f' Допустимы адреса с 1024 до 65535. Клиент завершается.')
sys.exit(1)
logging_client.info(
f'Запущен клиент с парамертами: '
f'адрес сервера: {server_address}, порт: {server_port}')
try:
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.connect((server_address, server_port))
message_to_server = create_presence()
send_message(transport, message_to_server)
answer = process_answer(get_message(transport))
logging_client.info(f'Принят ответ от сервера {answer}')
print(answer)
except json.JSONDecodeError:
logging_client.error('Не удалось декодировать полученную Json строку.')
except RequiredFieldMissingError as missing_error:
logging_client.error(f'В ответе сервера отсутствует необходимое поле '
f'{missing_error.missing_field}')
except ConnectionRefusedError:
logging_client.critical(
f'Не удалось подключиться к серверу {server_address}:{server_port}, '
f'конечный компьютер отверг запрос на подключение.')
def run(self):
"""Функция содержащая основной цикл работы транспортного потока."""
LOGGER.debug('Запущен процесс приема сообщений с сервера')
while self.running:
time.sleep(1)
with sock_lock:
try:
self.transport.settimeout(0.5)
message = get_message(self.transport)
except OSError as e:
if e.errno:
LOGGER.critical(f'Соединение с сервером потеряно')
self.running = False
self.connection_lost.emit()
except IncorrectDataRecivedError:
LOGGER.error(f'Не удалось декодировать сообщение')
except (ConnectionError, ConnectionAbortedError, ConnectionResetError, json.JSONDecodeError, TypeError):
LOGGER.critical(f'Соединение с сервером потеряно')
self.running = False
self.connection_lost.emit()
finally:
self.transport.settimeout(1)
# Если сообщение получено, то вызываем функцию обработчик:
if message:
LOGGER.debug(f'Принято сообщение с сервера: {message}')
self.process_ans(message)
def test_get_message():
test_message = {"response": "200", "alert": "test"}
test_socket = Test_Socket(test_message)
assert get_message(test_socket, CONFIGS) == {
"response": "200",
"alert": "test"
}
def run(self):
"""Basic function to run server."""
self.init_socket()
while self.running:
try:
client, client_address = self.sock.accept()
except OSError:
pass
else:
logger.info(f'Applied connection from {client_address}')
client.settimeout(5)
self.clients.append(client)
recv_data_lst = []
send_data_lst = []
err_lst = []
try:
if self.clients:
recv_data_lst, self.listen_sockets, self.error_sockets = select.select(
self.clients, self.clients, [], 0)
except OSError as err:
logger.error(f'Socket Error: {err.errno}')
if recv_data_lst:
for client_with_message in recv_data_lst:
try:
self.process_client_message(
get_message(client_with_message),
client_with_message)
except (OSError, json.JSONDecodeError, TypeError):
self.remove_client(client_with_message)
def main():
"""
Основная функция клиента, связывается с сервером, отправляет ему сообщение
и получает ответ от него.
:return: None
"""
try:
server_address = sys.argv[1]
server_port = int(sys.argv[2])
if server_port < 1024 or server_port > 65535:
raise ValueError
except IndexError:
server_address = DEFAULT_IP_ADDRESS
server_port = DEFAULT_PORT
except ValueError:
print('В качестве порта может быть указано значение от 1024 до 65535.')
sys.exit(1)
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect((server_address, server_port))
message_to_server = create_message(PRESENCE)
send_message(client_socket, message_to_server)
try:
answer = get_answer(get_message(client_socket))
print(f'Server answer: {answer}')
except (ValueError, json.JSONDecodeError):
print('Не удалось декодировать сообщение сервера.')
def main():
"""Загружаем параметы коммандной строки"""
parser = create_arg_parser()
namespace = parser.parse_args(sys.argv[1:])
server_address = namespace.addr
server_port = namespace.port
# проверим подходящий номер порта
if not 1023 < server_port < 65536:
LOGGER.critical(
f'Попытка запуска клиента с неподходящим номером порта: {server_port}. '
f'Допустимы адреса с 1024 до 65535. Клиент завершается.')
sys.exit(1)
LOGGER.info(f'Запущен клиент с парамертами: адрес сервера: '
f'{server_address}, порт: {server_port}')
# Инициализация сокета и обмен
try:
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.connect((server_address, server_port))
message_to_server = create_presence()
send_message(transport, message_to_server)
answer = process_ans(get_message(transport))
LOGGER.info(f'Принят ответ от сервера {answer}')
except json.JSONDecodeError:
LOGGER.error('Не удалось декодировать полученную Json строку.')
except ReqFieldMissingError as missing_error:
LOGGER.error(
f'В ответе сервера отсутствует необходимое поле {missing_error.missing_field}'
)
except ConnectionRefusedError:
LOGGER.critical(
f'Не удалось подключиться к серверу {server_address}:{server_port}, '
f'конечный компьютер отверг запрос на подключение.')
def test_send_message_ok(self):
msg = {'tst_key': 'tst_value ₽'}
send_message(self.client_socket, msg)
# будем считать, что если тесты выше пройдены - то get_message работает нормально
incoming_msg = get_message(self.client_to_srv)
self.assertEqual(incoming_msg, msg)
def run(self):
"""Основной цикл работы потока"""
client_logger.debug('Запущен процесс - приёмник собщений с сервера.')
while self.running:
time.sleep(1)
message = None
with socket_lock:
try:
self.client_sock.settimeout(0.5)
message = get_message(self.client_sock)
except OSError as err:
if err.errno:
client_logger.critical(
f'Потеряно соединение с сервером.')
self.running = False
self.connection_lost.emit()
except (ConnectionError, ConnectionAbortedError,
ConnectionResetError, json.JSONDecodeError, TypeError):
client_logger.debug(f'Потеряно соединение с сервером.')
self.running = False
self.connection_lost.emit()
finally:
self.client_sock.settimeout(5)
if message:
client_logger.debug(f'Принято сообщение с сервера: {message}')
self.server_response_handler(message)
def run(self):
"""Метод основной цикл потока."""
self.init_socket()
while self.running:
try:
client, client_address = self.sock.accept()
except OSError:
pass
else:
logger.info(f'Установлено соедение с ПК {client_address}')
client.settimeout(5)
self.clients.append(client)
recv_data_lst = []
send_data_lst = []
err_lst = []
try:
if self.clients:
recv_data_lst, self.listen_sockets, self.error_sockets = select.select(
self.clients, self.clients, [], 0)
except OSError as err:
logger.error(f'Ошибка работы с сокетами: {err.errno}')
if recv_data_lst:
for client_with_message in recv_data_lst:
try:
self.process_client_message(
get_message(client_with_message),
client_with_message)
except (OSError, json.JSONDecodeError, TypeError):
self.remove_client(client_with_message)
def get_user_answer(self, sock):
"""Обрабатка сообщения сервера"""
CLIENT_LOG.debug('Обрабатка сообщения сервера')
while True:
try:
message = get_message(sock)
if ACTION in message and message[ACTION] == MSG and \
SENDER in message and TO in message and \
MESSAGE in message and \
message[TO] == self.account_name:
time_mess = datetime.fromtimestamp(message[TIME]).\
strftime("%H:%M:%S")
user_msg = f'[{time_mess}] {message[SENDER]}: \
{message[MESSAGE]}'
print(f'{user_msg}')
CLIENT_LOG.info(f'{user_msg}')
else:
CLIENT_LOG.debug(f'Некорректное сообщение от сервера: \
{message}')
CLIENT_LOG.critical('Принято некорректное сообщение от \
сервера: {message}')
except (OSError, ConnectionError, ConnectionAbortedError,
ConnectionResetError, json.JSONDecodeError):
CLIENT_LOG.critical(f'Потеряно соединение с сервером.')
break
def __call__(self):
print(f'Клиент с ником: {self.account_name}')
try:
CLIENT = socket(AF_INET, SOCK_STREAM)
CLIENT.connect((self.address, self.port))
send_message(CLIENT, self.create_presence())
answer = self.process_answer(get_message(CLIENT))
CLIENT_LOG.info(f'Установлено соединение с сервером: {answer}')
print('Установлено соединение с сервером')
except json.JSONDecodeError:
CLIENT_LOG.error('Не удалось декодировать JSON строку')
sys.exit(1)
except (ConnectionRefusedError, ConnectionError):
CLIENT_LOG.error(f'Не удалось подключиться к серверу \
{self.address}:{self.port}')
sys.exit(1)
else:
receiver = Thread(target=self.get_user_answer, args=(CLIENT, ))
receiver.daemon = True
receiver.start()
self.user_interface = Thread(target=self.user_interactive,
args=(CLIENT, ))
self.user_interface.daemon = True
self.user_interface.start()
CLIENT_LOG.info('Запущены потоки')
while True:
sleep(1)
if receiver.is_alive() and self.user_interface.is_alive():
continue
break
def main():
'''
Загружаем параметы коммандной строки
:return:
'''
try:
server_address = sys.argv[1]
server_port = int(sys.argv[2])
if server_port < 1024 or server_port > 65535:
raise ValueError
except IndexError:
server_address = DEFAULT_IP_ADDRESS
server_port = DEFAULT_PORT
except ValueError:
print(
'В качастве порта может быть указано только число в диапазоне от 1024 до 65535.'
)
sys.exit(1)
# Инициализация сокета и обмен
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.connect((server_address, server_port))
message_to_server = create_presence()
send_message(transport, message_to_server)
try:
answer = process_ans(get_message(transport))
print(answer)
except (ValueError, json.JSONDecodeError):
print('Не удалось декодировать сообщение сервера.')
def main_loop(self):
client_args = parse_client_args()
if client_args.v != 0:
LOG.setLevel(logging.DEBUG)
LOG.debug('create socket')
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as srv_socket:
LOG.debug('connect to %(a)s:%(p)s', vars(client_args))
srv_socket.connect((client_args.a, client_args.p))
# presence надо отправить в любом случае - слушаем мы или отправляем
LOG.debug('create presence')
presence = get_jim_presence(client_args.u)
LOG.debug('send presence: %s', presence)
send_message(srv_socket, presence)
srv_msg = self.process_srv_msg(get_message(srv_socket))
LOG.info(srv_msg)
LOG.debug('Create input_thread')
input_thread = Thread(target=self.processing_input, args=(srv_socket, client_args.u))
input_thread.daemon = True
input_thread.start()
LOG.debug('input_thread started')
LOG.debug('Create output_thread')
output_thread = Thread(target=self.processing_output, args=(srv_socket, client_args.u))
output_thread.daemon = True
output_thread.start()
LOG.debug('output_thread started')
while True:
sleep(1)
if input_thread.is_alive() and output_thread.is_alive():
continue
break
def run(self):
# Инициализация Сокета
self.init_socket()
# Основной цикл программы сервера
while self.running:
# Ждём подключения, если таймаут вышел, ловим исключение.
try:
client, client_address = self.sock.accept()
except OSError:
pass
else:
logger.info(f'Установлено соедение с ПК {client_address}')
client.settimeout(5)
self.clients.append(client)
recv_data_lst = []
send_data_lst = []
err_lst = []
# Проверяем на наличие ждущих клиентов
try:
if self.clients:
recv_data_lst, self.listen_sockets, self.error_sockets = select.select(
self.clients, self.clients, [], 0)
except OSError as err:
logger.error(f'Ошибка работы с сокетами: {err.errno}')
# принимаем сообщения и если ошибка, исключаем клиента.
if recv_data_lst:
for client_with_message in recv_data_lst:
try:
self.process_client_message(get_message(client_with_message), client_with_message)
except (OSError, json.JSONDecodeError, TypeError):
self.remove_client(client_with_message)
def main():
'''
Загрузка параметров командной строки, если нет параметров, то задаём значения по умоланию.
Сначала обрабатываем порт:
server.py -p 8079 -a 192.168.1.2
:return:
'''
try:
if '-p' in sys.argv:
listen_port = int(sys.argv[sys.argv.index('-p') + 1])
else:
listen_port = DEFAULT_PORT
if listen_port < 1024 or listen_port > 65535:
raise ValueError
except IndexError:
print('После параметра -\'p\' необходимо указать номер порта.')
sys.exit(1)
except ValueError:
print(
'В качастве порта может быть указано только число в диапазоне от 1024 до 65535.'
)
sys.exit(1)
# Затем загружаем какой адрес слушать
try:
if '-a' in sys.argv:
listen_address = sys.argv[sys.argv.index('-a') + 1]
else:
listen_address = ''
except IndexError:
print(
'После параметра \'a\'- необходимо указать адрес, который будет слушать сервер.'
)
sys.exit(1)
# Готовим сокет
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.bind((listen_address, listen_port))
# Слушаем порт
transport.listen(MAX_CONNECTIONS)
while True:
client, client_address = transport.accept()
try:
message_from_cient = get_message(client)
print(message_from_cient)
# {'action': 'presence', 'time': 1573760672.167031, 'user': {'account_name': 'Guest'}}
response = process_client_message(message_from_cient)
send_message(client, response)
client.close()
except (ValueError, json.JSONDecodeError):
print('Принято некорретное сообщение от клиента.')
client.close()
def test_get_message_ok(self):
msg = {'tst_key': 'tst_value ₽'}
json_msg = json.dumps(msg)
outcoming_encoded_msg = json_msg.encode(ENCODING)
self.client_socket.send(outcoming_encoded_msg)
incoming_msg = get_message(self.client_to_srv)
self.assertEqual(incoming_msg, msg)
def main():
'''
Загружаем параметы коммандной строки
'''
server_address, server_port, client_mode = arg_parser()
LOGGER_CLIENT.info(f'Запущен клиент с адресом сервера: {server_address}, '
f'портом: {server_port} и режимом работы: {client_mode}')
try:
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transport.connect((server_address, server_port))
send_message(transport, create_presence())
answer = process_ans(get_message(transport))
LOGGER_CLIENT.info(f'Установлено соединение с сервером. Ответ сервера: {answer}')
print(f'Установлено соединение с сервером.')
except json.JSONDecodeError:
LOGGER_CLIENT.error('Не удалось декодировать полученную Json строку.')
sys.exit(1)
except ServerError as error:
LOGGER_CLIENT.error(f'При установке соединения сервер вернул ошибку: {error.text}')
sys.exit(1)
except ReqFieldMissingError as missing_error:
LOGGER_CLIENT.error(f'В ответе сервера отсутствует необходимое поле {missing_error.missing_field}')
sys.exit(1)
except ConnectionRefusedError:
LOGGER_CLIENT.critical(
f'Не удалось подключиться к серверу {server_address}:{server_port}')
sys.exit(1)
else:
if client_mode == 'send':
print('Режим работы - отправка сообщений.')
else:
print('Режим работы - приём сообщений.')
while True:
if client_mode == 'send':
try:
send_message(transport, create_message(transport))
except (ConnectionResetError, ConnectionError, ConnectionAbortedError):
LOGGER_CLIENT.error(f'Соединение с сервером {server_address} было потеряно.')
sys.exit(1)
if client_mode == 'listen':
try:
message_from_server(get_message(transport))
except (ConnectionResetError, ConnectionError, ConnectionAbortedError):
LOGGER_CLIENT.error(f'Соединение с сервером {server_address} было потеряно.')
sys.exit(1)
def autorize_user(self, message, sock):
"""Authorize function. Receive a values from client.
Send a result of authorizing.
"""
if message[USER][ACCOUNT_NAME] in self.names.keys():
response = RESPONSE_400
response[ERROR] = 'Username is already exists'
try:
send_message(sock, response)
except OSError:
pass
self.clients.remove(sock)
sock.close()
elif not self.database.check_user(message[USER][ACCOUNT_NAME]):
response = RESPONSE_400
response[ERROR] = "User is not registered"
try:
send_message(sock, response)
except OSError:
pass
self.clients.remove(sock)
sock.close()
else:
message_auth = RESPONSE_511
random_str = binascii.hexlify(os.urandom(64))
message_auth[DATA] = random_str.decode('ascii')
hash = hmac.new(
self.database.get_hash(message[USER][ACCOUNT_NAME]),
random_str)
digest = hash.digest()
try:
send_message(sock, message_auth)
ans = get_message(sock)
except OSError:
sock.close()
return
client_digest = binascii.a2b_base64(ans[DATA])
if RESPONSE in ans and ans[RESPONSE] == 511 and hmac.compare_digest(
digest, client_digest):
self.names[message[USER][ACCOUNT_NAME]] = sock
client_ip, client_port = sock.getpeername()
try:
send_message(sock, RESPONSE_200)
except OSError:
self.remove_client(message[USER][ACCOUNT_NAME])
self.database.user_login(message[USER][ACCOUNT_NAME],
client_ip, client_port,
message[USER][PUBLIC_KEY])
else:
response = RESPONSE_400
response[ERROR] = 'Incorrect password'
try:
send_message(sock, response)
except OSError:
pass
self.clients.remove(sock)
sock.close()
def main():
'''Загружаем параметы коммандной строки'''
if '-a' in sys.argv:
server_address = sys.argv[sys.argv.index('-a') + 1]
else:
server_address = DEFAULT_IP
CLIENT_LOGGER.info(
f'Не найден параметр -\'a\'.'
f'Установлено стандартное значение IP адреса: {server_address}')
if '-p' in sys.argv:
server_port = int(sys.argv[sys.argv.index('-p') + 1])
else:
server_port = DEFAULT_PORT
CLIENT_LOGGER.info(
f'Не найден параметр -\'p\'.'
f'Установлено стандартное значение порта: {server_port}')
try:
# Проверка IP адреса, если не соответсвует регулярке то выкинет исключение AttributeError
[
0 <= int(x) < 256 for x in re.split(
'\.',
re.match(r'^\d+\.\d+\.\d+\.\d+$', server_address).group(0))
].count(True) == 4
if server_port < 1024 or server_port > 65535:
raise AttributeError
except AttributeError:
server_address = DEFAULT_IP
server_port = DEFAULT_PORT
CLIENT_LOGGER.critical(
f'Попытка запуска клиента с неподходящим номером порта или IP адреса.'
f'Установлены стандартные значения для '
f'подключения {server_port},{server_address}')
CLIENT_LOGGER.info(
f'Запущен клиент с парамертами: '
f'адрес сервера: {server_address} , порт: {server_port}')
# Инициализация сокета и обмен
transport = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
transport.connect((server_address, server_port))
except ConnectionRefusedError:
CLIENT_LOGGER.critical(
f'Не удалось подключиться к серверу {server_address}:{server_port}, '
f'конечный компьютер отверг запрос на подключение.')
sys.exit(1)
message_to_server = create_presence()
send_message(transport, message_to_server)
try:
answer = process_ans(get_message(transport))
CLIENT_LOGGER.info(f'Принят ответ от сервера {answer}')
except json.JSONDecodeError:
CLIENT_LOGGER.error('Не удалось декодировать полученную Json строку.')
except ReqFieldMissingError as error:
CLIENT_LOGGER.error(f'В ответе сервера отсутствует необходимое поле '
f'{error.missing_field}')
