Fix rebasing issues

rylev · rylev · commit 3ce559f2dba3 · 2024-09-04T11:10:46.000+02:00
Signed-off-by: Ryan Levick &lt;ryan.levick@fermyon.com&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -70,7 +70,7 @@ terminal = { path = "crates/terminal" }
 subprocess = "0.2.9"
 tempfile = "3.8.0"
 tokio = { version = "1.23", features = ["full"] }
-toml = "0.6"
+toml = "0.8"
 tracing = { workspace = true }
 url = "2.2.2"
 uuid = { version = "^1.0", features = ["v4"] }
diff --git a/crates/factors-derive/src/lib.rs b/crates/factors-derive/src/lib.rs
@@ -211,6 +211,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
             )*
         }
 
+        #[allow(dead_code)]
         impl #builders_name {
             #(
                 pub fn #factor_names(&mut self) -> &mut <#factor_types as #Factor>::InstanceBuilder {
diff --git a/crates/factors-executor/src/lib.rs b/crates/factors-executor/src/lib.rs
@@ -7,7 +7,7 @@ use spin_factors::{AsInstanceState, ConfiguredApp, RuntimeFactors, RuntimeFactor
 
 /// A FactorsExecutor manages execution of a Spin app.
 ///
-/// `Factors` is the executor's [`RuntimeFactors`]. `ExecutorInstanceState`
+/// It is generic over the executor's [`RuntimeFactors`]. Additionally, it
 /// holds any other per-instance state needed by the caller.
 pub struct FactorsExecutor<T: RuntimeFactors, U = ()> {
     core_engine: spin_core::Engine<InstanceState<T::InstanceState, U>>,
@@ -110,6 +110,9 @@ type InstancePre<T, U> =
     spin_core::InstancePre<InstanceState<<T as RuntimeFactors>::InstanceState, U>>;
 
 /// A FactorsExecutorApp represents a loaded Spin app, ready for instantiation.
+///
+/// It is generic over the executor's [`RuntimeFactors`] and any ad-hoc additional
+/// per-instance state needed by the caller.
 pub struct FactorsExecutorApp<T: RuntimeFactors, U> {
     executor: FactorsExecutor<T, U>,
     configured_app: ConfiguredApp<T>,
@@ -173,14 +176,16 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutorApp<T, U> {
     }
 }
 
-/// A FactorsInstanceBuilder manages the instantiation of a Spin component
-/// instance.
-pub struct FactorsInstanceBuilder<'a, T: RuntimeFactors, U> {
+/// A FactorsInstanceBuilder manages the instantiation of a Spin component instance.
+///
+/// It is generic over the executor's [`RuntimeFactors`] and any ad-hoc additional
+/// per-instance state needed by the caller.
+pub struct FactorsInstanceBuilder<'a, F: RuntimeFactors, U> {
     app_component: AppComponent<'a>,
     store_builder: spin_core::StoreBuilder,
-    factor_builders: T::InstanceBuilders,
-    instance_pre: &'a InstancePre<T, U>,
-    factors: &'a T,
+    factor_builders: F::InstanceBuilders,
+    instance_pre: &'a InstancePre<F, U>,
+    factors: &'a F,
 }
 
 impl<'a, T: RuntimeFactors, U> FactorsInstanceBuilder<'a, T, U> {
@@ -221,6 +226,9 @@ impl<'a, T: RuntimeFactors, U: Send> FactorsInstanceBuilder<'a, T, U> {
 }
 
 /// InstanceState is the [`spin_core::Store`] `data` for an instance.
+///
+/// It is generic over the [`RuntimeFactors::InstanceState`] and any ad-hoc
+/// data needed by the caller.
 pub struct InstanceState<T, U> {
     core: spin_core::State,
     factors: T,
diff --git a/crates/factors/src/runtime_factors.rs b/crates/factors/src/runtime_factors.rs
@@ -81,7 +81,9 @@ pub trait RuntimeFactors: Send + Sync + Sized + 'static {
     ) -> Option<Option<&mut F::InstanceBuilder>>;
 }
 
+/// Allows querying an `InstanceBuilders` for a particular `Factor`'s `InstanceBuilder`.
 pub trait HasInstanceBuilder {
+    /// Get the instance builder of a particular factor.
     fn for_factor<F: Factor>(&mut self) -> Option<&mut F::InstanceBuilder>;
 }
 
diff --git a/crates/runtime-config/src/lib.rs b/crates/runtime-config/src/lib.rs
@@ -118,7 +118,7 @@ where
             sqlite_resolver: sqlite_config_resolver,
             state_dir: toml_resolver.state_dir()?,
             log_dir: toml_resolver.log_dir()?,
-            toml,
+            toml: toml_resolver.toml(),
         })
     }
 
