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_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 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 presence(request):
user = request.get('user')
if not user:
return make_400(request)
user_name = user.get('account_name')
logger.info(f' User name - {user_name}')
return make_response(request, 200, 'Hello ' + user.get('account_name'))
def test_make_400():
request = {
'time': datetime.now().timestamp(),
'action': 'now',
'data': 'Hello'
}
response = make_400(request)
assert response.get("code") == 400
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 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_response_400(initial_request, expected_data, expected_time, code_400):
response = make_400(initial_request, expected_data, expected_time)
code = response.get('code')
assert code == code_400
def presence(request):
user = request.get('user')
if not user:
return make_400(request)
print(user.get('account_name'))
return make_response(request, 200, 'Hello ' + user.get('account_name'))
def get_lower_text(request):
data = request.get('data')
if not data:
return make_400(request)
logger.info(data.lower())
return make_response(request, 200, data.lower())
def test_data_make_400():
response = make_400(REQUEST, DATA, date=TIME)
action = response.get('data')
assert action == DATA
def shutdown_server(request):
data = 'Shutdown server'
if not data:
return make_400(request)
logger.info(data)
return make_response(request, 200, data)
def assert_invalid_response_time(invalid_request_none_time):
return make_400(invalid_request_none_time)
def assert_invalid_response_action(invalid_request_none_action):
return make_400(invalid_request_none_action)
def test_make_400(initial_request, code_400, expected_data, expected_time):
response = make_400(initial_request, expected_data, date=expected_time)
assert response.get('code') == code_400
def test_time_make_400():
response = make_400(REQUEST, DATA, date=TIME)
action = response.get('time')
assert action == TIME
def get_upper_text(request):
data = request.get('data')
if not data:
return make_400(request)
return make_response(request, 200, data.upper())
def get_exit(request):
data = request.get('data')
if data:
return make_response(request, 200, data)
return make_400(request)
def test_make_400(valid_request, assert_response):
response = make_400(valid_request)
for name, value in response.items():
if name != 'time':
assert assert_response.get('name') == response.get('name')
def get_lower_text(request):
data = request.get('data')
if not data:
return make_400(request)
print(data)
return make_response(request, 200, data.lower())
request = json.loads(bytes_request)
if vilidate_request(request):
action = request.get('action')
if action == 'echo':
try:
response = make_200(request, request.get('data'))
print(f'Request: {bytes_request.decode()}')
except Exception as er:
response = make_500(request)
print(er)
try:
print(f'Request: {bytes_request.decode()}')
# client.send(bytes_request)
response = make_200(request, 200, request.get('data'))
# client.send({'action': request.get("action"), 'code': 200, 'data': request.get('data')})
except Exception as err:
request = make_500(request)
print(err)
else:
response = make_400(request, 400, 'Request is not valide')
print(f'Wrong request: {request}')
# client.send({'action' :request.get("action"), 'code': 400, 'data': request.get('data')})
# print(f'Request: {bytes_request.decode()}')
# client.send(bytes_request)
string_response = json.dumps(response)
client.send(string_response.encode())
client.close()
except KeyboardInterrupt:
print('Server shotdown')
rlist, wlist, xlist = select(connections, connections, [], 0)
for client in rlist:
data = client.recv(1024)
try:
request = json.loads(data)
event = request['event']
# name = msg['name_client']
logger.debug(f'Получено сообщение:\n{request}')
requests.append(request)
except Exception as error:
request, event = None, None
requests.append(request)
response = make_400(data.decode('utf-8'))
logger.debug(f'Ошибочка => {error}')
if requests:
for request in requests:
for client in wlist:
if validate_request(request):
logger.debug(request.get('event'))
controller = resolve(request.get('event'))
if controller:
try:
response = controller(request)
response_string = json.dumps(response)
client.send(response_string.encode('utf-8'))
logger.debug(f'Отправка сообщения: {response_string}')
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()
def test_make_400(valid_request, ret_code):
response = make_400(valid_request)
assert response.get('code') == ret_code
