Feed runtime all the way through

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

Cargo.lock

@@ -49,6 +49,7 @@ spin-common = { path = "crates/common" }
 spin-doctor = { path = "crates/doctor" }
 spin-expressions = { path = "crates/expressions" }
 spin-factors = { path = "crates/factors" }
+spin-factors-executor = { path = "crates/factors-executor" }
 spin-http = { path = "crates/http" }
 spin-loader = { path = "crates/loader" }
 spin-locked-app = { path = "crates/locked-app" }

Cargo.toml

@@ -52,73 +52,43 @@ where
     T: for<'a, 'b> TryFrom<TomlRuntimeConfigSource<'a, 'b>>,
     for<'a, 'b> <T as TryFrom<TomlRuntimeConfigSource<'a, 'b>>>::Error: Into<anyhow::Error>,
 {
-    /// Creates a new resolved runtime configuration from an optional runtime config source TOML file.
-    pub fn from_optional_file(
-        runtime_config_path: Option<&Path>,
-        local_app_dir: Option<PathBuf>,
-        provided_state_dir: UserProvidedPath,
-        provided_log_dir: UserProvidedPath,
-        use_gpu: bool,
-    ) -> anyhow::Result<Self> {
-        match runtime_config_path {
-            Some(runtime_config_path) => Self::from_file(
-                runtime_config_path,
-                local_app_dir,
-                provided_state_dir,
-                provided_log_dir,
-                use_gpu,
-            ),
-            None => Self::new(
-                Default::default(),
-                None,
-                local_app_dir,
-                provided_state_dir,
-                provided_log_dir,
-                use_gpu,
-            ),
-        }
-    }
-
     /// Creates a new resolved runtime configuration from a runtime config source TOML file.
     ///
     /// `provided_state_dir` is the explicitly provided state directory, if any.
     pub fn from_file(
-        runtime_config_path: &Path,
+        runtime_config_path: Option<&Path>,
         local_app_dir: Option<PathBuf>,
         provided_state_dir: UserProvidedPath,
         provided_log_dir: UserProvidedPath,
         use_gpu: bool,
     ) -> anyhow::Result<Self> {
-        let file = std::fs::read_to_string(runtime_config_path).with_context(|| {
-            format!(
-                "failed to read runtime config file '{}'",
-                runtime_config_path.display()
-            )
-        })?;
-        let toml = toml::from_str(&file).with_context(|| {
-            format!(
-                "failed to parse runtime config file '{}' as toml",
-                runtime_config_path.display()
-            )
-        })?;
-
-        Self::new(
-            toml,
-            Some(runtime_config_path),
-            local_app_dir,
-            provided_state_dir,
-            provided_log_dir,
-            use_gpu,
-        )
+        let toml = match runtime_config_path {
+            Some(runtime_config_path) => {
+                let file = std::fs::read_to_string(runtime_config_path).with_context(|| {
+                    format!(
+                        "failed to read runtime config file '{}'",
+                        runtime_config_path.display()
+                    )
+                })?;
+                toml::from_str(&file).with_context(|| {
+                    format!(
+                        "failed to parse runtime config file '{}' as toml",
+                        runtime_config_path.display()
+                    )
+                })?
+            }
+            None => Default::default(),
+        };
+        let toml_resolver =
+            TomlResolver::new(&toml, local_app_dir, provided_state_dir, provided_log_dir);
+
+        Self::new(toml_resolver, runtime_config_path, use_gpu)
     }
 
     /// Creates a new resolved runtime configuration from a TOML table.
     pub fn new(
-        toml: toml::Table,
+        toml_resolver: TomlResolver<'_>,
         runtime_config_path: Option<&Path>,
-        local_app_dir: Option<PathBuf>,
-        provided_state_dir: UserProvidedPath,
-        provided_log_dir: UserProvidedPath,
         use_gpu: bool,
     ) -> anyhow::Result<Self> {
         let runtime_config_dir = runtime_config_path
@@ -189,6 +159,14 @@ where
     }
 }
 
+impl From<ResolvedRuntimeConfig<spin_trigger::TriggerFactorsRuntimeConfig>>
+    for spin_trigger::TriggerFactorsRuntimeConfig
+{
+    fn from(value: ResolvedRuntimeConfig<spin_trigger::TriggerFactorsRuntimeConfig>) -> Self {
+        value.runtime_config
+    }
+}
+
 #[derive(Clone, Debug)]
 /// Resolves runtime configuration from a TOML file.
 pub struct TomlResolver<'a> {

crates/runtime-config/src/lib.rs

