Move command implementations into dedicated module

Signed-off-by: Matthias Beyer <mail@beyermatthias.de>

1 files changed, 5 insertions, 287 deletions

diff --git a/src/main.rs b/src/main.rs
index 7bbbb4b..5c6d974 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,27 +1,16 @@
 #[macro_use] extern crate log as logcrate;
 #[macro_use] extern crate diesel;
 
-use std::collections::BTreeMap;
 use std::path::Path;
 use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::RwLock;
 
-use anyhow::Context;
-use anyhow::Error;
 use anyhow::Result;
 use anyhow::anyhow;
-use clap_v3::ArgMatches;
-use diesel::PgConnection;
-use diesel::prelude::*;
-use indicatif::*;
 use logcrate::debug;
-use resiter::Filter;
-use resiter::Map;
-use tokio::stream::StreamExt;
 use walkdir::WalkDir;
 
 mod cli;
+mod commands;
 mod config;
 mod db;
 mod endpoint;
@@ -37,15 +26,7 @@ mod ui;
 mod util;
 
 use crate::config::*;
-use crate::filestore::ReleaseStore;
-use crate::filestore::StagingStore;
-use crate::job::JobSet;
-use crate::orchestrator::OrchestratorSetup;
-use crate::package::PackageName;
-use crate::package::PackageVersion;
-use crate::package::Tree;
 use crate::repository::Repository;
-use crate::util::docker::ImageName;
 use crate::util::progress::ProgressBars;
 
 #[tokio::main]
@@ -86,25 +67,25 @@ async fn main() -> Result<()> {
 
             let repo = load_repo()?;
 
-            build(matches, progressbars, conn, &config, repo, &repo_path, max_packages as u64).await?
+            crate::commands::build(matches, progressbars, conn, &config, repo, &repo_path, max_packages as u64).await?
         },
         ("what-depends", Some(matches)) => {
             let repo = load_repo()?;
             let bar = progressbars.what_depends();
             bar.set_length(max_packages);
-            what_depends(matches, &config, repo, bar).await?
+            crate::commands::what_depends(matches, &config, repo, bar).await?
         },
 
         ("dependencies-of", Some(matches)) => {
             let repo = load_repo()?;
             let bar = progressbars.what_depends();
             bar.set_length(max_packages);
-            dependencies_of(matches, &config, repo, bar).await?
+            crate::commands::dependencies_of(matches, &config, repo, bar).await?
         },
 
         ("versions-of", Some(matches)) => {
             let repo = load_repo()?;
-            versions_of(matches, repo).await?
+            crate::commands::versions_of(matches, repo).await?
         }
 
         (other, _) => return Err(anyhow!("Unknown subcommand: {}", other)),
@@ -113,264 +94,6 @@ async fn main() -> Result<()> {
     Ok(())
 }
 
