WIP

Author: cdata

Cargo.toml

@@ -4,7 +4,8 @@ members = [
   "rust/common-javascript-interpreter",
   "rust/common-macros",
   "rust/common-protos",
-  "rust/common-runtime",
+  # "rust/common-runtime",
+  "rust/common-runtime-experiment",
   "rust/common-test-fixtures",
   "rust/common-tracing",
   "rust/common-wit",
@@ -28,7 +29,7 @@ common-builder = { path = "./rust/common-builder" }
 common-javascript-interpreter = { path = "./rust/common-javasript-interpreter" }
 common-macros = { path = "./rust/common-macros" }
 common-protos = { path = "./rust/common-protos", default-features = false }
-common-runtime = { path = "./rust/common-runtime" }
+common-runtime = { path = "./rust/common-runtime-experiment" }
 common-test-fixtures = { path = "./rust/common-test-fixtures" }
 common-tracing = { path = "./rust/common-tracing" }
 common-wit = { path = "./rust/common-wit" }

rust/common-javascript-interpreter/Cargo.toml

@@ -25,11 +25,8 @@ common-test-fixtures = { workspace = true }
 crate-type = ["cdylib"]
 
 [package.metadata.component.target]
-path = "wit/deps/script/script.wit"
-world = "common"
-
-[package.metadata.component.target.dependencies."common:module"]
-path = "wit/deps/module/module.wit"
+path = "wit/deps/function/function.wit"
+world = "virtual-module"
 
 [package.metadata.component.target.dependencies."common:data"]
 path = "wit/deps/data/data.wit"

rust/common-javascript-interpreter/build.rs

@@ -3,8 +3,7 @@ use std::process::Command;
 const TYPESCRIPT_SOURCE_DEPENDENCIES: &[&str] = &[
     "common/io/wit/io.wit",
     "common/data/wit/data.wit",
-    "common/module/wit/module.wit",
-    "common/script/wit/script.wit",
+    "common/function/wit/function.wit",
 ];
 
 fn main() {

rust/common-javascript-interpreter/wit/deps.lock

@@ -6,12 +6,8 @@ sha512 = "aa6f16d180975d35dde3ebcd1b6a21992ee9e38ba9edf3f5535ff3415c3933792c8be5
 sha256 = "3d6c8ae11439a90d1260d64030dc9ac003a72f2f7277df787b95c5a8f54d7474"
 sha512 = "87c77c5a22fdc2c9850ff9e6672f94a86c7c32a6f665d714caca5613f6bc2a1cca76d7ebb26ddf3bae80c32d5d692baab803aff61207aaaa87ffdbd8e6cdc109"
 
-[module]
-sha256 = "cc4b0b5358ef2f51743b26a09a4a81bca23cb647f0561691387d28bc48dbbd26"
-sha512 = "7ff0a2fc4fa76decae57a3a8b8ee7f68c25c813eb1405e90e0c89a8045056b9cf5c1f3fa419845579cf920fd7e00f9c923b25664dc282dbff232a1dbd6e295d2"
-
 [script]
-path = "../../../typescript/common/script/wit"
-sha256 = "a0eca742d07bf481984e31f05de30d89da0016b92a896bee3b83d6abada7ebf1"
-sha512 = "f8849fd3c07f9e553c7909b90e53ee8a34c8f4a6982ebbb1fe2493e9f7db75d3d51f34e967794714903443abf9a6f180a74bfc555a4ac43c76832eba6ecd9aa6"
-deps = ["data", "io", "module"]
+path = "../../../typescript/common/function/wit"
+sha256 = "4d2c15922d458487d376361c47a3dc62089540d2ebc0a1b2fc9e524c323d02b3"
+sha512 = "a7d6f665016bdb9bbb72d3cbf533266cc5390a133056499e5a2a01896b93685f50144c547b2fcede78a01d1b92cce9d2666e5e30dce5a1dd6397a7b5a3f9abcc"
+deps = ["data", "io"]

rust/common-javascript-interpreter/wit/deps.toml

@@ -1 +1 @@
-script = "../../../typescript/common/script/wit"
+script = "../../../typescript/common/function/wit"

rust/common-runtime-experiment/Cargo.toml

@@ -0,0 +1,54 @@
+[package]
+name = "common-runtime"
+description = "A Common runtime"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+async-stream = { workspace = true }
+blake3 = { workspace = true }
+bytes = { workspace = true }
+common-protos = { workspace = true, features = ["runtime", "builder"] }
+common-tracing = { workspace = true }
+common-wit = { workspace = true }
+http = { workspace = true }
+mime_guess = { workspace = true }
+rand = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+sieve-cache = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+clap = { workspace = true, features = ["derive"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "io-util", "process", "fs"] }
+tonic = { workspace = true, features = ["codegen", "prost", "transport"] }
+tower-http = { workspace = true, features = ["cors"] }
+wasmtime = { workspace = true }
+wasmtime-wasi = { workspace = true }
+wasmtime-wasi-http = { workspace = true }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+getrandom = { workspace = true, features = ["js"]}
+tokio = { workspace = true, features = ["rt"] }
+tonic = { workspace = true, features = ["codegen", "prost"] }
+tonic-web-wasm-client = { workspace = true }
+
+[build-dependencies]
+tempfile = { workspace = true }
+
+[dev-dependencies]
+common-builder = { workspace = true }
+common-test-fixtures = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = { workspace = true, features = ["async_tokio"] }
+
+# [[bench]]
+# name = "runtime_bench"
+# harness = false
+# required-features = ["bench"]

rust/common-runtime-experiment/README.md

@@ -0,0 +1,3 @@
+# common-runtime 
+
+The Common Runtime is responsible for instantiating a Common Recipe and managing its lifecycle.

rust/common-runtime-experiment/src/content_type.rs

@@ -0,0 +1,28 @@
+use common_protos::common;
+
+/// Supported content types that may be embodied as a [crate::CommonModule]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ContentType {
+    /// JavaScript or TypeScript code
+    JavaScript,
+    /// Python code
+    Python,
+}
+
+impl From<common::ContentType> for ContentType {
+    fn from(value: common::ContentType) -> Self {
+        match value {
+            common::ContentType::JavaScript => ContentType::JavaScript,
+            common::ContentType::Python => ContentType::Python,
+        }
+    }
+}
+
+impl From<ContentType> for common::ContentType {
+    fn from(value: ContentType) -> Self {
+        match value {
+            ContentType::JavaScript => common::ContentType::JavaScript,
+            ContentType::Python => common::ContentType::Python,
+        }
+    }
+}

rust/common-runtime-experiment/src/error.rs

@@ -0,0 +1,68 @@
+use std::fmt::Debug;
+use thiserror::Error;
+
+use crate::ModuleInstanceId;
+
+/// Various errors that may be encountered when invoking runtime code.
+#[derive(Error, Debug)]
+pub enum CommonRuntimeError {
+    /// A Wasm Component failed to prepare
+    #[error("Failed to prepare a Wasm Component: {0}")]
+    PreparationFailed(String),
+
+    /// A Wasm Component failed to link
+    #[error("Failed to link a Wasm Component: {0}")]
+    LinkFailed(String),
+
+    /// A sandbox failed to be created
+    #[error("Failed to instantiate a sandbox: {0}")]
+    SandboxCreationFailed(String),
+
+    /// A Common Module failed to be instantiated
+    #[error("Failed to instantiate a Common Module: {0}")]
+    ModuleInstantiationFailed(String),
+
+    /// An error occurred when a Common Module was run
+    #[error("Failed to run a Common Module: {0}")]
+    ModuleRunFailed(String),
+
+    /// An unexpected internal error occurred
+    #[error("Internal error")]
+    InternalError(String),
+
+    /// A specified Common Module ID was not valid
+    #[error("Invalid Common Module ID: {0}")]
+    InvalidModuleId(String),
+
+    /// The configured target was missing or invalid
+    #[error("Invalid Common Module Target: {0}")]
+    InvalidModuleTarget(String),
+
+    /// The configured target was missing or invalid
+    #[error("Invalid Common Module Affinity: {0}")]
+    InvalidModuleAffinity(String),
+
+    /// The specified Common Module instance ID did not correspond to a living
+    /// instance
+    #[error("Unknown Common Module instance ID: {0}")]
+    UnknownInstanceId(ModuleInstanceId),
+
+    /// A provided Value was empty or of an unexpected shape
+    #[error("Invalid Value")]
+    InvalidValue,
+
+    /// The provided module sources were missing or otherwise invalid
+    #[error("Invalid module source: {0}")]
+    InvalidModuleSource(String),
+
+    /// The provided instantiation parameters are not supported
+    #[error("Invalid instantiation parameters: {0}")]
+    InvalidInstantiationParameters(String),
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From<tonic::transport::Error> for CommonRuntimeError {
+    fn from(value: tonic::transport::Error) -> Self {
+        CommonRuntimeError::InternalError(format!("{value}"))
+    }
+}

rust/common-runtime-experiment/src/io.rs

@@ -0,0 +1,55 @@
+use std::collections::BTreeMap;
+
+use crate::{sync::ConditionalSync, Value, ValueKind};
+
+/// A convenience alias for the expected shape of Common Module outputs
+pub type Output = BTreeMap<String, Value>;
+
+/// A convenience alias for the expected shape of Common Module output shapes
+pub type OutputShape = BTreeMap<String, ValueKind>;
+
+/// A generic trait for a reference to state. The implementation may embody
+/// state that is opaque, readable and/or writable.
+pub trait InputOutput: Clone + Default + ConditionalSync + std::fmt::Debug {
+    /// Attempt to read some [Value] from state that is assigned some well-known
+    /// `key`. A value may be returned if it is part of the state, and the reader
+    /// is allowed to read it.
+    fn read(&self, key: &str) -> Option<Value>;
+
+    /// Write some [Value] to a well-known `key`. The write may or may not be
+    /// accepted. There is no prescription made as to the transactional
+    /// guarantees of a call to `write`. Subsequent calls to `read` for the same
+    /// `key` may or may not reflect the effect of a `write`, regardless of
+    /// whether or not it was considered to be successful.
+    fn write(&mut self, key: &str, value: Value);
+
+    /// Get a mapping of the output keys to their set values. Keys with no set
+    /// values will not be pressent in the output, even if they were allowed to
+    /// be set.
+    fn output(&self) -> &Output;
+
+    /// Get the shape of the output, which is the expected [ValueKind] that maps
+    /// to each allowed key in the output space
+    fn output_shape(&self) -> &OutputShape;
+}
+
+impl<Io> InputOutput for Box<Io>
+where
+    Io: InputOutput,
+{
+    fn read(&self, key: &str) -> Option<Value> {
+        self.as_ref().read(key)
+    }
+
+    fn write(&mut self, key: &str, value: Value) {
+        self.as_mut().write(key, value)
+    }
+
+    fn output(&self) -> &Output {
+        self.as_ref().output()
+    }
+
+    fn output_shape(&self) -> &OutputShape {
+        self.as_ref().output_shape()
+    }
+}