cuddle-rust-service-plan/crates/cuddle-rust-service-plan/src/main.rs

use std::collections::HashMap;
use std::path::PathBuf;
use std::time::{SystemTime, UNIX_EPOCH};

use async_trait::async_trait;
use cuddle_ci::cuddle_file::CuddleFile;
use cuddle_ci::cuddle_please::CuddlePlease;
use cuddle_ci::cuddle_releaser::CuddleReleaser;
use cuddle_ci::rust_service::architecture::{Architecture, Os};
use cuddle_ci::rust_service::RustService;
use cuddle_ci::rust_service::{extensions::*, RustServiceContext};
use cuddle_ci::{Context, CuddleCI, MainAction, PullRequestAction};
use cuddle_clusters::catalog::cluster_vars::ClusterVars;
use cuddle_clusters::catalog::crdb_database::CockroachDB;
use cuddle_clusters::catalog::cuddle_vars::CuddleVars;
use cuddle_clusters::catalog::ingress::Ingress;
use cuddle_clusters::catalog::postgres_database::PostgresDatabase;
use cuddle_clusters::catalog::vault_secret::VaultSecret;
use cuddle_clusters::releaser::Releaser;
use cuddle_clusters::IntoComponent;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    tracing_subscriber::fmt::init();

    dagger_sdk::connect(|client| async move {
        let cuddle_file = CuddleFile::from_cuddle_file().await?;

        let service = &RustService::from(client.clone())
            .with_cuddle_file(&cuddle_file)
            .with_arch(Architecture::Amd64)
            .with_os(Os::Linux)
            .with_apt(&["libssl-dev", "libz-dev", "libpq-dev", "protobuf-compiler"])
            .with_apt_release(&["libssl-dev", "libz-dev", "libpq-dev"])
            .with_apt_ca_certificates()
            .with_workspace_crates()
            .await
            .with_mold("2.3.3")
            .to_owned();

        let deployment = &CuddleReleaser::new(client.clone()).await?;

        let mut ci = CuddleCI::default();
        ci.with_pull_request(service)
            .with_main(service)
            .with_main(deployment);

        if cuddle_file.please.is_some() {
            ci.with_main(&CuddlePlease::new(client.clone()));
        }

        ci.execute(std::env::args()).await?;

        Ok(())
    })
    .await?;

    Ok(())
}

#[derive(Default, Clone)]
struct RustServiceRender {
    service: String,
    registry: String,
}

impl RustServiceRender {
    async fn render_templates(&self, image_tag: &str) -> eyre::Result<()> {
        let mut releaser = Releaser::default();

        releaser
            .with_service(&self.service)
            .with_registry(&self.registry);

        match cuddle_clusters::process_opts(
            vec![
                CuddleVars::new(&std::env::current_dir()?)
                    .await
                    .map_err(|e| eyre::anyhow!("failed to get cuddle vars: {}", e.to_string()))?
                    .into_component(),
                ClusterVars::default().into_component(),
                VaultSecret::default().into_component(),
                CockroachDB::new(&std::env::current_dir()?)
                    .await
                    .map_err(|e| eyre::anyhow!("failed to get cuddle vars: {}", e.to_string()))?
                    .into_component(),
                PostgresDatabase::new(&std::env::current_dir()?)
                    .await
                    .map_err(|e| eyre::anyhow!("failed to get cuddle vars: {}", e.to_string()))?
                    .into_component(),
                Ingress::new(&std::env::current_dir()?)
                    .await
                    .map_err(|e| eyre::anyhow!("failed to get cuddle vars: {}", e.to_string()))?
                    .into_component(),
            ],
            cuddle_clusters::process::ProcessOpts {
                path: std::env::current_dir()?,
                output: PathBuf::from(".cuddle/tmp/cuddle-clusters"),
                variables: HashMap::from([("image_tag".into(), image_tag.into())]),
            },
            Some(releaser),
        )
        .await
        .map_err(|e| eyre::anyhow!("failed to process templates: {}", e.to_string()))
        {
            Ok(_) => {}
            Err(e) => {
                tracing::error!("failed to process templates: {}", e);
            }
        }

        Ok(())
    }
}

#[async_trait]
impl MainAction for RustServiceRender {
    async fn execute_main(&self, ctx: &mut Context) -> eyre::Result<()> {
        let image_tag = ctx
            .get_image_tag()?
            .ok_or(eyre::anyhow!("failed to find image_tag"))?;

        self.render_templates(&image_tag).await?;

        // cuddle_ci::cuddle_x::well_known::render(vec![
        //     "--cluster",
        //     "clank-prod",
        //     "--image_tag",
        //     &image_tag,
        // ])
        // .await?;

        Ok(())
    }
}

#[async_trait]
impl PullRequestAction for RustServiceRender {
    async fn execute_pull_request(&self, ctx: &mut Context) -> eyre::Result<()> {
        let image_tag = ctx
            .get_image_tag()?
            .ok_or(eyre::anyhow!("failed to find image_tag"))?;

        self.render_templates(&image_tag).await?;

        Ok(())
    }
}