ockam_command 0.79.0

End-to-end encryption and mutual authentication for distributed applications.
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

use clap::Args;

use ockam::identity::credential::Credential;
use ockam::{Context, TcpTransport};
use ockam_api::clean_multiaddr;
use ockam_core::api::Request;
use ockam_multiaddr::MultiAddr;

use crate::node::NodeOpts;
use crate::util::api::CloudOpts;
use crate::util::{node_rpc, RpcBuilder};
use crate::{stop_node, CommandGlobalOpts, Result};

#[derive(Clone, Debug, Args)]
pub struct GetCredentialCommand {
    /// Orchestrator address to resolve projects present in the `at` argument
    #[command(flatten)]
    cloud_opts: CloudOpts,

    #[command(flatten)]
    node_opts: NodeOpts,

    #[arg(long, short)]
    to: MultiAddr,
}

impl GetCredentialCommand {
    pub fn run(self, opts: CommandGlobalOpts) {
        node_rpc(rpc, (opts, self));
    }
}

async fn rpc(
    mut ctx: Context,
    (opts, cmd): (CommandGlobalOpts, GetCredentialCommand),
) -> Result<()> {
    async fn go(
        ctx: &mut Context,
        opts: &CommandGlobalOpts,
        cmd: &GetCredentialCommand,
    ) -> Result<()> {
        let tcp = TcpTransport::create(ctx).await?;
        let (to, meta) = clean_multiaddr(&cmd.to, &opts.config.get_lookup()).unwrap();
        let projects_sc = crate::project::util::lookup_projects(
            ctx,
            opts,
            &tcp,
            &meta,
            &cmd.cloud_opts.route(),
            &cmd.node_opts.api_node,
        )
        .await?;
        let to = crate::project::util::clean_projects_multiaddr(to, projects_sc)?;

        let mut rpc = RpcBuilder::new(ctx, opts, &cmd.node_opts.api_node)
            .tcp(&tcp)
            .to(&to)?
            .build()?;
        rpc.request(Request::post("/credential")).await?;
        rpc.print_response::<Credential<'_>>()?;
        Ok(())
    }
    let result = go(&mut ctx, &opts, &cmd).await;
    stop_node(ctx).await?;
    result
}