mgt 0.2.2

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

//! Pushes Neo4J model DB images to the remote registry.

use crate::container::{container_command, local_image_names, verify_container_command};
use crate::neo4j::Neo4JImage;
use crate::progress::{CommandStatus, Progress, done, stderr_reader, summary};
use anyhow::bail;
use console::style;
use indicatif::MultiProgress;
use std::process::Stdio;
use tokio::task::JoinSet;
use tokio::time::Instant;
use wildfly_meta::MetaItem;

/// Pushes Neo4J model DB images for the given meta items to the remote registry.
pub async fn push(items: &[MetaItem], chunk_size: u16) -> anyhow::Result<()> {
    verify_container_command()?;

    let local = local_image_names().await?;
    let pushable: Vec<_> = items
        .iter()
        .filter(|item| {
            let tag = Neo4JImage::new(item).image_tag();
            if local.contains(&tag) {
                true
            } else {
                eprintln!(
                    "  {} {} not found locally, skipping",
                    style("\u{26a0}").yellow(),
                    style(&tag).cyan()
                );
                false
            }
        })
        .cloned()
        .collect();

    if pushable.is_empty() {
        bail!("No local images found for the given identifiers");
    }

    let count = pushable.len();
    let noun = if count == 1 { "image" } else { "images" };
    println!(
        "\n{}",
        style(format!("Pushing {} Neo4J model DB {}", count, noun)).bold()
    );

    let instant = Instant::now();
    if chunk_size > 0 {
        let mut all_status: Vec<CommandStatus> = Vec::with_capacity(count);
        for chunk in pushable.chunks(chunk_size as usize) {
            let status = push_batch(chunk).await?;
            all_status.extend(status);
        }
        summary(count, &all_status);
    } else {
        let status = push_batch(&pushable).await?;
        summary(count, &status);
    }
    done(instant);
    Ok(())
}

/// Pushes a batch of images in parallel.
async fn push_batch(items: &[MetaItem]) -> anyhow::Result<Vec<CommandStatus>> {
    let multi_progress = MultiProgress::new();
    let mut tasks = JoinSet::new();

    for item in items {
        let image = Neo4JImage::new(item);
        let image_tag = image.image_tag();
        let display = item.short_name();
        let progress = Progress::join(&multi_progress, &display);

        let mut cmd = container_command()?;
        cmd.arg("manifest")
            .arg("push")
            .arg(&image_tag)
            .stdout(Stdio::piped())
            .stderr(Stdio::piped());

        let mut child = cmd.spawn().expect("Unable to run container push command.");
        let stderr = stderr_reader(&mut child);
        let progress_clone = progress.clone();

        tasks.spawn(async move {
            let output = child.wait_with_output().await;
            progress.finish_output(output, None)
        });
        tokio::spawn(async move {
            progress_clone.trace_progress(stderr).await;
        });
    }

    Ok(tasks.join_all().await)
}