Merge pull request #28 from ZacHooper/feature/http-client

improve/refactor http client

Author: saviorand

lightbug_http/header.mojo

@@ -44,6 +44,21 @@ struct RequestHeader:
         self.raw_headers = Bytes()
         self.__trailer = Bytes()
 
+    fn __init__(inout self, host: String) -> None:
+        self.disable_normalization = False
+        self.no_http_1_1 = False
+        self.__connection_close = False
+        self.content_length = 0
+        self.content_length_bytes = Bytes()
+        self.__method = Bytes()
+        self.__request_uri = Bytes()
+        self.proto = Bytes()
+        self.__host = host._buffer
+        self.__content_type = Bytes()
+        self.__user_agent = Bytes()
+        self.raw_headers = Bytes()
+        self.__trailer = Bytes()
+
     fn __init__(inout self, rawheaders: Bytes) -> None:
         self.disable_normalization = False
         self.no_http_1_1 = False

lightbug_http/http.mojo

@@ -83,6 +83,15 @@ struct HTTPRequest(Request):
     var disable_redirect_path_normalization: Bool
 
     fn __init__(inout self, uri: URI):
+        self.header = RequestHeader(String("127.0.0.1"))
+        self.__uri = uri
+        self.body_raw = Bytes()
+        self.parsed_uri = False
+        self.server_is_tls = False
+        self.timeout = Duration()
+        self.disable_redirect_path_normalization = False
+
+    fn __init__(inout self, uri: URI, headers: RequestHeader):
         self.header = RequestHeader()
         self.__uri = uri
         self.body_raw = Bytes()
@@ -227,6 +236,48 @@ fn OK(body: Bytes, content_type: String) -> HTTPResponse:
     )
 
 
+fn encode(req: HTTPRequest) raises -> Bytes:
+    var res_str = String()
+    var protocol = strHttp11
+    var current_time = String()
+
+    var builder = StringBuilder()
+
+    _ = builder.write(req.header.method())
+    _ = builder.write_string(String(" "))
+    _ = builder.write(req.header.request_uri())
+    _ = builder.write_string(String(" "))
+    _ = builder.write(protocol)
+    _ = builder.write_string(String("\r\n"))
+
+    _ = builder.write_string(String("Host: " + req.host()))
+    _ = builder.write_string(String("\r\n"))
+
+    if len(req.body_raw) > 0:
+        _ = builder.write_string(String("Content-Type: "))
+        _ = builder.write(req.header.content_type())
+        _ = builder.write_string(String("\r\n"))
+
+        _ = builder.write_string(String("Content-Length: "))
+        _ = builder.write_string(String(len(req.body_raw)))
+        _ = builder.write_string(String("\r\n"))
+
+    _ = builder.write_string(String("Connection: "))
+    if req.connection_close():
+        _ = builder.write_string(String("close"))
+    else:
+        _ = builder.write_string(String("keep-alive"))
+    _ = builder.write_string(String("\r\n"))
+
+    _ = builder.write_string(String("\r\n"))
+    if len(req.body_raw) > 0:
+        _ = builder.write_string(String("\r\n"))
+        _ = builder.write(req.body_raw)
+
+    # Currently the server is expecting a null terminated string for conn.send().
+    return builder.get_null_terminated_bytes()
+
+
 fn encode(res: HTTPResponse) raises -> Bytes:
     var res_str = String()
     var protocol = strHttp11
@@ -236,38 +287,45 @@ fn encode(res: HTTPResponse) raises -> Bytes:
     except e:
         print("Error getting current time: " + str(e))
         current_time = str(now())
+
     var builder = StringBuilder()
+
     _ = builder.write(protocol)
     _ = builder.write_string(String(" "))
     _ = builder.write_string(String(res.header.status_code()))
     _ = builder.write_string(String(" "))
     _ = builder.write(res.header.status_message())
     _ = builder.write_string(String("\r\n"))
+
     _ = builder.write_string(String("Server: lightbug_http"))
     _ = builder.write_string(String("\r\n"))
+
     _ = builder.write_string(String("Content-Type: "))
     _ = builder.write(res.header.content_type())
+    _ = builder.write_string(String("\r\n"))
+
     # TODO: propagate charset
     # res_str += String("; charset=utf-8")
-    _ = builder.write_string(String("\r\n"))
-    _ = builder.write_string(String("Content-Length: "))
-    # TODO: fix this
-    _ = builder.write_string(String(len(res.body_raw)))
-    _ = builder.write_string(String("\r\n"))
+
+    if len(res.body_raw) > 0:
+        _ = builder.write_string(String("Content-Length: "))
+        _ = builder.write_string(String(len(res.body_raw)))
+        _ = builder.write_string(String("\r\n"))
+
     _ = builder.write_string(String("Connection: "))
     if res.connection_close():
         _ = builder.write_string(String("close"))
     else:
         _ = builder.write_string(String("keep-alive"))
     _ = builder.write_string(String("\r\n"))
+
     _ = builder.write_string(String("Date: "))
     _ = builder.write_string(String(current_time))
-    _ = builder.write_string(String("\r\n"))
-    _ = builder.write_string(String("\r\n"))
-    # _ = builder.write_string("<div>hello frend</div>")
-    # _ = builder.write(String("\r\n"))
-    # _ = builder.write(res.body())
-    _ = builder.write(res.body_raw)
+
+    if len(res.body_raw) > 0:
+        _ = builder.write_string(String("\r\n"))
+        _ = builder.write_string(String("\r\n"))
+        _ = builder.write(res.body_raw)
 
     # Currently the server is expecting a null terminated string for conn.send().
     return builder.get_null_terminated_bytes()

