cuddle-please/ci/src/main.rs

use std::path::Path;
use std::path::PathBuf;
use std::sync::Arc;

use clap::Args;
use clap::Parser;
use clap::Subcommand;
use clap::ValueEnum;

use dagger_rust::build::RustVersion;
use dagger_rust::build::SlimImage;

use crate::please_release::run_release_please;

#[derive(Parser, Clone)]
#[command(author, version, about, long_about = None, subcommand_required = true)]
pub struct Command {
    #[command(subcommand)]
    commands: Commands,

    #[command(flatten)]
    global: GlobalArgs,
}

#[derive(Subcommand, Clone)]
pub enum Commands {
    #[command(subcommand_required = true)]
    Local {
        #[command(subcommand)]
        command: LocalCommands,
    },
    PullRequest {
        #[arg(long)]
        bin_name: String,
    },
    Main {
        #[arg(long)]
        image: String,
        #[arg(long)]
        tag: String,
        #[arg(long)]
        bin_name: String,
    },
    Release {
        #[arg(long)]
        image: String,
        #[arg(long)]
        tag: String,
        #[arg(long)]
        bin_name: String,
    },
}

#[derive(Subcommand, Clone)]
pub enum LocalCommands {
    Build {
        #[arg(long, default_value = "debug")]
        profile: BuildProfile,
        #[arg(long)]
        bin_name: String,
    },
    Test,
    DockerImage {
        #[arg(long)]
        image: String,
        #[arg(long)]
        tag: String,
        #[arg(long)]
        bin_name: String,
    },
    PleaseRelease,
    BuildDocs {},
}

#[derive(Debug, Clone, ValueEnum)]
pub enum BuildProfile {
    Debug,
    Release,
}

#[derive(Debug, Clone, Args)]
pub struct GlobalArgs {
    #[arg(long, global = true, help_heading = "Global")]
    dry_run: bool,

    #[arg(long, global = true, help_heading = "Global")]
    rust_builder_image: Option<String>,

    #[arg(long, global = true, help_heading = "Global")]
    production_image: Option<String>,

    #[arg(long, global = true, help_heading = "Global")]
    mkdocs_image: Option<String>,

    #[arg(long, global = true, help_heading = "Global")]
    caddy_image: Option<String>,

    #[arg(long, global = true, help_heading = "Global")]
    source: Option<PathBuf>,

    #[arg(long, global = true, help_heading = "Global")]
    docs_image: Option<String>,

