Refactor request, response and header parsing and data structure to be more Pythonic

Signed-off-by: Brian Grenier <grenierb96@gmail.com>

Author: bgreni

bench.mojo

@@ -1,25 +1,119 @@
-import benchmark
-from lightbug_http.sys.server import SysServer
-from lightbug_http.python.server import PythonServer
-from lightbug_http.service import TechEmpowerRouter
+from benchmark import *
+from lightbug_http.io.bytes import bytes, Bytes
+from lightbug_http.header import Headers, Header
+from lightbug_http.utils import ByteReader, ByteWriter
+from lightbug_http.http import HTTPRequest, HTTPResponse, encode
+from lightbug_http.uri import URI
 from tests.utils import (
     TestStruct,
     FakeResponder,
     new_fake_listener,
     FakeServer,
-    getRequest,
 )
 
+alias headers = bytes('''GET /index.html HTTP/1.1\r\nHost: example.com\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/html\r\nContent-Length: 1234\r\nConnection: close\r\nTrailer: end-of-message\r\n\r\n''')
+alias body = bytes(String("I am the body of an HTTP request") * 5)
+alias Request = bytes('''GET /index.html HTTP/1.1\r\nHost: example.com\r\nUser-Agent: Mozilla/5.0\r\nContent-Type: text/html\r\nContent-Length: 1234\r\nConnection: close\r\nTrailer: end-of-message\r\n\r\n''') + body
+alias Response = bytes("HTTP/1.1 200 OK\r\nserver: lightbug_http\r\ncontent-type: application/octet-stream\r\nconnection: keep-alive\r\ncontent-length: 13\r\ndate: 2024-06-02T13:41:50.766880+00:00\r\n\r\n") + body
 
 fn main():
+    run_benchmark()
+
+fn run_benchmark():
     try:
