factors-executor: Add ComponentLoader::load_instance_pre

This lets embedders customize more of the component loading process.

Signed-off-by: Lann Martin <[email protected]>

Author: lann

crates/app/src/lib.rs

@@ -84,7 +84,7 @@ impl App {
     }
 
     /// Returns an iterator of [`AppComponent`]s defined for this app.
-    pub fn components(&self) -> impl Iterator<Item = AppComponent<'_>> {
+    pub fn components(&self) -> impl ExactSizeIterator<Item = AppComponent<'_>> {
         self.locked
             .components
             .iter()

crates/factors-executor/src/lib.rs

@@ -52,7 +52,7 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U> {
         self: Arc<Self>,
         app: App,
         runtime_config: T::RuntimeConfig,
-        component_loader: &impl ComponentLoader,
+        component_loader: &impl ComponentLoader<T, U>,
     ) -> anyhow::Result<FactorsExecutorApp<T, U>> {
         let configured_app = self
             .factors
@@ -63,15 +63,14 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutor<T, U> {
             hooks.configure_app(&configured_app).await?;
         }
 
-        let mut component_instance_pres = HashMap::new();
+        let components = configured_app.app().components();
+        let mut component_instance_pres = HashMap::with_capacity(components.len());
 
-        for app_component in configured_app.app().components() {
-            let component = component_loader
-                .load_component(self.core_engine.as_ref(), &app_component)
+        for component in components {
+            let instance_pre = component_loader
+                .load_instance_pre(&self.core_engine, &component)
                 .await?;
-            let instance_pre = self.core_engine.instantiate_pre(&component)?;
-
-            component_instance_pres.insert(app_component.id().to_string(), instance_pre);
+            component_instance_pres.insert(component.id().to_string(), instance_pre);
         }
 
         Ok(FactorsExecutorApp {
@@ -102,13 +101,23 @@ where
 
 /// A ComponentLoader is responsible for loading Wasmtime [`Component`]s.
 #[async_trait]
-pub trait ComponentLoader {
+pub trait ComponentLoader<T: RuntimeFactors, U>: Sync {
     /// Loads a [`Component`] for the given [`AppComponent`].
     async fn load_component(
         &self,
         engine: &spin_core::wasmtime::Engine,
         component: &AppComponent,
     ) -> anyhow::Result<Component>;
+
+    /// Loads [`InstancePre`] for the given [`AppComponent`].
+    async fn load_instance_pre(
+        &self,
+        engine: &spin_core::Engine<InstanceState<T::InstanceState, U>>,
+        component: &AppComponent,
+    ) -> anyhow::Result<spin_core::InstancePre<InstanceState<T::InstanceState, U>>> {
+        let component = self.load_component(engine.as_ref(), component).await?;
+        engine.instantiate_pre(&component)
+    }
 }
 
 type InstancePre<T, U> =
@@ -344,7 +353,7 @@ mod tests {
     struct DummyComponentLoader;
 
     #[async_trait]
-    impl ComponentLoader for DummyComponentLoader {
+    impl ComponentLoader<TestFactors, ()> for DummyComponentLoader {
         async fn load_component(
             &self,
             engine: &spin_core::wasmtime::Engine,

crates/trigger/src/cli.rs

@@ -309,7 +309,7 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
         app: App,
         common_options: FactorsConfig,
         options: B::CliArgs,
-        loader: &impl ComponentLoader,
+        loader: &impl ComponentLoader<B::Factors, T::InstanceState>,
     ) -> anyhow::Result<TriggerApp<T, B::Factors>> {
         let mut core_engine_builder = {
             self.trigger.update_core_config(&mut self.engine_config)?;
@@ -340,7 +340,7 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
         app: App,
         common_options: FactorsConfig,
         options: B::CliArgs,
-        loader: &impl ComponentLoader,
+        loader: &impl ComponentLoader<B::Factors, T::InstanceState>,
     ) -> anyhow::Result<impl Future<Output = anyhow::Result<()>>> {
         let configured_app = self.build(app, common_options, options, loader).await?;
         Ok(self.trigger.run(configured_app))

crates/trigger/src/loader.rs

@@ -2,7 +2,7 @@ use anyhow::Context as _;
 use spin_common::{ui::quoted_path, url::parse_file_url};
 use spin_compose::ComponentSourceLoaderFs;
 use spin_core::{async_trait, wasmtime, Component};
-use spin_factors::AppComponent;
+use spin_factors::{AppComponent, RuntimeFactors};
 
 #[derive(Default)]
 pub struct ComponentLoader {
@@ -68,7 +68,7 @@ impl ComponentLoader {
 }
 
 #[async_trait]
-impl spin_factors_executor::ComponentLoader for ComponentLoader {
+impl<T: RuntimeFactors, U> spin_factors_executor::ComponentLoader<T, U> for ComponentLoader {
     async fn load_component(
         &self,
         engine: &wasmtime::Engine,