def set_server(conn, adr): while True: try: msg = "" while True: msg_chunk = conn.recv(64) msg += msg_chunk if len(msg_chunk) < 64: try: resp_uri = server.parse_request(msg) except ValueError: response = server.response_error(400, b"Bad Request") except NotImplementedError: response = server.response_error(505, b"Version Not Supported") except IndexError: response = server.response_error(405, b"Method Not Allowed") except LookupError: response = server.response_error(404, b"Not Found") except Exception: response = server.response_error(500, b"Internal Server Error") else: response = server.response_ok(resp_uri) conn.sendall(response) conn.close() except KeyboardInterrupt: break
def return_concurrent_request(): ADDR = ('127.0.0.1', 8000) socket = g.socket( g.AF_INET, g.SOCK_STREAM, g.IPPROTO_IP ) socket.bind(ADDR) socket.listen(5) while True: try: conn, addr = socket.accept() request = "" while True: msg = conn.recv(1024) request += msg if len(msg) < 1024: break try: response = server.response_ok(server.parse_request(request)) except ValueError as detail: response = server.response_error(b"400", str(detail)) except LookupError as detail: response = server.response_error(b"404", str(detail)) except AttributeError as detail: response = server.response_error(b"405", str(detail)) except NotImplementedError as detail: response = server.response_error(b"400", str(detail)) except UserWarning as detail: response = server.response_error(b"403", str(detail)) conn.sendall(response) conn.close() except KeyboardInterrupt: break
def send_response(conn, addr): """Send response to client.""" conn.settimeout(2) req = b'' try: packet = conn.recv(8) req = packet while b'\r\n\r\n' not in req: packet = conn.recv(8) req += packet except socket.timeout: pass print(req.decode('utf8')) try: uri = parse_request(req) uri = uri if isinstance(uri, str) else uri.decode('utf8') res = response_ok(*resolve_uri(uri)) except ValueError: res = response_error(400, 'Bad Request') except NotImplementedError as error: if 'GET' in error.args[0]: res = response_error(405, 'Method Not Allowed') else: res = response_error(501, 'Not Implmented') except (OSError, IOError) as error: res = response_error(404, 'Not Found') conn.sendall(res) conn.close()
def test_response_error(): response = server.response_error(400, 'Bad Request').split(b'\r\n') assert b"HTTP/1.1 400 Bad Request" in response[0] assert b"Content-Type: text/plain" in response response = server.response_error(405, 'Method Not Allowed').split(b'\r\n') assert b"HTTP/1.1 405 Method Not Allowed" in response[0] assert b"Content-Type: text/plain" in response response = server.response_error(403, 'Forbidden').split(b'\r\n') assert b"HTTP/1.1 403 Forbidden" in response[0] assert b"Content-Type: text/plain" in response
def test_parse(): """Assert 404 error works correctly.""" from server import response_error request = u'404 Page Not Found' response = response_error(request) response = response.split() assert response[1] == '404'
def test_response_error(): """Test response_error function.""" from server import response_error response = response_error("405", "Method not allowed") response = response.decode('utf-8') slit_response = response[9:12] assert "405" == slit_response
def test_response_error_504(server_setup): valid = [] valid.append(b'HTTP/1.1 504 Gateway Timeout') valid.append(b'Content-Type: text/html; charset=UTF-8' + _CRLF) valid = _CRLF.join(valid) response = server.response_error(504, 'Gateway Timeout') assert valid == response
def test_response_error_500(server_setup): valid = [] valid.append(b'HTTP/1.1 500 Internal Server Error') valid.append(b'Content-Type: text/html; charset=UTF-8' + _CRLF) valid = _CRLF.join(valid) response = server.response_error(500, 'Internal Server Error') assert valid == response
def test_response_error(): response = server.response_error( b"405", b"Method Not Allowed", b"GET method required." ) assert b"GET method required" in response assert b"text/html" in response assert b"</body>" in response
def test_response_error(): from server import response_error response = response_error() lines = response.split('\n') init_line = lines[0].split(' ') assert len(lines) >= 1 assert '500' in init_line[1] assert init_line[0][:4] == 'HTTP' assert 'Internal' in init_line[2] assert 'Server' in init_line[3] assert 'Error' in init_line[4] assert '\r\n' in response
def test_response_break(): """Test responses for blank break line between header and body.""" from server import response_ok from server import response_error good_resp_msg = response_ok() bad_resp_msg = response_error("500", "some text") good_split = good_resp_msg.split("\r\n\r\n") bad_split = bad_resp_msg.split("\r\n\r\n") assert len(good_split) == 2 assert len(bad_split) == 2
def send_http_response(conn, address): # pragma: no cover """Send a properly formatted HTTP response to the client. Request sent by the client should be a properly formatted HTTP request. """ conn.settimeout(2) request = b'' try: packet = conn.recv(8) request = packet while b'\r\n\r\n' not in request: packet = conn.recv(8) request += packet except socket.timeout: pass print(request.decode('utf8')) try: uri = parse_request(request) uri = uri if isinstance(uri, str) else uri.decode('utf8') response = response_ok(*resolve_uri(uri)) except ValueError: response = response_error(400, 'Bad Request') except NotImplementedError as error: if 'GET' in error.args[0]: response = response_error(405, 'Method Not Allowed') else: response = response_error(501, 'Not Implmented') except (OSError, IOError) as error: response = response_error(404, 'Not Found') conn.sendall(response) conn.close()
def test_response_headers(): """Test responses for proper headers.""" from server import response_ok from server import response_error good_resp_msg = response_ok() bad_resp_msg = response_error("500", "some text") good_split = good_resp_msg.split("\r\n") bad_split = bad_resp_msg.split("\r\n") assert good_split[1][:7:] == "Content" assert good_split[1][12] == ":" assert bad_split[1] == ""
def test_response_status(): """Test responses for presence of status code and protocol.""" from server import response_ok from server import response_error good_resp_msg = response_ok() bad_resp_msg = response_error("500", "some text") good_split = good_resp_msg.split(" ") bad_split = bad_resp_msg.split(" ") assert good_split[1][:1:] == "2" assert bad_split[1][:1:] == "5" assert good_split[0] == "HTTP/1.1" assert bad_split[0] == "HTTP/1.1"
def test_error_response_405_well_formatted(fake_socket): """Test that error reponse of 405 HTTP response is correct.""" from server import response_error from datetime import datetime as time if sys.version_info.major == 3: from http.client import HTTPResponse else: from httplib import HTTPResponse source = fake_socket(response_error(405, 'Method Not Allowed')) response = HTTPResponse(source) response.begin() assert response.status == 405 assert time.strptime(response.getheader('Date'), '%a, %d %b %Y %H:%M:%S %Z')
def test_error(): """Test to get an error response.""" from server import response_error msg = response_error() msg = msg.split() HTTP = msg[0] status_code = msg[1] content_type = msg[6] charset = msg[7] body = (str(msg[17] + msg[18])) assert HTTP == 'HTTP/1.1' assert status_code == '500' assert content_type == 'text/plain;' assert charset == 'charset=utf-8' assert body == "ServerError"
def server_handler(connection, address): """Handles the gevent StreamServer for individual clients.""" try: result, mime = parse_request(server_read(connection)) print("log:", result) to_send = response_ok(result, mime) server_response(to_send, connection) except Exception as error: try: error = error.args[0] code = int(error.split(':')[0]) error = error.split(':')[1].strip() except: code = 500 error = "Server Error" server_response(response_error(code, error), connection) finally: connection.close()
def server(conn, address): """Return message to client.""" try: buffer_length = 8 reply_complete = False full_string = u"" while not reply_complete: part = conn.recv(buffer_length) full_string = full_string + part.decode('utf-8') if len(part) < buffer_length: reply_complete = True print(full_string) try: uri = parse_request(full_string) body_tuple = resolve_uri(uri) if body_tuple: conn.send(response_ok(body_tuple)) else: conn.sendall(response_error(u'404 Page Not Found')) conn.close() except NameError('Method not GET'): conn.sendall(response_error(u'405 Method Not Allowed')) conn.close() except TypeError('HTTP protol incorrect'): conn.sendall(response_error(u'505 HTTP Version Not Supported')) conn.close() except SyntaxError('URI incorrect'): conn.sendall(response_error(u'404 Page Not Found')) conn.close() except IOError('File not found'): conn.sendall(response_error(u'404 Page Not Found')) conn.close() except SystemError('Request not fully received'): conn.sendall(response_error()) conn.close() except KeyboardInterrupt: conn.close() finally: conn.close()
def test_response_error_unknown(): with pytest.raises(KeyError): response_error('700')
def test_response_error(msg, result): """Pass in an error and receive the appropriate response.""" from server import response_error assert response_error(msg) == result
def test_404_message_response(): """Testing for if 200 ok is triggered.""" returned = client_socket('GET /URI HTTP/1.1 Host:') error_message = response_error('404') assert returned == error_message
def test_response_error(code, result): """Test return of error message from response error function.""" assert response_error(code) == result
def test_response_error(): response = server.response_error(500, b"Internal Server Error") assert parse_response(response)[0] == '500'
def test_response_error_no_support_returns_505_error(): """Test that no_support error returns 505 Error.""" from server import response_error assert b"HTTP" in response_error("no_support")
def test_response_error(code, result): """Test response error for correct error messages for a given code.""" from server import response_error assert response_error(code) == result
def test_error(): """Test that the server retruns 500 on error.""" from server import response_error assert response_error() == 'HTTP/1.1 500 Internal Server Error\r\n'
def test_405_error_message_response(): """Testing for if 405 error is triggered.""" returned = client_socket('POST /URI HTTP/1.1 Host:') error_message = response_error('405') assert returned == error_message
def test_response_error(): response = response_error('405') headers, body = process_response(response) assert headers[0] == 'HTTP/1.1 405 Method Not Allowed'
def test_400_error_message_respoonse(): """Testing if 500 error is triggered.""" returned = client_socket('GET /URI HTTP/1.1 HO') error_message = response_error('400') assert returned == error_message
def test_response_error(): """Test to see if response error returns a correct error message.""" from server import response_error valid_header = b"HTTP/1.1 500 Internal Server Error\r\n\r\n" assert response_error(500, "Internal Server Error") == valid_header
def test_response_error(): """Check if correct message sent when response ok called.""" from server import response_error assert response_error( '405', 'METHOD NOT ALLOWED') == b"""HTTP/1.1 405 METHOD NOT ALLOWED
def test_response_error_malformed_request_returns_400_error(): """Test that malformed_request error returns 400 Error.""" from server import response_error assert b"server" in response_error("malformed_request")
def test_response_error_bad_request_returns_400_error(): """Test that bad_request error returns 400 Error.""" from server import response_error assert b"No" in response_error("bad_request")
def test_not_found_error(n, result): """Test invalid http request returns response error.""" from client import client from server import response_error assert client(n) == response_error(*result)
def test_505_error_message_response(): """Testing if 505 error is triggered.""" returned = client_socket('GET /URI HTTP/1.2 Host:') error_message = response_error('505') assert returned == error_message
def test_server_error(): """Test server error.""" from server import response_error assert response_error( "failure" ) == '''HTTP/1.1 500 Internal Server Error\r\nUnknown arguements passed into request.\r\n\r\n'''
def test_response_error(err_msg): """Test that response_error returns '500 Internal Server Error'.""" from server import response_error error_text = b'HTTP/1.1 %s' % err_msg assert response_error(err_msg).split(b'\r\n')[0] == error_text
def test_response_error(): """Test that we get an 500 error message.""" from server import response_error resp = response_error("500", 'Internal Server Error') assert resp.startswith(b"HTTP/1.1 500")
def test_response_error_forbidden_returns_403_error(): """Test that forbidden error returns 403 Error.""" from server import response_error assert b"permission" in response_error("forbidden")
def test_response_error_returns_valid_response_header(): """Test that the error_response returns a correctly formed response.""" from server import response_error assert response_error(404, "Not Found") == b"HTTP/1.1 404 Not Found\r\n\r\n"
def test_response_error(): """Test first line of server faliure response message.""" from server import response_error output_ = 'HTTP/1.1 500 Internal Server Error' http_list = response_error().split('\r\n') assert http_list[0] == output_
def test_response_error_end_header(): """Test to make sure response header has two CLRFs, i.e end of header.""" from server import response_error end_header = b'\r\n\r\n' response = response_error(500, "Internal Server Error") assert end_header in response
def test_response_error_number_of_crlf(error): """Test server response contains the right amount of CRLF.""" from server import response_error assert response_error(error).count(b'\r\n') == 4