-        var server = SysServer(tcp_keep_alive=True)
-        var handler = TechEmpowerRouter()
-        server.listen_and_serve("0.0.0.0:8080", handler)
-    except e:
-        print("Error starting server: " + e.__str__())
-        return
+        var config = BenchConfig(warmup_iters=100)
+        config.verbose_timing = True
+        config.tabular_view = True
+        var m = Bench(config)
+        m.bench_function[lightbug_benchmark_header_encode](BenchId("HeaderEncode"))
+        m.bench_function[lightbug_benchmark_header_parse](BenchId("HeaderParse"))
+        m.bench_function[lightbug_benchmark_request_encode](BenchId("RequestEncode"))
+        m.bench_function[lightbug_benchmark_request_parse](BenchId("RequestParse"))
+        m.bench_function[lightbug_benchmark_response_encode](BenchId("ResponseEncode"))
+        m.bench_function[lightbug_benchmark_response_parse](BenchId("ResponseParse"))
+        m.dump_report()
+    except:
+        print("failed to start benchmark")
+
+
+var headers_struct = Headers(
+    Header("Content-Type", "application/json"),
+    Header("Content-Length", "1234"),
+    Header("Connection", "close"),
+    Header("Date", "some-datetime"),
+    Header("SomeHeader", "SomeValue")
+)
+
+@parameter
+fn lightbug_benchmark_response_encode(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn response_encode():
+        var res = HTTPResponse(body, headers = headers_struct)
+        _ = encode(res^)
+    b.iter[response_encode]()
 
+@parameter
+fn lightbug_benchmark_response_parse(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn response_parse():
+        var res = Response
+        try:
+            _ = HTTPResponse.from_bytes(res^)
+        except:
+            pass
+    b.iter[response_parse]()
+
+@parameter
+fn lightbug_benchmark_request_parse(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn request_parse():
+        var r = Request
+        try:
+            _ = HTTPRequest.from_bytes("127.0.0.1/path", 4096, r^)
+        except:
+            pass
+    b.iter[request_parse]()
+
+@parameter
+fn lightbug_benchmark_request_encode(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn request_encode():
+        var req = HTTPRequest(
+            URI.parse("http://127.0.0.1:8080/some-path")[URI],
+            headers = headers_struct,
+            body = body
+        )
+        _ = encode(req^)
+    b.iter[request_encode]()
+        
+@parameter
+fn lightbug_benchmark_header_encode(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn header_encode():
+        var b = ByteWriter()
+        var h = headers_struct
+        h.encode_to(b)
+    b.iter[header_encode]()
+
+@parameter
+fn lightbug_benchmark_header_parse(inout b: Bencher):
+    @always_inline
+    @parameter
+    fn header_parse():
+        try:
+            var b = headers
+            var header = Headers()
+            var reader = ByteReader(b^)
+            _ = header.parse_raw(reader)
+        except:
+            print("failed")
+
+    b.iter[header_parse]()
 
 fn lightbug_benchmark_server():
     var server_report = benchmark.run[run_fake_server](max_iters=1)
@@ -38,9 +132,11 @@ fn lightbug_benchmark_misc() -> None:
     recreating_set_report.print(benchmark.Unit.ms)
 
 
+var GetRequest = HTTPRequest(URI.parse("http://127.0.0.1/path")[URI])
+
 fn run_fake_server():
     var handler = FakeResponder()
-    var listener = new_fake_listener(2, getRequest)
+    var listener = new_fake_listener(2, encode(GetRequest))
     var server = FakeServer(listener, handler)
     server.serve()
 

bench_server.mojo

@@ -0,0 +1,11 @@
+from lightbug_http.sys.server import SysServer
+from lightbug_http.service import TechEmpowerRouter
+
+def main():
+    try:
+        var server = SysServer(tcp_keep_alive=True)
+        var handler = TechEmpowerRouter()
+        server.listen_and_serve("0.0.0.0:8080", handler)
+    except e:
+        print("Error starting server: " + e.__str__())
+        return

client.mojo

@@ -2,28 +2,24 @@ from lightbug_http import *
 from lightbug_http.sys.client import MojoClient
 
 fn test_request(inout client: MojoClient) raises -> None:
-    var uri = URI("http://httpbin.org/status/404")
-    try:
-        uri.parse()
-    except e:
-        print("error parsing uri: " + e.__str__())
+    var uri = URI.parse_raises("http://httpbin.org/status/404")
 
 
     var request = HTTPRequest(uri)
-    var response = client.do(request)
+    var response = client.do(request^)
 
     # print status code
-    print("Response:", response.header.status_code())
+    print("Response:", response.status_code)
 
     # print parsed headers (only some are parsed for now)
-    print("Content-Type:", to_string(response.header.content_type()))
-    print("Content-Length", response.header.content_length())
-    print("Server:", to_string(response.header.server()))
+    print("Content-Type:", response.headers["Content-Type"])
+    print("Content-Length", response.headers["Content-Length"])
+    print("Server:", to_string(response.headers["Server"]))
 
-    print("Is connection set to connection-close? ", response.header.connection_close())
+    print("Is connection set to connection-close? ", response.connection_close())
 
     # print body
-    print(to_string(response.get_body_bytes()))
+    print(to_string(response.body_raw))
 
 
 fn main() raises -> None:

lightbug.🔥

@@ -1,4 +1,4 @@
-from lightbug_http import *
+from lightbug_http import Welcome, SysServer
 
 fn main() raises:
     var server = SysServer()

lightbug_http/client.mojo

@@ -8,5 +8,5 @@ trait Client:
     fn __init__(inout self, host: StringLiteral, port: Int) raises:
         ...
 
-    fn do(self, req: HTTPRequest) raises -> HTTPResponse:
+    fn do(self, owned req: HTTPRequest) raises -> HTTPResponse:
         ...

lightbug_http/error.mojo

@@ -1,5 +1,4 @@
 from lightbug_http.http import HTTPResponse
-from lightbug_http.header import ResponseHeader
 from lightbug_http.io.bytes import bytes
 
 alias TODO_MESSAGE = String("TODO").as_bytes()
@@ -8,4 +7,4 @@ alias TODO_MESSAGE = String("TODO").as_bytes()
 @value
 struct ErrorHandler:
     fn Error(self) -> HTTPResponse:
-        return HTTPResponse(ResponseHeader(), TODO_MESSAGE)
+        return HTTPResponse(TODO_MESSAGE)