genpac 0.1.0

Sandbox for Gentoo ebuild development using bubblewrap
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Copyright (C) 2023 Gokul Das B
// SPDX-License-Identifier: GPL-3.0-or-later
//! Main entry point: Genpac (Gentoo Packaging Environment)
//!
//! This module deals mainly with finding the configuration file, initiating cli processing,
//! starting the logger and dispatching work to appropriate submodules.

use anyhow::{Context, Result as AResult};
use clap::{Parser, Subcommand};
pub use common::*;
use global::GlobalsFinal;
use std::path::PathBuf;

mod bubblewrap;
mod common;
mod extract;
mod global;
#[cfg(feature = "remap")]
mod remap;
mod sandbox;
mod snapshot;

const CONFIGFILE: &str = "${XDG_CONFIG_HOME:-~/.config}/genpac/config.toml";

/// Subcommands and subcommand dispatcher
#[derive(Subcommand)]
pub enum SubCommands {
    #[cfg(feature = "remap")]
    Remap(remap::SubCmdArgs),

    #[command(alias = "sbox")]
    Sandbox(sandbox::SubCmdArgs),

    #[command(subcommand, alias = "snap")]
    Snapshot(snapshot::SubCmdArgs),

    Extract(extract::SubCmdArgs),
}

impl SubCommands {
    fn dispatch(self, globals: GlobalsFinal) -> AResult<()> {
        match self {
            #[cfg(feature = "remap")]
            Self::Remap(sc) => sc.handle(globals)?,
            Self::Sandbox(sc) => sc.handle(globals)?,
            Self::Snapshot(sc) => sc.handle(globals)?,
            Self::Extract(sc) => sc.handle(globals)?,
        }
        Ok(())
    }
}

fn main() -> AResult<()> {
    let cli = global::Cli::parse();
    let globals = cli.globals().init_logger()?;

    let cfg = shellexpand::env(CONFIGFILE).context("Cannot expand config file path")?;
    let cfg = shellexpand::tilde(&cfg);
    let cfg = PathBuf::from(cfg.as_ref());
    if !cfg.is_file() {
        let e = format!("Config file '{}' not found. Cannot proceed!", cfg.display());
        log::error!("{e}");
        anyhow::bail!(e);
    } else {
        log::debug!("Loading config from '{}'", cfg.display());
    }
    let cfg = std::fs::read_to_string(cfg).context("Unable to read config file")?;
    let globals = match globals.config(cfg) {
        Ok(x) => x,
        Err(e) => {
            log::error!("Unable to parse configuration file:");
            log::error!("{e}");
            anyhow::bail!(e);
        }
    };

    match cli.subcmd().dispatch(globals) {
        Ok(()) => Ok(()),
        Err(e) => {
            log::error!("Failed to execute subcommand:");
            log::error!("{e}");
            anyhow::bail!(e);
        }
    }
}