flyboat 2.0.0

Container environment manager for development
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

use crate::Result;
use crate::cli::ListArgs;
use crate::environment::EnvironmentManager;
use colored::Colorize;
use serde::Serialize;

#[derive(Serialize)]
struct EnvInfo {
    name: String,
    description: String,
    aliases: Vec<String>,
    network: String,
    disk_access: String,
}

pub fn execute_list(args: &ListArgs, verbose: bool) -> Result<()> {
    if verbose {
        eprintln!("Listing environments");
    }

    let manager = EnvironmentManager::new()?;
    let env_dir = manager.paths().env_dir();

    if manager.is_empty() {
        eprintln!(
            "{}: No environments found in {}",
            "Warning".yellow(),
            env_dir.display()
        );
        eprintln!();
        eprintln!("To create an environment:");
        eprintln!(
            "  1. Create a folder: mkdir -p {}/<name>",
            env_dir.display()
        );
        eprintln!("  2. Add a Dockerfile and dev_env.yaml");
        return Ok(());
    }

    let mut envs: Vec<EnvInfo> = manager
        .list()
        .iter()
        .map(|env| EnvInfo {
            name: env.full_name(),
            description: env.config.description.clone(),
            aliases: env.config.aliases.clone(),
            network: env.config.settings.network.clone(),
            disk_access: env.config.settings.disk_access.clone(),
        })
        .collect();
    envs.sort_by(|a, b| a.name.cmp(&b.name));

    if args.json {
        let json = serde_json::to_string_pretty(&envs)?;
        println!("{}", json);
    } else {
        println!(
            "{:<28} {:<35} {:<10} {:<12} {}",
            "NAME".bold(),
            "DESCRIPTION".bold(),
            "NETWORK".bold(),
            "DISK".bold(),
            "ALIASES".bold()
        );
        println!("{}", "-".repeat(105));

        for env in envs {
            let aliases = if env.aliases.is_empty() {
                "-".to_string()
            } else {
                env.aliases.join(", ")
            };

            let desc = if env.description.len() > 33 {
                format!("{}...", &env.description[..30])
            } else {
                env.description
            };

            println!(
                "{:<28} {:<35} {:<10} {:<12} {}",
                env.name.green(),
                desc,
                env.network,
                env.disk_access,
                aliases.dimmed()
            );
        }

        eprintln!();
        eprintln!("To create an environment:");
        eprintln!(
            "  1. Create a folder: mkdir -p {}/<name>",
            env_dir.display()
        );
        eprintln!("  2. Add a Dockerfile and dev_env.yaml");

        if verbose {
            eprintln!("\nName Env Mapping:");
            let display_max = 5;

            let mut reference_mapping = manager.reference_mapping();
            reference_mapping.sort_keys();

            for (key, envs) in reference_mapping {
                let x_more = if envs.len() > display_max {
                    format!(", .. and {} more", envs.len() - display_max)
                } else {
                    "".to_owned()
                };
                eprintln!(
                    "  - {key:<25} -> [{}{}]",
                    envs.iter()
                        .map(|env| env.full_name())
                        .take(display_max)
                        .collect::<Vec<_>>()
                        .join(", "),
                    x_more
                );
            }
        }
    }

    Ok(())
}