def handle_request(raw_request):
request = jim.unpack(raw_request)
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
response = controller(request)
if response.get('code') != 200:
logging.error('Wrong request format')
else:
logging.info(
f'Request is valid and processed by controller')
except Exception as err:
logging.critical(err)
response = make_response(request, 500, 'Internal server error')
else:
logging.error(f'Action {action_name} does not exits')
response = make_404(request)
else:
logging.error('Request is not valid')
response = make_400(request)
return jim.pack(response)
def handle_tcp_req(bytes_req, action_mapping):
"""
Функция формирования ответа
:param bytes_req: bytes
:param action_mapping: dict
:return: bytes
"""
req = json.loads(bytes_req)
if validate_request(req):
action = req.get('action')
controller = action_mapping.get(action)
if controller:
try:
logging.debug(f'Request: {bytes_req.decode()}')
resp = controller(req)
except Exception as err:
if err.args[0] == 401:
resp = make_401(req)
logging.error(f'{err}: Unauthorized. Please enter the password')
else:
resp = make_500(req)
logging.critical(err)
else:
resp = make_404(req)
logging.error(f'404: Wrong action: {req}')
else:
resp = make_400(req, 'Request is not valid')
logging.error(f'400: Wrong request: {req}')
str_resp = json.dumps(resp)
return str_resp.encode()
def handle_default_request(raw_request):
request = json.loads(raw_request.decode(ENCODING_NAME))
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
response = controller(request)
print('response', response)
if response.get('code') != 200:
logging.error(f'Request is not valid')
else:
logging.info(
f'Function { controller.__name__ } was called')
except Exception as err:
logging.critical(err, exc_info=True)
response = make_response(
request,
500,
'Internal server error',
)
else:
logging.error(f'Action { action_name } does not exits')
response = make_404(request)
else:
logging.error(f'Request is not valid')
response = make_400(request)
return json.dumps(response).encode(ENCODING_NAME)
def test_make_404():
request = {
'time': datetime.now().timestamp(),
'action': 'now',
'data': 'Hello'
}
response = make_404(request)
assert response.get("code") == 404
def handle_tcp_request(bytes_request, action_mapping):
request = json.loads(bytes_request)
if validate_request(request):
action = request.get('action')
controller = action_mapping.get(action)
if controller:
try:
response = controller(request)
logging.debug(f'Request: {bytes_request.decode()}')
except Exception as err:
response = make_500(request)
logging.critical(err)
else:
response = make_404(request)
logging.error(f'Action with name {action} not found')
else:
response = make_404(request, 'Request is not valid')
logging.error(f'Wrong request: {request}')
string_response = json.dumps(response)
return string_response.encode()
def check_validate(request, server_actions):
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name, server_actions)
if controller:
try:
return controller(request)
except Exception as err:
logging.critical(err)
return make_response(request, 500, 'Internal server error')
else:
logging.error(f'Action with name { action_name } does not exists')
return make_404(request)
else:
logging.error('Request is not valid')
return make_400(request)
def main():
try:
sock = socket.socket()
sock.bind((host, port))
sock.listen(5)
logging.info(f'Server started with {host}:{port}')
while True:
client, address = sock.accept()
logging.info(f'Client detected {address}')
b_request = client.recv(settings.BUFFERSIZE)
request = jim.unpack(b_request)
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
response = controller(request)
if response.get('code') != 200:
logging.error('Wrong request format')
else:
logging.info(
f'Request is valid and processed by controller'
)
except Exception as err:
logging.critical(err)
response = make_response(request, 500,
'Internal server error')
else:
logging.error(f'Action {action_name} does not exits')
response = make_404(request)
else:
logging.error('Request is not valid')
response = make_400(request)
response = jim.pack(response)
logging.info('Send response to client')
client.sendall(response)
except KeyboardInterrupt:
logging.info('Server closed')
def default_handler(raw_request):
request = json.loads(raw_request)
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
response = controller(request)
except Exception as err:
logger.critical(err)
response = make_response(request, 500, 'Internal server error')
else:
logger.error(f'Action with name {action_name} does not exists')
response = make_404(request)
else:
logger.error('request is not valid')
response = make_400(request)
return json.dumps(response)
def test_make_404():
action_name = 'echo'
data = 'some data'
request = {
'action': action_name,
'time': datetime.now().timestamp(),
'data': data,
}
expected = {
'action': action_name,
'user': None,
'time': None,
'data': data,
'code': 404
}
response = make_404(request)
assert expected.get('code') == response.get('code')
def handle_client_request(request):
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
return controller(request)
# if action_name == 'shutdown_server':
# logger.info('Shutdown server')
# response_string = json.dumps(response)
# client.send(response_string.encode('utf-8'))
# break
except Exception as err:
logger.critical(err, exc_info=True)
return make_response(request, 500, 'Internal server error.')
else:
logger.error(f'Action not found: {action_name}')
return make_404(request)
else:
logger.error(f'Bad request: {request}')
return make_400(request)
def write_response(client, request):
response = None
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name)
if controller:
try:
response = controller(request)
except Exception as err:
logging.critical(err, exc_info=True)
respoonse = make_response(request, 500,
'Internal server error')
else:
logging.error(f'Action not found: {action_name}')
response = make_404(request)
else:
logging.error(f'Bad Request: {action_name} request: {request}')
response = make_400(request)
response_string = json.dumps(response)
client.send(response_string.encode('utf-8'))
def handle_default_request(row_request):
request = json.loads(row_request.decode(ENCODING))
server_actions = get_server_actions()
action_name = request.get('action')
if validate_request(request):
controller = resolve(action_name, server_actions)
if controller:
try:
response = controller(request)
except Exception as err:
logging.critical(err)
response = make_response(request, 500, 'Internal server error')
else:
logging.error(f'Action with name {action_name} does not exist')
response = make_404(request)
else:
logging.error(f'Request is no valid')
response = make_400(request)
row_response = json.dumps(response).encode(ENCODING)
return row_response
def test_make_400(valid_request, ret_code):
response = make_404(valid_request)
assert response.get('code') == ret_code
while True:
client, (client_host, client_port) = sock.accept()
print(f'Client {client_host}:{client_port} was connected')
bytes_request = client.recv(buffersize)
request = json.loads(bytes_request)
if validate_request(request):
action = request.get('action')
controller = action_mapping.get(action)
if controller:
try:
response = controller(request)
print(f'Request: {bytes_request.decode()}')
except Exception as err:
response = make_500(request)
print(err)
else:
response = make_404(request)
else:
response = make_404(request, 'Request is not valid')
print(f'Wrong request: {request}')
string_response = json.dumps(response)
client.send(string_response.encode())
client.close()
except KeyboardInterrupt:
print('Server shutdown')
def test_code_make_404():
response = make_404(REQUEST, date=TIME)
action = response.get('code')
assert action == 404
def test_data_make_404():
response = make_404(REQUEST, date=TIME)
action = response.get('data')
assert action == DATA_404
def test_time_make_404():
response = make_404(REQUEST, date=TIME)
action = response.get('time')
assert action == TIME
def test_make_404(initial_request, code_404, expected_time):
response = make_404(initial_request, date=expected_time)
assert response.get('code') == code_404
def assert_invalid_action(invalid_request_action):
return make_404(invalid_request_action)
def test_make_404(valid_request, assert_response):
response = make_404(valid_request)
for name, value in response.items():
if name != 'time':
assert assert_response.get('name') == response.get('name')
def test_make_response_404(initial_request, expected_time, code_404):
response = make_404(initial_request, expected_time)
code = response.get('code')
assert code == code_404
action_name = request.get('action')
controller = resolve(action_name)
if controller:
try:
response = controller(request)
if action_name == 'shutdown_server':
logger.info('Shutdown server')
response_string = json.dumps(response)
client.send(response_string.encode('utf-8'))
break
except Exception as err:
logger.critical(err, exc_info=True)
response = make_response(request, 500,
'Internal server error.')
else:
logger.error(f'Action not found: {action_name}')
response = make_404(request)
else:
logger.error(f'Bad request: {request}')
response = make_400(request)
response_string = json.dumps(response)
client.send(response_string.encode('utf-8'))
except KeyboardInterrupt:
logger.info('Shutdown server')
sock.close()
print(f'Server started with {host}:{port}')
action_mapping = find_server_action()
while True:
client, (client_host, client_port) = sock.accept()
print(f'Client {client_host}:{client_port} was connected')
bytes_request = client.recv(buffersize)
request = json.loads(bytes_request)
if vilidate_request(request):
action = request.get('action')
controller = action_mapping.get(action)
if controller:
try:
response = controller(request)
print(f'Request: {bytes_request.decode()}')
except Exception as er:
response = make_500(request)
print(er)
else:
response = make_404(request)
else:
response = make_404(request, request.get('data'))
print(f'Wrong request: {request}')
string_response = json.dumps(response)
client.send(string_response.encode())
client.close()
except KeyboardInterrupt:
print('Server shutdown')
