update client

Author: saviorand

lightbug_http/header.mojo

@@ -244,20 +244,18 @@ struct RequestHeader:
         return String(self.raw_headers)
 
     fn parse_raw(inout self, inout r: Reader) raises -> Int:
-        var n = 1
-        # while True:
-        var first_byte = r.peek(n)
+        var first_byte = r.peek(1)
         if len(first_byte) == 0:
-            raise Error("Failed to read first byte from header")
+            raise Error("Failed to read first byte from request header")
 
         var buf: Bytes
         var e: Error
 
         buf, e = r.peek(r.buffered())
         if e:
-            raise Error("Failed to read header: " + e.__str__())
+            raise Error("Failed to read request header: " + e.__str__())
         if len(buf) == 0:
-            raise Error("Failed to read header")
+            raise Error("Failed to read request header, empty buffer")
 
         var end_of_first_line = self.parse_first_line(buf)
 
@@ -278,14 +276,14 @@ struct RequestHeader:
 
         var first_whitespace = index_byte(b, bytes(whitespace, pop=False)[0])
         if first_whitespace <= 0:
-            raise Error("Could not find HTTP request method in the request: " + String(b))
+            raise Error("Could not find HTTP request method in request line: " + String(b))
 
         _ = self.set_method_bytes(b[:first_whitespace])
 
         var last_whitespace = last_index_byte(b, bytes(whitespace, pop=False)[0]) + 1
 
         if last_whitespace < 0:
-            raise Error("Could not find last whitespace in request line: " + String(b))
+            raise Error("Could not find request target or HTTP version in request line: " + String(b))
         elif last_whitespace == 0:
             raise Error("Request URI is empty: " + String(b))
 
@@ -629,47 +627,78 @@ struct ResponseHeader:
     fn headers(self) -> String:
         return String(self.raw_headers)
 
-    fn parse_first_line(inout self, first_line: String) raises -> None:
-        var n = first_line.find(" ")
-        
-        var proto = first_line[:n + 1]
+    # fn parse_from_list(inout self, headers: List[String], first_line: String) raises -> None:
+    #     _ = self.parse_first_line(first_line)
+
+    #     for header in headers:
+    #         var header_str = header[]
+    #         var separator = header_str.find(":")
+    #         if separator == -1:
+    #             raise Error("Invalid header")
 
-        _ = self.set_protocol(proto)
+    #         var key = String(header_str)[:separator]
+    #         var value = String(header_str)[separator + 1 :]
 
-        var rest_of_response_line = first_line[n + 1 :]
+    #         if len(key) > 0:
+    #             self.parse_header(key, value)
 
-        var status_code = atol(rest_of_response_line[:3])
-        _ = self.set_status_code(status_code)
-
-        var message = rest_of_response_line[4:]
-        if len(message) > 1:
-            _ = self.set_status_message(bytes((message), pop=False))
+    fn parse_raw(inout self, inout r: Reader) raises -> Int:
+        var first_byte = r.peek(1)
+        if len(first_byte) == 0:
+            raise Error("Failed to read first byte from response header")
 
-        _ = self.set_content_length(-2)
+        var buf: Bytes
+        var e: Error
+        
+        buf, e = r.peek(r.buffered())
+        if e:
+            raise Error("Failed to read response header: " + e.__str__())
+        if len(buf) == 0:
+            raise Error("Failed to read response header, empty buffer")
 
-    fn parse_from_list(inout self, headers: List[String], first_line: String) raises -> None:
-        _ = self.parse_first_line(first_line)
+        var end_of_first_line = self.parse_first_line(buf)
+
+        var header_len = self.read_raw_headers(buf[end_of_first_line:])
 
