feat: with git name

Signed-off-by: kjuulh <contact@kjuulh.io>

.drone.yml

@@ -102,6 +102,8 @@ steps:
       CUDDLE_SECRETS_PROVIDER: 1password
       CUDDLE_ONE_PASSWORD_DOT_ENV: ".env.ci"
       CUDDLE_SSH_AGENT: "true"
+      GIT_PASSWORD:
+        from_secret: gitea_token
       CI_PREFIX: "/mnt/ci/ci"
       CUDDLE_PLEASE_TOKEN:
         from_secret: cuddle_please_token

Cargo.lock

@@ -320,6 +320,19 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "cuddle-ci"
+version = "0.2.0"
+dependencies = [
+ "async-trait",
+ "clap",
+ "dagger-rust",
+ "dagger-sdk",
+ "eyre",
+ "futures",
+ "tokio",
+]
+
 [[package]]
 name = "cuddle-components"
 version = "0.1.0"

Cargo.toml

@@ -23,3 +23,7 @@ eyre = "0.6.9"
 tokio = "1.34.0"
 dotenv = "0.15.0"
 async-trait = "0.1.74"
+color-eyre = "*"
+clap = {version = "4", features = ["derive"]}
+futures = "0.3.29"
+async-scoped = { version = "0.8.0", features = ["tokio", "use-tokio"] }

ci/src/main.rs

@@ -1,5 +1,4 @@
 use std::path::PathBuf;
-use std::sync::Arc;
 
 use clap::Args;
 use clap::Parser;