    #[arg(long, global = true, help_heading = "Global")]
    docs_image_tag: Option<String>,
}

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let _ = dotenv::dotenv();
    let _ = color_eyre::install();

    let client = dagger_sdk::connect().await?;

    let cli = Command::parse();

    let crates = &["crates/*", "ci"];
    let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];
    let debian_image = "debian:bullseye".to_string();

    match &cli.commands {
        Commands::Local { command } => match command {
            LocalCommands::Build {
                profile: _,
                bin_name,
            } => {
                dagger_rust::build::RustBuild::new(client.clone())
                    .build_release(
                        None::<PathBuf>,
                        RustVersion::Nightly,
                        crates,
                        debian_deps,
                        vec![SlimImage::Debian {
                            image: debian_image,
                            deps: debian_deps
                                .iter()
                                .map(|s| s.to_string())
                                .collect::<Vec<_>>(),
                            architecture: dagger_rust::build::BuildArchitecture::Amd64,
                        }],
                        &bin_name,
                    )
                    .await?;
            }
            LocalCommands::Test => {
                dagger_rust::test::RustTest::new(client.clone())
                    .test(None::<PathBuf>, RustVersion::Nightly, crates, debian_deps)
                    .await?;
            }
            LocalCommands::DockerImage {
                tag,
                image,
                bin_name,
            } => {
                let images = dagger_rust::build::RustBuild::new(client.clone())
                    .build_release(
                        None::<PathBuf>,
                        RustVersion::Nightly,
                        crates,
                        debian_deps,
                        vec![SlimImage::Debian {
                            image: debian_image,
                            deps: debian_deps
                                .iter()
                                .map(|s| s.to_string())
                                .collect::<Vec<_>>(),
                            architecture: dagger_rust::build::BuildArchitecture::Amd64,
                        }],
                        &bin_name,
                    )
                    .await?;

                dagger_rust::publish::RustPublish::new(client.clone())
                    .publish(image, tag, images)
                    .await?;
            }
            LocalCommands::PleaseRelease => todo!(),
            LocalCommands::BuildDocs {} => {
                let _image = docs::execute(
                    client.clone(),
                    &cli.global,
                    &Some("linux/amd64".to_string()),
                )
                .await?;
            }
        },
        Commands::PullRequest { bin_name } => {
            async fn test(client: Arc<dagger_sdk::Query>) {
                let crates = &["crates/*", "ci"];
                let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];

                dagger_rust::test::RustTest::new(client.clone())
                    .test(None::<PathBuf>, RustVersion::Nightly, crates, debian_deps)
                    .await
                    .expect("rust to test crates");
            }
            async fn build(client: Arc<dagger_sdk::Query>, bin_name: &String) {
                let crates = &["crates/*", "ci"];
                let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];
                let debian_image = "debian:bullseye".to_string();

                dagger_rust::build::RustBuild::new(client.clone())
                    .build_release(
                        None::<PathBuf>,
                        RustVersion::Nightly,
                        crates,
                        debian_deps,
                        vec![SlimImage::Debian {
                            image: debian_image,
                            deps: debian_deps
                                .iter()
                                .map(|s| s.to_string())
                                .collect::<Vec<_>>(),
                            architecture: dagger_rust::build::BuildArchitecture::Amd64,
                        }],
                        &bin_name,
                    )
                    .await
                    .expect("dagger rust to build crates");
            }

            tokio::join!(test(client.clone()), build(client.clone(), bin_name),);
        }
        Commands::Main {
            image,
            tag,
            bin_name,
        } => {
            async fn test(client: Arc<dagger_sdk::Query>) {
                let crates = &["crates/*", "ci"];
                let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];

                dagger_rust::test::RustTest::new(client.clone())
                    .test(None::<PathBuf>, RustVersion::Nightly, crates, debian_deps)
                    .await
                    .expect("rust to test crates");
            }
            async fn build(
                client: Arc<dagger_sdk::Query>,
                bin_name: &String,
                image: &String,
                tag: &String,
            ) {
                let crates = &["crates/*", "ci"];
                let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];
                let debian_image = "debian:bullseye".to_string();

                let images = dagger_rust::build::RustBuild::new(client.clone())
                    .build_release(
                        None::<PathBuf>,
                        RustVersion::Nightly,
                        crates,
                        debian_deps,
                        vec![SlimImage::Debian {
                            image: debian_image,
                            deps: debian_deps
                                .iter()
                                .map(|s| s.to_string())
                                .collect::<Vec<_>>(),
                            architecture: dagger_rust::build::BuildArchitecture::Amd64,
                        }],
                        &bin_name,
                    )
                    .await
                    .expect("rust build to build release crates");

                dagger_rust::publish::RustPublish::new(client.clone())
                    .publish(image, tag, images)
                    .await
                    .expect("rust publish to publish crates");
            }

            async fn cuddle_please(client: Arc<dagger_sdk::Query>, cli: &Command) {
                run_release_please(client.clone(), &cli.global)
                    .await
                    .unwrap();
            }

            tokio::join!(
                test(client.clone()),
                build(client.clone(), bin_name, image, tag),
                cuddle_please(client.clone(), &cli)
            );
        }
        Commands::Release {
            image,
            tag,
            bin_name,
        } => {
            async fn build(
                client: Arc<dagger_sdk::Query>,
                bin_name: &String,
                image: &String,
                tag: &String,
            ) {
                let crates = &["crates/*", "ci"];
                let debian_deps = &["libssl-dev", "pkg-config", "openssl", "git", "jq"];
                let debian_image = "debian:bullseye".to_string();

                let images = dagger_rust::build::RustBuild::new(client.clone())
                    .build_release(
                        None::<PathBuf>,
                        RustVersion::Nightly,
                        crates,
                        debian_deps,
                        vec![SlimImage::Debian {
                            image: debian_image,
                            deps: debian_deps
                                .iter()
                                .map(|s| s.to_string())
                                .collect::<Vec<_>>(),
                            architecture: dagger_rust::build::BuildArchitecture::Amd64,
                        }],
                        &bin_name,
                    )
                    .await
                    .expect("rust build to build release crates");

                dagger_rust::publish::RustPublish::new(client.clone())
                    .publish(image, tag, images)
                    .await
                    .expect("rust publish to publish crates");
            }

            build(client.clone(), bin_name, image, tag).await;
        }
    }

    Ok(())
}

mod please_release {

