def test_get_message(self):
"""
test of receiving options
"""
test_sock_ok = TestSocket(self.succesfull_dict)
test_sock_err = TestSocket(self.error_dict)
self.assertEqual(get_message(test_sock_ok), self.succesfull_dict)
self.assertEqual(get_message(test_sock_err), self.error_dict)
def client_initializer():
"""
Loading param of cmd and do init of socket
with transfer by result
"""
server_addr, server_port, client_mode = argument_parser()
CLIENT_SIDE_LOGGER.info(
f'client application was launched with parameters: '
f'server address: {server_addr} '
f'port: {server_port}, mode: {client_mode}')
try:
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.connect((server_addr, server_port))
send_message(transfer, launch_presence())
answer = server_response(get_message(transfer))
CLIENT_SIDE_LOGGER.info(f'received response from server {answer}')
print('Сonnection to the server has been established')
except json.JSONDecodeError:
CLIENT_SIDE_LOGGER.error(f'failed to decode received Json string')
sys.exit(1)
except ExceptionServerError as error:
CLIENT_SIDE_LOGGER.error(
f'during attempt to connect, server return error: {error.text}')
sys.exit(1)
except RequestedFieldAbsentError as missing_error:
CLIENT_SIDE_LOGGER.error(f'in server response has no requested field'
f'{missing_error.missing_field}')
sys.exit(1)
except ConnectionRefusedError:
CLIENT_SIDE_LOGGER.critical(
f'connection to server is unavailable {server_addr}:{server_port}, '
f'request to connect was refused')
sys.exit(1)
else:
if client_mode == 'send':
print('Status - preparing to send messages')
else:
print('Status - receiving messages')
while True:
if client_mode == 'send':
try:
send_message(transfer, message_writer(transfer))
except (ConnectionResetError, ConnectionError,
ConnectionAbortedError):
CLIENT_SIDE_LOGGER.error(
f'connection with server {server_addr} was lost')
sys.exit(1)
if client_mode == 'listen':
try:
server_msg_handler(get_message(transfer))
except (ConnectionResetError, ConnectionError,
ConnectionAbortedError):
CLIENT_SIDE_LOGGER.error(
f'connection with server {server_addr} was lost')
sys.exit(1)
def client_initializer():
"""
Loading param of cmd and do init of socket
with transfer by result
"""
try:
server_addr = sys.argv[1]
server_port = int(sys.argv[2])
if server_port < 1024 or server_port > 65535:
raise ValueError
except IndexError:
server_addr = DEFAULT_IP_ADDRESS
server_port = DEFAULT_PORT
except ValueError:
print(
'Only a number between 1024 and 65535 can be specified as a port.')
sys.exit(1)
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.connect((server_addr, server_port))
confirmation_for_server = launch_presence()
send_message(transfer, confirmation_for_server)
try:
answer = server_response(get_message(transfer))
print(answer)
except (ValueError, json.JSONDecodeError):
print('Failed to decode server message.')
def server_msg_handler(from_socket, to_socket):
"""
function - handler of messages from other users, received from server
"""
while True:
try:
message = get_message(from_socket)
if ACTION in message and message[ACTION] == MESSAGE and \
SENDER in message and DESTINATION in message \
and MESSAGE_TEXT in message and\
message[DESTINATION] == to_socket:
print(f'\n Received message from user {message[SENDER]}: '
f'\n {message[MESSAGE_TEXT]}')
CLIENT_SIDE_LOGGER.info(
f'\n Received message from user {message[SENDER]}: '
f'\n {message[MESSAGE_TEXT]}')
else:
CLIENT_SIDE_LOGGER.error(
f'Received incorrect message from server: {message}')
except UnreadableReceivedDataError:
CLIENT_SIDE_LOGGER.error(f'message decoding failed')
except (OSError, ConnectionError, ConnectionAbortedError,
ConnectionResetError, json.JSONDecodeError):
CLIENT_SIDE_LOGGER.critical(f'connection with server was lost')
break
def client_initializer():
"""
Loading param of cmd and do init of socket
with transfer by result
"""
print('Welcome to MikeT messenger!')
server_addr, server_port, client_name = argument_parser()
if not client_name:
client_name = input('Enter your name: ')
CLIENT_SIDE_LOGGER.info(
f'client application was launched with parameters: '
f'server address: {server_addr} '
f'port: {server_port}, mode: {client_name}')
try:
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.connect((server_addr, server_port))
send_message(transfer, launch_presence(client_name))
answer = server_response(get_message(transfer))
CLIENT_SIDE_LOGGER.info(f'received response from server {answer}')
print('Сonnection to the server has been established')
except json.JSONDecodeError:
CLIENT_SIDE_LOGGER.error(f'failed to decode received Json string')
sys.exit(1)
except ExceptionServerError as error:
CLIENT_SIDE_LOGGER.error(
f'during attempt to connect, server return error: {error.text}')
sys.exit(1)
except RequestedFieldAbsentError as missing_error:
CLIENT_SIDE_LOGGER.error(f'in server response has no requested field'
f'{missing_error.missing_field}')
sys.exit(1)
except (ConnectionRefusedError, ConnectionError):
CLIENT_SIDE_LOGGER.critical(f'connection to server is not available'
f' {server_addr}:{server_port}, '
f'request to connect was refused')
sys.exit(1)
else:
target_side = threading.Thread(target=server_msg_handler,
args=(transfer, client_name))
target_side.daemon = True
target_side.start()
user_side = threading.Thread(target=user_online,
args=(transfer, client_name))
user_side.daemon = True
user_side.start()
CLIENT_SIDE_LOGGER.debug('process started')
while True:
time.sleep(1)
if target_side.is_alive() and user_side.is_alive():
continue
break
def server_launcher():
"""
loading params of cmd, if they're not set,
will defined by default, after that function detects
addr which will be listen, prepares port and
starts to receive a information
"""
try:
if '-p' in sys.argv:
port_data = int(sys.argv[sys.argv.index('-p') + 1])
else:
port_data = DEFAULT_PORT
if port_data < 1024 or port_data > 65535:
raise ValueError
except IndexError:
print('After the parameter -\'p\' must be specified the port'
' number.')
sys.exit(1)
except ValueError:
print('Only a number between 1024 and 65535 can be specified'
' as a port.')
sys.exit(1)
try:
if '-a' in sys.argv:
addr_data = sys.argv[sys.argv.index('-a') + 1]
else:
addr_data = ''
except IndexError:
print('After the parameter \'a\'- must be specified the address'
' that the server will listen to.')
sys.exit(1)
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.bind((addr_data, port_data))
transfer.listen(MAX_CONNECTIONS)
while True:
client_socket_box, client_addr = transfer.accept()
try:
message_receiver = get_message(client_socket_box)
print(message_receiver)
response = analyzer(message_receiver)
send_message(client_socket_box, response)
client_socket_box.close()
except (ValueError, json.JSONDecodeError):
print('Incorrect message was received from client side')
client_socket_box.close()
def server_launcher():
"""
loading params of cmd, if they're not set,
will defined by default, after that function detects
addr which will be listen, prepares port and
starts to receive a information
"""
parser = argument_parser()
namespace = parser.parse_args(sys.argv[1:])
addr_data = namespace.a
port_data = namespace.p
if not 1023 < port_data < 65536:
SERVER_SIDE_LOGGER.critical(
f'port was defined incorrectly {port_data} '
f'port address range available between 1024 and 65535')
sys.exit(1)
SERVER_SIDE_LOGGER.info(
f'server launched, port to connect: {port_data} '
f'connection from address: {addr_data} '
f'(If address not defined, connection will be available without it)')
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.bind((addr_data, port_data))
transfer.listen(MAX_CONNECTIONS)
while True:
client_socket_box, client_addr = transfer.accept()
SERVER_SIDE_LOGGER.info(f'connection with {client_addr} stabilized')
try:
message_receiver = get_message(client_socket_box)
SERVER_SIDE_LOGGER.debug(f'message received: {message_receiver}')
response = analyzer(message_receiver)
SERVER_SIDE_LOGGER.info(f'response is ready to sent: {response}')
send_message(client_socket_box, response)
SERVER_SIDE_LOGGER.debug(
f'connection with client {client_addr} will be closed')
client_socket_box.close()
except (ValueError, json.JSONDecodeError):
SERVER_SIDE_LOGGER.error(
f'json file, received from {client_addr} '
f'was unavailable to decode. Connection will be closed')
client_socket_box.close()
except UnreadableReceivedDataError:
SERVER_SIDE_LOGGER.error(
f'message format from {client_addr} is unreadable'
f'the connection will be closed')
def client_initializer():
"""
Loading param of cmd and do init of socket
with transfer by result
"""
parser = argument_parser()
namespace = parser.parse_args(sys.argv[1:])
server_addr = namespace.addr
server_port = namespace.port
if not 1023 < server_port < 65536:
CLIENT_SIDE_LOGGER.critical(
f'attempt to launch client with wrong port: {server_port} '
f'allowed ports between 1024 and 65535 numbers, process ends')
sys.exit(1)
CLIENT_SIDE_LOGGER.info(
f'client application was launched with parameters: '
f'server address: {server_addr} '
f'port: {server_port}')
try:
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.connect((server_addr, server_port))
confirm_presence_to_server = launch_presence()
send_message(transfer, confirm_presence_to_server)
answer = server_response(get_message(transfer))
CLIENT_SIDE_LOGGER.info(f'received response from server {answer}')
print(answer)
except json.JSONDecodeError:
CLIENT_SIDE_LOGGER.error(f'failed to decode received Json string')
except RequestedFieldAbsentError as missing_error:
CLIENT_SIDE_LOGGER.error(f'in server response has no requested field'
f'{missing_error}{missing_field}')
except ConnectionRefusedError:
CLIENT_SIDE_LOGGER.critical(
f'connection to server is unavailable {server_addr}:{server_port}, '
f'request to connect was refused')
def server_launcher():
"""
loading params of cmd, if they're not set,
will defined by default, after that function detects
addr which will be listen, prepares port and
starts to receive a information
"""
addr_to_listen, port_to_listen = argument_parser()
SERVER_SIDE_LOGGER.info(
f'server launched, port to connect: {port_to_listen} '
f'connection from address: {addr_to_listen} '
f'(If address not defined, connection will be available without it)')
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.bind((addr_to_listen, port_to_listen))
transfer.settimeout(0.5)
clients_online = []
messages_queue = []
names = dict()
transfer.listen(MAX_CONNECTIONS)
while True:
try:
client_socket_box, client_data = transfer.accept()
except OSError:
pass
else:
SERVER_SIDE_LOGGER.info(
f'connection with PC {client_data} stabilized')
clients_online.append(client_socket_box)
data_list_for_receiving = []
data_list_to_send = []
data_list_of_err_occured = []
try:
if clients_online:
data_list_for_receiving, data_list_to_send, data_list_of_err_occured = \
select.select(clients_online, clients_online, [], 0)
except OSError:
pass
if data_list_for_receiving:
for msg_by_client in data_list_for_receiving:
try:
analyzer(get_message(msg_by_client), messages_queue,
msg_by_client, clients_online, names)
except Exception:
SERVER_SIDE_LOGGER.info(
f'client {msg_by_client.getpeername()} '
f'disconnected from server')
clients_online.remove(msg_by_client)
for i in messages_queue:
try:
process_message(i, names, data_list_to_send)
except Exception:
SERVER_SIDE_LOGGER.info(
f'connection with client {i[DESTINATION]} lost')
clients_online.remove(names[i[DESTINATION]])
del names[i[DESTINATION]]
messages_queue.clear()
def server_launcher():
"""
loading params of cmd, if they're not set,
will defined by default, after that function detects
addr which will be listen, prepares port and
starts to receive a information
"""
addr_to_listen, port_to_listen = argument_parser()
SERVER_SIDE_LOGGER.info(
f'server launched, port to connect: {port_to_listen} '
f'connection from address: {addr_to_listen} '
f'(If address not defined, connection will be available without it)'
)
transfer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
transfer.bind((addr_to_listen, port_to_listen))
transfer.settimeout(0.5)
clients_online = []
messages_queue = []
transfer.listen(MAX_CONNECTIONS)
while True:
try:
client_socket_box, addr_to_listen = transfer.accept()
except OSError:
pass
else:
SERVER_SIDE_LOGGER.info(f'connection with PC {addr_to_listen} stabilized')
clients_online.append(client_socket_box)
data_list_for_receiving = []
data_list_to_send = []
data_list_of_err_occured = []
try:
if clients_online:
data_list_for_receiving, data_list_to_send, data_list_of_err_occured = \
select.select(clients_online, clients_online, [], 0)
except OSError:
pass
if data_list_for_receiving:
for msg_by_client in data_list_for_receiving:
try:
analyzer(get_message(msg_by_client),
messages_queue, msg_by_client)
except:
SERVER_SIDE_LOGGER.info(f'client {msg_by_client.getpeername()} '
f'disconnected from server')
clients_online.remove(msg_by_client)
if messages_queue and data_list_to_send:
message = {
ACTION: MESSAGE,
SENDER: messages_queue[0][0],
TIME: time.time(),
MESSAGE_TEXT: messages_queue[0][1]
}
del messages_queue[0]
for client_from_queue in data_list_to_send:
try:
send_message(client_from_queue, message)
except:
SERVER_SIDE_LOGGER.info(f' client {client_from_queue.getpeername()} '
f'disconnected from server')
clients_online.remove(client_from_queue)
