juiz_app 0.0.21

JUIZ utility command-line application package
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

use std::path::Path;

use juiz_core::log;
use juiz_core::prelude::*;
use juiz_core::utils::yaml_conf_load;

use clap::Subcommand;

use crate::namespace::{format_list, ListEntry};
use crate::Args;

#[derive(Debug, Subcommand, Clone)]
pub(crate) enum ContSubCommands {
    /// get logs
    #[clap(arg_required_else_help = false)]
    List {
        #[arg(
            short = 'f',
            default_value = "./juiz.conf",
            help = "Input system definition file path"
        )]
        filepath: String,

        #[arg(
            long = "namespace",
            help = "List only objects in this namespace and below (ex., robot1)"
        )]
        namespace: Option<String>,

        #[arg(long = "long", help = "Show namespace, name and type columns")]
        long: bool,
    },

    /// get logs
    #[clap(arg_required_else_help = false)]
    Info {
        #[arg(help = "ID of container")]
        identifier: String,
    },
}

pub(crate) fn on_container(
    manifest: Value,
    working_dir: &Path,
    subcommand: ContSubCommands,
    args: Args,
) -> JuizResult<()> {
    match on_container_inner(manifest, working_dir, subcommand, args) {
        Ok(_) => return Ok(()),
        Err(e) => println!("Error: {e:?}"),
    };
    Ok(())
}

pub(crate) fn on_container_inner(
    manifest: Value,
    working_dir: &Path,
    subcommand: ContSubCommands,
    args: Args,
) -> JuizResult<()> {
    let recursive = args.recursive;
    match subcommand {
        ContSubCommands::List {
            filepath,
            namespace,
            long,
        } => {
            log::trace!("container list command is selected.");
            let manifest2 = yaml_conf_load(filepath.clone())?;
            let server = args.server;
            System::new(manifest2)?
                .set_working_dir(working_dir)
                .start_http_broker(args.start_http_broker)
                .setup()?
                .add_systemproxy_by_id(Some(server.clone()))?
                .run_and_do_once(|system| on_container_list(system, recursive, namespace, long))
        }
        ContSubCommands::Info { identifier } => {
            let server = args.server;
            System::new(manifest)?
                .set_working_dir(working_dir)
                .start_http_broker(args.start_http_broker)
                .setup()?
                .add_systemproxy_by_id(Some(server.clone()))?
                .run_and_do_once(|system| on_container_info(system, identifier))
        }
    }
}

fn on_container_list(
    system: &mut System,
    recursive: bool,
    namespace: Option<String>,
    long: bool,
) -> JuizResult<()> {
    log::trace!("on_container_list() called");
    let ids = system.container_list(recursive)?;
    log::debug!("system.container_list() returns '{ids:?}'");
    let entries = ids.iter().map(ListEntry::from).collect();
    println!("{}", format_list(entries, namespace.as_deref(), long)?);
    Ok(())
}

fn on_container_info(system: &mut System, id: String) -> JuizResult<()> {
    let p = system
        .core_broker()
        .lock_mut()?
        .worker_mut()
        .container_from_identifier(&id.try_into()?);
    match p {
        Ok(ps) => println!("{:}", ps.lock()?.profile()?),
        Err(e) => println!("Error: {e:?}"),
    }
    Ok(())
}