    use std::sync::Arc;

    use crate::{base_rust_image, GlobalArgs};

    pub async fn run_release_please(
        client: Arc<dagger_sdk::Query>,
        args: &GlobalArgs,
    ) -> eyre::Result<()> {
        let base_image = base_rust_image(
            client.clone(),
            args,
            &Some("linux/amd64".to_string()),
            &"cuddle-please".to_string(),
            &"release".into(),
        )
        .await?;

        let build_image = base_image.with_exec(vec![
            "cargo",
            "install",
            "--target",
            "x86_64-unknown-linux-gnu",
            "--path=crates/cuddle-please",
        ]);

        let src = client
            .git_opts(
                "https://git.front.kjuulh.io/kjuulh/cuddle-please",
                dagger_sdk::QueryGitOpts {
                    experimental_service_host: None,
                    keep_git_dir: Some(true),
                },
            )
            .branch("main")
            .tree();

        let res = build_image
            .with_secret_variable(
                "CUDDLE_PLEASE_TOKEN",
                client
                    .set_secret("CUDDLE_PLEASE_TOKEN", std::env::var("CUDDLE_PLEASE_TOKEN")?)
                    .id()
                    .await?,
            )
            .with_workdir("/mnt/app")
            .with_directory(".", src.id().await?)
            .with_exec(vec![
                "git",
                "remote",
                "set-url",
                "origin",
                &format!(
                    "https://git:{}@git.front.kjuulh.io/kjuulh/cuddle-please.git",
                    std::env::var("CUDDLE_PLEASE_TOKEN")?
                ),
            ])
            .with_exec(vec![
                "cuddle-please",
                "release",
                "--engine=gitea",
                "--owner=kjuulh",
                "--repo=cuddle-please",
                "--branch=main",
                "--api-url=https://git.front.kjuulh.io",
                "--log-level=debug",
            ]);

        let exit_code = res.exit_code().await?;
        if exit_code != 0 {
            eyre::bail!("failed to run cuddle-please");
        }

        let please_out = res.stdout().await?;
        println!("{please_out}");
        let please_out = res.stderr().await?;
        println!("{please_out}");

        Ok(())
    }
}

mod docs {
    use std::sync::Arc;

    use dagger_sdk::Container;

    use crate::GlobalArgs;

    pub fn get_docs_src(client: Arc<dagger_sdk::Query>) -> eyre::Result<dagger_sdk::Directory> {
        let docs_content = client.host().directory_opts(
            ".",
            dagger_sdk::HostDirectoryOpts {
                exclude: None,
                include: Some(vec!["mkdocs.yml", "docs/"]),
            },
        );

        Ok(docs_content)
    }

    pub async fn execute(
        client: Arc<dagger_sdk::Query>,
        args: &GlobalArgs,
        _platform: &Option<String>,
    ) -> eyre::Result<Container> {
        let mkdocs_container = client.container().from(
            args.mkdocs_image
                .as_ref()
                .expect("--mkdocs-image to be set"),
        );

        let built_mkdocs_container = mkdocs_container
            .with_directory("/docs", get_docs_src(client.clone())?.id().await?)
            .with_exec(vec!["build"]);

        let site_output = built_mkdocs_container.directory("/docs/site").id().await?;

        let caddy_file = client.host().directory("templates").file("Caddyfile");

        let dep_image = client
            .container()
            .from(args.caddy_image.as_ref().expect("--caddy-image to be set"))
            .with_directory("/usr/share/caddy", site_output)
            .with_file("/etc/caddy/Caddyfile", caddy_file.id().await?)
            .with_exec(vec!["echo", "caddy"]);

        Ok(dep_image)
    }
}

pub fn get_src(
    client: Arc<dagger_sdk::Query>,
    args: &GlobalArgs,
) -> eyre::Result<dagger_sdk::Directory> {
    let directory = client.host().directory_opts(
        args.source
            .clone()
            .unwrap_or(PathBuf::from("."))
            .display()
            .to_string(),
        dagger_sdk::HostDirectoryOptsBuilder::default()
            .exclude(vec!["node_modules/", ".git/", "target/"])
            .build()?,
    );

    Ok(directory)
}

pub async fn get_rust_dep_src(
    client: Arc<dagger_sdk::Query>,
    args: &GlobalArgs,
) -> eyre::Result<dagger_sdk::Directory> {
    let directory = client.host().directory_opts(
        args.source
            .clone()
            .unwrap_or(PathBuf::from("."))
            .display()
            .to_string(),
        dagger_sdk::HostDirectoryOptsBuilder::default()
            .include(vec!["**/Cargo.toml", "**/Cargo.lock"])
            .build()?,
    );

    Ok(directory)
}

