Merge remote-tracking branch 'upstream/main'

Author: saviorand

.env.example

@@ -0,0 +1,3 @@
+DEFAULT_SERVER_PORT=8080
+DEFAULT_SERVER_HOST=localhost
+APP_ENTRYPOINT=lightbug.🔥

.github/workflows/branch.yml

@@ -20,3 +20,15 @@ jobs:
 
   package:
     uses: ./.github/workflows/package.yml
+
+  docker:
+    needs: package
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      tags: |
+        type=ref,event=branch
+        type=sha,format=long
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
+

.github/workflows/docker-build.yml

@@ -0,0 +1,48 @@
+name: Docker Build and Push
+
+on:
+  workflow_call:
+    inputs:
+      tags:
+        required: true
+        type: string
+    secrets:
+      DOCKERHUB_USERNAME:
+        required: true
+      DOCKERHUB_TOKEN:
+        required: true
+
+jobs:
+  docker:
+    name: Build and push Docker image
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/lightbug_http
+          tags: ${{ inputs.tags }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./docker/lightbug.dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/main.yml

@@ -19,4 +19,14 @@ jobs:
     secrets:
       PREFIX_API_KEY: ${{ secrets.PREFIX_API_KEY }}
 
-
+  docker:
+    needs: [package, publish]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      tags: |
+        type=raw,value=edge
+        type=raw,value=stable
+        type=sha,prefix=stable-
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}

.github/workflows/release.yml

@@ -40,3 +40,15 @@ jobs:
           file: lightbug_http.mojopkg
           tag: ${{ steps.get_version.outputs.VERSION }}
           overwrite: true
+
+  docker:
+    needs: [package, upload-to-release]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      tags: |
+        type=semver,pattern={{version}}
+        type=semver,pattern={{major}}.{{minor}}
+        type=raw,value=latest
+    secrets:
+      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
+      DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}

README.md

@@ -29,17 +29,16 @@ Lightbug is a simple and sweet HTTP framework for Mojo that builds on best pract
 This is not production ready yet. We're aiming to keep up with new developments in Mojo, but it might take some time to get to a point when this is safe to use in real-world applications.
 
 Lightbug currently has the following features:
