feat(push): allow pushing composed components to registry

Signed-off-by: Brian H <[email protected]>

Author: fibonacci1729

Cargo.lock

@@ -8,6 +8,7 @@ edition = { workspace = true }
 anyhow = { workspace = true }
 async-compression = { version = "0.4", features = ["gzip", "tokio"] }
 async-tar = "0.5"
+async-trait = { workspace = true }
 base64 = "0.22"
 chrono = "0.4"
 # Fork with updated auth to support ACR login
@@ -22,6 +23,8 @@ reqwest = "0.12"
 serde = { workspace = true }
 serde_json = { workspace = true }
 spin-common = { path = "../common" }
+spin-componentize = { path = "../componentize" }
+spin-compose = { path = "../compose" }
 spin-loader = { path = "../loader" }
 spin-locked-app = { path = "../locked-app" }
 tempfile = { workspace = true }

crates/oci/Cargo.toml

@@ -4,6 +4,7 @@ use std::collections::{BTreeMap, HashMap};
 use std::path::{Path, PathBuf};
 
 use anyhow::{bail, Context, Result};
+use async_trait::async_trait;
 use docker_credential::DockerCredential;
 use futures_util::future;
 use futures_util::stream::{self, StreamExt, TryStreamExt};
@@ -18,7 +19,7 @@ use spin_common::ui::quoted_path;
 use spin_common::url::parse_file_url;
 use spin_loader::cache::Cache;
 use spin_loader::FilesMountStrategy;
-use spin_locked_app::locked::{ContentPath, ContentRef, LockedApp};
+use spin_locked_app::locked::{ContentPath, ContentRef, LockedApp, LockedComponentSource};
 use tokio::fs;
 use walkdir::WalkDir;
 
@@ -119,6 +120,7 @@ impl Client {
         reference: impl AsRef<str>,
         annotations: Option<BTreeMap<String, String>>,
         infer_annotations: InferPredefinedAnnotations,
+        skip_compose: bool,
     ) -> Result<Option<String>> {
         let reference: Reference = reference
             .as_ref()
@@ -137,8 +139,15 @@ impl Client {
         )
         .await?;
 
-        self.push_locked_core(locked, auth, reference, annotations, infer_annotations)
-            .await
+        self.push_locked_core(
+            locked,
+            auth,
+            reference,
+            annotations,
+            infer_annotations,
+            skip_compose,
+        )
+        .await
     }
 
     /// Push a Spin application to an OCI registry and return the digest (or None
@@ -149,15 +158,23 @@ impl Client {
         reference: impl AsRef<str>,
         annotations: Option<BTreeMap<String, String>>,
         infer_annotations: InferPredefinedAnnotations,
+        skip_compose: bool,
     ) -> Result<Option<String>> {
         let reference: Reference = reference
             .as_ref()
             .parse()
             .with_context(|| format!("cannot parse reference {}", reference.as_ref()))?;
         let auth = Self::auth(&reference).await?;
 
-        self.push_locked_core(locked, auth, reference, annotations, infer_annotations)
-            .await
+        self.push_locked_core(
+            locked,
+            auth,
+            reference,
+            annotations,
+            infer_annotations,
+            skip_compose,
+        )
+        .await
     }
 
     /// Push a Spin application to an OCI registry and return the digest (or None
