feature(kratactl): rework cli to use subcommands (#268)

crates/ctl/src/cli/zone/list.rs

@@ -0,0 +1,170 @@
+use anyhow::{anyhow, Result};
+use clap::{Parser, ValueEnum};
+use comfy_table::{presets::UTF8_FULL_CONDENSED, Cell, Color, Table};
+use krata::{
+    events::EventStream,
+    v1::{
+        common::{Zone, ZoneStatus},
+        control::{
+            control_service_client::ControlServiceClient, ListZonesRequest, ResolveZoneRequest,
+        },
+    },
+};
+
+use serde_json::Value;
+use tonic::{transport::Channel, Request};
+
+use crate::format::{kv2line, proto2dynamic, proto2kv, zone_simple_line, zone_status_text};
+
+#[derive(ValueEnum, Clone, Debug, PartialEq, Eq)]
+enum ZoneListFormat {
+    Table,
+    Json,
+    JsonPretty,
+    Jsonl,
+    Yaml,
+    KeyValue,
+    Simple,
+}
+
+#[derive(Parser)]
+#[command(about = "List the zones on the isolation engine")]
+pub struct ZoneListCommand {
+    #[arg(short, long, default_value = "table", help = "Output format")]
+    format: ZoneListFormat,
+    #[arg(help = "Limit to a single zone, either the name or the uuid")]
+    zone: Option<String>,
+}
+
+impl ZoneListCommand {
+    pub async fn run(
+        self,
+        mut client: ControlServiceClient<Channel>,
+        _events: EventStream,
+    ) -> Result<()> {
+        let mut zones = if let Some(ref zone) = self.zone {
+            let reply = client
+                .resolve_zone(Request::new(ResolveZoneRequest { name: zone.clone() }))
+                .await?
+                .into_inner();
+            if let Some(zone) = reply.zone {
+                vec![zone]
+            } else {
+                return Err(anyhow!("unable to resolve zone '{}'", zone));
+            }
+        } else {
+            client
+                .list_zones(Request::new(ListZonesRequest {}))
+                .await?
+                .into_inner()
+                .zones
+        };
+
+        zones.sort_by(|a, b| {
+            a.spec
+                .as_ref()
+                .map(|x| x.name.as_str())
+                .unwrap_or("")
+                .cmp(b.spec.as_ref().map(|x| x.name.as_str()).unwrap_or(""))
+        });
+
+        match self.format {
+            ZoneListFormat::Table => {
+                self.print_zone_table(zones)?;
+            }
+
+            ZoneListFormat::Simple => {
+                for zone in zones {
+                    println!("{}", zone_simple_line(&zone));
+                }
+            }
+
+            ZoneListFormat::Json | ZoneListFormat::JsonPretty | ZoneListFormat::Yaml => {
+                let mut values = Vec::new();
+                for zone in zones {
+                    let message = proto2dynamic(zone)?;
+                    values.push(serde_json::to_value(message)?);
+                }
+                let value = Value::Array(values);
+                let encoded = if self.format == ZoneListFormat::JsonPretty {
+                    serde_json::to_string_pretty(&value)?
+                } else if self.format == ZoneListFormat::Yaml {
+                    serde_yaml::to_string(&value)?
+                } else {
+                    serde_json::to_string(&value)?
+                };
+                println!("{}", encoded.trim());
+            }
+
+            ZoneListFormat::Jsonl => {
+                for zone in zones {
+                    let message = proto2dynamic(zone)?;
+                    println!("{}", serde_json::to_string(&message)?);
+                }
+            }
+
+            ZoneListFormat::KeyValue => {
+                self.print_key_value(zones)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn print_zone_table(&self, zones: Vec<Zone>) -> Result<()> {
+        let mut table = Table::new();
+        table.load_preset(UTF8_FULL_CONDENSED);
+        table.set_content_arrangement(comfy_table::ContentArrangement::Dynamic);
+        table.set_header(vec!["name", "uuid", "status", "ipv4", "ipv6"]);
+        for zone in zones {
+            let ipv4 = zone
+                .state
+                .as_ref()
+                .and_then(|x| x.network.as_ref())
+                .map(|x| x.zone_ipv4.as_str())
+                .unwrap_or("n/a");
+            let ipv6 = zone
+                .state
+                .as_ref()
+                .and_then(|x| x.network.as_ref())
+                .map(|x| x.zone_ipv6.as_str())
+                .unwrap_or("n/a");
+            let Some(spec) = zone.spec else {
+                continue;
+            };
+            let status = zone.state.as_ref().cloned().unwrap_or_default().status();
+            let status_text = zone_status_text(status);
+
+            let status_color = match status {
+                ZoneStatus::Destroyed | ZoneStatus::Failed => Color::Red,
+                ZoneStatus::Destroying | ZoneStatus::Exited | ZoneStatus::Starting => Color::Yellow,
+                ZoneStatus::Started => Color::Green,
+                _ => Color::Reset,
+            };
+
+            table.add_row(vec![
+                Cell::new(spec.name),
+                Cell::new(zone.id),
+                Cell::new(status_text).fg(status_color),
+                Cell::new(ipv4.to_string()),
+                Cell::new(ipv6.to_string()),
+            ]);
+        }
+        if table.is_empty() {
+            if self.zone.is_none() {
+                println!("no zones have been launched");
+            }
+        } else {
+            println!("{}", table);
+        }
+        Ok(())
+    }
+
+    fn print_key_value(&self, zones: Vec<Zone>) -> Result<()> {
+        for zone in zones {
+            let kvs = proto2kv(zone)?;
+            println!("{}", kv2line(kvs),);
+        }
+        Ok(())
+    }
+}