wash-lib 0.25.1

wasmCloud Shell (wash) libraries
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

use anyhow::{bail, Context, Result};
use clap::Parser;
use wasmcloud_control_interface::HostInventory;

use crate::{
    common::{boxed_err_to_anyhow, get_all_inventories},
    component::update_component,
    config::WashConnectionOptions,
};

use super::{validate_component_id, CliConnectionOpts, CommandOutput};

#[derive(Debug, Clone, Parser)]
pub enum UpdateCommand {
    /// Update a component running in a host to a newer version
    #[clap(name = "component")]
    Component(UpdateComponentCommand),
}

#[derive(Debug, Clone, Parser)]
pub struct UpdateComponentCommand {
    #[clap(flatten)]
    pub opts: CliConnectionOpts,

    /// ID of host to update the component on. If a non-ID is provided, the host will be selected based
    /// on matching the prefix of the ID or the friendly name and will return an error if more than
    /// one host matches. If no host ID is passed, a host will be selected based on whether or not
    /// the component is running on it. If more than 1 host is running this component, an error will be
    /// returned with a list of hosts running the component
    #[clap(long = "host-id")]
    pub host_id: Option<String>,

    /// Unique ID of the component to update
    #[clap(name = "component-id", value_parser = validate_component_id)]
    pub component_id: String,

    /// Component reference to replace the current running comonent with, e.g. the absolute file path or OCI URL.
    #[clap(name = "new-component-ref")]
    pub new_component_ref: String,
}

pub async fn handle_update_component(cmd: UpdateComponentCommand) -> Result<CommandOutput> {
    let wco: WashConnectionOptions = cmd.opts.try_into()?;
    let client = wco.into_ctl_client(None).await?;

    let inventory = if let Some(host_id) = cmd.host_id {
        client
            .get_host_inventory(&host_id)
            .await
            .map(|inventory| inventory.response)
            .map_err(boxed_err_to_anyhow)?
            .context(format!(
                "Supplied host [{}] did not respond to inventory query",
                host_id
            ))?
    } else {
        let mut inventories = get_all_inventories(&client)
            .await?
            .into_iter()
            .filter(|inv| {
                inv.components
                    .iter()
                    .any(|component| component.id == cmd.component_id)
            })
            .collect::<Vec<HostInventory>>();

        match inventories[..] {
            // No hosts
            [] => {
                bail!("No host found running component [{}]", cmd.component_id)
            }
            // Single host
            [_] => inventories.remove(0),
            // Multiple hosts
            _ => {
                bail!(
                    "Component [{}] cannot be updated because multiple hosts are running it: [{}]",
                    cmd.component_id,
                    inventories
                        .iter()
                        .map(|h| h.host_id.to_string())
                        .collect::<Vec<String>>()
                        .join(","),
                );
            }
        }
    };

    let Some((host_id, component_ref)) = inventory
        .components
        .iter()
        .find(|component| component.id == cmd.component_id)
        .map(|component| (inventory.host_id.clone(), component.image_ref.clone()))
    else {
        bail!(
            "Component {} not found on host [{}]",
            cmd.component_id,
            inventory.host_id,
        );
    };

    if component_ref == cmd.new_component_ref {
        return Ok(CommandOutput::from_key_and_text(
            "result",
            format!(
                "Component {} already updated to {} on host [{}]",
                cmd.component_id, cmd.new_component_ref, host_id
            ),
        ));
    }

    let ack =
        update_component(&client, &host_id, &cmd.component_id, &cmd.new_component_ref).await?;
    if !ack.success {
        bail!("Operation failed on host [{}]: {}", host_id, ack.message);
    }

    let message = match ack.message {
        message if message.is_empty() => format!(
            "component {} updating from {} to {}",
            cmd.component_id, component_ref, cmd.new_component_ref
        ),
        message => message,
    };

    Ok(CommandOutput::from_key_and_text(
        "result",
        format!("Host [{}]: {}", host_id, message),
    ))
}