mgt 0.2.5

Command line tool to analyze the WildFly management model.
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

//! Stops running Neo4J model DB containers.

use crate::container::{running_neo4j_containers, stop_container, verify_container_command};
use crate::json::CommandResult;
use crate::neo4j::{Neo4JContainer, Neo4JImage};
use crate::progress::{CommandStatus, Progress, done, summary};
use console::style;
use indicatif::MultiProgress;
use tokio::task::JoinSet;
use tokio::time::Instant;
use wildfly_meta::MetaItem;

/// Stops Neo4J containers by meta item identifier, or all if `--all` is passed.
pub async fn stop(items: Option<&[MetaItem]>, all: bool, json: bool) -> anyhow::Result<()> {
    verify_container_command()?;

    let containers: Vec<(String, String)> = if all {
        running_neo4j_containers()
            .await?
            .iter()
            .map(|r| {
                (
                    r.container.container_name(),
                    r.container.image.item.expression(),
                )
            })
            .collect()
    } else {
        items
            .expect("Argument <identifier> expected!")
            .iter()
            .map(|item| {
                let container_name = Neo4JContainer::new(Neo4JImage::new(item)).container_name();
                (container_name, item.expression())
            })
            .collect()
    };

    if containers.is_empty() {
        if json {
            println!("[]");
        } else {
            println!("\nNo running Neo4J model DB containers found.");
        }
        return Ok(());
    }

    let count = containers.len();
    let multi_progress = if json {
        None
    } else {
        let noun = if count == 1 {
            "container"
        } else {
            "containers"
        };
        println!(
            "\n{}",
            style(format!("Stopping {} Neo4J model DB {}", count, noun)).bold()
        );
        Some(MultiProgress::new())
    };

    let instant = Instant::now();
    let mut tasks = JoinSet::new();

    for (container_name, expression) in containers {
        let progress = match &multi_progress {
            Some(mp) => Progress::join(mp, &container_name),
            None => Progress::hidden(&container_name),
        };
        tasks.spawn(async move {
            let result = stop_container(&container_name).await;
            if !json {
                match &result {
                    Ok(()) => progress.finish_success(Some("Stopped")),
                    Err(e) => progress.finish_error(&e.to_string()),
                }
            }
            (container_name, expression, result)
        });
    }

    let results = tasks.join_all().await;

    if json {
        let command_results: Vec<CommandResult> = results
            .into_iter()
            .map(|(_, identifier, result)| match result {
                Ok(()) => CommandResult {
                    identifier,
                    success: true,
                    bolt: None,
                    http: None,
                    error: None,
                },
                Err(e) => CommandResult {
                    identifier,
                    success: false,
                    bolt: None,
                    http: None,
                    error: Some(e.to_string()),
                },
            })
            .collect();
        println!("{}", serde_json::to_string(&command_results).unwrap());
    } else {
        let status: Vec<CommandStatus> = results
            .iter()
            .map(|(name, _, result)| CommandStatus::from_result(name, result))
            .collect();
        summary(count, &status);
        done(instant);
    }
    Ok(())
}