@@ -262,6 +262,10 @@ impl<'a> TomlResolver<'a> {
     pub fn validate_all_keys_used(&self) -> spin_factors::Result<()> {
         self.table.validate_all_keys_used()
     }
+
+    fn toml(&self) -> toml::Table {
+        self.table.as_ref().clone()
+    }
 }
 
 /// The TOML based runtime configuration source Spin CLI.
diff --git a/crates/trigger-http/src/lib.rs b/crates/trigger-http/src/lib.rs
@@ -30,7 +30,10 @@ pub use tls::TlsConfig;
 
 pub(crate) use wasmtime_wasi_http::body::HyperIncomingBody as Body;
 
+/// A [`spin_trigger::TriggerApp`] for the HTTP trigger.
 pub(crate) type TriggerApp<F> = spin_trigger::TriggerApp<HttpTrigger, F>;
+
+/// A [`spin_trigger::TriggerInstanceBuilder`] for the HTTP trigger.
 pub(crate) type TriggerInstanceBuilder<'a, F> =
     spin_trigger::TriggerInstanceBuilder<'a, HttpTrigger, F>;
 
diff --git a/crates/trigger-http/src/wagi.rs b/crates/trigger-http/src/wagi.rs
@@ -79,7 +79,7 @@ impl HttpExecutor for WagiHttpExecutor {
             .factor_builders()
             .for_factor::<WasiFactor>()
         {
-            // // Set up Wagi environment
+            // Set up Wagi environment
             wasi_builder.args(argv.split(' '));
             wasi_builder.env(headers);
             wasi_builder.stdin_pipe(Cursor::new(body));
diff --git a/crates/trigger/Cargo.toml b/crates/trigger/Cargo.toml
@@ -26,7 +26,6 @@ spin-factor-sqlite = { path = "../factor-sqlite" }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-factors = { path = "../factors" }
 spin-factors-executor = { path = "../factors-executor" }
-spin-runtime-config = { path = "../runtime-config" }
 spin-telemetry = { path = "../telemetry" }
 tokio = { version = "1.23", features = ["fs", "rt"] }
 toml = "0.8"
diff --git a/crates/trigger/src/cli.rs b/crates/trigger/src/cli.rs
@@ -23,7 +23,7 @@ pub use launch_metadata::LaunchMetadata;
 pub use sqlite_statements::SqlStatementExecutorHook;
 use stdio::FollowComponents;
 pub use stdio::StdioLoggingExecutorHooks;
-pub use summary::KeyValueDefaultStoreSummaryHook;
+pub use summary::{KeyValueDefaultStoreSummaryHook, SqliteDefaultStoreSummaryHook};
 
 pub const APP_LOG_DIR: &str = "APP_LOG_DIR";
 pub const DISABLE_WASMTIME_CACHE: &str = "DISABLE_WASMTIME_CACHE";
@@ -398,8 +398,11 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
 
 /// A builder for runtime factors.
 pub trait RuntimeFactorsBuilder {
-    type Options: clap::Args;
+    /// The factors type to build.
     type Factors: RuntimeFactors;
+    /// CLI arguments not included in [`CommonTriggerOptions`] needed  to build the [`RuntimeFactors`].
+    type Options: clap::Args;
+    /// The wrapped runtime config type.
     type RuntimeConfig: Into<<Self::Factors as RuntimeFactors>::RuntimeConfig>;
 
     /// Build the factors and runtime config from the given options.
diff --git a/crates/trigger/src/cli/initial_kv_setter.rs b/crates/trigger/src/cli/initial_kv_setter.rs
@@ -4,6 +4,7 @@ use spin_factor_key_value::KeyValueFactor;
 use spin_factors::RuntimeFactors;
 use spin_factors_executor::ExecutorHooks;
 
+/// An [`ExecutorHooks`] that sets initial key-value pairs in the default store.
 pub struct InitialKvSetterHook {
     kv_pairs: Vec<(String, String)>,
 }
diff --git a/crates/trigger/src/cli/summary.rs b/crates/trigger/src/cli/summary.rs
@@ -1,52 +1,8 @@
-use std::path::Path;
-
-use spin_common::ui::quoted_path;
 use spin_core::async_trait;
 use spin_factor_key_value::KeyValueFactor;
 use spin_factor_sqlite::SqliteFactor;
 use spin_factors::RuntimeFactors;
 use spin_factors_executor::ExecutorHooks;
-use spin_runtime_config::ResolvedRuntimeConfig;
-use toml::Value;
-
-use crate::factors::TriggerFactors;
-
-pub fn summarize_runtime_config<T>(
-    runtime_config: &ResolvedRuntimeConfig<T>,
-    runtime_config_path: Option<&Path>,
-) {
-    let toml = &runtime_config.toml;
-    let summarize_labeled_typed_tables = |key| {
-        let mut summaries = vec![];
-        if let Some(tables) = toml.get(key).and_then(Value::as_table) {
-            for (label, config) in tables {
-                if let Some(ty) = config.get("type").and_then(Value::as_str) {
-                    summaries.push(format!("[{key}.{label}: {ty}]"))
-                }
-            }
-        }
-        summaries
-    };
-
-    let mut summaries = vec![];
-    // [key_value_store.<label>: <type>]
-    summaries.extend(summarize_labeled_typed_tables("key_value_store"));
-    // [sqlite_database.<label>: <type>]
-    summaries.extend(summarize_labeled_typed_tables("sqlite_database"));
-    // [llm_compute: <type>]
-    if let Some(table) = toml.get("llm_compute").and_then(Value::as_table) {
-        if let Some(ty) = table.get("type").and_then(Value::as_str) {
-            summaries.push(format!("[llm_compute: {ty}"));
-        }
-    }
-    if !summaries.is_empty() {
-        let summaries = summaries.join(", ");
-        let from_path = runtime_config_path
-            .map(|path| format!("from {}", quoted_path(path)))
-            .unwrap_or_default();
-        println!("Using runtime config {summaries} {from_path}");
-    }
-}
 
 /// An [`ExecutorHooks`] that prints information about the default KV store.
 pub struct KeyValueDefaultStoreSummaryHook;
@@ -75,10 +31,10 @@ impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for KeyValueDefaultStoreSummaryHo
 pub struct SqliteDefaultStoreSummaryHook;
 
 #[async_trait]
-impl<U> ExecutorHooks<TriggerFactors, U> for SqliteDefaultStoreSummaryHook {
+impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for SqliteDefaultStoreSummaryHook {
     async fn configure_app(
         &mut self,
-        configured_app: &spin_factors::ConfiguredApp<TriggerFactors>,
+        configured_app: &spin_factors::ConfiguredApp<F>,
     ) -> anyhow::Result<()> {
         let Ok(sqlite_app_state) = configured_app.app_state::<SqliteFactor>() else {
             return Ok(());
diff --git a/crates/trigger/src/lib.rs b/crates/trigger/src/lib.rs
@@ -9,23 +9,31 @@ use spin_factors_executor::{FactorsExecutorApp, FactorsInstanceBuilder};
 
 pub use spin_app::App;
 
-/// Type alias for a [`FactorsExecutorApp`] specialized to a [`Trigger`].
+/// Type alias for a [`spin_factors_executor::FactorsExecutorApp`] specialized to a [`Trigger`].
 pub type TriggerApp<T, F> = FactorsExecutorApp<F, <T as Trigger<F>>::InstanceState>;
 
+/// Type alias for a [`spin_factors_executor::FactorsInstanceBuilder`] specialized to a [`Trigger`].
 pub type TriggerInstanceBuilder<'a, T, F> =
     FactorsInstanceBuilder<'a, F, <T as Trigger<F>>::InstanceState>;
 
+/// Type alias for a [`spin_core::Store`] specialized to a [`Trigger`].
 pub type Store<T, F> = spin_core::Store<TriggerInstanceState<T, F>>;
 
+/// Type alias for [`spin_factors_executor::InstanceState`] specialized to a [`Trigger`].
 type TriggerInstanceState<T, F> = spin_factors_executor::InstanceState<
     <F as RuntimeFactors>::InstanceState,
     <T as Trigger<F>>::InstanceState,
 >;
 
+/// A trigger for a Spin runtime.
 pub trait Trigger<F: RuntimeFactors>: Sized + Send {
+    /// A unique identifier for this trigger.
     const TYPE: &'static str;
 
+    /// The specific CLI arguments for this trigger.
     type CliArgs: Args;
+
+    /// The instance state for this trigger.
     type InstanceState: Send + 'static;
 
     /// Constructs a new trigger.
diff --git a/examples/spin-timer/Cargo.lock b/examples/spin-timer/Cargo.lock
diff --git a/src/runtime_factors.rs b/src/runtime_factors.rs

Original file line number	Diff line number	Diff line change
`@@ -211,6 +211,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {`
`211`	`211`	`)*`
`212`	`212`	`}`
`213`	`213`
	`214`	`+ #[allow(dead_code)]`
`214`	`215`	`impl #builders_name {`
`215`	`216`	`#(`
`216`	`217`	`pub fn #factor_names(&mut self) -> &mut <#factor_types as #Factor>::InstanceBuilder {`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,9 @@ pub trait RuntimeFactors: Send + Sync + Sized + 'static {`
`81`	`81`	`) -> Option<Option<&mut F::InstanceBuilder>>;`
`82`	`82`	`}`
`83`	`83`
	`84`	+/// Allows querying an `InstanceBuilders` for a particular `Factor`'s `InstanceBuilder`.
`84`	`85`	`pub trait HasInstanceBuilder {`
	`86`	`+ /// Get the instance builder of a particular factor.`
`85`	`87`	`fn for_factor<F: Factor>(&mut self) -> Option<&mut F::InstanceBuilder>;`
`86`	`88`	`}`
`87`	`89`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,7 @@ where`
`118`	`118`	`sqlite_resolver: sqlite_config_resolver,`
`119`	`119`	`state_dir: toml_resolver.state_dir()?,`
`120`	`120`	`log_dir: toml_resolver.log_dir()?,`
`121`		`- toml,`
	`121`	`+ toml: toml_resolver.toml(),`
`122`	`122`	`})`
`123`	`123`	`}`
`124`	`124`
`@@ -262,6 +262,10 @@ impl<'a> TomlResolver<'a> {`
`262`	`262`	`pub fn validate_all_keys_used(&self) -> spin_factors::Result<()> {`
`263`	`263`	`self.table.validate_all_keys_used()`
`264`	`264`	`}`
	`265`	`+`
	`266`	`+ fn toml(&self) -> toml::Table {`
	`267`	`+ self.table.as_ref().clone()`
	`268`	`+ }`
`265`	`269`	`}`
`266`	`270`
`267`	`271`	`/// The TOML based runtime configuration source Spin CLI.`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ impl HttpExecutor for WagiHttpExecutor {`
`79`	`79`	`.factor_builders()`
`80`	`80`	`.for_factor::<WasiFactor>()`
`81`	`81`	`{`
`82`		`- // // Set up Wagi environment`
	`82`	`+ // Set up Wagi environment`
`83`	`83`	`wasi_builder.args(argv.split(' '));`
`84`	`84`	`wasi_builder.env(headers);`
`85`	`85`	`wasi_builder.stdin_pipe(Cursor::new(body));`