- - [x] Pure Mojo networking! No dependencies on Python by default
- - [x] TCP-based server and client implementation
- - [x] Assign your own custom handler to a route
- - [x] Craft HTTP requests and responses with built-in primitives
- - [x] Everything is fully typed, with no `def` functions used
+ - [x] Pure Mojo! No Python dependencies. Everything is fully typed, with no `def` functions used
+ - [x] HTTP Server and Client implementations
+ - [x] TCP and UDP support
+ - [x] Cookie support
 
  ### Check Out These Mojo Libraries:
 
 - Logging - [@toasty/stump](https://github.com/thatstoasty/stump)
 - CLI and Terminal - [@toasty/prism](https://github.com/thatstoasty/prism), [@toasty/mog](https://github.com/thatstoasty/mog)
-- Date/Time - [@mojoto/morrow](https://github.com/mojoto/morrow.mojo) and [@toasty/small-time](https://github.com/thatstoasty/small-time)
+- Date/Time - [@mojoto/morrow](https://github.com/mojoto/morrow.mojo) and [@toasty/small_time](https://github.com/thatstoasty/small_time)
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
@@ -61,7 +60,7 @@ Once you have a Mojo project set up locally,
 
    ```toml
    [dependencies]
-   lightbug_http = ">=0.1.9"
+   lightbug_http = ">=0.1.11"
    ```
 
 3. Run `magic install` at the root of your project, where `mojoproject.toml` is located
@@ -97,25 +96,22 @@ Once you have a Mojo project set up locally,
    For example, to make a `Printer` service that prints some details about the request to console:
 
    ```mojo
-    from lightbug_http import *
+    from lightbug_http.http import HTTPRequest, HTTPResponse, OK
+    from lightbug_http.strings import to_string
+    from lightbug_http.header import HeaderKey
 
     @value
     struct Printer(HTTPService):
         fn func(mut self, req: HTTPRequest) raises -> HTTPResponse:
-            var uri = req.uri
-            print("Request URI: ", to_string(uri.request_uri))
-
-            var header = req.headers
-            print("Request protocol: ", req.protocol)
-            print("Request method: ", req.method)
-            print(
-                "Request Content-Type: ", to_string(header[HeaderKey.CONTENT_TYPE])
-            )
-
-            var body = req.body_raw
-            print("Request Body: ", to_string(body))
-
-            return OK(body)
+            print("Request URI:", req.uri.request_uri)
+            print("Request protocol:", req.protocol)
+            print("Request method:", req.method)
+            if HeaderKey.CONTENT_TYPE in req.headers:
+                print("Request Content-Type:", req.headers[HeaderKey.CONTENT_TYPE])
+            if req.body_raw:
+                print("Request Body:", to_string(req.body_raw))
+
+            return OK(req.body_raw)
    ```
 
 6. Start a server listening on a port with your service like so.
@@ -126,12 +122,12 @@ Once you have a Mojo project set up locally,
     fn main() raises:
         var server = Server()
         var handler = Welcome()
-        server.listen_and_serve("0.0.0.0:8080", handler)
+        server.listen_and_serve("localhost:8080", handler)
     ```
 
 Feel free to change the settings in `listen_and_serve()` to serve on a particular host and port.
 
-Now send a request `0.0.0.0:8080`. You should see some details about the request printed out to the console.
+Now send a request `localhost:8080`. You should see some details about the request printed out to the console.
 
 Congrats 🥳 You're using Lightbug!
 
@@ -200,19 +196,15 @@ from lightbug_http import *
 from lightbug_http.client import Client
 
 fn test_request(mut client: Client) raises -> None:
-    var uri = URI.parse_raises("http://httpbin.org/status/404")
-    var headers = Header("Host", "httpbin.org")
-
+    var uri = URI.parse("google.com")
+    var headers = Headers(Header("Host", "google.com"))
     var request = HTTPRequest(uri, headers)
     var response = client.do(request^)
 
     # print status code
     print("Response:", response.status_code)
 
-    # print parsed headers (only some are parsed for now)
-    print("Content-Type:", response.headers["Content-Type"])
-    print("Content-Length", response.headers["Content-Length"])
-    print("Server:", to_string(response.headers["Server"]))
+    print(response.headers)
 
     print(
         "Is connection set to connection-close? ", response.connection_close()
@@ -232,16 +224,50 @@ fn main() -> None:
 
 Pure Mojo-based client is available by default. This client is also used internally for testing the server.
 
-## Switching between pure Mojo and Python implementations
-
-By default, Lightbug uses the pure Mojo implementation for networking. To use Python's `socket` library instead, just import the `PythonServer` instead of the `Server` with the following line:
+### UDP Support
+To get started with UDP, just use the `listen_udp` and `dial_udp` functions, along with `write_to` and `read_from` methods, like below.
 
+On the client:
 ```mojo
-from lightbug_http.python.server import PythonServer
+from lightbug_http.connection import dial_udp
+from lightbug_http.address import UDPAddr
+from utils import StringSlice
+
+alias test_string = "Hello, lightbug!"
+
+fn main() raises:
+    print("Dialing UDP server...")
+    alias host = "127.0.0.1"
+    alias port = 12000
+    var udp = dial_udp(host, port)
+
+    print("Sending " + str(len(test_string)) + " messages to the server...")
+    for i in range(len(test_string)):
+        _ = udp.write_to(str(test_string[i]).as_bytes(), host, port)
+
+        try:
+            response, _, _ = udp.read_from(16)
+            print("Response received:", StringSlice(unsafe_from_utf8=response))
+        except e:
+            if str(e) != str("EOF"):
+                raise e
+
 ```
 
-You can then use all the regular server commands in the same way as with the default server.
-Note: as of September, 2024, `PythonServer` and `PythonClient` throw a compilation error when starting. There's an open [issue](https://github.com/saviorand/lightbug_http/issues/41) to fix this - contributions welcome!
+On the server:
+```mojo
+fn main() raises:
+    var listener = listen_udp("127.0.0.1", 12000)
+
+    while True:
+        response, host, port = listener.read_from(16)
+        var message = StringSlice(unsafe_from_utf8=response)
+        print("Message received:", message)
+
+        # Response with the same message in uppercase
+        _ = listener.write_to(String.upper(message).as_bytes(), host, port)
+
+```
 
 <!-- ROADMAP -->
 ## Roadmap
@@ -252,19 +278,17 @@ Note: as of September, 2024, `PythonServer` and `PythonClient` throw a compilati
 
 We're working on support for the following (contributors welcome!):
 
--  [ ] [WebSocket Support](https://github.com/saviorand/lightbug_http/pull/57)
+ - [ ] [JSON support](https://github.com/saviorand/lightbug_http/issues/4)
+ - [ ] Complete HTTP/1.x support compliant with RFC 9110/9112 specs (see issues)
  - [ ] [SSL/HTTPS support](https://github.com/saviorand/lightbug_http/issues/20)
- - [ ] UDP support
- - [ ] [Better error handling](https://github.com/saviorand/lightbug_http/issues/3), [improved form/multipart and JSON support](https://github.com/saviorand/lightbug_http/issues/4)
  - [ ] [Multiple simultaneous connections](https://github.com/saviorand/lightbug_http/issues/5), [parallelization and performance optimizations](https://github.com/saviorand/lightbug_http/issues/6)
  - [ ] [HTTP 2.0/3.0 support](https://github.com/saviorand/lightbug_http/issues/8)
- - [ ] [ASGI spec conformance](https://github.com/saviorand/lightbug_http/issues/17)
 
 The plan is to get to a feature set similar to Python frameworks like [Starlette](https://github.com/encode/starlette), but with better performance.
 
 Our vision is to develop three libraries, with `lightbug_http` (this repo) as a starting point: 
- - `lightbug_http` - HTTP infrastructure and basic API development
- - `lightbug_api` - (coming later in 2024!) Tools to make great APIs fast, with support for OpenAPI spec and domain driven design
+ - `lightbug_http` - Lightweight and simple HTTP framework, basic networking primitives
+ - [`lightbug_api`](https://github.com/saviorand/lightbug_api) - Tools to make great APIs fast, with OpenAPI support and automated docs
  - `lightbug_web` - (release date TBD) Full-stack web framework for Mojo, similar to NextJS or SvelteKit
 
 The idea is to get to a point where the entire codebase of a simple modern web application can be written in Mojo. 

benchmark/bench.mojo

@@ -2,7 +2,7 @@ from memory import Span
 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.io.bytes import ByteReader, ByteWriter
 from lightbug_http.http import HTTPRequest, HTTPResponse, encode
 from lightbug_http.uri import URI
 
@@ -11,9 +11,7 @@ alias headers = "GET /index.html HTTP/1.1\r\nHost: example.com\r\nUser-Agent: Mo
 alias body = "I am the body of an HTTP request" * 5
 alias body_bytes = bytes(body)
 alias Request = "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 = "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
+alias Response = "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():
@@ -26,24 +24,12 @@ fn run_benchmark():
         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.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")
@@ -99,15 +85,19 @@ fn lightbug_benchmark_request_parse(mut b: Bencher):
 fn lightbug_benchmark_request_encode(mut b: Bencher):
     @always_inline
     @parameter
-    fn request_encode():
+    fn request_encode() raises:
+        var uri = URI.parse("http://127.0.0.1:8080/some-path")
         var req = HTTPRequest(
-            URI.parse("http://127.0.0.1:8080/some-path"),
+            uri=uri,
             headers=headers_struct,
             body=body_bytes,
         )
         _ = encode(req^)
 
-    b.iter[request_encode]()
+    try:
+        b.iter[request_encode]()
+    except e:
+        print("failed to encode request, error: ", e)
 
 
 @parameter
@@ -130,8 +120,7 @@ fn lightbug_benchmark_header_parse(mut b: Bencher):
             var header = Headers()
             var reader = ByteReader(headers.as_bytes())
             _ = header.parse_raw(reader)
-        except:
-            print("failed")
+        except e:
+            print("failed", e)
 
     b.iter[header_parse]()
-

benchmark/bench_server.mojo

@@ -6,7 +6,7 @@ def main():
     try:
         var server = Server(tcp_keep_alive=True)
         var handler = TechEmpowerRouter()
-        server.listen_and_serve("0.0.0.0:8080", handler)
+        server.listen_and_serve("localhost:8080", handler)
     except e:
         print("Error starting server: " + e.__str__())
         return