feat(http-server): Add WASI reactor support to http-server cap (#359)

Cargo.toml

@@ -99,5 +99,7 @@ rand = "0.8"
 members = [
     "crates/core",
     "crates/common",
+    "crates/http-server-macro",
+    "crates/http-handler-macro",
     "tests"
 ]

crates/common/src/context.rs

@@ -1,9 +1,12 @@
-use slight_http_api::HttpHandlerData;
+use slight_http_api::{HttpHandlerData, HttpServerExportData};
 
 /// A WebAssembly runtime context to be consumed by the wasm component.
 pub trait Ctx {
     /// Get the mutable reference to the http handler data.
-    fn get_http_state_mut(&mut self) -> &mut HttpHandlerData;
+    fn get_http_handler_mut(&mut self) -> &mut HttpHandlerData;
+
+    /// Get the mutable reference to the http server data.
+    fn get_http_server_mut(&mut self) -> &mut HttpServerExportData;
 
     /// Get the runtime host state for a given resource key.
     fn get_host_state<T: 'static, TTable: 'static>(

crates/http-api/src/lib.rs

@@ -1,14 +1,53 @@
 use anyhow::{bail, Result};
 pub use http_handler::{HttpError, HttpHandlerData, Method, Request, Response};
+pub use http_server_export::HttpServerExportData;
 use hyper::{
     body::HttpBody as HyperHttpBody,
     header::{HeaderName, HeaderValue},
     Body, HeaderMap, StatusCode,
 };
 
 wit_bindgen_wasmtime::import!({paths: ["../../wit/http-handler.wit"], async: *});
+wit_bindgen_wasmtime::import!({paths: ["../../wit/http-server-export.wit"], async: *});
 wit_error_rs::impl_error!(http_handler::HttpError);
 
+/// An exported HTTP server init function from the wasm module
+///
+/// This is a wrapper implementation of the WIT generated `HttpServerExport`
+pub struct HttpServerInit<T> {
+    inner: http_server_export::HttpServerExport<T>,
+}
+
+impl<T> AsRef<http_server_export::HttpServerExport<T>> for HttpServerInit<T> {
+    fn as_ref(&self) -> &http_server_export::HttpServerExport<T> {
+        &self.inner
+    }
+}
+
+impl<T> AsMut<http_server_export::HttpServerExport<T>> for HttpServerInit<T> {
+    fn as_mut(&mut self) -> &mut http_server_export::HttpServerExport<T> {
+        &mut self.inner
+    }
+}
+
+impl<T: Send> HttpServerInit<T> {
+    pub fn new(
+        store: impl wasmtime::AsContextMut<Data = T>,
+        instance: &wasmtime::Instance,
+        get_state: impl Fn(&mut T) -> &mut HttpServerExportData + Send + Sync + Copy + 'static,
+    ) -> Result<Self> {
+        http_server_export::HttpServerExport::new(store, instance, get_state)
+            .map(|inner| Self { inner })
+    }
+
+    pub async fn on_server_init(
+        &self,
+        caller: impl wasmtime::AsContextMut<Data = T>,
+    ) -> Result<Result<(), String>, anyhow::Error> {
+        self.inner.on_server_init(caller).await
+    }
+}
+
 /// A HTTP Handler that finds the handler function from the wasm module
 /// and calls it with the HTTP request.
 ///

crates/http-handler-macro/src/lib.rs

@@ -64,7 +64,6 @@ pub fn register_handler(_attr: TokenStream, item: TokenStream) -> TokenStream {
     // builds struct name from function name
     let struct_name = handle_func
         .split('_')
-        .into_iter()
         .map(capitalize_first_letter)
         .collect::<String>();
 
@@ -74,7 +73,6 @@ pub fn register_handler(_attr: TokenStream, item: TokenStream) -> TokenStream {
     // builds trait name from mod name
     let trait_name = mod_name
         .split('_')
-        .into_iter()
         .map(capitalize_first_letter)
         .collect::<String>();
     let internal_mod = format!("{}_internal", &mod_name);
@@ -120,6 +118,20 @@ pub fn register_handler(_attr: TokenStream, item: TokenStream) -> TokenStream {
             impl #trait_ident for #struct_ident {
                 #func
             }
+
+            impl std::fmt::Display for #mod_ident::Method {
+                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                    match self {
+                        #mod_ident::Method::Get => write!(f, "GET"),
+                        #mod_ident::Method::Post => write!(f, "POST"),
+                        #mod_ident::Method::Put => write!(f, "PUT"),
+                        #mod_ident::Method::Delete => write!(f, "DELETE"),
+                        #mod_ident::Method::Patch => write!(f, "PATCH"),
+                        #mod_ident::Method::Head => write!(f, "HEAD"),
+                        #mod_ident::Method::Options => write!(f, "OPTIONS")
+                    }
+                }
+            }
         }
     )
     .into()
@@ -135,15 +147,13 @@ mod unittests {
         let struct_name = func_name
             .to_string()
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(struct_name, "HandleHello".to_string());
 
         let mod_name = format!("{func_name}_mod");
         let trait_name = mod_name
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(trait_name, "HandleHelloMod");
@@ -152,15 +162,13 @@ mod unittests {
         let struct_name = func_name
             .to_string()
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(struct_name, "Handle".to_string());
 
         let mod_name = format!("{func_name}_mod");
         let trait_name = mod_name
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(trait_name, "HandleMod");
@@ -169,15 +177,13 @@ mod unittests {
         let struct_name = func_name
             .to_string()
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(struct_name, "HandleFuncA".to_string());
 
         let mod_name = format!("{func_name}_mod");
         let trait_name = mod_name
             .split('_')
-            .into_iter()
             .map(capitalize_first_letter)
             .collect::<String>();
         assert_eq!(trait_name, "HandleFuncAMod");

crates/http-server-macro/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "slight-http-server-macro"
+version = "0.1.0"
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+repository = { workspace = true }
+
+[lib]
+proc-macro = true
+doctest = false
+
+[dependencies]
+anyhow = { workspace = true }
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "1", features = ["full"] }
+wit-bindgen-gen-rust-wasm = { git = "https://github.com/fermyon/wit-bindgen-backport" }
+wit-bindgen-gen-core = { git = "https://github.com/fermyon/wit-bindgen-backport" }

crates/http-server-macro/src/lib.rs

@@ -0,0 +1,28 @@
+use proc_macro::TokenStream;
+use quote::quote;
+
+#[proc_macro_attribute]
+pub fn on_server_init(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    // parse the item as rust Fn
+    let func = syn::parse_macro_input!(item as syn::ItemFn);
+    let func_name = &func.sig.ident;
+
+    // generate rust code
+    quote!(
+
+        struct HttpServerExport {}
+
+        impl http_server_export::HttpServerExport for HttpServerExport {
+            fn on_server_init() -> Result<(), String> {
+
+                #func
+
+                match #func_name() {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(e.to_string()),
+                }
+            }
+        }
+    )
+    .into()
+}

crates/http-server/src/lib.rs

@@ -18,6 +18,7 @@ use slight_common::{impl_resource, Builder, Ctx, WasmtimeBuildable};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tracing::log;
 
+pub use slight_http_api::HttpServerInit;
 use slight_http_api::{HttpBody, HttpHandler, HttpHeader, Method, Request};
 
 wit_bindgen_wasmtime::export!("../../wit/http-server.wit");
@@ -335,7 +336,7 @@ async fn handler<T: WasmtimeBuildable + Send + Sync + 'static>(
     // Construct http handler
     let handler_name = &route.handler.replace('_', "-");
     let handler = HttpHandler::new(&mut store, &instance, handler_name, |ctx| {
-        ctx.get_http_state_mut()
+        ctx.get_http_handler_mut()
     })?;
 
     // Invoke the handler with http request

crates/runtime/src/lib.rs

@@ -9,7 +9,7 @@ use std::{
 use anyhow::Result;
 use async_trait::async_trait;
 use ctx::SlightCtxBuilder;
-use resource::{get_host_state, HttpData};
+use resource::{get_host_state, HttpData, HttpServerExportData};
 use slight_common::{CapabilityBuilder, WasmtimeBuildable, WasmtimeLinkable};
 use wasi_cap_std_sync::{ambient_authority, Dir, WasiCtxBuilder};
 use wasi_common::pipe::{ReadPipe, WritePipe};
@@ -34,10 +34,11 @@ pub struct RuntimeContext {
     pub wasi: Option<WasiCtx>,
     pub slight: SlightCtx,
     pub http_state: HttpData,
+    pub http_server_state: HttpServerExportData,
 }
 
 impl slight_common::Ctx for RuntimeContext {
-    fn get_http_state_mut(&mut self) -> &mut HttpData {
+    fn get_http_handler_mut(&mut self) -> &mut HttpData {
         &mut self.http_state
     }
 
@@ -47,6 +48,10 @@ impl slight_common::Ctx for RuntimeContext {
     ) -> (&mut T, &mut TTable) {
         get_host_state(self, resource_key)
     }
+
+    fn get_http_server_mut(&mut self) -> &mut slight_http_api::HttpServerExportData {
+        &mut self.http_server_state
+    }
 }
 
 /// Input and output redirects to be used for the running module
@@ -147,6 +152,7 @@ impl WasmtimeBuildable for Builder {
             wasi: Some(wasi),
             slight: self.state_builder.build(),
             http_state: HttpData::default(),
+            http_server_state: HttpServerExportData::default(),
         };
 
         let mut store = Store::new(&self.engine, ctx);

crates/runtime/src/resource.rs

@@ -3,7 +3,7 @@ pub use crate::RuntimeContext;
 
 use as_any::Downcast;
 
-use slight_http_api::HttpHandlerData;
+pub use slight_http_api::{HttpHandlerData, HttpServerExportData};
 pub use wasmtime::Linker;
 
 /// Guest data for http handler