def process_message(self, message):
"""
Метод отправки сообщения клиенту.
"""
if message[CONFIGS.get('TO_USER')] in self.names and self.names[
message[CONFIGS.get('TO_USER')]] in self.listen_sockets:
try:
send_message(
self.names[message[CONFIGS.get('TO_USER')]],
message,
CONFIGS
)
server_logger.info(
f'Отправлено сообщение пользователю '
f'{message[CONFIGS.get("TO_USER")]} '
f'от пользователя {message[CONFIGS.get("FROM_USER")]}.')
except OSError:
self.remove_client(message[CONFIGS.get('TO_USER')])
elif message[CONFIGS.get('TO_USER')] in self.names and self.names[
message[CONFIGS.get('TO_USER')]] not in self.listen_sockets:
server_logger.error(
f'Связь с клиентом {message[CONFIGS.get("TO_USER")]} '
f'была потеряна. '
f'Соединение закрыто, доставка невозможна.')
self.remove_client(self.names[message[CONFIGS.get('TO_USER')]])
else:
server_logger.error(
f'Пользователь {message[CONFIGS.get("TO_USER")]} '
f'не зарегистрирован на сервере, '
f'отправка сообщения невозможна.')
def processing_input(self, server_socket, client_name):
"""
По умолчанию - сообщение отправляется всем.
Для указания конкретного получателя:
- если пользователь - пишем его через @. Пример:
@user1 сообщение получит только user1
- если комната - пишем через #. Пример:
#room1 сообщение получат все участники комнаты room1
Управляющие команды начинаются с \\ (одиночный бэкслэш). Пример:
- \\q - выключить клиент
- \\j [#room_name] - подключиться к комнате #room_name
- \\l [#room_name] - выйти из комнаты #room_name
"""
while True:
msg_to_srv = ''
while msg_to_srv.strip() == '':
msg_to_srv = input()
if msg_to_srv.startswith('\\q'):
break
elif msg_to_srv.startswith('\\j'):
LOG.info('Извините. Функционал еще не поддерживается =(')
elif msg_to_srv.startswith('\\l'):
LOG.info('Извините. Функционал еще не поддерживается =(')
elif msg_to_srv.startswith('@'):
LOG.info('Извините. Функционал еще не поддерживается =(')
elif msg_to_srv.startswith('#'):
LOG.info('Извините. Функционал еще не поддерживается =(')
else:
LOG.debug('send msg to #all: %s', msg_to_srv)
send_message(server_socket, get_jim_send_msg(msg_to_srv, client_name, None))
def process_client_message(message, messages_list, client):
'''
Обработчик сообщений от клиентов, принимает словарь -
сообщение от клинта, проверяет корректность,
возвращает словарь-ответ для клиента
:param message:
:return:
'''
SERVER_LOGGER.debug(f'Разбор сообщения от клиента : {message}')
if ACTION in message and message[ACTION] == PRESENCE and TIME in message \
and USER in message and message[USER][LOGIN] == 'Guest':
send_message(client, {RESPONSE: 200})
return
# Если это сообщение, то добавляем его в очередь сообщений. Ответ не требуется.
elif ACTION in message and message[ACTION] == MESSAGE and \
TIME in message and MESSAGE_TEXT in message:
messages_list.append((message[LOGIN], message[MESSAGE_TEXT]))
return
# Иначе отдаём Bad request
else:
send_message(
client, {
RESPONSE: 400,
ERROR: 'Сервер не понимает запрос из-за неверного синтаксиса'
})
return
def service_update_lists(self):
'''Отправка 205 сообщения'''
for client in self.names:
try:
send_message(self.names[client], {"response": 205})
except OSError:
self.remove_client(self.names[client])
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 send_msg_to_destinations(_msg, _all_user_names, _clients_to_send):
"""
Функция из списка принятых сообщений рассылает ожидающим адресатам.
:param _msg:
:param _all_user_names:
:param _clients_to_send:
:return:
"""
# если имя получателя в списке и его сокет в списке ожидания
if _msg[DESTINATION] in _all_user_names and \
_all_user_names[_msg[DESTINATION]] in _clients_to_send:
# отправляем получателю
send_message(_all_user_names[_msg[DESTINATION]], _msg)
LOGGER.info(f'От:{_msg[SENDER]} \n'
f'сообщение:{_msg[MESSAGE_TEXT]}\n'
f'отправлено в {_msg[TIME]}')
# если зарег. пользользователь не в сети
elif _msg[DESTINATION] in _all_user_names and \
_all_user_names[_msg[DESTINATION]] not in _clients_to_send:
# выдать ошибку соединения
raise ConnectionError
# если нет такого получателя
else:
LOGGER.error(f'Пользователь{_msg[DESTINATION]} не зарегистрирован '
f'на сервере')
try:
# сообщим отправителю
fail_send = CODE_400
fail_send[ERROR] = f'Пользователь{_msg[DESTINATION]} не ' \
f'зарегистрирован на сервере, сообщение не ' \
f'доставлено.'
send_message(_all_user_names[_msg[SENDER]])
except (ConnectionError, ConnectionResetError, ConnectionRefusedError,
ConnectionAbortedError):
LOGGER.error(f'Потеря связи! c отправителем {_msg[SENDER]} ')
def process_client_message(client_socket, messages_list, client):
"""
Обработчик сообщений от клиентов, принимает словарь -
сообщение от клинта, проверяет корректность,
возвращает словарь-ответ для клиента с результатом приёма.
:param client_socket:
:param messages_list:
:param client:
:return:
"""
SERVER_LOGGER.debug(f'Разбор сообщения от клиента : {client_socket}')
# Если это сообщение о присутствии, принимаем и отвечаем, если успех
if ACTION in client_socket and client_socket[ACTION] == PRESENCE and TIME in client_socket \
and USER in client_socket and client_socket[USER][ACCOUNT_NAME] == 'Guest':
send_message(client, {RESPONSE: 200})
return
# Если это сообщение, то добавляем его в очередь сообщений. Ответ не требуется.
elif ACTION in client_socket and client_socket[ACTION] == MESSAGE and \
TIME in client_socket and MESSAGE_TEXT in client_socket:
messages_list.append(
(client_socket[ACCOUNT_NAME], client_socket[MESSAGE_TEXT]))
return
# Иначе отдаём Bad request
else:
send_message(client, {RESPONSE: 400, ERROR: 'Bad Request'})
return
def fetch(self):
# given a ccn, a cellphone number and a studentname
#print "running?"
info_list, has_waitlist = _find_info(self.ccn)
current_enroll, enroll_limit, current_waitlist, waitlist_limit = -1, -1, -1, -1
all_full = False
if has_waitlist: # if this class has waitlist
if len(info_list) == 4:
current_enroll, enroll_limit, current_waitlist, waitlist_limit = info_list
elif len(info_list) == 2:
current_waitlist, waitlist_limit = info_list
elif len(info_list) == 0:
all_full = True
else:
if len(info_list) == 4:
current_enroll, enroll_limit, current_waitlist, waitlist_limit = info_list
elif len(info_list) == 2:
current_enroll, enroll_limit = info_list
elif len(info_list) == 0:
all_full = True
#print current_enroll, enroll_limit, current_waitlist, waitlist_limit, all_full, has_waitlist
is_different, different_list = self.update(current_enroll, enroll_limit, current_waitlist, waitlist_limit, all_full, has_waitlist)
if is_different:
msg = "Change in course %d:\n%s" % (self.ccn, '; '.join(different_list) + '.')
if self.user_profile.is_phone_set:
cell_mail = '%s@%s' % (self.user_profile.cellphone, self.user_profile.cell_mail)
send_message(toaddrs=cell_mail, msg=msg)
if self.user_profile.is_email_set:
send_email(toaddrs=self.user_profile.email, title="Status change of course with CCN %s" % self.ccn, msg=msg)
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 __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 console_interface(sock_of_conn, account='Guest'):
"""
Функция - интерфейс меню, создания и отправки сообщения
"""
while True:
cmd = input('Команды: m - написать сообщение, e - выход.\n Введите '
'команду')
if cmd == 'm':
try:
send_message(sock_of_conn, create_users_message(account))
LOGGER.debug('Собщение отправлено')
except (ConnectionError, ConnectionResetError,
ConnectionRefusedError, ConnectionAbortedError):
LOGGER.error(f'Потеря связи! Сервер '
f'{sock_of_conn.getpeername()} '
f'не доступен.')
sys.exit(1)
elif cmd == 'e':
send_message(sock_of_conn, create_message_disconnect(account))
print('Завершение соединения.')
LOGGER.info('Пользователь завершил работу приложения по команде '
'exit.')
# Пауза для того, чтобы сообщение о выходе успело придти на сервер
time.sleep(0.5)
sock_of_conn.close()
sys.exit(0)
# break
else:
print('Неправильная команда ! ! !.')
LOGGER.debug(f'Неправильная команда:{cmd}')
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 service_update_lists(self):
"""Updating clients list function."""
for client in self.names:
try:
send_message(self.names[client], RESPONSE_205)
except OSError:
self.remove_client(self.names[client])
def service_update_lists(self):
"""Метод реализующий отправки сервисного сообщения 205 клиентам."""
for client in self.names:
try:
send_message(self.names[client], RESPONSE_205)
except OSError:
self.remove_client(self.names[client])
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 autorize_user(self, message, sock):
"""Метод реализующий аутентификацию и авторизацию пользователей."""
client_digest = binascii.a2b_base64(message['data'])
# Если ответ клиента корректный, то сохраняем его в список
# пользователей.
digest = self.clients_hash[message["username"]]
if 'response' in message and message['response'] == 511 and hmac.compare_digest(digest, client_digest):
self.clients_info[sock] = message["username"]
client_ip, client_port = sock.getpeername()
try:
send_success_code(sock)
except OSError:
self.db.user_logout(message["username"])
# добавляем пользователя в список активных и если у него изменился открытый ключ
# сохраняем новый
self.db.user_login(message["username"], client_ip, client_port, message["keys"])
print('Корректный пароль')
else:
response = RESPONSE_400
response['error'] = 'Неверный пароль.'
try:
send_message(sock, response)
except OSError:
pass
print('Неверный пароль')
self.db.user_logout(message["username"])
if self.clients_info.get(sock):
self.clients_info.pop(sock)
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 send_success_code(client):
"""Отправляем код успешного подключения"""
msg_response = {
"response": '200',
"time": int(time.time()),
}
send_message(client, msg_response)
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():
'''
Загружаем параметы коммандной строки
: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():
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_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 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 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}')
def send_users_list(client, contact_list):
"""Возвращаем список контактов"""
msg_response = {
"action": 'users',
"time": int(time.time()),
"response": '202',
"alert": contact_list,
}
send_message(client, msg_response)
def send_user_keys(client, key):
"""Возвращаем список контактов"""
msg_response = {
"action": 'public_key_request',
"time": int(time.time()),
"response": '511',
"data": key,
}
send_message(client, msg_response)
def service_update_lists(self):
"""Method for sending response 205 (update user lists) to all clients."""
res = self.form_response(205)
for client in self.names:
try:
send_message(res, self.names[client], SERVER_LOG)
except OSError:
self.remove_client(self.names[client])
def presence(self, passwd_hash_string):
"""
Отправка сообщения о подключении к серверу
:param passwd_hash_string:
"""
msg_presence = {
"action": "presence",
"time": int(time.time()),
"type": "status",
"user": {
"account_name": self.username,
"status": "Connect to server"
}
}
with socket_lock:
send_message(self.sock, msg_presence)
try:
response = self.sock.recv(1000000)
ans = get_data_from_message(response)
print('Начинаем авторизацию!', response)
if 'response' in ans:
if ans['response'] == 400:
raise ServerError(ans['error'])
elif ans['response'] == 511:
# Если всё нормально, то продолжаем процедуру
# авторизации.
ans_data = ans['data']
hash = hmac.new(passwd_hash_string,
ans_data.encode('utf-8'), 'MD5')
digest = hash.digest()
pubkey = self.keys.publickey().export_key().decode(
'ascii')
print(pubkey)
my_ans = {
'action': 'join',
'username': self.username,
'response': 511,
'data':
binascii.b2a_base64(digest).decode('ascii'),
'keys': pubkey
}
send_message(self.sock, my_ans)
response = self.sock.recv(1000000)
ans = get_data_from_message(response)
print(ans['response'])
if ans['response'] != '200':
print('Неверный пароль!')
raise ServerError(ans['error'])
else:
print('Авторизация прошла успешно!')
else:
raise ServerError(ans['error'])
except Exception:
logger.exception('Ошибка при авторизации на сервере')
self.connection_lost.emit()
sys.exit(1)
def send_message(self, to, content):
"""Method for forming a text message to be sent to a target user."""
req = self.form_text_message(to, content)
with socket_lock:
send_message(req, self._socket, CLIENT_LOG)
self.process_server_answer(
receive_message(self._socket, CLIENT_LOG))
CLIENT_LOG.info(f'Sent a message to the user {to}')
def del_contact(self, contact):
"""Method for informing a server about contact removal."""
CLIENT_LOG.debug(f'Removing a contact {contact}')
req = self.form_edit_contact_message(contact, op='/del')
with socket_lock:
send_message(req, self._socket, CLIENT_LOG)
self.process_server_answer(
receive_message(self._socket, CLIENT_LOG))
def fetch(self):
url = self.url
if getsize(url) > MAXIMUM_SIZE:
return
new_hash = gethash(url)
if not self.hash_data:
self.hash_data = new_hash
self.save()
else:
if new_hash != self.hash_data:
msg = "There has been a change of status in your monitoring course page %s (%s)." % (self.shortname, self.url)
print self.user_profile
if self.user_profile.is_phone_set:
cell_mail = '%s@%s' % (self.user_profile.cellphone, self.user_profile.cell_mail)
send_message(toaddrs=cell_mail, msg=msg[:100]+'...')
if self.user_profile.is_email_set:
send_email(toaddrs=self.user_profile.email, title="Status change of course page %s" % self.shortname, msg=msg)
self.hash_data = new_hash
self.save()
def test(request):
send_message('*****@*****.**', 'test')
return HttpResponse('Done')