-        for header in headers:
-            var header_str = header[]
-            var separator = header_str.find(":")
-            if separator == -1:
-                raise Error("Invalid header")
+        self.parse_headers(buf[end_of_first_line:])
+        
+        return end_of_first_line + header_len
+    
+    fn parse_first_line(inout self, buf: Bytes) raises -> Int:
+        var b_next = buf
+        var b = Bytes()
+        while len(b) == 0:
+            try:
+                b, b_next = next_line(b_next)
+            except e:
+                raise Error("Failed to read first line from response, " + e.__str__())
+        
+        var first_whitespace = index_byte(b, bytes(whitespace, pop=False)[0])
+        if first_whitespace <= 0:
+            raise Error("Could not find HTTP version in response line: " + String(b))
 
-            var key = String(header_str)[:separator]
-            var value = String(header_str)[separator + 1 :]
+        _ = self.set_protocol(b[:first_whitespace])
 
-            if len(key) > 0:
-                self.parse_header(key, value)
+        var last_whitespace = last_index_byte(b, bytes(whitespace, pop=False)[0]) + 1
 
-    fn parse_raw(inout self, first_line: String) raises -> None:
-        var headers = self.raw_headers
-        
-        _ = self.parse_first_line(first_line)
+        if last_whitespace < 0:
+            raise Error("Could not find status code or in response line: " + String(b))
+        elif last_whitespace == 0:
+            raise Error("Response URI is empty: " + String(b))
 
+        var status_text = b[last_whitespace :]
+        if len(status_text) > 1:
+            _ = self.set_status_message(status_text)   
+
+        var status_code = atol(b[first_whitespace+1:last_whitespace])
+        _ = self.set_status_code(status_code)
+
+        return len(buf) - len(b_next)
+
+    fn parse_headers(inout self, buf: Bytes) raises -> None:
+        _ = self.set_content_length(-2)
         var s = headerScanner()
-        s.set_b(headers)
-        s.disable_normalization = self.disable_normalization
+        s.set_b(buf)
 
         while s.next():
             if len(s.key()) > 0:
@@ -710,6 +739,31 @@ struct ResponseHeader:
                 return
             if key.lower() == "trailer":
                 _ = self.set_trailer_bytes(bytes(value, pop=False))
+    
+    fn read_raw_headers(inout self, buf: Bytes) raises -> Int:
+        var n = index_byte(buf, bytes(nChar, pop=False)[0])
+        
+        if n == -1:
+            self.raw_headers = self.raw_headers[:0]
+            raise Error("Failed to find a newline in headers")
+        
+        if n == 0 or (n == 1 and (buf[0] == bytes(rChar, pop=False)[0])):
+            # empty line -> end of headers
+            return n + 1
+        
+        n += 1
+        var b = buf
+        var m = n
+        while True:
+            b = b[m:]
+            m = index_byte(b, bytes(nChar, pop=False)[0])
+            if m == -1:
+                raise Error("Failed to find a newline in headers")
+            m += 1
+            n += m
+            if m == 2 and (b[0] == bytes(rChar, pop=False)[0]) or m == 1:
+                self.raw_headers = self.raw_headers + buf[:n]
+                return n
 
 struct headerScanner:
     var __b: Bytes

lightbug_http/http.mojo

@@ -211,6 +211,10 @@ struct HTTPResponse(Response):
     fn get_body_bytes(self) -> BytesView:
         return BytesView(unsafe_ptr=self.body_raw.unsafe_ptr(), len=self.body_raw.size)
 
+    fn set_body_bytes(inout self, body: Bytes) -> Self:
+        self.body_raw = body
+        return self
+    
     fn set_status_code(inout self, status_code: Int) -> Self:
         _ = self.header.set_status_code(status_code)
         return self
@@ -224,6 +228,14 @@ struct HTTPResponse(Response):
 
     fn connection_close(self) -> Bool:
         return self.header.connection_close()