pub async fn get_rust_skeleton_files(
    client: Arc<dagger_sdk::Query>,
    _args: &GlobalArgs,
) -> eyre::Result<(dagger_sdk::Directory, Vec<String>)> {
    let mut rust_crates = vec![PathBuf::from("ci")];
    let mut dirs = tokio::fs::read_dir("crates").await?;

    while let Some(entry) = dirs.next_entry().await? {
        if entry.metadata().await?.is_dir() {
            rust_crates.push(entry.path())
        }
    }

    fn create_skeleton_files(
        directory: dagger_sdk::Directory,
        path: &Path,
    ) -> eyre::Result<dagger_sdk::Directory> {
        println!("found crates: {}", path.display());
        let main_content = r#"
        #[allow(dead_code)]
        fn main() { panic!("should never be executed"); }"#;
        let lib_content = r#"
        #[allow(dead_code)]
        fn some() { panic!("should never be executed"); }"#;

        let directory = directory.with_new_file(
            path.join("src").join("main.rs").display().to_string(),
            main_content,
        );
        let directory = directory.with_new_file(
            path.join("src").join("lib.rs").display().to_string(),
            lib_content,
        );

        Ok(directory)
    }

    let mut directory = client.directory();
    let mut crate_names = Vec::new();

    for rust_crate in rust_crates.iter() {
        if let Some(file_name) = rust_crate.file_name() {
            crate_names.push(file_name.to_str().unwrap().to_string());
        }
        directory = create_skeleton_files(directory, rust_crate)?;
    }

    Ok((directory, crate_names))
}

pub async fn base_rust_image(
    client: Arc<dagger_sdk::Query>,
    args: &GlobalArgs,
    platform: &Option<String>,
    bin_name: &String,
    profile: &String,
) -> eyre::Result<dagger_sdk::Container> {
    let dep_src = get_rust_dep_src(client.clone(), args).await?;
    let (skeleton_files, crates) = get_rust_skeleton_files(client.clone(), args).await?;
    let src = get_src(client.clone(), args)?;

    let client = client.pipeline("rust_base_image");

    let rust_target = match platform
        .clone()
        .unwrap_or("linux/amd64".to_string())
        .as_str()
    {
        "linux/amd64" => "x86_64-unknown-linux-gnu",
        "linux/arm64" => "aarch64-unknown-linux-gnu",
        _ => eyre::bail!("architecture not supported"),
    };
    let rust_build_image = client
        .container()
        .from(
            args.rust_builder_image
                .as_ref()
                .unwrap_or(&"rustlang/rust:nightly".into()),
        )
        .with_exec(vec!["rustup", "target", "add", rust_target])
        .with_exec(vec!["apt", "update"])
        .with_exec(vec!["apt", "install", "-y", "jq"]);

    let target_cache = client.cache_volume(format!("rust_target_{}", profile));
    let mut build_options = vec!["cargo", "build", "--target", rust_target, "-p", bin_name];

    if profile == "release" {
        build_options.push("--release");
    }
    let rust_prebuild = rust_build_image
        .with_workdir("/mnt/src")
        .with_directory("/mnt/src", dep_src.id().await?)
        .with_directory("/mnt/src/", skeleton_files.id().await?)
        .with_exec(build_options)
        .with_mounted_cache("/mnt/src/target/", target_cache.id().await?);

    let exclude = crates
        .iter()
        .filter(|c| **c != "ci")
        .map(|c| format!("**/*{}*", c.replace('-', "_")))
        .collect::<Vec<_>>();

    let exclude = exclude.iter().map(|c| c.as_str()).collect();

    let incremental_dir = client.directory().with_directory_opts(
        ".",
        rust_prebuild.directory("target").id().await?,
        dagger_sdk::DirectoryWithDirectoryOpts {
            exclude: Some(exclude),
            include: None,
        },
    );

    let rust_with_src = rust_build_image
        .with_workdir("/mnt/src")
        .with_directory(
            "/usr/local/cargo",
            rust_prebuild.directory("/usr/local/cargo").id().await?,
        )
        .with_directory("target", incremental_dir.id().await?)
        .with_directory("/mnt/src/", src.id().await?);

    Ok(rust_with_src)
}