feat(rust): Improve JSON output of ockam node show

Improves the output of the command `ockam node show --output json`
adding all the information that is being displayed with the plain
output. Refactors the plain response to build it using the Output
trait erasing the a clippy alert in the process.

Closes build-trust#6142

implementations/rust/ockam/ockam_api/src/util.rs

@@ -1,4 +1,5 @@
 use miette::miette;
+use serde::Serializer;
 use std::net::{SocketAddrV4, SocketAddrV6};
 
 use ockam::TcpTransport;
@@ -307,6 +308,15 @@ pub fn addr_to_multiaddr<T: Into<Address>>(a: T) -> Option<MultiAddr> {
     route_to_multiaddr(&r)
 }
 
+/// Serialize the field attempting to convert it first to a MultiAddr.
+pub fn serialize_as_multiaddr<T, S>(t: &T, s: S) -> Result<S::Ok, S::Error>
+where
+    T: Into<Address> + Clone,
+    S: Serializer,
+{
+    s.serialize_some(&addr_to_multiaddr(t.clone()))
+}
+
 /// Tells whether the input MultiAddr references a local node or a remote node.
 ///
 /// This should be called before cleaning the MultiAddr.

implementations/rust/ockam/ockam_command/src/node/mod.rs

@@ -18,6 +18,7 @@ mod default;
 mod delete;
 mod list;
 mod logs;
+mod models;
 mod show;
 mod start;
 mod stop;

implementations/rust/ockam/ockam_command/src/node/models/mod.rs

@@ -0,0 +1,5 @@
+pub mod portal;
+pub mod secure_channel;
+pub mod services;
+pub mod show;
+pub mod transport;

implementations/rust/ockam/ockam_command/src/node/models/portal.rs

@@ -0,0 +1,44 @@
+use std::net::SocketAddr;
+
+use ockam_api::{
+    addr_to_multiaddr,
+    nodes::models::portal::{InletStatus, OutletStatus},
+    route_to_multiaddr,
+};
+use ockam_core::Route;
+use ockam_multiaddr::MultiAddr;
+use serde::Serialize;
+
+/// Information to display of the inlets in the `ockam node show` command
+#[derive(Debug, Serialize)]
+pub struct ShowInletStatus {
+    pub listen_address: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub route_to_outlet: Option<MultiAddr>,
+}
+
+impl From<InletStatus> for ShowInletStatus {
+    fn from(value: InletStatus) -> Self {
+        Self {
+            listen_address: value.bind_addr,
+            route_to_outlet: Route::parse(value.outlet_route).and_then(|r| route_to_multiaddr(&r)),
+        }
+    }
+}
+
+/// Information to display of the inlets in the `ockam node show` command
+#[derive(Debug, Serialize)]
+pub struct ShowOutletStatus {
+    pub forward_address: SocketAddr,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub address: Option<MultiAddr>,
+}
+
+impl From<OutletStatus> for ShowOutletStatus {
+    fn from(value: OutletStatus) -> Self {
+        Self {
+            forward_address: value.socket_addr,
+            address: addr_to_multiaddr(value.worker_addr),
+        }
+    }
+}

implementations/rust/ockam/ockam_command/src/node/models/secure_channel.rs

@@ -0,0 +1,22 @@
+use ockam_api::{
+    addr_to_multiaddr, nodes::models::secure_channel::ShowSecureChannelListenerResponse,
+};
+use ockam_core::flow_control::FlowControlId;
+use ockam_multiaddr::MultiAddr;
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct ShowSecureChannelListener {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub address: Option<MultiAddr>,
+    pub flow_control: FlowControlId,
+}
+
+impl From<ShowSecureChannelListenerResponse> for ShowSecureChannelListener {
+    fn from(value: ShowSecureChannelListenerResponse) -> Self {
+        Self {
+            address: addr_to_multiaddr(value.addr),
+            flow_control: value.flow_control_id,
+        }
+    }
+}

implementations/rust/ockam/ockam_command/src/node/models/services.rs

@@ -0,0 +1,20 @@
+use ockam_api::{addr_to_multiaddr, nodes::models::services::ServiceStatus};
+use ockam_multiaddr::MultiAddr;
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct ShowServiceStatus {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub address: Option<MultiAddr>,
+    #[serde(rename = "type")]
+    pub service_type: String,
+}
+
+impl From<ServiceStatus> for ShowServiceStatus {
+    fn from(value: ServiceStatus) -> Self {
+        Self {
+            address: addr_to_multiaddr(value.addr),
+            service_type: value.service_type,
+        }
+    }
+}

implementations/rust/ockam/ockam_command/src/node/models/show.rs

