churn/crates/churning/src/main.rs

use std::{path::PathBuf, sync::Arc};

use dagger_rust::build::{RustVersion, SlimImage};
use dagger_sdk::{Config, Query};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let mut config = Config::default();
    config.logger = None;

    println!("Building churning...");

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

    let cli = build_container(client.clone(), "churn").await?;
    let server = build_container(client.clone(), "churn-server").await?;
    let server = server
        .with_exec(vec!["churn-server", "serve", "--host", "0.0.0.0:3000"])
        .with_exposed_port(3000);

    let server_id = server.id().await?;

    let agent = build_container(client.clone(), "churn-agent").await?;
    let agent = agent
        .with_service_binding("churn-server", server_id.clone())
        .with_exec(vec!["churn-agent", "daemon", "--host", "0.0.0.0:3000"])
        .with_exposed_port(3000);

    let churning = cli
        .with_service_binding("churn-agent", agent.id().await?)
        .with_service_binding("churn-server", server_id)
        .with_env_variable("CHURN_SERVER", "http://churn-server:3000")
        .with_env_variable("CHURN_SERVER_TOKEN", "something")
        .with_env_variable("CHURN_AGENT", "http://churn-agent:3000")
        .with_env_variable("CHURN_AGENT_NAME", "churn-agent")
        .with_exec(vec![
            "churn",
            "health",
            "--server",
            "http://churn-server:3000",
            "--agent",
            "http://churn-agent:3000",
        ]);

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

    churning.exit_code().await?;
    println!("Finished building churning...");

    repl(churning).await?; //.with_entrypoint(vec!["churn"])).await?;

    Ok(())
}

async fn repl(container: dagger_sdk::Container) -> eyre::Result<()> {
    let mut container = container;

    loop {
        let stdin = tokio::io::stdin();
        let mut stdout = tokio::io::stdout();

        stdout.write_all(b"> ").await?;
        stdout.flush().await?;

        let mut input = String::new();

        let mut stdin = tokio::io::BufReader::new(stdin);

        stdin.read_line(&mut input).await?;

        let input = input.trim();
        if input == "q" {
            break;
        }

        container = container.with_exec(input.split(' ').collect());

        match container.stdout().await {
            Ok(stdout) => {
                println!("{stdout}");
            }
            Err(e) => {
                eprintln!("{}", e);
            }
        }
        // match container.stderr().await {
        //     Ok(stderr) => {
        //         println!("{stderr}");
        //     }
        //     Err(e) => {
        //         eprintln!("{}", e);
        //     }
        // }

        match container.exit_code().await {
            Ok(_) => {}
            Err(_e) => {
                //eprintln!("encountred error: {}", e);
            }
        }
    }

    Ok(())
}

async fn build_container(
    client: Arc<Query>,
    bin_name: &str,
) -> eyre::Result<dagger_sdk::Container> {
    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?;

    Ok(images.first().take().unwrap().clone())
}