Allow dynamic querying of instance builders

Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>

Author: rylev

Cargo.lock

@@ -211,7 +211,6 @@ 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 {
@@ -220,6 +219,23 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
             )*
         }
 
+        impl #factors_path::HasInstanceBuilder for #builders_name {
+            fn for_factor<F: #Factor>(
+                &mut self
+            ) -> Option<&mut F::InstanceBuilder> {
+                let type_id = #TypeId::of::<F::InstanceBuilder>();
+                #(
+                    if type_id == #TypeId::of::<<#factor_types as #Factor>::InstanceBuilder>() {
+                        let builder = self.#factor_names.as_mut().unwrap();
+                        return Some(
+                            <dyn #Any>::downcast_mut(builder).unwrap()
+                        );
+                    }
+                )*
+                None
+            }
+        }
+
         #vis struct #state_name {
             __table: #ResourceTable,
             #(

crates/factors-derive/src/lib.rs

@@ -14,7 +14,9 @@ pub use crate::{
     factor::{ConfigureAppContext, ConfiguredApp, Factor, FactorInstanceState, InitContext},
     prepare::{FactorInstanceBuilder, InstanceBuilders, PrepareContext, SelfInstanceBuilder},
     runtime_config::{FactorRuntimeConfigSource, RuntimeConfigSourceFinalizer},
-    runtime_factors::{AsInstanceState, RuntimeFactors, RuntimeFactorsInstanceState},
+    runtime_factors::{
+        AsInstanceState, HasInstanceBuilder, RuntimeFactors, RuntimeFactorsInstanceState,
+    },
 };
 
 /// Result wrapper type defaulting to use [`Error`].

crates/factors/src/lib.rs

@@ -36,7 +36,7 @@ pub trait RuntimeFactors: Send + Sync + Sized + 'static {
     /// The per instance state of the factors.
     type InstanceState: RuntimeFactorsInstanceState;
     /// The collection of all the `InstanceBuilder`s of the factors.
-    type InstanceBuilders: Send;
+    type InstanceBuilders: Send + HasInstanceBuilder;
     /// The runtime configuration of all the factors.
     type RuntimeConfig: Default;
 
@@ -81,6 +81,10 @@ pub trait RuntimeFactors: Send + Sync + Sized + 'static {
     ) -> Option<Option<&mut F::InstanceBuilder>>;
 }
 
+pub trait HasInstanceBuilder {
+    fn for_factor<F: Factor>(&mut self) -> Option<&mut F::InstanceBuilder>;
+}
+
 /// Get the state of a particular Factor from the overall InstanceState
 ///
 /// Implemented by `#[derive(RuntimeFactors)]`

crates/factors/src/runtime_factors.rs

@@ -13,8 +13,8 @@ use hyper::{
 };
 use hyper_util::rt::TokioIo;
 use spin_app::{APP_DESCRIPTION_KEY, APP_NAME_KEY};
