feat: implement deploy and run

Author: dmeijboom

Cargo.lock

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 aho-corasick = "1.1.3"
 async-tempfile = "0.7.0"
+change-case = "0.2.0"
 clap = { version = "4.5.45", features = ["derive"] }
 docker_credential = "1.3.2"
 futures = "0.3.31"

Cargo.toml

@@ -174,7 +174,6 @@ Platform-specific builds:
 ```yaml
 build:
   multi-arch:
-    type: bazel
     platforms:
       linux/amd64: //platforms:linux_amd64
       linux/arm64: //platforms:linux_arm64

README.md

@@ -83,12 +83,12 @@ impl Builder for BazelBuilder {
 
     async fn build(
         self,
-        mut progress: prodash::tree::Item,
         Context {
             service_name,
             platform,
-            input,
-        }: Context<Self::Input>,
+            mut progress,
+        }: Context,
+        input: Self::Input,
     ) -> Result<Output, Self::Error> {
         progress.set_name(&service_name);
         progress.message(MessageLevel::Info, "starting builder");

src/builder/bazel.rs

@@ -8,7 +8,7 @@ use tokio::process::Command;
 use crate::{
     builder::{Builder, Context, Output},
     config::Docker,
-    exec::{self, ExitError},
+    exec::{self, CmdBuilder, ExitError},
     image,
 };
 
@@ -103,12 +103,12 @@ impl Builder for DockerBuilder {
 
     async fn build(
         self,
-        mut progress: prodash::tree::Item,
         Context {
             service_name,
             platform,
-            input,
-        }: Context<Self::Input>,
+            mut progress,
+        }: Context,
+        input: Self::Input,
     ) -> Result<Output, Self::Error> {
         progress.set_name(&service_name);
         progress.message(MessageLevel::Info, "starting builder");
@@ -136,26 +136,23 @@ impl Builder for DockerBuilder {
             progress.message(MessageLevel::Info, "using existing buildkit builder");
         }
 
-        let mut custom_args = vec![];
+        let mut cmd = CmdBuilder::new(&self.binary);
+        cmd.arg("buildx").arg("build");
+
         let build_args = fmt_map(input.build_args, '=');
         let hosts = fmt_map(input.hosts, ':');
 
         for entry in build_args.iter() {
-            custom_args.push("--build-arg");
-            custom_args.push(entry);
+            cmd.flag("--build-arg", entry);
         }
 
         for entry in hosts.iter() {
-            custom_args.push("--add-host");
-            custom_args.push(entry);
+            cmd.flag("--add-host", entry);
         }
 
         let dest = TempDir::new_with_name(&service_name).await?;
         let status = exec::run_with_progress(
-            Command::new(&self.binary)
-                .arg("build")
-                .args(custom_args)
-                .arg("--builder")
+            cmd.arg("--builder")
                 .arg("steiger")
                 .arg("--platform")
                 .arg(&platform)

src/builder/docker.rs

@@ -3,7 +3,6 @@ use std::{path::PathBuf, process::ExitStatus};
 use async_tempfile::TempDir;
 use gix::progress::MessageLevel;
 use miette::Diagnostic;
-use prodash::tree::Item;
 use tokio::process::Command;
 
 use crate::{
@@ -47,12 +46,12 @@ impl Builder for KoBuilder {
 
     async fn build(
         self,
-        mut progress: Item,
         Context {
             service_name,
             platform,
-            input,
-        }: Context<Self::Input>,
+            mut progress,
+        }: Context,
+        input: Self::Input,
     ) -> Result<Output, Self::Error> {
         progress.set_name(&service_name);
         progress.message(MessageLevel::Info, "starting builder");

src/builder/ko.rs

@@ -1,4 +1,3 @@
-use futures::TryFutureExt;
 use miette::Diagnostic;
 use prodash::{messages::MessageLevel, tree::Item};
 use tokio::{task::JoinSet, time::Instant};
@@ -43,26 +42,18 @@ impl Output {
     }
 }
 
-pub struct Context<T> {
+pub struct Context {
     pub service_name: String,
     pub platform: String,
-    pub input: T,
+    pub progress: Item,
 }
 
-impl<T> Context<T> {
-    pub fn new(service_name: String, platform: String, input: T) -> Self {
+impl Context {
+    pub fn new(service_name: String, platform: String, progress: Item) -> Self {
         Self {
             service_name,
             platform,
-            input,
-        }
-    }
-
-    pub fn with<I>(self, input: I) -> Context<I> {
-        Context {
-            input,
-            platform: self.platform,
-            service_name: self.service_name,
+            progress,
         }
     }
 }
@@ -74,22 +65,18 @@ pub trait Builder: Clone {
     fn try_init() -> Result<Self, Self::Error>
     where
         Self: Sized;
-    async fn build(
-        self,
-        progress: Item,
-        input: Context<Self::Input>,
-    ) -> Result<Output, Self::Error>;
+    async fn build(self, ctx: Context, input: Self::Input) -> Result<Output, Self::Error>;
 }
 
 type ErrorOf<T> = <T as Builder>::Error;
 
-use std::{collections::HashMap, sync::Arc};
+use std::collections::HashMap;
 
 fn run_builder<B>(
     var: &mut Option<B>,
-    progress: Item,
-    ctx: Context<B::Input>,
-) -> Result<impl Future<Output = Result<Output, <B as Builder>::Error>> + use<B>, BuildError>
+    ctx: Context,
+    input: B::Input,
+) -> Result<impl Future<Output = Result<Output, BuildError>> + use<B>, BuildError>
 where
     B: Builder,
     BuildError: From<<B as Builder>::Error>,
@@ -103,19 +90,19 @@ where
         }
     }?;
 
-    Ok(builder.build(progress, ctx))
+    Ok(async { Ok(builder.build(ctx, input).await?) })
 }
 
 pub struct MetaBuild {
-    config: Arc<Config>,
+    config: Config,
     ko: Option<KoBuilder>,
     bazel: Option<BazelBuilder>,
     docker: Option<DockerBuilder>,
     nix: Option<NixBuilder>,
 }
 
 impl MetaBuild {
-    pub fn new(config: Arc<Config>) -> Self {
+    pub fn new(config: Config) -> Self {
         Self {
             config,
             ko: None,
@@ -127,40 +114,27 @@ impl MetaBuild {
 
     pub async fn build(mut self, mut pb: Item, platform: &str) -> Result<Output, BuildError> {
         let instant = Instant::now();
-        let config = Arc::clone(&self.config);
         let mut set = JoinSet::default();
 
-        pb.init(Some(config.build.len()), None);
+        pb.init(Some(self.config.build.len()), None);
         pb.message(MessageLevel::Info, format!("detected platform: {platform}"));
 
-        for (name, build) in config.build.iter() {
-            let progress = pb.add_child(name);
-            let ctx = Context::new(name.clone(), platform.to_string(), ());
+        for (name, build) in self.config.build {
+            let progress = pb.add_child(&name);
+            let ctx = Context::new(name, platform.to_string(), progress);
 
-            match &build {
+            match build {
                 Build::Ko(ko) => {
-                    set.spawn(
-                        run_builder(&mut self.ko, progress, ctx.with(ko.clone()))?
-                            .map_err(BuildError::Ko),
-                    );
+                    set.spawn(run_builder(&mut self.ko, ctx, ko)?);
                 }
                 Build::Bazel(bazel) => {
-                    set.spawn(
-                        run_builder(&mut self.bazel, progress, ctx.with(bazel.clone()))?
-                            .map_err(BuildError::Bazel),
-                    );
+                    set.spawn(run_builder(&mut self.bazel, ctx, bazel)?);
                 }
                 Build::Docker(docker) => {
-                    set.spawn(
-                        run_builder(&mut self.docker, progress, ctx.with(docker.clone()))?
-                            .map_err(BuildError::Docker),
-                    );
+                    set.spawn(run_builder(&mut self.docker, ctx, docker)?);
                 }
                 Build::Nix(nix) => {
-                    set.spawn(
-                        run_builder(&mut self.nix, progress, ctx.with(nix.clone()))?
-                            .map_err(BuildError::Nix),
-                    );
+                    set.spawn(run_builder(&mut self.nix, ctx, nix)?);
                 }
             };
         }

src/builder/mod.rs

@@ -161,12 +161,12 @@ pub struct EvalResult {
 
 impl EvalResult {
     async fn build(
-        self,
+        mut self,
         nix_binary: Arc<PathBuf>,
         mut progress: Item,
     ) -> Result<OutPaths, NixError> {
-        if let Some(error) = self.error {
-            progress.message(MessageLevel::Failure, error.clone());
+        if let Some(error) = self.error.take() {
+            progress.message(MessageLevel::Failure, &error);
             return Err(NixError::Eval(error));
         }
 
@@ -262,7 +262,7 @@ impl NixBuilder {
 
             if packages.values().any(|v| v == &attr_path) {
                 progress.init(Some(set.len() + 1), None);
-                let binary = self.nix_binary.clone();
+                let binary = Arc::clone(&self.nix_binary);
                 let progress = progress.add_child(format!("{attr_path} › nix"));
                 set.spawn(drv.build(binary, progress));
             }
@@ -303,12 +303,12 @@ impl Builder for NixBuilder {
 
     async fn build(
         self,
-        mut progress: Item,
         Context {
             service_name,
             platform,
-            input,
-        }: Context<Self::Input>,
+            mut progress,
+        }: Context,
+        input: Self::Input,
     ) -> Result<Output, Self::Error> {
         progress.set_name(&service_name);
         progress.info("starting builder".to_string());