lightbug_http/strings.mojo

@@ -2,7 +2,9 @@ from lightbug_http.io.bytes import Bytes
 
 alias strSlash = String("/").as_bytes()
 alias strHttp = String("http").as_bytes()
+alias http = String("http")
 alias strHttps = String("https").as_bytes()
+alias https = String("https")
 alias strHttp11 = String("HTTP/1.1").as_bytes()
 alias strHttp10 = String("HTTP/1.0").as_bytes()
 

lightbug_http/sys/client.mojo

@@ -1,32 +1,24 @@
 from lightbug_http.client import Client
-from lightbug_http.http import HTTPRequest, HTTPResponse
+from lightbug_http.http import HTTPRequest, HTTPResponse, encode
+from lightbug_http.sys.net import create_connection
+from lightbug_http.io.bytes import Bytes
 from external.libc import (
-    c_void,
     c_int,
-    c_uint,
-    c_char,
-    sockaddr,
-    sockaddr_in,
     AF_INET,
     SOCK_STREAM,
-    SHUT_RDWR,
-    htons,
-    inet_pton,
-    to_char_ptr,
     socket,
     connect,
     send,
     recv,
-    shutdown,
     close,
 )
 
+
 struct MojoClient(Client):
     var fd: c_int
-    var name: String
-
     var host: StringLiteral
     var port: Int
+    var name: String
 
     fn __init__(inout self) raises:
         self.fd = socket(AF_INET, SOCK_STREAM, 0)
@@ -39,14 +31,35 @@ struct MojoClient(Client):
         self.host = host
         self.port = port
         self.name = "lightbug_http_client"
-    
-    fn close(self) raises:
-        _ = shutdown(self.fd, SHUT_RDWR)
-        var close_status = close(self.fd)
-        if close_status == -1:
-            print("Failed to close new_sockfd")
 
     fn do(self, req: HTTPRequest) raises -> HTTPResponse:
+        """
+        The `do` method is responsible for sending an HTTP request to a server and receiving the corresponding response.
+
+        It performs the following steps:
+        1. Creates a connection to the server specified in the request.
+        2. Sends the request body using the connection.
+        3. Receives the response from the server.
+        4. Closes the connection.
+        5. Returns the received response as an `HTTPResponse` object.
+
+        Note: The code assumes that the `HTTPRequest` object passed as an argument has a valid URI with a host and port specified.
+
+        Parameters
+        ----------
+        req : HTTPRequest :
+            An `HTTPRequest` object representing the request to be sent.
+
+        Returns
+        -------
+        HTTPResponse :
+            The received response.
+
+        Raises
+        ------
+        Error :
+            If there is a failure in sending or receiving the message.
+        """
         var uri = req.uri()
         try:
             _ = uri.parse()
@@ -58,35 +71,43 @@ struct MojoClient(Client):
         if host == "":
             raise Error("URI is nil")
         var is_tls = False
+
         if uri.is_https():
             is_tls = True
 
-        var host_port = host.split(":")
-        var host_str = host_port[0]
-
-        var ip_buf = Pointer[c_void].alloc(4)
-        var conv_status = inet_pton(AF_INET, to_char_ptr(host_str), ip_buf)
-        var raw_ip = ip_buf.bitcast[c_uint]().load()
+        var host_str: String
+        var port: Int
 
-        var port = atol(host_port[1])
+        if host.__contains__(":"):
+            var host_port = host.split(":")
+            host_str = host_port[0]
+            port = atol(host_port[1])
+        else:
+            host_str = host
+            if is_tls:
+                port = 443
+            else:
+                port = 80
 
-        var bin_port = htons(UInt16(port))
+        var conn = create_connection(self.fd, host_str, port)
 
-        var ai = sockaddr_in(AF_INET, bin_port, raw_ip, StaticTuple[c_char, 8]())
-        var ai_ptr = Pointer[sockaddr_in].address_of(ai).bitcast[sockaddr]()
+        var req_encoded = encode(req)
+        var bytes_sent = conn.write(req_encoded)
+        if bytes_sent == -1:
+            raise Error("Failed to send message")
 
-        if connect(self.fd, ai_ptr, sizeof[sockaddr_in]()) == -1:
-            _ = shutdown(self.fd, SHUT_RDWR)
-            raise Error("Connection error")  # Ensure to exit if connection fails
+        var response: String = ""
+        var new_buf = Bytes()
 
-        var bytes_sent = send(self.fd, to_char_ptr(req.body_raw), len(req.body_raw), 0)
-        if bytes_sent == -1:
-            print("Failed to send message")
+        while True:
+            var bytes_recv = conn.read(new_buf)
+            if bytes_recv == -1:
+                raise Error("Failed to receive message")
+            elif bytes_recv == 0:
+                break
+            else:
+                response += String(new_buf)
 
-        var buf_size = 1024
-        var buf = Pointer[UInt8]().alloc(buf_size)
-        var bytes_recv = recv(self.fd, buf, buf_size, 0)
-        var bytes_str = String(buf.bitcast[Int8](), bytes_recv)
-        _ = close(self.fd)
+        conn.close()
 
-        return HTTPResponse(bytes_str._buffer)
+        return HTTPResponse(response._buffer)