338 lines
9.7 KiB
Rust
338 lines
9.7 KiB
Rust
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 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 {},
|
|
Main {},
|
|
Release,
|
|
}
|
|
|
|
#[derive(Subcommand, Clone)]
|
|
pub enum LocalCommands {
|
|
Test,
|
|
PleaseRelease,
|
|
}
|
|
|
|
#[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")]
|
|
source: Option<PathBuf>,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> eyre::Result<()> {
|
|
let _ = dotenv::dotenv();
|
|
let _ = color_eyre::install();
|
|
|
|
let client = dagger_sdk::connect().await?;
|
|
|
|
let cli = Command::parse();
|
|
|
|
match &cli.commands {
|
|
Commands::Local { command } => match command {
|
|
LocalCommands::Test => {
|
|
let base_image =
|
|
base_rust_image(client.clone(), &cli.global, &None, &"debug".into()).await?;
|
|
test::execute(client, &cli.global, base_image).await?;
|
|
}
|
|
LocalCommands::PleaseRelease => todo!(),
|
|
},
|
|
Commands::PullRequest {} => {
|
|
async fn test(client: Arc<dagger_sdk::Query>, cli: &Command) {
|
|
let args = &cli.global;
|
|
|
|
let base_image = base_rust_image(client.clone(), args, &None, &"debug".into())
|
|
.await
|
|
.unwrap();
|
|
test::execute(client.clone(), args, base_image)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
tokio::join!(test(client.clone(), &cli),);
|
|
}
|
|
Commands::Main {} => {
|
|
async fn test(client: Arc<dagger_sdk::Query>, cli: &Command) {
|
|
let args = &cli.global;
|
|
|
|
let base_image = base_rust_image(client.clone(), args, &None, &"debug".into())
|
|
.await
|
|
.unwrap();
|
|
test::execute(client.clone(), args, base_image)
|
|
.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),
|
|
cuddle_please(client.clone(), &cli)
|
|
);
|
|
}
|
|
Commands::Release => todo!(),
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
mod please_release {
|
|
use std::sync::Arc;
|
|
|
|
use dagger_cuddle_please::{models::CuddlePleaseSrcArgs, DaggerCuddlePleaseAction};
|
|
|
|
use crate::GlobalArgs;
|
|
|
|
pub async fn run_release_please(
|
|
client: Arc<dagger_sdk::Query>,
|
|
args: &GlobalArgs,
|
|
) -> eyre::Result<()> {
|
|
DaggerCuddlePleaseAction::dagger(client)
|
|
.execute_src(&CuddlePleaseSrcArgs {
|
|
cuddle_image: "kasperhermansen/cuddle-please:main-1691504183".into(),
|
|
server: dagger_cuddle_please::models::SrcServer::Gitea {
|
|
token: std::env::var("CUDDLE_PLEASE_TOKEN")
|
|
.expect("CUDDLE_PLEASE_TOKEN to be present"),
|
|
},
|
|
log_level: Some(dagger_cuddle_please::models::LogLevel::Debug),
|
|
})
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
mod test {
|
|
use std::sync::Arc;
|
|
|
|
use crate::GlobalArgs;
|
|
|
|
pub async fn execute(
|
|
_client: Arc<dagger_sdk::Query>,
|
|
_args: &GlobalArgs,
|
|
container: dagger_sdk::Container,
|
|
) -> eyre::Result<()> {
|
|
let test_image = container
|
|
.pipeline("rust:test")
|
|
.with_exec(vec!["apt", "update"])
|
|
.with_exec(vec!["apt", "install", "-y", "git"])
|
|
.with_exec(vec!["cargo", "test"]);
|
|
|
|
let please_out = test_image.stdout().await?;
|
|
println!("{please_out}");
|
|
let please_out = test_image.stderr().await?;
|
|
println!("{please_out}");
|
|
|
|
test_image.exit_code().await?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
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())
|
|
}
|
|
}
|
|
|
|
let mut dirs = tokio::fs::read_dir("examples").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>,
|
|
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, "--workspace"];
|
|
|
|
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)
|
|
}
|