nix_builder/src/command/build/runner.rs

use crate::Result;
use crate::cli::parameters::BuildArgs;
use crate::config::Config;
use crate::config::TargetConfig;
use crate::database::db_handle::DbHandle;
use crate::fs_util::assert_directory;
use crate::fs_util::is_git_repo;
use crate::git_util::git_force_into_state;
use crate::git_util::git_init_at_rev;
use crate::nix_util::nixos_build_target;

pub(crate) async fn run_build(args: BuildArgs) -> Result<()> {
    println!("{:?}", args);
    let config = Config::load_from_file(args.config).await?;
    println!("{:?}", config);

    let database_path = config.get_database_path()?;
    let database_parent = database_path
        .parent()
        .expect("Database should exist in a folder.");
    let database_path = database_path.to_string_lossy();
    assert_directory!(
        database_parent,
        "Creating database directory {}",
        database_parent.to_string_lossy()
    );

    let db_handle = DbHandle::new(Some(database_path)).await?;

    for target_name in args.target {
        let target_config = {
            let target_config = config.get_target_config(&target_name)?;
            if let Some(conf) = target_config {
                conf
            } else {
                return Err(format!("Could not find target {}", target_name).into());
            }
        };

        prepare_flake_repo(&config, target_config).await?;
        build_target(&db_handle, &config, target_config).await?;
    }

    db_handle.conn.close().await;

    Ok(())
}

async fn prepare_flake_repo(config_root: &Config, target_config: &TargetConfig) -> Result<()> {
    let repo_directory = target_config.get_repo_directory(config_root)?;
    assert_directory!(
        &repo_directory,
        "Creating repo directory {}",
        repo_directory.to_string_lossy()
    );

    if is_git_repo(&repo_directory).await? {
        // Clean up the existing clone
        git_force_into_state(
            &repo_directory,
            target_config.get_branch()?,
            "origin",
            target_config.get_repo()?,
            target_config.get_revision()?,
        )
        .await?;
    } else {
        git_init_at_rev(
            &repo_directory,
            target_config.get_branch()?,
            target_config.get_repo()?,
            target_config.get_revision()?,
        )
        .await?;
    }
    Ok(())
}

async fn build_target(
    db_handle: &DbHandle,
    config_root: &Config,
    target_config: &TargetConfig,
) -> Result<()> {
    let flake_directory = target_config.get_flake_directory(config_root)?;
    let build_directory = target_config.get_build_directory(config_root)?;
    assert_directory!(
        &build_directory,
        "Creating build directory {}",
        build_directory.to_string_lossy()
    );

    nixos_build_target(
        db_handle,
        build_directory,
        flake_directory,
        target_config.get_attr()?,
    )
    .await?;

    Ok(())
}