@@ -20,6 +20,7 @@ use tokio::sync::OnceCell;
 ///
 /// This type implements how Spin CLI's SQLite implementation is configured
 /// through the runtime config toml as well as the behavior of the "default" label.
+#[derive(Clone, Debug)]
 pub struct RuntimeConfigResolver {
     default_database_dir: Option<PathBuf>,
     local_database_dir: PathBuf,

crates/sqlite/src/lib.rs

@@ -39,6 +39,7 @@ spin-factor-variables = { path = "../factor-variables" }
 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" }
 terminal = { path = "../terminal" }
 tokio = { version = "1.23", features = ["fs", "rt"] }

crates/trigger/Cargo.toml

@@ -5,6 +5,7 @@ mod summary;
 use std::future::Future;
 use std::path::PathBuf;
 
+pub use crate::stdio::StdioLoggingExecutorHooks;
 use anyhow::{Context, Result};
 use clap::{Args, IntoApp, Parser};
 use spin_app::App;
@@ -14,12 +15,10 @@ use spin_common::url::parse_file_url;
 use spin_core::async_trait;
 use spin_factors::RuntimeFactors;
 use spin_factors_executor::{ComponentLoader, FactorsExecutor};
-use sqlite_statements::SqlStatementExecutorHook;
-use summary::{
-    summarize_runtime_config, KeyValueDefaultStoreSummaryHook, SqliteDefaultStoreSummaryHook,
-};
+pub use sqlite_statements::SqlStatementExecutorHook;
+pub use summary::KeyValueDefaultStoreSummaryHook;
 
-use crate::stdio::{FollowComponents, StdioLoggingExecutorHooks};
+use crate::stdio::FollowComponents;
 use crate::{Trigger, TriggerApp};
 pub use launch_metadata::LaunchMetadata;
 
@@ -315,7 +314,7 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
         };
         self.trigger.add_to_linker(core_engine_builder.linker())?;
 
-        let (factors, runtime_config) = B::build(common_options, options)?;
+        let (factors, runtime_config) = B::build(&common_options, &options)?;
 
         // TODO: port the rest of the component loader logic
         struct SimpleComponentLoader;
@@ -377,19 +376,12 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
         }
 
         let mut executor = FactorsExecutor::new(core_engine_builder, factors)?;
-
-        executor.add_hooks(StdioLoggingExecutorHooks::new(
-            options.follow_components,
-            log_dir,
-        ));
-        executor.add_hooks(KeyValueDefaultStoreSummaryHook);
-        executor.add_hooks(SqliteDefaultStoreSummaryHook);
-        executor.add_hooks(SqlStatementExecutorHook::new(options.sqlite_statements));
+        B::configure_app(&mut executor, &runtime_config, &common_options, &options)?;
 
         let configured_app = {
             let _sloth_guard = warn_if_wasm_build_slothful();
             executor
-                .load_app(app, runtime_config, SimpleComponentLoader)
+                .load_app(app, runtime_config.into(), SimpleComponentLoader)
                 .await?
         };
 
