commands/status: handle output for shared resources

Author: bertschinger

src/commands/status.rs

@@ -1,9 +1,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright 2025. Triad National Security, LLC.
 
+use std::collections::{HashMap, HashSet};
+
 use clap::Args;
 
-use crate::{commands::*, manager::http, Handle, HandledResult};
+use crate::{
+    commands::*,
+    manager::http::{ClusterJson, EventJson, ResourceJson},
+    Handle, HandledResult,
+};
 
 #[derive(Args, Debug, Clone)]
 pub struct StatusArgs {
@@ -16,43 +22,154 @@ pub struct StatusArgs {
     event_count: usize,
 }
 
+/// A representation of a Resource for the topological ordering. The depth is tracked in order to
+/// indent resource groups according to their tree structure.
+#[derive(Debug)]
+struct ResourceNode {
+    id: String,
+    depth: usize,
+}
+
+/// Returns a list of ResourceNodes in a topologically sorted order with the following properties:
+///
+///   - Resource group roots appear in lexicographic order.
+///
+///   - Child resources appear after their parent resources, but with no intervening resources from
+///     another group.
+fn sorted_resource_list(
+    cluster: &ClusterJson,
+    map: &HashMap<String, ResourceJson>,
+) -> Vec<ResourceNode> {
+    /// Returns a list of the resource roots, in reverse sorted order. Reversed because the full
+    /// topographical sorted list is built up backwards, and then reversed at the end to create
+    /// the final list.
+    fn get_roots(cluster: &ClusterJson) -> Vec<&ResourceJson> {
+        let mut non_roots: HashSet<String> = HashSet::new();
+
+        for res in &cluster.resources {
+            for child in &res.dependents {
+                non_roots.insert(child.clone());
+            }
+        }
+
+        let mut roots: Vec<&ResourceJson> = cluster
+            .resources
+            .iter()
+            .filter(|res| !non_roots.contains(&res.id))
+            .collect();
+
+        roots.sort_by(|a, b| b.id.cmp(&a.id));
+
+        roots
+    }
+
+    /// Visit a node in the DAG, in a depth-first search, building up the topographical order in
+    /// the parameter `list` as we go.
+    fn visit(
+        node: &ResourceJson,
+        visited: &mut HashSet<String>,
+        list: &mut Vec<ResourceNode>,
+        map: &HashMap<String, ResourceJson>,
+        depth: usize,
+    ) {
+        if visited.contains(&node.id) {
+            return;
+        }
+
+        for child in &node.dependents {
+            let child = map.get(child).unwrap();
+            // We trust that the data sent to us by the manager is legit, i.e., it doesn't contain
+            // cycles. So there is no risk of an infinite loop here.
+            visit(child, visited, list, map, depth + 1);
+        }
+
+        visited.insert(node.id.clone());
+
+        // This pushes the parent resource onto the list *after* its children...
+        list.push(ResourceNode {
+            id: node.id.clone(),
+            depth,
+        });
+    }
+
+    let mut visited: HashSet<String> = HashSet::new();
+    let mut list: Vec<ResourceNode> = Vec::new();
+
+    for node in get_roots(cluster) {
+        visit(node, &mut visited, &mut list, map, 0);
+    }
+
+    // ...the list was built up in backwards order. Need to reverse it.
+    list.into_iter().rev().collect()
+}
+
+fn status_and_comment(res: &ResourceJson) -> (String, Option<String>) {
+    if !res.exclusive {
+        return res.shared_host_status();
+    }
+
+    let (status, maybe_comment) = res.single_host_status();
+
+    let location = match status {
+        "Running" => format!(" on {}", res.home_host),
+        "Running (Failed Over)" => format!(
+            " on {}",
+            res.failover_host
+                .as_ref()
+                .expect("Failover host must be set here.")
+        ),
+        _ => "".to_owned(),
+    };
+
+    let status = format!("{}{}", status, location);
+
+    (status, maybe_comment)
+}
+
+/// Get the resource parameters as a string.
+fn parameters(res: &ResourceJson) -> String {
+    let mut s = " [".to_owned();
+
+    let mut first_one = true;
+    let mut params: Vec<_> = res.parameters.iter().collect();
+    params.sort();
+    for (key, value) in params {
+        if first_one {
+            first_one = false;
+        } else {
+            s += "; ";
+        }
+        s += &format!("{key}: {value}");
+    }
+    s += "]";
+
+    s
+}
+
 pub fn status(cli: &Cli, args: &StatusArgs) -> HandledResult<()> {
     let cluster = get_status(cli.socket.as_deref())?;
 
-    for res in cluster.resources {
+    let resource_map: HashMap<String, ResourceJson> = cluster
+        .resources
+        .iter()
+        .map(|r| (r.id.clone(), r.clone()))
+        .collect();
+
+    for ResourceNode { id, depth } in sorted_resource_list(&cluster, &resource_map) {
+        let res = resource_map.get(&id).unwrap();
+
         if args.exclude_normal && res.single_host_status().0 == "Running" {
             continue;
         }
 
-        print!("{:<20}\t", res.id);
+        print!("{:<20}\t", " ".repeat(depth) + &res.id);
         print!("({})\t", res.kind);
 
-        let (status, maybe_comment) = res.single_host_status();
-
-        print!("{}", status);
-        match status {
-            "Running" => print!(" on {}", res.home_host),
-            "Running (Failed Over)" => print!(
-                " on {}",
-                res.failover_host.expect("Failover host must be set here.")
-            ),
-            _ => {}
-        };
+        let (status, maybe_comment) = status_and_comment(res);
+        print!("{status}");
 
         if cli.verbose {
-            print!(" [");
-            let mut first_one = true;
-            let mut params: Vec<_> = res.parameters.iter().collect();
-            params.sort();
-            for (key, value) in params {
-                if first_one {
-                    first_one = false;
-                } else {
-                    print!("; ");
-                }
-                print!("{key}: {value}");
-            }
-            print!("]");
+            print!("{}", parameters(res));
         }
 
         if let Some(comment) = maybe_comment {
@@ -133,7 +250,7 @@ pub fn status(cli: &Cli, args: &StatusArgs) -> HandledResult<()> {
     Ok(())
 }
 
-fn tail(events: &[http::EventJson], n: usize) -> &[http::EventJson] {
+fn tail(events: &[EventJson], n: usize) -> &[EventJson] {
     for i in 0..events.len() {
         // Start checking from the end of the events list (newest event checked first):
         let ind = events.len() - i - 1;
@@ -153,7 +270,7 @@ fn tail(events: &[http::EventJson], n: usize) -> &[http::EventJson] {
     events
 }
 
-pub fn get_status(socket: Option<&str>) -> HandledResult<http::ClusterJson> {
+pub fn get_status(socket: Option<&str>) -> HandledResult<ClusterJson> {
     let client = get_http_client(socket)?;
 
     let response = client

src/manager/http.rs

@@ -82,7 +82,7 @@ pub struct ClusterJson {
 
 /// The representation of Resource state that is communicated back to the admin using the status
 /// command.
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct ResourceJson {
     pub id: String,
     pub kind: String,
@@ -181,9 +181,42 @@ impl ResourceJson {
 
         ("Unexpected", None)
     }
+
+    pub fn shared_host_status(&self) -> (String, Option<String>) {
+        let running_on_hosts: Vec<_> = self
+            .status
+            .iter()
+            .filter(|(_, st)| st.status == "Running")
+            .map(|(host, _)| host)
+            .collect();
+
+        if !running_on_hosts.is_empty() {
+            let mut hosts = "".to_owned();
+            for host in running_on_hosts {
+                hosts += &format!("{host},");
+            }
+            let hosts: nodeset::NodeSet = hosts.parse().expect("unable to parse nodeset.");
+
+            return (format!("Running on {hosts}"), None);
+        }
+
+        if self.is_stopped_everywhere() {
+            return ("Stopped".to_owned(), None);
+        }
+
+        for status in ["Error", "Unknown"] {
+            match self.has_status(status) {
+                StatusWhere::Home(comment) => return (status.to_owned(), comment),
+                StatusWhere::Failover(comment) => return (status.to_owned(), comment),
+                _ => {}
+            }
+        }
+
+        ("Unexpected".to_owned(), None)
+    }
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct StatusJson {
     pub status: String,
     pub comment: Option<String>,