Interim commit for transfer

itowlson · itowlson · commit 816226ba30bd · 2026-02-17T14:53:54.000+13:00
Signed-off-by: itowlson &lt;ivan.towlson@fermyon.com&gt;
diff --git a/crates/manifest/src/normalize.rs b/crates/manifest/src/normalize.rs
@@ -63,51 +63,6 @@ fn normalize_inline_components(manifest: &mut AppManifest) {
                 normalize_spec(spec, trigger_id, false);
             }
         }
-
-        // let component_specs = trigger
-        //     .component
-        //     .iter_mut()
-        //     .chain(
-        //         trigger
-        //             .components
-        //             .values_mut()
-        //             .flat_map(|specs| specs.0.iter_mut()),
-        //     )
-        //     .collect::<Vec<_>>();
-        // let multiple_components = component_specs.len() > 1;
-
-        // for spec in component_specs {
-        //     if !matches!(spec, ComponentSpec::Inline(_)) {
-        //         continue;
-        //     };
-
-        //     let inline_id = {
-        //         // Try a "natural" component ID...
-        //         let mut id = KebabId::try_from(format!("{trigger_id}-component"));
-        //         // ...falling back to a counter-based component ID
-        //         if multiple_components
-        //             || id.is_err()
-        //             || components.contains_key(id.as_ref().unwrap())
-        //         {
-        //             id = Ok(loop {
-        //                 let id = KebabId::try_from(format!("inline-component{counter}")).unwrap();
-        //                 if !components.contains_key(&id) {
-        //                     break id;
-        //                 }
-        //                 counter += 1;
-        //             });
-        //         }
-        //         id.unwrap()
-        //     };
-
-        //     // Replace the inline component with a reference...
-        //     let inline_spec = std::mem::replace(spec, ComponentSpec::Reference(inline_id.clone()));
-        //     let ComponentSpec::Inline(component) = inline_spec else {
-        //         unreachable!();
-        //     };
-        //     // ...moving the inline component into the top-level components map.
-        //     components.insert(inline_id.clone(), *component);
-        // }
     }
 }
 
