feature(krata): rename guest to zone (#266)

crates/ctl/src/cli/list.rs

@@ -4,9 +4,9 @@ use comfy_table::{presets::UTF8_FULL_CONDENSED, Cell, Color, Table};
 use krata::{
     events::EventStream,
     v1::{
-        common::{Guest, GuestStatus},
+        common::{Zone, ZoneStatus},
         control::{
-            control_service_client::ControlServiceClient, ListGuestsRequest, ResolveGuestRequest,
+            control_service_client::ControlServiceClient, ListZonesRequest, ResolveZoneRequest,
         },
     },
 };
@@ -14,7 +14,7 @@ use krata::{
 use serde_json::Value;
 use tonic::{transport::Channel, Request};
 
-use crate::format::{guest_simple_line, guest_status_text, kv2line, proto2dynamic, proto2kv};
+use crate::format::{kv2line, proto2dynamic, proto2kv, zone_simple_line, zone_status_text};
 
 #[derive(ValueEnum, Clone, Debug, PartialEq, Eq)]
 enum ListFormat {
@@ -28,12 +28,12 @@ enum ListFormat {
 }
 
 #[derive(Parser)]
-#[command(about = "List the guests on the isolation engine")]
+#[command(about = "List the zones on the isolation engine")]
 pub struct ListCommand {
     #[arg(short, long, default_value = "table", help = "Output format")]
     format: ListFormat,
-    #[arg(help = "Limit to a single guest, either the name or the uuid")]
-    guest: Option<String>,
+    #[arg(help = "Limit to a single zone, either the name or the uuid")]
+    zone: Option<String>,
 }
 
 impl ListCommand {
@@ -42,27 +42,25 @@ impl ListCommand {
         mut client: ControlServiceClient<Channel>,
         _events: EventStream,
     ) -> Result<()> {
-        let mut guests = if let Some(ref guest) = self.guest {
+        let mut zones = if let Some(ref zone) = self.zone {
             let reply = client
-                .resolve_guest(Request::new(ResolveGuestRequest {
-                    name: guest.clone(),
-                }))
+                .resolve_zone(Request::new(ResolveZoneRequest { name: zone.clone() }))
                 .await?
                 .into_inner();
-            if let Some(guest) = reply.guest {
-                vec![guest]
+            if let Some(zone) = reply.zone {
+                vec![zone]
             } else {
-                return Err(anyhow!("unable to resolve guest '{}'", guest));
+                return Err(anyhow!("unable to resolve zone '{}'", zone));
             }
         } else {
             client
-                .list_guests(Request::new(ListGuestsRequest {}))
+                .list_zones(Request::new(ListZonesRequest {}))
                 .await?
                 .into_inner()
-                .guests
+                .zones
         };
 
-        guests.sort_by(|a, b| {
+        zones.sort_by(|a, b| {
             a.spec
                 .as_ref()
                 .map(|x| x.name.as_str())
@@ -72,19 +70,19 @@ impl ListCommand {
 
         match self.format {
             ListFormat::Table => {
-                self.print_guest_table(guests)?;
+                self.print_zone_table(zones)?;
             }
 
             ListFormat::Simple => {
-                for guest in guests {
-                    println!("{}", guest_simple_line(&guest));
+                for zone in zones {
+                    println!("{}", zone_simple_line(&zone));
                 }
             }
 
             ListFormat::Json | ListFormat::JsonPretty | ListFormat::Yaml => {
                 let mut values = Vec::new();
-                for guest in guests {
-                    let message = proto2dynamic(guest)?;
+                for zone in zones {
+                    let message = proto2dynamic(zone)?;
                     values.push(serde_json::to_value(message)?);
                 }
                 let value = Value::Array(values);
@@ -99,64 +97,62 @@ impl ListCommand {
             }
 
             ListFormat::Jsonl => {
-                for guest in guests {
-                    let message = proto2dynamic(guest)?;
+                for zone in zones {
+                    let message = proto2dynamic(zone)?;
                     println!("{}", serde_json::to_string(&message)?);
                 }
             }
 
             ListFormat::KeyValue => {
-                self.print_key_value(guests)?;
+                self.print_key_value(zones)?;
             }
         }
 
         Ok(())
     }
 
-    fn print_guest_table(&self, guests: Vec<Guest>) -> Result<()> {
+    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 guest in guests {
-            let ipv4 = guest
+        for zone in zones {
+            let ipv4 = zone
                 .state
                 .as_ref()
                 .and_then(|x| x.network.as_ref())
-                .map(|x| x.guest_ipv4.as_str())
+                .map(|x| x.zone_ipv4.as_str())
                 .unwrap_or("n/a");
-            let ipv6 = guest
+            let ipv6 = zone
                 .state
                 .as_ref()
                 .and_then(|x| x.network.as_ref())
-                .map(|x| x.guest_ipv6.as_str())
+                .map(|x| x.zone_ipv6.as_str())
                 .unwrap_or("n/a");
-            let Some(spec) = guest.spec else {
+            let Some(spec) = zone.spec else {
                 continue;
             };
-            let status = guest.state.as_ref().cloned().unwrap_or_default().status();
-            let status_text = guest_status_text(status);
+            let status = zone.state.as_ref().cloned().unwrap_or_default().status();
+            let status_text = zone_status_text(status);
 
             let status_color = match status {
-                GuestStatus::Destroyed | GuestStatus::Failed => Color::Red,
-                GuestStatus::Destroying | GuestStatus::Exited | GuestStatus::Starting => {
-                    Color::Yellow
-                }
-                GuestStatus::Started => Color::Green,
+                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(guest.id),
+                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.guest.is_none() {
-                println!("no guests have been launched");
+            if self.zone.is_none() {
+                println!("no zones have been launched");
             }
         } else {
             println!("{}", table);
@@ -164,9 +160,9 @@ impl ListCommand {
         Ok(())
     }
 
-    fn print_key_value(&self, guests: Vec<Guest>) -> Result<()> {
-        for guest in guests {
-            let kvs = proto2kv(guest)?;
+    fn print_key_value(&self, zones: Vec<Zone>) -> Result<()> {
+        for zone in zones {
+            let kvs = proto2kv(zone)?;
             println!("{}", kv2line(kvs),);
         }
         Ok(())