feat: Basic Runtime demos

Author: cdata

Cargo.lock

@@ -1,6 +1,5 @@
 [workspace]
 members = [
-  "rust/example-crate",
   "rust/usuba",
   "rust/usuba-compat"
 ]
@@ -14,6 +13,7 @@ async-trait = { version = "0.1" }
 axum = { version = "0.7" }
 blake3 = { version = "1.5" }
 bytes = { version = "1" }
+hyper-util = { version = "0.1", features = ["client", "client-legacy"] }
 js-component-bindgen = { version = "1", features = ["transpile-bindgen"] }
 js-sys = { version = "0.3" }
 mime_guess = { version = "2" }
@@ -24,6 +24,7 @@ serde_json = { version = "1" }
 tempfile = { version = "3" }
 thiserror = { version = "1" }
 tokio = { version = "1" }
+tower-http = { version = "0.5" }
 tracing = { version = "0.1" }
 tracing-subscriber = { version = "0.3", features = ["env-filter", "tracing-log", "json"] }
 tracing-web = { version = "0.1" }
@@ -37,4 +38,4 @@ wit-parser = { version = "0.208" }
 
 [profile.release]
 opt-level = 'z'
-lto = true
+lto = true

Cargo.toml

@@ -12,6 +12,7 @@ async-trait = { workspace = true }
 axum = { workspace = true, features = ["multipart"] }
 blake3 = { workspace = true }
 bytes = { workspace = true }
+hyper-util = { workspace = true }
 mime_guess = { workspace = true }
 redb = { workspace = true }
 rust-embed = { workspace = true }
@@ -20,6 +21,7 @@ serde_json = { workspace = true }
 tempfile = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "io-util", "process", "fs"] }