-async fn build<'a>(matches: &ArgMatches,
-               progressbars: ProgressBars,
-               database_connection: PgConnection,
-               config: &Configuration<'a>,
-               repo: Repository,
-               repo_path: &Path,
-               max_packages: u64)
-    -> Result<()>
-{
-    use crate::db::models::{
-        Package,
-        GitHash,
-        Image,
-        Submit,
-    };
-
-    let now = chrono::offset::Local::now().naive_local();
-    let submit_id = uuid::Uuid::new_v4();
-    info!("Submit {}, started {}", submit_id, now);
-
-    let image_name = matches.value_of("image").map(String::from).map(ImageName::from).unwrap(); // safe by clap
-    if config.docker().verify_images_present() {
-        if !config.docker().images().iter().any(|img| image_name == *img) {
-            return Err(anyhow!("Requested build image {} is not in the configured images"))
-                .with_context(|| anyhow!("Available images: {:?}", config.docker().images()))
-                .with_context(|| anyhow!("Image present verification failed"))
-                .map_err(Error::from)
-        }
-    }
-
-    debug!("Getting repository HEAD");
-    let hash_str   = crate::util::git::get_repo_head_commit_hash(repo_path)?;
-    trace!("Repository HEAD = {}", hash_str);
-    let phases = config.available_phases();
-
-    let endpoint_configurations = config.docker().endpoints()
-        .iter()
-        .cloned()
-        .map(|ep_cfg| {
-            crate::endpoint::EndpointConfiguration::builder()
-                .endpoint(ep_cfg)
-                .required_images(config.docker().images().clone())
-                .required_docker_versions(config.docker().docker_versions().clone())
-                .required_docker_api_versions(config.docker().docker_api_versions().clone())
-                .build()
-        })
-        .collect();
-    info!("Endpoint config build");
-
-    let pname = matches.value_of("package_name")
-        .map(String::from)
-        .map(PackageName::from)
-        .unwrap(); // safe by clap
-
-    let pvers = matches.value_of("package_version")
-        .map(String::from)
-        .map(PackageVersion::from);
-    info!("We want {} ({:?})", pname, pvers);
-
-    let packages = if let Some(pvers) = pvers {
-        repo.find(&pname, &pvers)
-    } else {
-        repo.find_by_name(&pname)
-    };
-    debug!("Found {} relevant packages", packages.len());
-
-    /// We only support building one package per call.
-    /// Everything else is invalid
-    if packages.len() > 1 {
-        return Err(anyhow!("Found multiple packages ({}). Cannot decide which one to build", packages.len()))
-    }
-    let package = *packages.get(0).ok_or_else(|| anyhow!("Found no package."))?;
-
-    let release_dir  = {
-        let bar_release_loading = progressbars.release_loading();
-        bar_release_loading.set_length(max_packages);
-
-        let variables = BTreeMap::new();
-        let p = config.releases_directory(&variables)?;
-        debug!("Loading release directory: {}", p.display());
-        let r = ReleaseStore::load(&p, bar_release_loading.clone());
-        if r.is_ok() {
-            bar_release_loading.finish_with_message("Loaded releases successfully");
-        } else {
-            bar_release_loading.finish_with_message("Failed to load releases");
-        }
-        r.map(RwLock::new).map(Arc::new)?
-    };
-
-    let staging_dir = {
-        let bar_staging_loading = progressbars.staging_loading();
-        bar_staging_loading.set_length(max_packages);
-
-        let variables = BTreeMap::new();
-        let p = config.staging_directory(&variables)?;
-        debug!("Loading staging directory: {}", p.display());
-        let r = StagingStore::load(&p, bar_staging_loading.clone());
-        if r.is_ok() {
-            bar_staging_loading.finish_with_message("Loaded staging successfully");
-        } else {
-            bar_staging_loading.finish_with_message("Failed to load staging");
-        }
-        r.map(RwLock::new).map(Arc::new)?
-    };
-
-    let tree = {
-        let bar_tree_building = progressbars.tree_building();
-        bar_tree_building.set_length(max_packages);
-
-        let mut tree = Tree::new();
-        tree.add_package(package.clone(), &repo, bar_tree_building.clone())?;
-
-        bar_tree_building.finish_with_message("Finished loading Tree");
-        tree
-    };
-
-    trace!("Setting up database jobs for Package, GitHash, Image");
-    let db_package = async { Package::create_or_fetch(&database_connection, &package) };
-    let db_githash = async { GitHash::create_or_fetch(&database_connection, &hash_str) };
-    let db_image   = async { Image::create_or_fetch(&database_connection, &image_name) };
-
-    trace!("Running database jobs for Package, GitHash, Image");
-    let (db_package, db_githash, db_image) = tokio::join!(
-        db_package,
-        db_githash,
-        db_image
-    );
-
-    let (db_package, db_githash, db_image) = (db_package?, db_githash?, db_image?);
-
-    trace!("Database jobs for Package, GitHash, Image finished successfully");
-    trace!("Creating Submit in database");
-    let submit = Submit::create(&database_connection,
-        &tree,
-        &now,
-        &submit_id,
-        &db_image,
-        &db_package,
-        &db_githash)?;
-    trace!("Creating Submit in database finished successfully");
-
-    trace!("Setting up job sets");
-    let jobsets = JobSet::sets_from_tree(tree, image_name, phases.clone())?;
-    trace!("Setting up job sets finished successfully");
-
-    trace!("Setting up Orchestrator");
-    let orch = OrchestratorSetup::builder()
-        .progress_generator(progressbars)
-        .endpoint_config(endpoint_configurations)
-        .staging_store(staging_dir)
-        .release_store(release_dir)
-        .database(database_connection)
-        .submit(submit)
-        .file_log_sink_factory(None)
-        .jobsets(jobsets)
-        .build()
-        .setup()
-        .await?;
-
-    info!("Running orchestrator...");
-    orch.run().await
-}
-
-async fn what_depends<'a>(matches: &ArgMatches, config: &Configuration<'a>, repo: Repository, progress: ProgressBar) -> Result<()> {
-    use filters::failable::filter::FailableFilter;
-
-    let print_runtime_deps     = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_RUNTIME);
-    let print_build_deps       = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_BUILD);
-    let print_sys_deps         = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_SYSTEM);
-    let print_sys_runtime_deps = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_SYSTEM_RUNTIME);
-
-    let package_filter = {
-        let name = matches.value_of("package_name").map(String::from).map(PackageName::from).unwrap();
-
-        crate::util::filters::build_package_filter_by_dependency_name(
-            &name,
-            print_sys_deps,
-            print_sys_runtime_deps,
-            print_build_deps,
-            print_runtime_deps
-        )
-    };
-
-    let format = config.package_print_format();
-    let mut stdout = std::io::stdout();
-
-    let packages = repo.packages()
-        .map(|package| package_filter.filter(package).map(|b| (b, package)))
-        .filter_ok(|(b, _)| *b)
-        .map_ok(|tpl| tpl.1)
-        .inspect(|pkg| trace!("Found package: {:?}", pkg))
-        .collect::<Result<Vec<_>>>()?;
-
-    ui::print_packages(&mut stdout,
-                       format,
-                       packages.into_iter(),
-                       print_runtime_deps,
-                       print_build_deps,
-                       print_sys_deps,
-                       print_sys_runtime_deps)
-}
-
-async fn dependencies_of<'a>(matches: &ArgMatches, config: &Configuration<'a>, repo: Repository, progress: ProgressBar) -> Result<()> {
-    use filters::filter::Filter;
-
-    let package_filter = {
-        let name = matches.value_of("package_name").map(String::from).map(PackageName::from).unwrap();
-        trace!("Checking for package with name = {}", name);
-
-        crate::util::filters::build_package_filter_by_name(name)
-    };
-
-    let format = config.package_print_format();
-    let mut stdout = std::io::stdout();
-    let iter = repo.packages().filter(|package| package_filter.filter(package))
-        .inspect(|pkg| trace!("Found package: {:?}", pkg));
-
-    let print_runtime_deps     = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_RUNTIME);
-    let print_build_deps       = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_BUILD);
-    let print_sys_deps         = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_SYSTEM);
-    let print_sys_runtime_deps = getbool(matches, "dependency_type", crate::cli::IDENT_DEPENDENCY_TYPE_SYSTEM_RUNTIME);
-
-    trace!("Printing packages with format = '{}', runtime: {}, build: {}, sys: {}, sys_rt: {}",
-           format,
-           print_runtime_deps,
-           print_build_deps,
-           print_sys_deps,
-           print_sys_runtime_deps);
-
-    ui::print_packages(&mut stdout,
-                       format,
-                       iter,
-                       print_runtime_deps,
-                       print_build_deps,
-                       print_sys_deps,
-                       print_sys_runtime_deps)
-}
-
-async fn versions_of(matches: &ArgMatches, repo: Repository) -> Result<()> {
-    use filters::filter::Filter;
-    use std::io::Write;
-
-    let package_filter = {
-        let name = matches.value_of("package_name").map(String::from).map(PackageName::from).unwrap();
-        trace!("Checking for package with name = {}", name);
-
-        crate::util::filters::build_package_filter_by_name(name)
-    };
-
-    let mut stdout = std::io::stdout();
-    repo.packages()
-        .filter(|package| package_filter.filter(package))
-        .inspect(|pkg| trace!("Found package: {:?}", pkg))
-        .map(|pkg| writeln!(stdout, "{}", pkg.version()).map_err(Error::from))
-        .collect::<Result<Vec<_>>>()
-        .map(|_| ())
-}
-
 fn count_pkg_files(p: &Path) -> u64 {
     WalkDir::new(p)
         .follow_links(true)
@@ -381,8 +104,3 @@ fn count_pkg_files(p: &Path) -> u64 {
         .count() as u64
 }
 
-fn getbool(m: &ArgMatches, name: &str, cmp: &str) -> bool {
-    // unwrap is safe here because clap is configured with default values
-    m.values_of(name).unwrap().any(|v| v == cmp)
-}
-