diff --git a/crates/manifest/src/schema/v2.rs b/crates/manifest/src/schema/v2.rs
@@ -132,7 +132,8 @@ pub struct Trigger {
     /// Learn more: https://spinframework.dev/triggers#triggers-and-components
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub component: Option<ComponentSpec>,
-    /// Reserved for future use.
+    /// Additional components used when the trigger occurs.
+    /// The meaning of entries in this table is trigger-specific.
     ///
     /// `components = { ... }`
     #[serde(default, skip_serializing_if = "Map::is_empty")]
diff --git a/crates/oci/src/client.rs b/crates/oci/src/client.rs
@@ -370,14 +370,26 @@ impl Client {
         let locked_url = write_locked_app(&locked, working_dir).await.unwrap();
 
         for mut c in locked.components {
-            let complicate =
-                |data: Vec<u8>| compose_trigger_extras(&c, &locked_url, working_dir, data);
+            // TODO: what if, instead of having a separate complicate that
+            // called the trigger, we had the trigger do the full compose
+            // (in the presence of extras)?  The trigger already has logic
+            // for that...
+            let extras =  c.metadata.get("trigger-extras").and_then(|e| e.as_object());
+
+            let composed = if extras.is_none_or(|e| e.is_empty()) {
+                spin_compose::compose(&ComponentSourceLoaderFs, &c, async |a| Ok(a)).await?
+            } else {
+                compose_trigger_extras_2(&c, &locked_url, working_dir).await?
+            };
 
-            let composed = spin_compose::compose(&ComponentSourceLoaderFs, &c, complicate)
-                .await
-                .with_context(|| {
-                    format!("failed to resolve dependencies for component {:?}", c.id)
-                })?;
+            // let complicate =
+            //     |data: Vec<u8>| compose_trigger_extras(&c, &locked_url, working_dir, data);
+
+            // let composed = spin_compose::compose(&ComponentSourceLoaderFs, &c, complicate)
+            //     .await
+            //     .with_context(|| {
+            //         format!("failed to resolve dependencies for component {:?}", c.id)
+            //     })?;
             let layer = ImageLayer::new(composed, WASM_LAYER_MEDIA_TYPE.to_string(), None);
             c.source.content = self.content_ref_for_layer(&layer);
             c.dependencies.clear();
@@ -938,11 +950,76 @@ fn add_inferred(map: &mut BTreeMap<String, String>, key: &str, value: Option<Str
 const SPIN_LOCKED_URL: &str = "SPIN_LOCKED_URL";
 const SPIN_WORKING_DIR: &str = "SPIN_WORKING_DIR";
 
-async fn compose_trigger_extras(
+// async fn compose_trigger_extras(
+//     c: &LockedComponent,
+//     locked_url: &str,
+//     working_dir: &Path,
+//     data: Vec<u8>,
+// ) -> Result<Vec<u8>, spin_compose::ComposeError> {
+//     use spin_compose::ComposeError;
+
+//     let Some(resolve_extras_using) = c
+//         .metadata
+//         .get("resolve-extras-using")
+//         .and_then(|v| v.as_str())
+//     else {
+//         return Result::<_, ComposeError>::Ok(data);
+//     };
+
+//     let resolver_subcmd = match resolve_extras_using {
+//         "http" | "redis" => vec!["trigger".into(), resolve_extras_using.into()],
+//         _ => vec![format!("trigger-{resolve_extras_using}")],
+//     };
+
+//     let mut cmd = tokio::process::Command::new(std::env::current_exe().unwrap());
+//     cmd.args(resolver_subcmd)
+//         .args(["--resolve-extras-only", "--resolve-extras-component-id"])
+//         .arg(&c.id)
+//         // .stdin(std::process::Stdio::piped())
+//         .stdout(std::process::Stdio::piped())
+//         .stderr(std::process::Stdio::inherit())
+//         .env("SPIN_PLUGINS_SUPPRESS_COMPATIBILITY_WARNINGS", "1")
+//         .env(SPIN_LOCKED_URL, locked_url)
+//         .env(SPIN_WORKING_DIR, working_dir);
+
+//     let child = cmd
+//         .spawn()
+//         .map_err(|e| ComposeError::PrepareError(e.into()))?;
+
+//     // use tokio::io::AsyncWriteExt;
+
+//     // let mut input = child.stdin.take().unwrap();
+//     // input
+//     //     .write_all(&data)
+//     //     .await
+//     //     .map_err(|e| ComposeError::PrepareError(e.into()))?;
+//     // input
+//     //     .flush()
+//     //     .await
+//     //     .map_err(|e| ComposeError::PrepareError(e.into()))?;
+//     // drop(input);
+
+//     let trigger_out = child
+//         .wait_with_output()
+//         .await
+//         .map_err(|e| ComposeError::PrepareError(e.into()))?;
+
+//     if !trigger_out.status.success() {
+//         return Err(ComposeError::PrepareError(anyhow::anyhow!(
+//             "unable to compose additional components for {} using `{}`",
+//             c.id,
+//             resolve_extras_using
+//         )));
+//     }
+
+//     let complicated = trigger_out.stdout;
+//     Ok(complicated)
+// }
+
+async fn compose_trigger_extras_2(
     c: &LockedComponent,
     locked_url: &str,
     working_dir: &Path,
-    data: Vec<u8>,
 ) -> Result<Vec<u8>, spin_compose::ComposeError> {
     use spin_compose::ComposeError;
 
@@ -951,7 +1028,8 @@ async fn compose_trigger_extras(
         .get("resolve-extras-using")
         .and_then(|v| v.as_str())
     else {
-        return Result::<_, ComposeError>::Ok(data);
+        return spin_compose::compose(&ComponentSourceLoaderFs, &c, async |a| Ok(a)).await;
+        // return Result::<_, ComposeError>::Ok(data);
     };
 
     let resolver_subcmd = match resolve_extras_using {
@@ -961,32 +1039,18 @@ async fn compose_trigger_extras(
 
     let mut cmd = tokio::process::Command::new(std::env::current_exe().unwrap());
     cmd.args(resolver_subcmd)
-        .args(["--resolve-extras-only", "--resolve-extras-component-id"])
+        .args(["--precompose-only", "--precompose-component-id"])
         .arg(&c.id)
-        .stdin(std::process::Stdio::piped())
         .stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::inherit())
         .env("SPIN_PLUGINS_SUPPRESS_COMPATIBILITY_WARNINGS", "1")
         .env(SPIN_LOCKED_URL, locked_url)
         .env(SPIN_WORKING_DIR, working_dir);
 
-    let mut child = cmd
+    let child = cmd
         .spawn()
         .map_err(|e| ComposeError::PrepareError(e.into()))?;
 
-    use tokio::io::AsyncWriteExt;
-
-    let mut input = child.stdin.take().unwrap();
-    input
-        .write_all(&data)
-        .await
-        .map_err(|e| ComposeError::PrepareError(e.into()))?;
-    input
-        .flush()
-        .await
-        .map_err(|e| ComposeError::PrepareError(e.into()))?;
-    drop(input);
-
     let trigger_out = child
         .wait_with_output()
         .await
diff --git a/crates/trigger/src/cli.rs b/crates/trigger/src/cli.rs
@@ -138,10 +138,10 @@ pub struct FactorsTriggerCommand<T: Trigger<B::Factors>, B: RuntimeFactorsBuilde
     #[clap(long = "launch-metadata-only", hide = true)]
     pub launch_metadata_only: bool,
 
-    #[clap(long = "resolve-extras-only", hide = true)]
-    pub resolve_extras_only: bool,
-    #[clap(long = "resolve-extras-component-id", hide = true)]
-    pub resolve_extras_component_id: Option<String>,
+    #[clap(long = "precompose-only", hide = true)]
+    pub precompose_only: bool,
+    #[clap(long = "precompose-component-id", hide = true)]
+    pub precompose_component_id: Option<String>,
 }
 
 #[cfg(feature = "experimental-wasm-features")]
@@ -219,54 +219,26 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> FactorsTriggerCommand<T,
             anyhow::bail!("This application requires the following features that are not available in this version of the '{}' trigger: {unmet}", T::TYPE);
         }
 
-        let trigger = T::new(self.trigger_args, &app)?;
-
-        if self.resolve_extras_only {
-            use spin_factors_executor::Complicator;
-
-            let Some(resolve_extras_component_id) = self.resolve_extras_component_id.as_ref()
+        if self.precompose_only {
+            let Some(resolve_extras_component_id) = self.precompose_component_id.as_ref()
             else {
                 anyhow::bail!("got --resolve-extras-only but no --resolve-extras-component-id");
             };
 
-            let complicator = T::complicator();
             let Some(component) = app.get_component(resolve_extras_component_id) else {
                 anyhow::bail!("--resolve-extras-component-id: component does not exist");
             };
-            let Some(extras) = component
-                .locked
-                .metadata
-                .get("trigger-extras")
-                .and_then(|v| v.as_object())
-            else {
-                anyhow::bail!("--resolve-extras-component-id: component has no extras");
-            };
-
-            // let loader = spin_compose::ComponentSourceLoaderFs;
 
-            let complications = crate::loader::load_complications(
-                &app,
-                extras,
-                &spin_compose::ComponentSourceLoaderFs,
-            )
-            .await?;
-
-            // let complicand = loader.load_component_source(&component.locked).await.unwrap();
-            use std::io::Read;
-            let mut complicand = Vec::with_capacity(16384);
-            let read_count = std::io::stdin().read_to_end(&mut complicand)?;
-            complicand.truncate(read_count);
-
-            let complicated = complicator
-                .complicate(&complications, complicand)
-                .await
-                .unwrap();
+            let loader = crate::loader::ComponentLoader::new();
+            let composed = loader.load_full(&component, &T::complicator()).await?;
 
             use std::io::Write;
-            std::io::stdout().write_all(&complicated).unwrap();
+            std::io::stdout().write_all(&composed).unwrap();
             return Ok(());
         }
 
+        let trigger = T::new(self.trigger_args, &app)?;
+
         let mut builder: TriggerAppBuilder<T, B> = TriggerAppBuilder::new(trigger);
         let config = builder.engine_config();
 
diff --git a/crates/trigger/src/loader.rs b/crates/trigger/src/loader.rs
@@ -66,31 +66,8 @@ impl ComponentLoader {
             }
         }
     }
-}
-
-#[async_trait]
-impl<T: RuntimeFactors, U> spin_factors_executor::ComponentLoader<T, U> for ComponentLoader {
-    async fn load_component(
-        &self,
-        engine: &wasmtime::Engine,
-        component: &AppComponent,
-        complicator: &impl spin_factors_executor::Complicator,
-    ) -> anyhow::Result<Component> {
-        let source = component
-            .source()
-            .content
-            .source
-            .as_ref()
-            .context("LockedComponentSource missing source field")?;
-        let path = parse_file_url(source)?;
-
-        #[cfg(feature = "unsafe-aot-compilation")]
-        if self.aot_compilation_enabled {
-            return self
-                .load_precompiled_component(engine, &path)
-                .with_context(|| format!("error deserializing component from {path:?}"));
-        }
 
+    pub(crate) async fn load_full(&self, component: &AppComponent<'_>, complicator: &impl spin_factors_executor::Complicator) -> anyhow::Result<Vec<u8>> {
         let loader = ComponentSourceLoaderFs;
 
         let empty: serde_json::Map<String, serde_json::Value> = Default::default();
@@ -119,6 +96,63 @@ impl<T: RuntimeFactors, U> spin_factors_executor::ComponentLoader<T, U> for Comp
                 )
             })?;
 
+        Ok(composed)
+    }
+}
+
+#[async_trait]
+impl<T: RuntimeFactors, U> spin_factors_executor::ComponentLoader<T, U> for ComponentLoader {
+    async fn load_component(
+        &self,
+        engine: &wasmtime::Engine,
+        component: &AppComponent,
+        complicator: &impl spin_factors_executor::Complicator,
+    ) -> anyhow::Result<Component> {
+        let source = component
+            .source()
+            .content
+            .source
+            .as_ref()
+            .context("LockedComponentSource missing source field")?;
+        let path = parse_file_url(source)?;
+
+        #[cfg(feature = "unsafe-aot-compilation")]
+        if self.aot_compilation_enabled {
+            return self
+                .load_precompiled_component(engine, &path)
+                .with_context(|| format!("error deserializing component from {path:?}"));
+        }
+
+        let composed = self.load_full(component, complicator).await?;
+
+        // let loader = ComponentSourceLoaderFs;
+
+        // let empty: serde_json::Map<String, serde_json::Value> = Default::default();
+        // let extras = component
+        //     .locked
+        //     .metadata
+        //     .get("trigger-extras")
+        //     .and_then(|v| v.as_object())
+        //     .unwrap_or(&empty);
+
+        // let complications = load_complications(component.app, extras, &loader).await?;
+
+        // let complicate = async |c: Vec<u8>| {
+        //     complicator
+        //         .complicate(&complications, c)
+        //         .await
+        //         .map_err(spin_compose::ComposeError::PrepareError)
+        // };
+
+        // let composed = spin_compose::compose(&loader, component.locked, complicate)
+        //     .await
+        //     .with_context(|| {
+        //         format!(
+        //             "failed to resolve dependencies for component {:?}",
+        //             component.locked.id
+        //         )
+        //     })?;
+
         spin_core::Component::new(engine, composed)
             .with_context(|| format!("failed to compile component from {}", quoted_path(&path)))
     }