+tower-http = { workspace = true, features = ["cors"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 utoipa = { workspace = true, features = ["axum_extras"] }

rust/usuba/Cargo.toml

@@ -9,5 +9,6 @@ pub trait Bake {
         world: &str,
         wit: Vec<Bytes>,
         source_code: Bytes,
+        library: Vec<Bytes>,
     ) -> Result<Bytes, UsubaError>;
 }

rust/usuba/src/bake/bake.rs

@@ -32,6 +32,7 @@ impl Bake for JavaScriptBaker {
         world: &str,
         wit: Vec<Bytes>,
         source_code: Bytes,
+        library: Vec<Bytes>,
     ) -> Result<Bytes, crate::UsubaError> {
         let workspace = TempDir::new()?;
         debug!(
@@ -44,12 +45,22 @@ impl Bake for JavaScriptBaker {
 
         debug!(?workspace, "Created temporary workspace");
 
+        let wit_path = workspace.path().join("wit");
+        let wit_deps_path = wit_path.join("deps");
+
+        tokio::fs::create_dir_all(&wit_deps_path).await?;
+
         let mut writes = JoinSet::new();
 
         wit.into_iter()
             .enumerate()
-            .map(|(i, wit)| write_file(workspace.path().join(format!("module{}.wit", i)), wit))
+            .map(|(i, wit)| write_file(wit_path.join(format!("module{}.wit", i)), wit))
             .chain([write_file(js_path.clone(), source_code)])
+            .chain(
+                library.into_iter().enumerate().map(|(i, wit)| {
+                    write_file(wit_deps_path.join(format!("library{}.wit", i)), wit)
+                }),
+            )
             .for_each(|fut| {
                 writes.spawn(fut);
             });
@@ -66,7 +77,7 @@ impl Bake for JavaScriptBaker {
         command
             .arg("componentize")
             .arg("-w")
-            .arg(workspace.path())
+            .arg(wit_path)
             .arg("-o")
             .arg(wasm_path.display().to_string())
             .arg(js_path.display().to_string());

rust/usuba/src/bake/javascript.rs

@@ -18,9 +18,14 @@ impl Bake for Baker {
         world: &str,
         wit: Vec<Bytes>,
         source_code: Bytes,
+        library: Vec<Bytes>,
     ) -> Result<Bytes, crate::UsubaError> {
         match self {
-            Baker::JavaScript => (JavaScriptBaker {}).bake(world, wit, source_code).await,
+            Baker::JavaScript => {
+                (JavaScriptBaker {})
+                    .bake(world, wit, source_code, library)
+                    .await
+            }
         }
     }
 }

rust/usuba/src/bake/mod.rs

@@ -17,10 +17,16 @@ pub async fn main() -> Result<(), UsubaError> {
     let port = std::option_env!("PORT").unwrap_or("8080");
     let socket_address: SocketAddr = format!("0.0.0.0:{port}").parse()?;
     let listener = tokio::net::TcpListener::bind(socket_address).await?;
+    let upstream = std::option_env!("UPSTREAM")
+        .map(|upstream| upstream.parse().ok())
+        .unwrap_or(None);
 
     info!("Server listening on {}", socket_address);
+    if let Some(upstream) = &upstream {
+        info!("Reverse proxying requests to {}", upstream);
+    }
 
-    serve(listener).await?;
+    serve(listener, upstream).await?;
 
     Ok(())
 }

rust/usuba/src/bin/usuba.rs

@@ -1,6 +1,11 @@
 // use std::fmt::Display;
 
-use axum::{extract::multipart::MultipartError, http::StatusCode, response::IntoResponse, Json};
+use axum::{
+    extract::multipart::MultipartError,
+    http::{uri::InvalidUri, StatusCode},
+    response::IntoResponse,
+    Json,
+};
 use blake3::HexError;
 use redb::{CommitError, DatabaseError, StorageError, TableError, TransactionError};
 use serde::{Deserialize, Serialize};
@@ -21,6 +26,8 @@ pub enum UsubaError {
     InvalidModule(String),
     #[error("Module not found")]
     ModuleNotFound,
+    #[error("Upstream request failed: {0}")]
+    UpstreamError(String),
     #[error("An internal error occurred")]
     Internal(String),
 }
@@ -100,7 +107,20 @@ impl From<JoinError> for UsubaError {
 
 impl From<anyhow::Error> for UsubaError {
     fn from(value: anyhow::Error) -> Self {
-        todo!()
+        UsubaError::Internal(format!("{}", value))
+    }
+}
+
+impl From<hyper_util::client::legacy::Error> for UsubaError {
+    fn from(value: hyper_util::client::legacy::Error) -> Self {
+        UsubaError::UpstreamError(format!("{}", value))
+    }
+}
+
+impl From<InvalidUri> for UsubaError {
+    fn from(value: InvalidUri) -> Self {
+        warn!("{}", value);
+        UsubaError::BadRequest
     }
 }
 
@@ -113,6 +133,7 @@ impl IntoResponse for UsubaError {
             UsubaError::InvalidConfiguration(_) => StatusCode::BAD_REQUEST,
             UsubaError::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
             UsubaError::ModuleNotFound => StatusCode::NOT_FOUND,
+            UsubaError::UpstreamError(_) => StatusCode::BAD_GATEWAY,
         };
 
         (

rust/usuba/src/error.rs

@@ -42,11 +42,12 @@ impl IntoResponse for BuildModuleResponse {
   )
 )]
 pub async fn build_module(
-    State(UsubaState { mut storage }): State<UsubaState>,
+    State(UsubaState { mut storage, .. }): State<UsubaState>,
     mut form_data: Multipart,
 ) -> Result<BuildModuleResponse, UsubaError> {
     let mut world_name: Option<String> = None;
     let mut wit: Vec<Bytes> = Vec::new();
+    let mut library: Vec<Bytes> = Vec::new();
     let mut source_code: Option<Bytes> = None;
     let mut baker: Option<Baker> = None;
 
@@ -89,7 +90,7 @@ pub async fn build_module(
                     }
                 }
                 Some("library") => {
-                    wit.push(field.bytes().await?);
+                    library.push(field.bytes().await?);
                 }
                 Some(name) => warn!("Unexpected multipart content: {name}"),
                 _ => warn!("Skipping unnamed multipart content"),
@@ -98,7 +99,7 @@ pub async fn build_module(
     }
 
     if let (Some(world_name), Some(source_code), Some(baker)) = (world_name, source_code, baker) {
-        let wasm = baker.bake(&world_name, wit, source_code).await?;
+        let wasm = baker.bake(&world_name, wit, source_code, library).await?;
         let hash = storage.write(wasm).await?;
 
         Ok(BuildModuleResponse {

rust/usuba/src/routes/module/build.rs

@@ -15,7 +15,7 @@ use crate::{HashStorage, UsubaError, UsubaState};
   )
 )]
 pub async fn retrieve_module(
-    State(UsubaState { storage }): State<UsubaState>,
+    State(UsubaState { storage, .. }): State<UsubaState>,
     Path((id,)): Path<(String,)>,
 ) -> Result<Bytes, UsubaError> {
     let hash = Hash::from_str(&id)?;