@@ -411,14 +403,22 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
 pub trait RuntimeFactorsBuilder {
     type Options: clap::Args;
     type Factors: RuntimeFactors;
+    type RuntimeConfig: Into<<Self::Factors as RuntimeFactors>::RuntimeConfig>;
 
     fn build(
-        common_options: CommonTriggerOptions,
-        options: Self::Options,
-    ) -> anyhow::Result<(
-        Self::Factors,
-        <Self::Factors as RuntimeFactors>::RuntimeConfig,
-    )>;
+        common_options: &CommonTriggerOptions,
+        options: &Self::Options,
+    ) -> anyhow::Result<(Self::Factors, Self::RuntimeConfig)>;
+
+    fn configure_app<U: Send + 'static>(
+        executor: &mut FactorsExecutor<Self::Factors, U>,
+        runtime_config: &Self::RuntimeConfig,
+        common_options: &CommonTriggerOptions,
+        options: &Self::Options,
+    ) -> anyhow::Result<()> {
+        let _ = (executor, runtime_config, common_options, options);
+        Ok(())
+    }
 }
 
 pub mod help {

crates/trigger/src/cli.rs

@@ -92,10 +92,10 @@ pub struct TriggerAppOptions {
     /// default store. Any existing value will be overwritten.
     /// Can be used multiple times.
     #[clap(long = "key-value", parse(try_from_str = parse_kv))]
-    key_values: Vec<(String, String)>,
+    pub key_values: Vec<(String, String)>,
 
     /// Run a SQLite statement such as a migration against the default database.
     /// To run from a file, prefix the filename with @ e.g. spin up --sqlite @migration.sql
     #[clap(long = "sqlite")]
-    sqlite_statements: Vec<String>,
+    pub sqlite_statements: Vec<String>,
 }

crates/trigger/src/factors.rs

@@ -17,9 +17,13 @@ use spin_cli::commands::{
     watch::WatchCommand,
 };
 use spin_cli::{build_info::*, subprocess::ExitStatusError};
+use spin_factors_executor::FactorsExecutor;
 use spin_runtime_config::ResolvedRuntimeConfig;
 use spin_trigger::cli::help::HelpArgsOnlyTrigger;
-use spin_trigger::cli::{CommonTriggerOptions, FactorsTriggerCommand, RuntimeFactorsBuilder};
+use spin_trigger::cli::{
+    CommonTriggerOptions, FactorsTriggerCommand, KeyValueDefaultStoreSummaryHook,
+    RuntimeFactorsBuilder, SqlStatementExecutorHook, StdioLoggingExecutorHooks,
+};
 use spin_trigger::{TriggerAppOptions, TriggerFactors, TriggerFactorsRuntimeConfig};
 use spin_trigger_http::HttpTrigger;
 use spin_trigger_redis::RedisTrigger;
@@ -177,42 +181,57 @@ struct Builder;
 impl RuntimeFactorsBuilder for Builder {
     type Options = TriggerAppOptions;
     type Factors = TriggerFactors;
+    type RuntimeConfig = ResolvedRuntimeConfig<TriggerFactorsRuntimeConfig>;
 
     fn build(
-        common_options: CommonTriggerOptions,
-        options: Self::Options,
-    ) -> anyhow::Result<(
-        Self::Factors,
-        <Self::Factors as spin_factors::RuntimeFactors>::RuntimeConfig,
-    )> {
-        let runtime_config_path = common_options.runtime_config_file;
-        let local_app_dir = common_options.local_app_dir.map(PathBuf::from);
+        common_options: &CommonTriggerOptions,
+        options: &Self::Options,
+    ) -> anyhow::Result<(Self::Factors, Self::RuntimeConfig)> {
+        let runtime_config_path = common_options.runtime_config_file.clone();
+        let local_app_dir = common_options.local_app_dir.clone().map(PathBuf::from);
         // Hardcode `use_gpu` to true for now
         let use_gpu = true;
-        let runtime_config =
-            ResolvedRuntimeConfig::<TriggerFactorsRuntimeConfig>::from_optional_file(
-                runtime_config_path.as_deref(),
-                local_app_dir,
-                common_options.state_dir,
-                common_options.log_dir,
-                use_gpu,
-            )?;
-
-        // runtime_config
-        //     .set_initial_key_values(&options.initial_key_values)
-        //     .await?;
+        let runtime_config = ResolvedRuntimeConfig::<TriggerFactorsRuntimeConfig>::from_file(
+            runtime_config_path.as_deref(),
+            local_app_dir,
+            common_options.state_dir.clone(),
+            common_options.log_dir.clone(),
+            use_gpu,
+        )?;
 
-        let log_dir = runtime_config.log_dir();
         let factors = TriggerFactors::new(
             runtime_config.state_dir(),
-            common_options.working_dir,
+            common_options.working_dir.clone(),
             options.allow_transient_write,
-            runtime_config.key_value_resolver,
-            runtime_config.sqlite_resolver,
+            runtime_config.key_value_resolver.clone(),
+            runtime_config.sqlite_resolver.clone(),
             use_gpu,
         )
         .context("failed to create factors")?;
-        Ok((factors, runtime_config.runtime_config))
+        Ok((factors, runtime_config))
+    }
+
+    fn configure_app<U: Send + 'static>(
+        executor: &mut FactorsExecutor<Self::Factors, U>,
+        runtime_config: &Self::RuntimeConfig,
+        common_options: &CommonTriggerOptions,
+        options: &Self::Options,
+    ) -> anyhow::Result<()> {
+        executor.add_hooks(SqlStatementExecutorHook::new(
+            options.sqlite_statements.clone(),
+        ));
+        executor.add_hooks(StdioLoggingExecutorHooks::new(
+            common_options.follow_components.clone(),
+            runtime_config.log_dir(),
+        ));
+        executor.add_hooks(KeyValueDefaultStoreSummaryHook);
+        // TODO: implement initial key values as a hook
+        // runtime_config
+        //     .set_initial_key_values(&options.initial_key_values)
+        //     .await?;
+        // builder.hooks(SummariseRuntimeConfigHook::new(&self.runtime_config_file));
+        // builder.hooks(SqlitePersistenceMessageHook);
+        Ok(())
     }
 }