@@ -0,0 +1,162 @@
+use std::fmt::Display;
+
+use colorful::Colorful;
+
+use ockam_multiaddr::{
+    proto::{DnsAddr, Node, Tcp},
+    MultiAddr,
+};
+use serde::Serialize;
+
+use crate::output::Output;
+
+use super::{
+    portal::{ShowInletStatus, ShowOutletStatus},
+    secure_channel::ShowSecureChannelListener,
+    services::ShowServiceStatus,
+    transport::ShowTransportStatus,
+};
+
+#[derive(Debug, Serialize)]
+pub struct ShowNodeResponse<'a> {
+    pub is_default: bool,
+    pub name: &'a str,
+    pub is_up: bool,
+    pub route: RouteToNode,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub identity: Option<String>,
+    pub transports: Vec<ShowTransportStatus>,
+    pub secure_channel_listeners: Vec<ShowSecureChannelListener>,
+    pub inlets: Vec<ShowInletStatus>,
+    pub outlets: Vec<ShowOutletStatus>,
+    pub services: Vec<ShowServiceStatus>,
+}
+#[derive(Debug, Serialize)]
+pub struct RouteToNode {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub short: Option<MultiAddr>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub verbose: Option<MultiAddr>,
+}
+
+impl<'a> ShowNodeResponse<'a> {
+    pub fn new(
+        is_default: bool,
+        name: &'a str,
+        is_up: bool,
+        node_port: Option<u16>,
+    ) -> ShowNodeResponse {
+        let mut m = MultiAddr::default();
+        let short = m.push_back(Node::new(name)).ok().map(|_| m);
+
+        let verbose = node_port.and_then(|port| {
+            let mut m = MultiAddr::default();
+            if m.push_back(DnsAddr::new("localhost")).is_ok() && m.push_back(Tcp::new(port)).is_ok()
+            {
+                Some(m)
+            } else {
+                None
+            }
+        });
+
+        ShowNodeResponse {
+            is_default,
+            name,
+            is_up,
+            route: RouteToNode { short, verbose },
+            identity: None,
+            transports: Default::default(),
+            secure_channel_listeners: Default::default(),
+            inlets: Default::default(),
+            outlets: Default::default(),
+            services: Default::default(),
+        }
+    }
+}
+
+impl<'a> Display for ShowNodeResponse<'a> {
+    fn fmt(&self, buffer: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(buffer, "Node:")?;
+
+        if self.is_default {
+            writeln!(buffer, "  Name: {} (default)", self.name)?;
+        } else {
+            writeln!(buffer, "  Name: {}", self.name)?;
+        }
+
+        writeln!(
+            buffer,
+            "  Status: {}",
+            match self.is_up {
+                true => "UP".light_green(),
+                false => "DOWN".light_red(),
+            }
+        )?;
+
+        writeln!(buffer, "  Route To Node:")?;
+        if let Some(short) = &self.route.short {
+            writeln!(buffer, "    Short: {short}")?;
+        }
+        if let Some(verbose) = &self.route.verbose {
+            writeln!(buffer, "    Verbose: {verbose}")?;
+        }
+
+        if let Some(identity) = &self.identity {
+            writeln!(buffer, "  Identity: {}", identity)?;
+        }
+
+        writeln!(buffer, "  Transports:")?;
+        for e in &self.transports {
+            writeln!(buffer, "    Transport:")?;
+            writeln!(buffer, "      Type: {}", &e.tt)?;
+            writeln!(buffer, "      Mode: {}", &e.mode)?;
+            writeln!(buffer, "      Socket: {}", &e.socket)?;
+            writeln!(buffer, "      Worker: {}", &e.worker)?;
+            writeln!(buffer, "      FlowControlId: {}", &e.flow_control)?;
+        }
+
+        writeln!(buffer, "  Secure Channel Listeners:")?;
+        for e in &self.secure_channel_listeners {
+            writeln!(buffer, "    Listener:")?;
+            if let Some(ma) = &e.address {
+                writeln!(buffer, "      Address: {ma}")?;
+            }
+            writeln!(buffer, "      FlowControlId: {}", &e.flow_control)?;
+        }
+
+        writeln!(buffer, "  Inlets:")?;
+        for e in &self.inlets {
+            writeln!(buffer, "    Inlet:")?;
+            writeln!(buffer, "      Listen Address: {}", e.listen_address)?;
+            if let Some(r) = &e.route_to_outlet {
+                writeln!(buffer, "      Route To Outlet: {r}")?;
+            }
+        }
+
+        writeln!(buffer, "  Outlets:")?;
+        for e in &self.outlets {
+            writeln!(buffer, "    Outlet:")?;
+            writeln!(buffer, "      Forward Address: {}", e.forward_address)?;
+            if let Some(ma) = &e.address {
+                writeln!(buffer, "      Address: {ma}")?;
+            }
+        }
+
+        writeln!(buffer, "  Services:")?;
+        for e in &self.services {
+            writeln!(buffer, "    Service:")?;
+            writeln!(buffer, "      Type: {}", e.service_type)?;
+            if let Some(ma) = &e.address {
+                writeln!(buffer, "      Address: {ma}")?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a> Output for ShowNodeResponse<'a> {
+    fn output(&self) -> crate::error::Result<String> {
+        Ok(self.to_string())
+    }
+}

implementations/rust/ockam/ockam_command/src/node/models/transport.rs

@@ -0,0 +1,25 @@
+use ockam_api::nodes::models::transport::{TransportMode, TransportStatus, TransportType};
+use ockam_core::flow_control::FlowControlId;
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct ShowTransportStatus {
+    #[serde(rename = "type")]
+    pub tt: TransportType,
+    pub mode: TransportMode,
+    pub socket: String,
+    pub worker: String,
+    pub flow_control: FlowControlId,
+}
+
+impl From<TransportStatus> for ShowTransportStatus {
+    fn from(value: TransportStatus) -> Self {
+        Self {
+            tt: value.tt,
+            mode: value.tm,
+            socket: value.socket_addr,
+            worker: value.worker_addr,
+            flow_control: value.flow_control_id,
+        }
+    }
+}