hbox 0.7.1

CLI tool that leverages container technology to manage packages.
Documentation 
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::configs::app::AppConfig;
use crate::configs::index::Package as PackageIndex;
use crate::configs::version::Package as PackageVersion;
use log::{debug, info};
use std::error::Error;
use std::fs;

#[derive(Debug, Clone)]
pub struct Package {
    pub name: String,
    pub index: PackageIndex,
    pub versions: PackageVersion,
}

// Public API
impl Package {
    pub fn new(name: &str, versions_package: PackageVersion) -> Result<Self, Box<dyn Error>> {
        let index_package = crate::configs::index::IndexConfig::load(name.to_owned())?;
        Ok(Self {
            name: String::from(name),
            index: index_package,
            versions: versions_package,
        })
    }

    pub fn load(name: &str) -> Result<Option<Self>, Box<dyn Error>> {
        if let Some(versions_package) =
            crate::configs::version::VersionConfig::load(name.to_owned())?
        {
            let index_package = crate::configs::index::IndexConfig::load(name.to_owned())?;
            let package = Self::make_from(name, index_package, versions_package)?;
            Ok(Some(package))
        } else {
            Ok(None)
        }
    }

    pub fn load_all() -> Result<Vec<Self>, Box<dyn Error>> {
        let mut packages: Vec<Self> = Vec::new();
        let config = AppConfig::load();

        if !config.versions_path().exists() {
            fs::create_dir_all(config.versions_path())?;
        }

        for entry in fs::read_dir(config.versions_path())? {
            let entry = entry?;
            let path = entry.path();
            if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("json") {
                let name = path
                    .file_stem()
                    .and_then(|s| s.to_str())
                    .ok_or("Invalid package name")?
                    .to_string();

                if let Some(package) = Self::load(&name)? {
                    debug!("Loading package {}", name);
                    packages.push(package);
                }
            }
        }
        Ok(packages)
    }

    pub fn print(&self, verbose: bool) {
        info!("- [{}]", self.name);
        if verbose {
            info!("  - image:");
            info!("    - name: {}", &self.index.image.name);
            if let Some(build) = &self.index.image.build {
                info!("    - build:");
                info!("      - dockerfile: {}", build.dockerfile);
                info!("      - context: {}", build.context);
                info!("      - args:");
                if let Some(args) = &build.args {
                    for (arg_name, arg_value) in args.iter() {
                        info!("        - {}: {}", arg_name, arg_value);
                    }
                }
            }
            if let Some(ports) = &self.index.ports {
                info!("  - ports:");
                for port in ports {
                    info!("    - {}:{}", port.host, port.container);
                }
            }
            if let Some(volumes) = &self.index.volumes {
                info!("  - volumes:");
                for volume in volumes {
                    info!("    - {}:{}", volume.source, volume.target);
                }
            }
            if let Some(environment_variables) = &self.index.environment_variables {
                info!("  - environment variables:");
                for env_var in environment_variables {
                    info!("    - {}={}", env_var.name, env_var.value);
                }
            }
            if let Some(binaries) = &self.index.binaries {
                info!("  - binaries:");
                for binary in binaries {
                    info!("    - {} -> {}", binary.name, binary.path);
                }
            }
            info!("  - only_shim_binaries: {}", &self.index.only_shim_binaries);
            if let Some(current_directory) = &self.index.current_directory {
                info!("  - current directory: {}", current_directory.clone());
            }
        }
        info!("  - versions:");
        for version in &self.versions.versions {
            if version == &self.versions.current {
                info!("    - {} ✔", version);
            } else {
                info!("    - {}", version);
            }
        }
    }
}

// Private API
impl Package {
    fn make_from(
        name: &str,
        index_package: PackageIndex,
        versions_package: PackageVersion,
    ) -> Result<Self, Box<dyn Error>> {
        Ok(Self {
            name: String::from(name),
            index: index_package,
            versions: versions_package,
        })
    }
}