def main():
"""
main function. Loading params from the command line:
<port>, <address>
:return:
"""
try:
each_server_port = int(sys.argv[1])
each_server_address = sys.argv[2]
if each_server_port <= 1024 and each_server_port > 65535:
print(each_server_port)
raise ValueError
except IndexError:
each_server_address = DEFAULT_IP_ADDRESS
each_server_port = DEFAULT_PORT
except ValueError:
print("Port value must be between 1024 and 65536.")
print(each_server_port)
sys.exit(1)
print(f'each_server_address = {each_server_address}, each_server_port = {each_server_port}')
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect((each_server_address, each_server_port))
send_message(client_socket, make_online())
try:
print(parse_server_answer(get_message(client_socket)))
except (ValueError, json.JSONDecodeError):
print("Can't decode server message")
def test_get_message(self):
"""
testing receive routine function.
:return:
"""
t_corretct_socket_200 = TestEachSocket(self.t_correct_response_200)
t_incorretct_socket_400 = TestEachSocket(self.t_incorrect_response_400)
self.assertEqual(get_message(t_corretct_socket_200),
self.t_correct_response_200)
self.assertEqual(
get_message(t_incorretct_socket_400),
# get_message(self.t_int_value),
self.t_incorrect_response_400)
with self.assertRaises(AttributeError):
get_message(self.t_int_value)
def test_send_get_message(self):
proc = subprocess.Popen(['python3', 'run_test_server.py'])
time.sleep(1)
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect((DEFAULT_IP_ADDRESS, DEFAULT_PORT))
encoded = json.dumps(CORRECT_MESSAGE).encode(ENCODING)
self.assertEqual(encoded, send_message(client_socket, CORRECT_MESSAGE))
self.assertEqual(get_message(client_socket), CORRECT_RESPONSE_200)
client_socket.close()
proc.kill()
def main():
"""
main function. Loading params from the command line:
<port>, <address>
:return:
"""
try:
each_server_port = int(sys.argv[1])
each_server_address = sys.argv[2]
if each_server_port <= 1024 and each_server_port > 65535:
print(each_server_port)
raise ValueError
except IndexError:
each_server_address = DEFAULT_IP_ADDRESS
each_server_port = DEFAULT_PORT
C_LOGGER.info(f'Port and address assigned to the default values.')
except ValueError:
C_LOGGER.critical(f"Bad port number entered: {each_server_port} "
f"(must lay between 1024 and 65536).")
sys.exit(1)
C_LOGGER.info(
f'Port: {each_server_port} and address: {each_server_address} - assigned.'
)
try:
client_socket = socket(AF_INET, SOCK_STREAM)
client_socket.connect((each_server_address, each_server_port))
C_LOGGER.info('Client connected to server.')
online_msg = make_online()
send_message(client_socket, online_msg)
C_LOGGER.info(f'Message: {online_msg} sent to server.')
response_message = parse_server_answer(get_message(client_socket))
C_LOGGER.info(f'Received message from the server: {response_message}.')
except (ValueError, json.JSONDecodeError):
C_LOGGER.error(
"Incorrect client message received. Can\'t decode server message.")
except ConnectionRefusedError:
C_LOGGER.critical(f'Can\'t connect to server.')
"""
module containes test server socket to test Easy Chat routine functions
"""
import json
import os
import sys
from socket import socket, AF_INET, SOCK_STREAM
sys.path.append(os.path.join(os.getcwd(), '..'))
from each_server import parse_message
from lib.routines import get_message, send_message
from lib.settings import MAX_CONNECTIONS, DEFAULT_PORT
print('Running test server')
each_server_socket = socket(AF_INET, SOCK_STREAM)
each_server_socket.bind(('', DEFAULT_PORT))
each_server_socket.listen(MAX_CONNECTIONS)
while True:
each_client_socket, each_client_address = each_server_socket.accept()
try:
client_message = get_message(each_client_socket)
server_response = parse_message(client_message)
send_message(each_client_socket, server_response)
each_client_socket.close()
except (ValueError, json.JSONDecodeError):
print('Incorrect client message received.')
each_client_socket.close()
def main():
"""
main function. Loading params from the command line:
-p - port
-a - address
:return:
"""
try:
if '-p' in sys.argv:
server_port = int(sys.argv[sys.argv.index('-p') + 1])
S_LOGGER.info(f'Connection port specified: {server_port}')
else:
server_port = DEFAULT_PORT
S_LOGGER.info(f'Using default port : {server_port}')
if server_port <= 1024 and server_port > 65535:
raise ValueError
except IndexError:
S_LOGGER.error("After '-p' option no port entered.")
sys.exit(1)
except ValueError:
S_LOGGER.critical(f"Bad port number entered: {server_port} "
f"(must lay between 1024 and 65536).")
sys.exit(1)
try:
if '-a' in sys.argv:
server_address = sys.argv[sys.argv.index('-a') + 1]
S_LOGGER.info(f'Connection address specified: {server_address}')
else:
server_address = '' # DEFAULT_IP_ADDRESS # =''
S_LOGGER.info('Using local address.')
except IndexError:
S_LOGGER.error('No address entered after -p param.')
sys.exit(1)
S_LOGGER.info(
f'Starting server on ip-address: {server_address}, port: {server_port}'
)
each_socket = socket(AF_INET, SOCK_STREAM)
each_socket.bind((server_address, server_port))
each_socket.listen(MAX_CONNECTIONS)
while True:
each_client_socket, each_client_address = each_socket.accept()
S_LOGGER.info(
f'Connection established. Client details: {each_client_address}.')
try:
client_message = get_message(each_client_socket)
S_LOGGER.info(
f'Received message {client_message} from client {each_client_address}.'
)
server_response = parse_message(client_message)
S_LOGGER.info(
f'Server response to {each_client_address}: {server_response}.'
)
send_message(each_client_socket, server_response)
S_LOGGER.info('Closing connection')
each_client_socket.close()
except (ValueError, json.JSONDecodeError):
S_LOGGER.error(
f'Incorrect client message received. Can\'t decode message from '
f'{each_client_address}.')
each_client_socket.close()