@@ -169,10 +186,11 @@ impl Client {
         reference: Reference,
         annotations: Option<BTreeMap<String, String>>,
         infer_annotations: InferPredefinedAnnotations,
+        skip_compose: bool,
     ) -> Result<Option<String>> {
         let mut locked_app = locked.clone();
         let mut layers = self
-            .assemble_layers(&mut locked_app, AssemblyMode::Simple)
+            .assemble_layers(&mut locked_app, AssemblyMode::Simple, skip_compose)
             .await
             .context("could not assemble layers for locked application")?;
 
@@ -183,7 +201,7 @@ impl Client {
         {
             locked_app = locked.clone();
             layers = self
-                .assemble_layers(&mut locked_app, AssemblyMode::Archive)
+                .assemble_layers(&mut locked_app, AssemblyMode::Archive, skip_compose)
                 .await
                 .context("could not assemble archive layers for locked application")?;
         }
@@ -246,43 +264,57 @@ impl Client {
         &mut self,
         locked: &mut LockedApp,
         assembly_mode: AssemblyMode,
+        skip_compose: bool,
     ) -> Result<Vec<ImageLayer>> {
         let mut layers = Vec::new();
         let mut components = Vec::new();
         for mut c in locked.clone().components {
-            // Add the wasm module for the component as layers.
-            let source = c
-                .clone()
-                .source
-                .content
-                .source
-                .context("component loaded from disk should contain a file source")?;
-
-            let source = parse_file_url(source.as_str())?;
-            let layer = Self::wasm_layer(&source).await?;
-
-            // Update the module source with the content ref of the layer.
-            c.source.content = self.content_ref_for_layer(&layer);
-
-            layers.push(layer);
-
-            let mut deps = BTreeMap::default();
-            for (dep_name, mut dep) in c.dependencies {
-                let source = dep
+            if !skip_compose {
+                let composed = spin_compose::compose(&ComponentSourceLoader, &c)
+                    .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();
+                layers.push(layer);
+            } else {
+                // Add the wasm module for the component as layers.
+                let source = c
+                    .clone()
                     .source
                     .content
                     .source
-                    .context("dependency loaded from disk should contain a file source")?;
-                let source = parse_file_url(source.as_str())?;
+                    .context("component loaded from disk should contain a file source")?;
 
+                let source = parse_file_url(source.as_str())?;
                 let layer = Self::wasm_layer(&source).await?;
 
-                dep.source.content = self.content_ref_for_layer(&layer);
-                deps.insert(dep_name, dep);
+                // Update the module source with the content ref of the layer.
+                c.source.content = self.content_ref_for_layer(&layer);
 
                 layers.push(layer);
+
+                let mut deps = BTreeMap::default();
+                for (dep_name, mut dep) in c.dependencies {
+                    let source = dep
+                        .source
+                        .content
+                        .source
+                        .context("dependency loaded from disk should contain a file source")?;
+                    let source = parse_file_url(source.as_str())?;
+
+                    let layer = Self::wasm_layer(&source).await?;
+
+                    dep.source.content = self.content_ref_for_layer(&layer);
+                    deps.insert(dep_name, dep);
+
+                    layers.push(layer);
+                }
+                c.dependencies = deps;
             }
-            c.dependencies = deps;
 
             let mut files = Vec::new();
             for f in c.files {
@@ -669,6 +701,32 @@ impl Client {
     }
 }
 
+struct ComponentSourceLoader;
+
+#[async_trait]
+impl spin_compose::ComponentSourceLoader for ComponentSourceLoader {
+    async fn load_component_source(
+        &self,
+        source: &LockedComponentSource,
+    ) -> anyhow::Result<Vec<u8>> {
+        let source = source
+            .content
+            .source
+            .as_ref()
+            .context("component loaded from disk should contain a file source")?;
+
+        let source = parse_file_url(source.as_str())?;
+
+        let bytes = fs::read(&source)
+            .await
+            .with_context(|| format!("cannot read wasm module {}", quoted_path(source)))?;
+
+        let component = spin_componentize::componentize_if_necessary(&bytes)?;
+
+        Ok(component.into())
+    }
+}
+
 /// Unpack contents of the provided archive layer, represented by bytes and its
 /// corresponding digest, into the provided cache.
 /// A temporary staging directory is created via tempfile::tempdir() to store
@@ -1137,7 +1195,7 @@ mod test {
                     assert_eq!(
                         e,
                         client
-                            .assemble_layers(&mut locked, AssemblyMode::Simple)
+                            .assemble_layers(&mut locked, AssemblyMode::Simple, true)
                             .await
                             .unwrap_err()
                             .to_string(),
@@ -1149,7 +1207,7 @@ mod test {
                     assert_eq!(
                         tc.expected_layer_count,
                         client
-                            .assemble_layers(&mut locked, AssemblyMode::Simple)
+                            .assemble_layers(&mut locked, AssemblyMode::Simple, true)
                             .await
                             .unwrap()
                             .len(),

crates/oci/src/client.rs

@@ -49,6 +49,10 @@ pub struct Push {
     )]
     pub insecure: bool,
 
+    /// Skip composing the application's components before pushing it.
+    #[clap(long = "skip-compose")]
+    pub skip_compose: bool,
+
     /// Specifies to perform `spin build` before pushing the application.
     #[clap(long, takes_value = false, env = ALWAYS_BUILD_ENV)]
     pub build: bool,
@@ -94,6 +98,7 @@ impl Push {
                 &self.reference,
                 annotations,
                 InferPredefinedAnnotations::All,
+                self.skip_compose,
             )
             .await?;
         match digest {