+    
+    fn read_body(inout self, inout r: Reader, header_len: Int) raises -> None:
+        _ = r.discard(header_len)
+
+        var body_buf: Bytes
+        body_buf, _ = r.peek(r.buffered())
+        
+        _ = self.set_body_bytes(bytes(body_buf)) 
 
 fn OK(body: StringLiteral) -> HTTPResponse:
     return HTTPResponse(

lightbug_http/sys/client.mojo

@@ -1,8 +1,5 @@
-from lightbug_http.client import Client
-from lightbug_http.http import HTTPRequest, HTTPResponse, encode, split_http_string
-from lightbug_http.header import ResponseHeader
-from lightbug_http.sys.net import create_connection
-from lightbug_http.io.bytes import Bytes
+from external.gojo.bufio import Reader, Scanner, scan_words, scan_bytes
+from external.gojo.bytes import buffer
 from external.libc import (
     c_int,
     AF_INET,
@@ -13,6 +10,12 @@ from external.libc import (
     recv,
     close,
 )
+from lightbug_http.client import Client
+from lightbug_http.net import default_buffer_size
+from lightbug_http.http import HTTPRequest, HTTPResponse, encode, split_http_string
+from lightbug_http.header import ResponseHeader
+from lightbug_http.sys.net import create_connection
+from lightbug_http.io.bytes import Bytes
 
 
 struct MojoClient(Client):
@@ -92,46 +95,49 @@ struct MojoClient(Client):
 
         var conn = create_connection(self.fd, host_str, port)
 
-        var req_encoded = encode(req, uri)
+        var req_encoded = encode(req)
 
         var bytes_sent = conn.write(req_encoded)
         if bytes_sent == -1:
             raise Error("Failed to send message")
 
-        var new_buf = Bytes()
-
+        var new_buf = Bytes(capacity=default_buffer_size)
         var bytes_recv = conn.read(new_buf)
         if bytes_recv == 0:
             conn.close()
 
-        var response_first_line: String
-        var response_headers: String
-        var response_body: String
+        var buf = buffer.new_buffer(new_buf^)
+        var reader = Reader(buf^)
 
-        response_first_line, response_headers, response_body = split_http_string(new_buf)
+        var error = Error()
 
-        # Ugly hack for now in case the default buffer is too large and we read additional responses from the server
-        var newline_in_body = response_body.find("\r\n")
-        if newline_in_body != -1:
-            response_body = response_body[:newline_in_body]
-
-        var header = ResponseHeader(response_headers.as_bytes())
+        # # Ugly hack for now in case the default buffer is too large and we read additional responses from the server
+        # var newline_in_body = response_body.find("\r\n")
+        # if newline_in_body != -1:
+        #     response_body = response_body[:newline_in_body]
 
+        var header = ResponseHeader()
+        var first_line_and_headers_len = 0
         try:
-            header.parse_raw(response_first_line)
+            first_line_and_headers_len = header.parse_raw(reader)
         except e:
             conn.close()
-            raise Error("Failed to parse response header: " + e.__str__())
+            error = Error("Failed to parse response headers: " + e.__str__())
 
-        var total_recv = bytes_recv
+        var response = HTTPResponse(header, Bytes())
 
-        while header.content_length() > total_recv:
-            if header.content_length() != 0 and header.content_length() != -2:
-                var remaining_body = Bytes()
-                var read_len = conn.read(remaining_body)
-                response_body += remaining_body
-                total_recv += read_len
+        try:
+            response.read_body(reader, first_line_and_headers_len,)
+        except e:
+            error = Error("Failed to read request body: " + e.__str__())
+        # var total_recv = bytes_recv
+        # while header.content_length() > total_recv:
+        #     if header.content_length() != 0 and header.content_length() != -2:
+        #         var remaining_body = Bytes()
+        #         var read_len = conn.read(remaining_body)
+        #         response_body += remaining_body
+        #         total_recv += read_len
 
         conn.close()
 
-        return HTTPResponse(header, response_body.as_bytes_slice())
+        return response

lightbug_http/sys/server.mojo

@@ -191,11 +191,6 @@ struct SysServer:
                 buf = buffer.new_buffer(b^)
                 reader = Reader(buf^)
 
-
-            var first_byte = reader.peek(1)
-            if len(first_byte) == 0:
-                error = Error("Failed to read first byte from connection")
-            
             var header = RequestHeader()
             var first_line_and_headers_len = 0
             try: