feat: with working main

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

ci/Cargo.toml

@@ -13,3 +13,4 @@ tokio = "1"
 clap = {version = "4", features = ["derive"]}
 futures = "0.3.28"
 async-scoped = { version = "0.7.1", features = ["tokio", "use-tokio"] }
+dotenv.workspace = true

ci/src/main.rs

@@ -2,19 +2,21 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-
+use build::build_and_deploy;
 use clap::Args;
 use clap::Parser;
 use clap::Subcommand;
 use clap::ValueEnum;
 
-
-
+use dagger_sdk::ContainerId;
+use dagger_sdk::ContainerPublishOpts;
 use dagger_sdk::Platform;
 use dagger_sdk::QueryContainerOpts;
 use futures::StreamExt;
+use tokio::sync::Mutex;
+use tokio::task::JoinHandle;
 
-
+use crate::please_release::run_release_please;
 
 #[derive(Parser, Clone)]
 #[command(author, version, about, long_about = None, subcommand_required = true)]
@@ -101,6 +103,7 @@ pub struct GlobalArgs {
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
+    let _ = dotenv::dotenv();
     let _ = color_eyre::install();
 
     let client = dagger_sdk::connect().await?;
@@ -113,23 +116,34 @@ async fn main() -> eyre::Result<()> {
                 profile: _,
                 bin_name,
             } => {
-                let base_image =
-                    base_rust_image(client.clone(), &cli.global, &None, &bin_name.clone()).await?;
+                let base_image = base_rust_image(
+                    client.clone(),
+                    &cli.global,
+                    &None,
+                    &bin_name.clone(),
+                    &"release".into(),
+                )
+                .await?;
                 let prod_image = get_base_debian_image(client.clone(), &cli.global, None).await?;
                 build::execute(
                     client,
                     &cli.global,
                     &base_image,
                     &prod_image,
-                    bin_name,
+                    &bin_name,
                     &None,
                 )
                 .await?;
             }
             LocalCommands::Test => {
-                let base_image =
-                    base_rust_image(client.clone(), &cli.global, &None, &"cuddle-please".into())
-                        .await?;
+                let base_image = base_rust_image(
+                    client.clone(),
+                    &cli.global,
+                    &None,
+                    &"cuddle-please".into(),
+                    &"debug".into(),
+                )
+                .await?;
                 test::execute(client, &cli.global, base_image).await?;
             }
             LocalCommands::DockerImage {
@@ -137,11 +151,11 @@ async fn main() -> eyre::Result<()> {
                 image,
                 bin_name,
             } => {
-                build::build_and_deploy(client, &cli.global, bin_name, image, tag).await?;
+                build::build_and_deploy(client, &cli.global, &bin_name, &image, &tag).await?;
             }
             LocalCommands::PleaseRelease => todo!(),
             LocalCommands::BuildDocs {} => {
-                let _image = docs::execute(
+                let image = docs::execute(
                     client.clone(),
                     &cli.global,
                     &Some("linux/amd64".to_string()),
@@ -158,10 +172,11 @@ async fn main() -> eyre::Result<()> {
             async fn test(client: Arc<dagger_sdk::Query>, cli: &Command, bin_name: &String) {
                 let args = &cli.global;
 
-                let base_image = base_rust_image(client.clone(), args, &None, bin_name)
-                    .await
-                    .unwrap();
-                test::execute(client.clone(), args, base_image)
+                let base_image =
+                    base_rust_image(client.clone(), &args, &None, bin_name, &"debug".into())
+                        .await
+                        .unwrap();
+                test::execute(client.clone(), &args, base_image)
                     .await
                     .unwrap();
             }
@@ -174,14 +189,21 @@ async fn main() -> eyre::Result<()> {
             ) {
                 let args = &cli.global;
 
-                build::build_and_deploy(client.clone(), args, bin_name, image, tag)
+                build::build_and_deploy(client.clone(), &args, bin_name, image, tag)
+                    .await
+                    .unwrap();
+            }
+
+            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(), &cli, bin_name),
-                build(client.clone(), &cli, bin_name, image, tag)
+                test(client.clone(), &cli, &bin_name),
+                build(client.clone(), &cli, &bin_name, &image, &tag),
+                cuddle_please(client.clone(), &cli)
             );
         }
         Commands::Release => todo!(),
@@ -190,6 +212,97 @@ async fn main() -> eyre::Result<()> {
     Ok(())
 }
 
+mod please_release {
+
+    use std::sync::Arc;
+
+    use dagger_sdk::Container;
+
+    use crate::{base_rust_image, build, get_base_debian_image, get_rust_dep_src, 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![
+                "git",
+                "config",
+                "http.extraheader",
+                "'Authorization: token b52c18cab8a95d33f34b0d081440f77a2b156886'",
+            ])
+            .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;
 
@@ -212,7 +325,7 @@ mod docs {
     pub async fn execute(
         client: Arc<dagger_sdk::Query>,
         args: &GlobalArgs,
-        _platform: &Option<String>,
+        platform: &Option<String>,
     ) -> eyre::Result<Container> {
         let mkdocs_container = client.container().from(
             args.mkdocs_image
@@ -275,9 +388,9 @@ mod build {
 
     use dagger_sdk::Container;
 
-    
-    
-    
+    use futures::StreamExt;
+    use tokio::sync::Mutex;
+    use tokio::task::JoinHandle;
 
     use crate::{base_rust_image, get_base_debian_image, GlobalArgs};
 
@@ -299,17 +412,18 @@ mod build {
 
         let container = base_rust_image(
             client.clone(),
-            args,
+            &args,
             &Some("linux/amd64".to_string()),
             &bin_name.clone(),
+            &"release".into(),
         )
         .await?;
         let build_image = execute(
             client.clone(),
-            args,
+            &args,
             &container,
             &base_image,
-            bin_name,
+            &bin_name,
             &Some("linux/amd64".to_string()),
         )
         .await?;
@@ -352,7 +466,7 @@ mod build {
             rust_target,
             "--release",
             "-p",
-            bin_name,
+            &bin_name,
         ]);
 
         let final_image = base_image
@@ -363,7 +477,7 @@ mod build {
                     .id()
                     .await?,
             )
-            .with_exec(vec![bin_name, "--help"]);
+            .with_exec(vec![&bin_name, "--help"]);
 
         let output = final_image.stdout().await?;
         println!("{output}");
@@ -458,12 +572,12 @@ pub async fn get_rust_dep_src(
             .build()?,
     );
 
-    Ok(directory)
+    return Ok(directory);
 }
 
 pub async fn get_rust_skeleton_files(
     client: Arc<dagger_sdk::Query>,
-    _args: &GlobalArgs,
+    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?;
@@ -505,7 +619,7 @@ pub async fn get_rust_skeleton_files(
         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)?;
+        directory = create_skeleton_files(directory, &rust_crate)?;
     }
 
     Ok((directory, crate_names))
@@ -516,6 +630,7 @@ pub async fn base_rust_image(
     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?;
@@ -541,27 +656,23 @@ pub async fn base_rust_image(
         )
         .with_exec(vec!["rustup", "target", "add", rust_target]);
 
-    let target_cache = client.cache_volume("rust_target");
+    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(vec![
-            "cargo",
-            "build",
-            "--target",
-            rust_target,
-            "--release",
-            "-p",
-            bin_name,
-        ])
+        .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('-', "_")))
+        .map(|c| format!("**/*{}*", c.replace("-", "_")))
         .collect::<Vec<_>>();
 
     let exclude = exclude.iter().map(|c| c.as_str()).collect();
@@ -581,12 +692,7 @@ pub async fn base_rust_image(
             "/usr/local/cargo",
             rust_prebuild.directory("/usr/local/cargo").id().await?,
         )
-        .with_directory(
-            //format!("/mnt/src/target/{}/release/build", rust_target),
-            "target",
-            //rust_prebuild.id().await?,
-            incremental_dir.id().await?,
-        )
+        .with_directory("target", incremental_dir.id().await?)
         .with_directory("/mnt/src/", src.id().await?);
 
     Ok(rust_with_src)