-use spin_factor_outbound_http::SelfRequestOrigin;
-use spin_factors::RuntimeFactors;
+use spin_factor_outbound_http::{OutboundHttpFactor, SelfRequestOrigin};
+use spin_factors::{HasInstanceBuilder, RuntimeFactors};
 use spin_http::{
     app_info::AppInfo,
     body,
@@ -236,11 +236,14 @@ impl<F: RuntimeFactors> HttpServer<F> {
         let mut instance_builder = self.trigger_app.prepare(component_id)?;
 
         // Set up outbound HTTP request origin and service chaining
-        // TODO: bring back once outbound networking is refactored
-        // let outbound_http = instance_builder.factor_builders().outbound_http();
-        // let origin = SelfRequestOrigin::create(server_scheme, &self.listen_addr)?;
-        // outbound_http.set_self_request_origin(origin);
-        // outbound_http.set_request_interceptor(OutboundHttpInterceptor::new(self.clone()))?;
+        if let Some(outbound_http) = instance_builder
+            .factor_builders()
+            .for_factor::<OutboundHttpFactor>()
+        {
+            let origin = SelfRequestOrigin::create(server_scheme, &self.listen_addr)?;
+            outbound_http.set_self_request_origin(origin);
+            outbound_http.set_request_interceptor(OutboundHttpInterceptor::new(self.clone()))?;
+        }
 
         // Prepare HTTP executor
         let trigger_config = self.component_trigger_configs.get(component_id).unwrap();

crates/trigger-http/src/server.rs

@@ -3,7 +3,8 @@ use std::{io::Cursor, net::SocketAddr};
 use anyhow::{ensure, Result};
 use http_body_util::BodyExt;
 use hyper::{Request, Response};
-use spin_factors::RuntimeFactors;
+use spin_factor_wasi::WasiFactor;
+use spin_factors::{HasInstanceBuilder, RuntimeFactors};
 use spin_http::{config::WagiTriggerConfig, routes::RouteMatch, wagi};
 use tracing::{instrument, Level};
 use wasmtime_wasi::pipe::MemoryOutputPipe;
@@ -74,14 +75,16 @@ impl HttpExecutor for WagiHttpExecutor {
 
         let stdout = MemoryOutputPipe::new(usize::MAX);
 
-        // TODO:
-        // let wasi_builder = instance_builder.factor_builders().wasi();
-
-        // // Set up Wagi environment
-        // wasi_builder.args(argv.split(' '));
-        // wasi_builder.env(headers);
-        // wasi_builder.stdin_pipe(Cursor::new(body));
-        // wasi_builder.stdout(stdout.clone());
+        if let Some(wasi_builder) = instance_builder
+            .factor_builders()
+            .for_factor::<WasiFactor>()
+        {
+            // // Set up Wagi environment
+            wasi_builder.args(argv.split(' '));
+            wasi_builder.env(headers);
+            wasi_builder.stdin_pipe(Cursor::new(body));
+            wasi_builder.stdout(stdout.clone());
+        }
 
         let (instance, mut store) = instance_builder.instantiate(()).await?;
 

crates/trigger-http/src/wagi.rs

@@ -90,10 +90,6 @@ pub struct FactorsTriggerCommand<T: Trigger<B::Factors>, B: RuntimeFactorsBuilde
         )]
     pub silence_component_logs: bool,
 
-    /// Set the static assets of the components in the temporary directory as writable.
-    #[clap(long = "allow-transient-write")]
-    pub allow_transient_write: bool,
-
     /// Configuration file for config providers and wasmtime config.
     #[clap(
         name = RUNTIME_CONFIG_FILE,
@@ -125,7 +121,7 @@ pub struct FactorsTriggerCommand<T: Trigger<B::Factors>, B: RuntimeFactorsBuilde
 }
 
 /// Configuration options that are common to all triggers.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct CommonTriggerOptions {
     /// The Spin working directory.
     pub working_dir: PathBuf,
@@ -135,8 +131,6 @@ pub struct CommonTriggerOptions {
     pub state_dir: UserProvidedPath,
     /// Path to the local app directory.
     pub local_app_dir: Option<String>,
-    /// Whether to allow transient writes to mounted files
-    pub allow_transient_write: bool,
     /// Which components should have their logs followed.
     pub follow_components: FollowComponents,
     /// Log directory for component stdout/stderr.
@@ -220,7 +214,6 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> FactorsTriggerCommand<T,
             runtime_config_file: self.runtime_config_file.clone(),
             state_dir,
             local_app_dir: local_app_dir.clone(),
-            allow_transient_write: self.allow_transient_write,
             follow_components,
             log_dir,
         };
@@ -281,18 +274,18 @@ fn help_heading<T: Trigger<F>, F: RuntimeFactors>() -> Option<&'static str> {
 }
 
 /// A builder for a [`TriggerApp`].
-pub struct TriggerAppBuilder<T, F> {
+pub struct TriggerAppBuilder<T, B> {
     engine_config: spin_core::Config,
     pub trigger: T,
-    _factors: std::marker::PhantomData<F>,
+    _factors_builder: std::marker::PhantomData<B>,
 }
 
 impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
     pub fn new(trigger: T) -> Self {
         Self {
             engine_config: spin_core::Config::default(),
             trigger,
-            _factors: Default::default(),
+            _factors_builder: Default::default(),
         }
     }
 
@@ -400,16 +393,19 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
     }
 }
 
+/// A builder for runtime factors.
 pub trait RuntimeFactorsBuilder {
     type Options: clap::Args;
     type Factors: RuntimeFactors;
     type RuntimeConfig: Into<<Self::Factors as RuntimeFactors>::RuntimeConfig>;
 
+    /// Build the factors and runtime config from the given options.
     fn build(
         common_options: &CommonTriggerOptions,
         options: &Self::Options,
     ) -> anyhow::Result<(Self::Factors, Self::RuntimeConfig)>;
 
+    /// Configure the factors in the executor.
     fn configure_app<U: Send + 'static>(
         executor: &mut FactorsExecutor<Self::Factors, U>,
         runtime_config: &Self::RuntimeConfig,
@@ -444,11 +440,12 @@ pub mod help {
 }
 
 /// A user provided option which be either be provided, default, or explicitly none.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub enum UserProvidedPath {
     /// Use the explicitly provided directory.
     Provided(PathBuf),
     /// Use the default.
+    #[default]
     Default,
     /// Explicitly unset.
     Unset,