Show zone server addrs

crates/api/src/lib.rs

@@ -452,13 +452,13 @@ pub struct ZoneStatus {
     pub receipt_report: Option<ZoneLoaderReport>,
     pub unsigned_serial: Option<Serial>,
     pub unsigned_review_status: Option<TimestampedZoneReviewStatus>,
-    pub unsigned_review_addr: Option<SocketAddr>,
+    pub unsigned_review_addr: Vec<SocketAddr>,
     pub signed_serial: Option<Serial>,
     pub signed_review_status: Option<TimestampedZoneReviewStatus>,
-    pub signed_review_addr: Option<SocketAddr>,
+    pub signed_review_addr: Vec<SocketAddr>,
     pub signing_report: Option<SigningReport>,
     pub published_serial: Option<Serial>,
-    pub publish_addr: SocketAddr,
+    pub publish_addr: Vec<SocketAddr>,
     pub halted_reason: Option<String>,
 }
 
@@ -762,6 +762,9 @@ impl fmt::Display for ZoneReloadError {
 pub struct ServerStatusResult {
     pub halted_zones: Vec<(ZoneName, String)>,
     pub signing_queue: Vec<SigningQueueReport>,
+    pub loaded_review_addrs: Vec<SocketAddr>,
+    pub signed_review_addrs: Vec<SocketAddr>,
+    pub server_addrs: Vec<SocketAddr>,
 }
 
 #[derive(Deserialize, Serialize, Debug, Clone)]

crates/cli/src/commands/status.rs

@@ -1,7 +1,9 @@
+use std::net::SocketAddr;
+
 use crate::ansi;
 use crate::api::{KeyMsg, KeyStatusResult, KeysPerZone, ServerStatusResult, SigningStageReport};
 use crate::client::CascadeApiClient;
-use crate::{eprintln, println};
+use crate::println;
 
 #[derive(Clone, Debug, clap::Args)]
 pub struct Status {
@@ -59,12 +61,32 @@ impl Status {
             None => {
                 let response: ServerStatusResult = client.get_json("/status").await?;
 
+                let print_addrs = |addrs: &[SocketAddr]| {
+                    if addrs.is_empty() {
+                        println!(" <none>");
+                    } else {
+                        println!();
+                    }
+                    for addr in addrs {
+                        println!("    - {addr}");
+                    }
+                };
+
+                println!("Serving zones at the following addresses:");
+                print!("  Loaded review:");
+                print_addrs(&response.loaded_review_addrs);
+                print!("  Signed review: ");
+                print_addrs(&response.signed_review_addrs);
+                print!("  Server: ");
+                print_addrs(&response.server_addrs);
+                println!();
+
                 if !response.halted_zones.is_empty() {
-                    eprintln!("The following zones are halted:");
+                    println!("The following zones are halted:");
                     for (zone_name, err) in response.halted_zones {
-                        eprintln!("   {}\u{78}{} {zone_name}: {err}", ansi::RED, ansi::RESET);
+                        println!("   {}\u{78}{} {zone_name}: {err}", ansi::RED, ansi::RESET);
                     }
-                    eprintln!();
+                    println!();
                 }
 
                 println!("Signing queue:");

crates/cli/src/commands/zone.rs

@@ -644,7 +644,10 @@ impl Zone {
 
         if zone.last_published.is_some() {
             println!("");
-            println!("Published zone available at {}", zone.publish_addr);
+            println!("Published zone available at:");
+            for addr in zone.publish_addr {
+                println!("  - {addr}")
+            }
         }
 
         if let Some(error) = zone.error {
@@ -719,14 +722,26 @@ pub fn print_status(current: Progress, zone: &ZoneStatus, policy: &PolicyInfo) {
     }
 
     print_load_phase(current, zone.unsigned_serial, &zone.receipt_report);
-    print_loaded_review_phase(&zone.name, zone.unsigned_serial, policy, current);
+    print_loaded_review_phase(
+        &zone.name,
+        zone.unsigned_serial,
+        policy,
+        current,
+        &zone.unsigned_review_addr,
+    );
     print_sign_phase(
         current,
         zone.unsigned_serial,
         zone.signed_serial,
         &zone.signing_report,
     );
-    print_signed_review_phase(&zone.name, zone.signed_serial, policy, current);
+    print_signed_review_phase(
+        &zone.name,
+        zone.signed_serial,
+        policy,
+        current,
+        &zone.signed_review_addr,
+    );
     print_publish_phase();
 }
 
@@ -787,6 +802,7 @@ fn print_loaded_review_phase(
     serial: Option<Serial>,
     policy: &PolicyInfo,
     current: Progress,
+    addrs: &[SocketAddr],
 ) {
     use ansi::{BLUE, DIM, RED, RESET, YELLOW};
 
@@ -807,6 +823,14 @@ fn print_loaded_review_phase(
             let serial = serial.map_or_else(|| "<SERIAL>".into(), |s| s.to_string());
             println!("  {Stopped} review loaded zone");
             println!("  |   {YELLOW}zone must be reviewed manually{RESET}");
+            if addrs.is_empty() {
+                println!("  |   {RED}no loaded review addresses were specified{RESET}");
+            } else {
+                println!("  |   loaded zone is available at:");
+                for addr in addrs {
+                    println!("  |     - {addr}");
+                }
+            }
             println!("  |   possible actions:");
             println!("  |     {BLUE}cascade zone approve --unsigned {zone} {serial}{RESET}");
             println!("  |     {BLUE}cascade zone reject --unsigned {zone} {serial}{RESET}");
@@ -866,6 +890,7 @@ fn print_signed_review_phase(
     signed_serial: Option<Serial>,
     policy: &PolicyInfo,
     current: Progress,
+    addrs: &[SocketAddr],
 ) {
     use ansi::{BLUE, DIM, RED, RESET, YELLOW};
 
@@ -885,6 +910,14 @@ fn print_signed_review_phase(
             let serial = signed_serial.map_or_else(|| "<SERIAL>".into(), |s| s.to_string());
             println!("  {Stopped} review signed zone");
             println!("  |   {YELLOW}zone must be reviewed manually{RESET}");
+            if addrs.is_empty() {
+                println!("  |   {RED}no signed review addresses were specified{RESET}");
+            } else {
+                println!("  |   signed zone is available at:");
+                for addr in addrs {
+                    println!("  |     - {addr}");
+                }
+            }
             println!("  |   possible actions:");
             println!("  |     {BLUE}cascade zone approve --signed {zone} {serial}{RESET}");
             println!("  |     {BLUE}cascade zone reject --signed {zone} {serial}{RESET}");

src/units/http_server.rs

@@ -229,9 +229,17 @@ impl HttpServer {
         // Fetch the signing queue.
         let signing_queue = center.signer.on_queue_report(center);
 
+        let f = |x: &Vec<cascade_cfg::SocketConfig>| x.iter().map(|s| s.addr()).collect::<Vec<_>>();
+        let loaded_review_addrs = f(&center.config.loader.review.servers);
+        let signed_review_addrs = f(&center.config.signer.review.servers);
+        let server_addrs = f(&center.config.server.servers);
+
         Json(ServerStatusResult {
             halted_zones,
             signing_queue,
+            loaded_review_addrs,
+            signed_review_addrs,
+            server_addrs,
         })
     }
 
@@ -404,24 +412,26 @@ impl HttpServer {
                 .loader
                 .review
                 .servers
-                .first()
-                .map(|v| v.addr());
+                .iter()
+                .map(|s| s.addr())
+                .collect();
             signed_review_addr = state
                 .center
                 .config
                 .signer
                 .review
                 .servers
-                .first()
-                .map(|v| v.addr());
+                .iter()
+                .map(|s| s.addr())
+                .collect();
             publish_addr = state
                 .center
                 .config
                 .server
                 .servers
-                .first()
-                .expect("Server must have a publish address")
-                .addr();
+                .iter()
+                .map(|s| s.addr())
+                .collect();
 
             unsigned_review_status = zone_state
                 .find_last_event(HistoricalEventType::UnsignedZoneReview, None)