@@ -62,10 +61,10 @@ async fn main() -> eyre::Result<()> {
     let _ = dotenv::dotenv();
     let _ = color_eyre::install();
 
-    let client = dagger_sdk::connect().await?;
-
     let cli = Command::parse();
 
+    let client = dagger_sdk::connect().await?;
+
     match &cli.commands {
         Commands::Local { command } => match command {
             LocalCommands::Test => {
@@ -107,7 +106,6 @@ async fn main() -> eyre::Result<()> {
 }
 
 mod please_release {
-    use std::sync::Arc;
 
     use dagger_cuddle_please::{models::CuddlePleaseSrcArgs, DaggerCuddlePleaseAction};
 
@@ -136,7 +134,7 @@ mod please_release {
 }
 
 mod test {
-    use std::{path::PathBuf, sync::Arc};
+    use std::path::PathBuf;
 
     use dagger_rust::build::RustVersion;
 

crates/cuddle-ci/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "cuddle-ci"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+readme.workspace = true
+repository.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dagger-rust.workspace = true
+
+dagger-sdk.workspace = true
+eyre.workspace = true
+clap.workspace = true
+async-trait.workspace = true
+futures.workspace = true
+tokio.workspace = true
+
+[dev-dependencies]
+tokio.workspace = true

crates/cuddle-ci/src/cli.rs

@@ -0,0 +1,166 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use tokio::sync::Mutex;
+
+pub struct CuddleCI {
+    pr_action: Arc<Mutex<dyn PullRequestAction + Send + Sync>>,
+    main_action: Arc<Mutex<dyn MainAction + Send + Sync>>,
+    release_action: Arc<Mutex<dyn ReleaseAction + Send + Sync>>,
+}
+
+impl CuddleCI {
+    pub fn new(
+        pr: Arc<Mutex<dyn PullRequestAction + Send + Sync>>,
+        main: Arc<Mutex<dyn MainAction + Send + Sync>>,
+        release: Arc<Mutex<dyn ReleaseAction + Send + Sync>>,
+    ) -> Self {
+        Self {
+            pr_action: pr,
+            main_action: main,
+            release_action: release,
+        }
+    }
+
+    pub fn with_pull_request(
+        &mut self,
+        pr: Arc<Mutex<dyn PullRequestAction + Send + Sync>>,
+    ) -> &mut Self {
+        self.pr_action = pr;
+
+        self
+    }
+
+    pub fn with_main(&mut self, main: Arc<Mutex<dyn MainAction + Send + Sync>>) -> &mut Self {
+        self.main_action = main;
+
+        self
+    }
+
+    pub fn with_release(
+        &mut self,
+        release: Arc<Mutex<dyn ReleaseAction + Send + Sync>>,
+    ) -> &mut Self {
+        self.release_action = release;
+
+        self
+    }
+
+    pub async fn execute(
+        &mut self,
+        args: impl IntoIterator<Item = impl Into<String>>,
+    ) -> eyre::Result<()> {
+        let matches = clap::Command::new("cuddle-ci")
+            .about("is a wrapper around common CI actions")
+            .subcommand(clap::Command::new("pr"))
+            .subcommand(clap::Command::new("main"))
+            .subcommand(clap::Command::new("release"))
+            .subcommand_required(true)
+            .try_get_matches_from(args.into_iter().map(|a| a.into()).collect::<Vec<String>>())?;
+
+        match matches.subcommand() {
+            Some((name, args)) => match (name, args) {
+                ("pr", _args) => {
+                    eprintln!("starting pr validate");
+                    self.pr_action.lock().await.execute_pull_request().await?;
+                    eprintln!("finished pr validate");
+                }
+                ("main", _args) => {
+                    eprintln!("starting main validate");
+                    self.main_action.lock().await.execute_main().await?;
+                    eprintln!("finished main validate");
+                }
+                ("release", _args) => {
+                    eprintln!("starting release validate");
+                    self.release_action.lock().await.execute_release().await?;
+                    eprintln!("finished release validate");
+                }
+                (command_name, _) => {
+                    eyre::bail!("command is not recognized: {}", command_name)
+                }
+            },
+            None => eyre::bail!("command required a subcommand [pr, main, release] etc."),
+        }
+
+        Ok(())
+    }
+}
+
+impl Default for CuddleCI {
+    fn default() -> Self {
+        Self::new(
+            Arc::new(Mutex::new(DefaultPullRequestAction {})),
+            Arc::new(Mutex::new(DefaultMainAction {})),
+            Arc::new(Mutex::new(DefaultReleaseAction {})),
+        )
+    }
+}
+
+#[async_trait]
+pub trait PullRequestAction {
+    async fn execute_pull_request(&self) -> eyre::Result<()> {
+        eprintln!("validate pull request: noop");
+        Ok(())
+    }
+}
+
+pub struct DefaultPullRequestAction {}
+#[async_trait]
+impl PullRequestAction for DefaultPullRequestAction {}
+
+#[async_trait]
+pub trait MainAction {
+    async fn execute_main(&self) -> eyre::Result<()> {
+        eprintln!("validate main: noop");
+        Ok(())
+    }
+}
+
+pub struct DefaultMainAction {}
+#[async_trait]
+impl MainAction for DefaultMainAction {}
+
+#[async_trait]
+pub trait ReleaseAction {
+    async fn execute_release(&self) -> eyre::Result<()> {
+        eprintln!("validate release: noop");
+
+        Ok(())
+    }
+}
+
+pub struct DefaultReleaseAction {}
+#[async_trait]
+impl ReleaseAction for DefaultReleaseAction {}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_can_call_default() -> eyre::Result<()> {
+        CuddleCI::default().execute(["cuddle-ci", "pr"]).await?;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_fails_on_no_command() -> eyre::Result<()> {
+        let res = CuddleCI::default().execute(["cuddle-ci"]).await;
+
+        assert!(res.is_err());
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_fails_on_wrong_command() -> eyre::Result<()> {
+        let res = CuddleCI::default()
+            .execute(["cuddle-ci", "something"])
+            .await;
+
+        assert!(res.is_err());
+
+        Ok(())
+    }
+}

crates/cuddle-ci/src/dagger_middleware.rs

@@ -0,0 +1,54 @@
+use async_trait::async_trait;
+use dagger_sdk::Container;
+use std::{future::Future, pin::Pin, sync::Arc};
+
+pub type DynMiddleware = Arc<dyn DaggerMiddleware + Send + Sync>;
+
+#[async_trait]
+pub trait DaggerMiddleware {
+    async fn handle(
+        &self,
+        container: dagger_sdk::Container,
+    ) -> eyre::Result<dagger_sdk::Container> {
+        Ok(container)
+    }
+}
+
+pub struct DaggerMiddlewareFn<F>
+where
+    F: Fn(Container) -> Pin<Box<dyn Future<Output = eyre::Result<Container>> + Send>>,
+{
+    pub func: F,
+}
+
+pub fn middleware<F>(func: F) -> Box<DaggerMiddlewareFn<F>>
+where
+    F: Fn(Container) -> Pin<Box<dyn Future<Output = eyre::Result<Container>> + Send>>,
+{
+    Box::new(DaggerMiddlewareFn { func })
+}
+
+#[async_trait]
+impl<F> DaggerMiddleware for DaggerMiddlewareFn<F>
+where
+    F: Fn(Container) -> Pin<Box<dyn Future<Output = eyre::Result<Container>> + Send>> + Send + Sync,
+{
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        // Call the closure stored in the struct
+        (self.func)(container).await
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use futures::FutureExt;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn can_add_middleware() -> eyre::Result<()> {
+        middleware(|c| async move { Ok(c) }.boxed());
+
+        Ok(())
+    }
+}

crates/cuddle-ci/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod cli;
+pub use cli::*;
+
+pub mod dagger_middleware;
+pub mod rust_service;

crates/cuddle-ci/src/rust_service.rs

@@ -0,0 +1,447 @@
+use std::{path::PathBuf, sync::Arc};
+
+use async_trait::async_trait;
+use dagger_rust::source::RustSource;
+use dagger_sdk::Container;
+use futures::{stream, StreamExt};
+
+use crate::{
+    dagger_middleware::{DaggerMiddleware, DynMiddleware},
+    MainAction, PullRequestAction,
+};
+
+use self::architecture::{Architecture, Os};
+
+#[derive(Clone)]
+pub enum RustServiceStage {
+    BeforeDeps(DynMiddleware),
+    AfterDeps(DynMiddleware),
+    BeforeBase(DynMiddleware),
+    AfterBase(DynMiddleware),
+    BeforeBuild(DynMiddleware),
+    AfterBuild(DynMiddleware),
+    BeforePackage(DynMiddleware),
+    AfterPackage(DynMiddleware),
+    BeforeRelease(DynMiddleware),
+    AfterRelease(DynMiddleware),
+}
+
+#[derive(Clone)]
+pub struct RustService {
+    client: dagger_sdk::Query,
+    base_image: Option<dagger_sdk::Container>,
+    final_image: Option<dagger_sdk::Container>,
+    stages: Vec<RustServiceStage>,
+    source: Option<PathBuf>,
+    crates: Vec<String>,
+    bin_name: String,
+    arch: Option<Architecture>,
+    os: Option<Os>,
+}
+
+impl From<dagger_sdk::Query> for RustService {
+    fn from(value: dagger_sdk::Query) -> Self {
+        Self {
+            client: value,
+            base_image: None,
+            final_image: None,
+            stages: Vec::new(),
+            source: None,
+            crates: Vec::new(),
+            bin_name: String::new(),
+            arch: None,
+            os: None,
+        }
+    }
+}
+
+impl RustService {
+    pub async fn new() -> eyre::Result<Self> {
+        Ok(Self {
+            client: dagger_sdk::connect().await?,
+            base_image: None,
+            final_image: None,
+            stages: Vec::new(),
+            source: None,
+            crates: Vec::new(),
+            bin_name: String::new(),
+            arch: None,
+            os: None,
+        })
+    }
+
+    pub fn with_base_image(&mut self, base: dagger_sdk::Container) -> &mut Self {
+        self.base_image = Some(base);
+
+        self
+    }
+
+    pub fn with_stage(&mut self, stage: RustServiceStage) -> &mut Self {
+        self.stages.push(stage);
+
+        self
+    }
+
+    pub fn with_source(&mut self, path: impl Into<PathBuf>) -> &mut Self {
+        self.source = Some(path.into());
+
+        self
+    }
+
+    pub fn with_bin_name(&mut self, bin_name: impl Into<String>) -> &mut Self {
+        self.bin_name = bin_name.into();
+
+        self
+    }
+
+    pub fn with_crates(
+        &mut self,
+        crates: impl IntoIterator<Item = impl Into<String>>,
+    ) -> &mut Self {
+        self.crates = crates.into_iter().map(|c| c.into()).collect();
+
+        self
+    }
+
+    pub fn with_arch(&mut self, arch: Architecture) -> &mut Self {
+        self.arch = Some(arch);
+
+        self
+    }
+
+    pub fn with_os(&mut self, os: Os) -> &mut Self {
+        self.os = Some(os);
+
+        self
+    }
+
+    fn get_src(&self) -> PathBuf {
+        self.source
+            .clone()
+            .unwrap_or(std::env::current_dir().unwrap())
+    }
+
+    fn get_arch(&self) -> Architecture {
+        self.arch
+            .clone()
+            .unwrap_or_else(|| match std::env::consts::ARCH {
+                "x86" | "x86_64" | "amd64" => Architecture::Amd64,
+                "arm" => Architecture::Arm64,
+                arch => panic!("unsupported architecture: {arch}"),
+            })
+    }
+
+    fn get_os(&self) -> Os {
+        self.os
+            .clone()
+            .unwrap_or_else(|| match std::env::consts::OS {
+                "linux" => Os::Linux,
+                "macos" => Os::MacOS,
+                os => panic!("unsupported os: {os}"),
+            })
+    }
+
+    async fn run_stage(
+        &self,
+        stages: impl IntoIterator<Item = &Arc<dyn DaggerMiddleware + Send + Sync>>,
+        container: Container,
+    ) -> eyre::Result<Container> {
+        let before_deps_stream = stream::iter(stages.into_iter().map(Ok));
+        let res = StreamExt::fold(before_deps_stream, Ok(container), |base, m| async move {
+            match (base, m) {
+                (Ok(base), Ok(m)) => m.handle(base).await,
+                (_, Err(e)) | (Err(e), _) => eyre::bail!("failed with {e}"),
+            }
+        })
+        .await?;
+
+        Ok(res)
+    }
+
+    pub async fn build_base(&self) -> eyre::Result<Container> {
+        let rust_src = RustSource::new(self.client.clone());
+
+        let (src, dep_src) = rust_src
+            .get_rust_src(Some(&self.get_src()), self.crates.clone())
+            .await?;
+
+        let base_image = self
+            .base_image
+            .clone()
+            .unwrap_or(self.client.container().from("rustlang/rust:nightly"));
+
+        let before_deps = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeDeps(middleware) => Some(middleware),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(before_deps, base_image).await?;
+
+        let after_deps = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterDeps(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(after_deps, image).await?;
+
+        let before_base = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBase(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(before_base, image).await?;
+
+        let cache = self.client.cache_volume("rust_target_cache");
+
+        let rust_prebuild = image
+            .with_workdir("/mnt/src")
+            .with_directory("/mnt/src", dep_src)
+            .with_exec(vec!["cargo", "build", "--release", "--bin", &self.bin_name])
+            .with_mounted_cache("/mnt/src/target/", cache);
+
+        let incremental_dir = rust_src
+            .get_rust_target_src(&self.get_src(), rust_prebuild.clone(), self.crates.clone())
+            .await?;
+
+        let rust_with_src = image
+            .with_workdir("/mnt/src")
+            .with_directory(
+                "/usr/local/cargo",
+                rust_prebuild.directory("/usr/local/cargo"),
+            )
+            .with_directory("/mnt/src/target", incremental_dir)
+            .with_directory("/mnt/src/", src);
+
+        let after_base = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterBase(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let image = self.run_stage(after_base, rust_with_src).await?;
+
+        Ok(image)
+    }
+
+    pub async fn build_release(&self) -> eyre::Result<Container> {
+        let base = self.build_base().await?;
+
+        let before_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let base = self.run_stage(before_build, base).await?;
+
+        let binary_build =
+            base.with_exec(vec!["cargo", "build", "--release", "--bin", &self.bin_name]);
+
+        let after_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let binary_build = self.run_stage(after_build, binary_build).await?;
+
+        let dest = self
+            .final_image
+            .clone()
+            .unwrap_or(self.client.container().from("debian:bullseye"));
+
+        let before_package = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforePackage(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let dest = self.run_stage(before_package, dest).await?;
+
+        let final_image = dest.with_workdir("/mnt/app").with_file(
+            format!("/usr/local/bin/{}", self.bin_name),
+            binary_build.file(format!("/mnt/src/target/release/{}", self.bin_name)),
+        );
+
+        let after_package = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::AfterPackage(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let final_image = self.run_stage(after_package, final_image).await?;
+
+        Ok(final_image)
+    }
+
+    pub async fn build_test(&self) -> eyre::Result<()> {
+        let base = self.build_base().await?;
+
+        let before_build = self
+            .stages
+            .iter()
+            .filter_map(|s| match s {
+                RustServiceStage::BeforeBuild(m) => Some(m),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        let base = self.run_stage(before_build, base).await?;
+
+        base.with_exec(vec!["cargo", "test", "--release"])
+            .sync()
+            .await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl PullRequestAction for RustService {
+    async fn execute_pull_request(&self) -> eyre::Result<()> {
+        self.build_test().await?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MainAction for RustService {
+    async fn execute_main(&self) -> eyre::Result<()> {
+        let container = self.build_release().await?;
+        let timestamp = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        container
+            .publish(format!(
+                "docker.io/kasperhermansen/{}:main-{}",
+                self.bin_name, timestamp,
+            ))
+            .await?;
+
+        let update_deployments_docker_image =
+            "docker.io/kasperhermansen/update-deployment:1690401410";
+        self.client
+            .container()
+            .from(update_deployments_docker_image)
+            .with_env_variable("GIT_USERNAME", "git")
+            .with_env_variable(
+                "GIT_PASSWORD",
+                std::env::var("GIT_PASSWORD").expect("GIT_PASSWORD to be set"),
+            )
+            .with_exec(vec![
+                "update-deployment",
+                "--repo",
+                &format!(
+                    "https://git.front.kjuulh.io/kjuulh/{}-deployment.git",
+                    self.bin_name
+                ),
+                "--service",
+                &self.bin_name,
+                "--image",
+                &format!("kasperhermansen/{}:main-{}", self.bin_name, timestamp),
+            ])
+            .sync()
+            .await?;
+
+        Ok(())
+    }
+}
+
+pub mod architecture {
+    #[derive(Debug, Clone)]
+    pub enum Architecture {
+        Amd64,
+        Arm64,
+    }
+
+    #[derive(Debug, Clone)]
+    pub enum Os {
+        Linux,
+        MacOS,
+    }
+}
+
+mod apt;
+mod cargo_binstall;
+mod cargo_clean;
+mod clap_sanity_test;
+mod mold;
+mod sqlx;
+
+pub mod extensions {
+    pub use super::apt::*;
+    pub use super::cargo_binstall::*;
+    pub use super::cargo_clean::*;
+    pub use super::clap_sanity_test::*;
+    pub use super::mold::*;
+    pub use super::sqlx::*;
+}
+
+#[cfg(test)]
+mod test {
+    use futures::FutureExt;
+
+    use crate::{
+        dagger_middleware::middleware,
+        rust_service::{
+            apt::AptExt,
+            architecture::{Architecture, Os},
+            cargo_binstall::CargoBInstallExt,
+            clap_sanity_test::ClapSanityTestExt,
+            mold::MoldActionExt,
+            RustService, RustServiceStage,
+        },
+    };
+
+    #[tokio::test]
+    async fn test_can_build_rust() -> eyre::Result<()> {
+        let client = dagger_sdk::connect().await?;
+
+        let root_dir = std::path::PathBuf::from("../../").canonicalize()?;
+
+        let container = RustService::from(client.clone())
+            .with_arch(Architecture::Amd64)
+            .with_os(Os::Linux)
+            .with_source(root_dir)
+            .with_bin_name("ci")
+            .with_crates(["crates/*", "examples/*", "ci"])
+            .with_apt(&["git"])
+            .with_cargo_binstall("latest", ["sqlx-cli"])
+            .with_mold("2.3.3")
+            .with_stage(RustServiceStage::BeforeDeps(middleware(|c| {
+                async move {
+                    // Noop
+                    Ok(c)
+                }
+                .boxed()
+            })))
+            .with_clap_sanity_test()
+            .build_release()
+            .await?;
+
+        container.sync().await?;
+
+        Ok(())
+    }
+}

crates/cuddle-ci/src/rust_service/apt.rs

@@ -0,0 +1,56 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::RustService;
+
+pub struct Apt {
+    deps: Vec<String>,
+}
+
+impl Apt {
+    pub fn new() -> Self {
+        Self { deps: Vec::new() }
+    }
+
+    pub fn add(mut self, dep_name: impl Into<String>) -> Self {
+        self.deps.push(dep_name.into());
+
+        self
+    }
+
+    pub fn extend(mut self, deps: &[&str]) -> Self {
+        self.deps.extend(deps.iter().map(|s| s.to_string()));
+
+        self
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for Apt {
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        let mut deps = vec!["apt", "install", "-y"];
+        deps.extend(self.deps.iter().map(|s| s.as_str()));
+
+        let c = container.with_exec(vec!["apt", "update"]).with_exec(deps);
+
+        Ok(c)
+    }
+}
+
+pub trait AptExt {
+    fn with_apt(&mut self, deps: &[&str]) -> &mut Self {
+        self
+    }
+}
+
+impl AptExt for RustService {
+    fn with_apt(&mut self, deps: &[&str]) -> &mut Self {
+        self.with_stage(super::RustServiceStage::BeforeDeps(Arc::new(
+            Apt::new().extend(deps),
+        )))
+    }
+}

crates/cuddle-ci/src/rust_service/cargo_binstall.rs

@@ -0,0 +1,106 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::{
+    architecture::{Architecture, Os},
+    RustService,
+};
+
+pub struct CargoBInstall {
+    arch: Architecture,
+    os: Os,
+    version: String,
+    crates: Vec<String>,
+}
+
+impl CargoBInstall {
+    pub fn new(
+        arch: Architecture,
+        os: Os,
+        version: impl Into<String>,
+        crates: impl Into<Vec<String>>,
+    ) -> Self {
+        Self {
+            arch,
+            os,
+            version: version.into(),
+            crates: crates.into(),
+        }
+    }
+
+    fn get_arch(&self) -> String {
+        match self.arch {
+            Architecture::Amd64 => "x86_64",
+            Architecture::Arm64 => "armv7",
+        }
+        .into()
+    }
+
+    fn get_os(&self) -> String {
+        match self.os {
+            Os::Linux => "linux",
+            Os::MacOS => "darwin",
+        }
+        .into()
+    }
+
+    pub fn get_download_url(&self) -> String {
+        format!("https://github.com/cargo-bins/cargo-binstall/releases/{}/download/cargo-binstall-{}-unknown-{}-musl.tgz", self.version, self.get_arch(), self.get_os())
+    }
+
+    pub fn get_archive(&self) -> String {
+        format!(
+            "cargo-binstall-{}-unknown-{}-musl.tgz",
+            self.get_arch(),
+            self.get_os()
+        )
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for CargoBInstall {
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        let c = container
+            .with_exec(vec!["wget", &self.get_download_url()])
+            .with_exec(vec!["tar", "-xvf", &self.get_archive()])
+            .with_exec(
+                "mv cargo-binstall /usr/local/cargo/bin"
+                    .split_whitespace()
+                    .collect(),
+            );
+
+        let c = self.crates.iter().cloned().fold(c, |acc, item| {
+            acc.with_exec(vec!["cargo", "binstall", &item, "-y"])
+        });
+
+        Ok(c)
+    }
+}
+
+pub trait CargoBInstallExt {
+    fn with_cargo_binstall(
+        &mut self,
+        version: impl Into<String>,
+        crates: impl IntoIterator<Item = impl Into<String>>,
+    ) -> &mut Self {
+        self
+    }
+}
+
+impl CargoBInstallExt for RustService {
+    fn with_cargo_binstall(
+        &mut self,
+        version: impl Into<String>,
+        crates: impl IntoIterator<Item = impl Into<String>>,
+    ) -> &mut Self {
+        let crates: Vec<String> = crates.into_iter().map(|s| s.into()).collect();
+
+        self.with_stage(super::RustServiceStage::BeforeDeps(Arc::new(
+            CargoBInstall::new(self.get_arch(), self.get_os(), version, crates),
+        )))
+    }
+}

crates/cuddle-ci/src/rust_service/cargo_clean.rs

@@ -0,0 +1,39 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::RustService;
+
+pub struct CargoClean;
+
+impl CargoClean {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for CargoClean {
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        Ok(container.with_exec(vec!["cargo", "clean"]))
+    }
+}
+
+pub trait CargoCleanExt {
+    fn with_cargo_clean(&mut self) -> &mut Self {
+        self
+    }
+}
+
+impl CargoCleanExt for RustService {
+    fn with_cargo_clean(&mut self) -> &mut Self {
+        self.with_stage(super::RustServiceStage::BeforeBuild(Arc::new(
+            CargoClean::new(),
+        )));
+
+        self
+    }
+}

crates/cuddle-ci/src/rust_service/clap_sanity_test.rs

@@ -0,0 +1,43 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::RustService;
+
+pub struct ClapSanityTest {
+    bin_name: String,
+}
+
+impl ClapSanityTest {
+    pub fn new(bin_name: impl Into<String>) -> Self {
+        Self {
+            bin_name: bin_name.into(),
+        }
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for ClapSanityTest {
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        Ok(container.with_exec(vec![&self.bin_name, "--help"]))
+    }
+}
+
+pub trait ClapSanityTestExt {
+    fn with_clap_sanity_test(&mut self) -> &mut Self {
+        self
+    }
+}
+
+impl ClapSanityTestExt for RustService {
+    fn with_clap_sanity_test(&mut self) -> &mut Self {
+        self.with_stage(super::RustServiceStage::AfterPackage(Arc::new(
+            ClapSanityTest::new(&self.bin_name),
+        )));
+
+        self
+    }
+}

crates/cuddle-ci/src/rust_service/mold.rs

@@ -0,0 +1,104 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::{
+    architecture::{Architecture, Os},
+    RustService,
+};
+
+pub struct MoldInstall {
+    arch: Architecture,
+    os: Os,
+    version: String,
+}
+
+impl MoldInstall {
+    pub fn new(arch: Architecture, os: Os, version: impl Into<String>) -> Self {
+        Self {
+            arch,
+            os,
+            version: version.into(),
+        }
+    }
+
+    fn get_arch(&self) -> String {
+        match self.arch {
+            Architecture::Amd64 => "x86_64",
+            Architecture::Arm64 => "arm",
+        }
+        .into()
+    }
+    fn get_os(&self) -> String {
+        match &self.os {
+            Os::Linux => "linux",
+            o => todo!("os not implemented for mold: {:?}", o),
+        }
+        .into()
+    }
+
+    pub fn get_download_url(&self) -> String {
+        format!(
+            "https://github.com/rui314/mold/releases/download/v{}/mold-{}-{}-{}.tar.gz",
+            self.version,
+            self.version,
+            self.get_arch(),
+            self.get_os()
+        )
+    }
+
+    pub fn get_folder(&self) -> String {
+        format!(
+            "mold-{}-{}-{}",
+            self.version,
+            self.get_arch(),
+            self.get_os()
+        )
+    }
+
+    pub fn get_archive_name(&self) -> String {
+        format!(
+            "mold-{}-{}-{}.tar.gz",
+            self.version,
+            self.get_arch(),
+            self.get_os()
+        )
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for MoldInstall {
+    async fn handle(
+        &self,
+        container: dagger_sdk::Container,
+    ) -> eyre::Result<dagger_sdk::Container> {
+        println!("installing mold");
+
+        let c = container
+            .with_exec(vec!["wget", &self.get_download_url()])
+            .with_exec(vec!["tar", "-xvf", &self.get_archive_name()])
+            .with_exec(vec![
+                "mv",
+                &format!("{}/bin/mold", self.get_folder()),
+                "/usr/bin/mold",
+            ]);
+
+        Ok(c)
+    }
+}
+
+pub trait MoldActionExt {
+    fn with_mold(&mut self, version: impl Into<String>) -> &mut Self {
+        self
+    }
+}
+
+impl MoldActionExt for RustService {
+    fn with_mold(&mut self, version: impl Into<String>) -> &mut Self {
+        self.with_stage(super::RustServiceStage::AfterDeps(Arc::new(
+            MoldInstall::new(self.get_arch(), self.get_os(), version),
+        )))
+    }
+}

crates/cuddle-ci/src/rust_service/sqlx.rs

@@ -0,0 +1,45 @@
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use dagger_sdk::Container;
+
+use crate::dagger_middleware::DaggerMiddleware;
+
+use super::RustService;
+
+pub struct Sqlx {
+    client: dagger_sdk::Query,
+}
+
+impl Sqlx {
+    pub fn new(client: dagger_sdk::Query) -> Self {
+        Self { client }
+    }
+}
+
+#[async_trait]
+impl DaggerMiddleware for Sqlx {
+    async fn handle(&self, container: Container) -> eyre::Result<Container> {
+        let src = self.client.host().directory(".sqlx/");
+
+        Ok(container
+            .with_directory(".sqlx", src)
+            .with_env_variable("SQLX_OFFLINE", "true"))
+    }
+}
+
+pub trait SqlxExt {
+    fn with_sqlx(&mut self) -> &mut Self {
+        self
+    }
+}
+
+impl SqlxExt for RustService {
+    fn with_sqlx(&mut self) -> &mut Self {
+        self.with_stage(super::RustServiceStage::BeforeBuild(Arc::new(Sqlx::new(
+            self.client.clone(),
+        ))));
+
+        self
+    }
+}

crates/dagger-cuddle-please/src/lib.rs

@@ -1,4 +1,4 @@
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc};
 
 use models::{CuddlePleaseArgs, CuddlePleaseSrcArgs};
 use traits::CuddlePlease;

crates/dagger-rust/src/build.rs

@@ -44,6 +44,9 @@ impl RustBuild {
             .from(rust_version.to_string())
             .with_exec(vec!["rustup", "target", "add", &target.to_string()])
             .with_exec(vec!["apt", "update"])
+            .with_exec(vec!["wget", "https://github.com/rui314/mold/releases/latest/download/mold-2.3.3-x86_64-linux.tar.gz"])
+            .with_exec("tar -xvf mold-2.3.3-x86_64-linux.tar.gz".split_whitespace().collect())
+            .with_exec("mv mold-2.3.3-x86_64-linux/bin/mold /usr/bin/mold".split_whitespace().collect())
             .with_exec(deps);
 
         let target_cache = self.client.cache_volume(format!(
@@ -94,7 +97,8 @@ impl RustBuild {
 
         let mut containers = Vec::new();
         for container_image in images {
-            let container = match &container_image {
+            let container =
+                match &container_image {
                     SlimImage::Debian { image, deps, .. } => {
                         let target = BuildTarget::from_target(&container_image);
 
@@ -110,6 +114,8 @@ impl RustBuild {
                             .await?;
 
                         let bin = build_container
+                            .with_env_variable("SQLX_OFFLINE", "true")
+                            .with_exec(vec!["cargo", "clean"])
                             .with_exec(vec![
                                 "cargo",
                                 "build",
@@ -119,11 +125,7 @@ impl RustBuild {
                                 "-p",
                                 bin_name,
                             ])
-                        .file(format!(
-                            "target/{}/release/{}",
-                            target.to_string(),
-                            bin_name
-                        ));
+                            .file(format!("target/{}/release/{}", target.to_string(), bin_name));
 
                         self.build_debian_image(
                             bin,
@@ -161,11 +163,7 @@ impl RustBuild {
                                 "-p",
                                 bin_name,
                             ])
-                        .file(format!(
-                            "target/{}/release/{}",
-                            target.to_string(),
-                            bin_name
-                        ));
+                            .file(format!("target/{}/release/{}", target.to_string(), bin_name));
 
                         self.build_alpine_image(
                             bin,

crates/dagger-rust/src/htmx.rs

@@ -110,7 +110,7 @@ impl HtmxBuild {
             let container =
                 match &container_image {
                     SlimImage::Debian { image, deps, .. } => {
-                        let target = BuildTarget::from_target(&container_image);
+                        let _target = BuildTarget::from_target(&container_image);
 
                         let build_container = self
                             .build(

crates/dagger-rust/src/leptos.rs

@@ -55,7 +55,7 @@ impl LeptosBuild {
             .client
             .cache_volume(format!("rust_leptos_{}", profile.to_string()));
 
-        let mut build_options = vec!["cargo", "leptos", "build", "--release", "-vv"];
+        let build_options = vec!["cargo", "leptos", "build", "--release", "-vv"];
 
         let rust_prebuild = rust_build_image
             .with_workdir("/mnt/src")
@@ -95,7 +95,7 @@ impl LeptosBuild {
         for container_image in images {
             let container = match &container_image {
                 SlimImage::Debian { image, deps, .. } => {
-                    let target = BuildTarget::from_target(&container_image);
+                    let _target = BuildTarget::from_target(&container_image);
 
                     let build_container = self
                         .build(

crates/dagger-rust/src/source.rs

@@ -1,6 +1,5 @@
 use std::{
     path::{Path, PathBuf},
-    sync::Arc,
 };
 
 use eyre::Context;

crates/dagger-rust/src/test.rs

@@ -1,4 +1,4 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{path::PathBuf};
 
 use crate::{build::RustVersion, source::RustSource};
 

examples/leptos-build/src/main.rs

@@ -1,4 +1,4 @@
-use dagger_rust::build::{BuildProfile, RustVersion, SlimImage};
+use dagger_rust::build::{RustVersion, SlimImage};
 
 #[tokio::main]
 pub async fn main() -> eyre::Result<()> {