[wicket] Add sled+switch location to status bar (#3810)

I don't think `Location:` is the right label for this - open to
suggestions. Maybe "Connected to:"? Example from madrid:


![wicket-statusbar](https://github.com/oxidecomputer/omicron/assets/1435635/deb20f98-e1b2-4526-ab6f-d66bf34e2427)

Fixes #3777

Author: jgallagher

openapi/wicketd.json

@@ -260,6 +260,31 @@
         }
       }
     },
+    "/location": {
+      "get": {
+        "summary": "Report the identity of the sled and switch we're currently running on /",
+        "description": "connected to.",
+        "operationId": "get_location",
+        "responses": {
+          "200": {
+            "description": "successful operation",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/GetLocationResponse"
+                }
+              }
+            }
+          },
+          "4XX": {
+            "$ref": "#/components/responses/Error"
+          },
+          "5XX": {
+            "$ref": "#/components/responses/Error"
+          }
+        }
+      }
+    },
     "/rack-setup": {
       "get": {
         "summary": "Query current state of rack setup.",
@@ -1147,6 +1172,48 @@
           }
         ]
       },
+      "GetLocationResponse": {
+        "description": "All the fields of this response are optional, because it's possible we don't know any of them (yet) if MGS has not yet finished discovering its location or (ever) if we're running in a dev environment that doesn't support MGS-location / baseboard mapping.",
+        "type": "object",
+        "properties": {
+          "sled_baseboard": {
+            "nullable": true,
+            "description": "The baseboard of our sled (where wicketd is running).",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/Baseboard"
+              }
+            ]
+          },
+          "sled_id": {
+            "nullable": true,
+            "description": "The identity of our sled (where wicketd is running).",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/SpIdentifier"
+              }
+            ]
+          },
+          "switch_baseboard": {
+            "nullable": true,
+            "description": "The baseboard of the switch our sled is physically connected to.",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/Baseboard"
+              }
+            ]
+          },
+          "switch_id": {
+            "nullable": true,
+            "description": "The identity of the switch our sled is physically connected to.",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/SpIdentifier"
+              }
+            ]
+          }
+        }
+      },
       "IpRange": {
         "oneOf": [
           {

wicket/src/events.rs

@@ -10,8 +10,8 @@ use std::fs::File;
 use std::time::{Duration, SystemTime};
 use wicket_common::update_events::EventReport;
 use wicketd_client::types::{
-    ArtifactId, CurrentRssUserConfig, IgnitionCommand, RackOperationStatus,
-    RackV1Inventory, SemverVersion,
+    ArtifactId, CurrentRssUserConfig, GetLocationResponse, IgnitionCommand,
+    RackOperationStatus, RackV1Inventory, SemverVersion,
 };
 
 /// Event report type returned by the get_artifacts_and_event_reports API call.
@@ -41,6 +41,9 @@ pub enum Event {
     /// The current state of rack initialization.
     RackSetupStatus(Result<RackOperationStatus, String>),
 
+    /// The location within the rack where wicketd is running.
+    WicketdLocation(GetLocationResponse),
+
     /// The tick of a Timer
     /// This can be used to draw a frame to the terminal
     Tick,

wicket/src/runner.rs

@@ -156,6 +156,10 @@ impl RunnerCore {
                 self.state.rack_setup_state = result;
                 self.screen.draw(&self.state, &mut self.terminal)?;
             }
+            Event::WicketdLocation(location) => {
+                self.state.wicketd_location = location;
+                self.screen.draw(&self.state, &mut self.terminal)?;
+            }
             Event::Shutdown => return Ok(true),
         }
         Ok(false)

wicket/src/state/mod.rs

@@ -23,7 +23,9 @@ pub use update::{
 };
 
 use serde::{Deserialize, Serialize};
-use wicketd_client::types::{CurrentRssUserConfig, RackOperationStatus};
+use wicketd_client::types::{
+    CurrentRssUserConfig, GetLocationResponse, RackOperationStatus,
+};
 
 /// The global state of wicket
 ///
@@ -40,6 +42,7 @@ pub struct State {
     pub force_update_state: ForceUpdateState,
     pub rss_config: Option<CurrentRssUserConfig>,
     pub rack_setup_state: Result<RackOperationStatus, String>,
+    pub wicketd_location: GetLocationResponse,
 }
 
 impl State {
@@ -54,6 +57,12 @@ impl State {
             force_update_state: ForceUpdateState::default(),
             rss_config: None,
             rack_setup_state: Err("status not yet polled from wicketd".into()),
+            wicketd_location: GetLocationResponse {
+                sled_baseboard: None,
+                sled_id: None,
+                switch_baseboard: None,
+                switch_id: None,
+            },
         }
     }
 }

wicket/src/ui/main.rs

@@ -14,6 +14,7 @@ use tui::layout::{Alignment, Constraint, Direction, Layout, Rect};
 use tui::style::{Modifier, Style};
 use tui::text::{Span, Spans};
 use tui::widgets::{Block, BorderType, Borders, List, ListItem, Paragraph};
+use wicketd_client::types::GetLocationResponse;
 
 /// The [`MainScreen`] is the primary UI element of the terminal, covers the
 /// entire terminal window/buffer and is visible for all interactions except
@@ -192,9 +193,13 @@ impl MainScreen {
         frame: &mut Frame<'_>,
         rect: Rect,
     ) {
+        let location_spans = location_spans(&state.wicketd_location);
         let wicketd_spans = state.service_status.wicketd_liveness().to_spans();
         let mgs_spans = state.service_status.mgs_liveness().to_spans();
-        let mut spans = vec![Span::styled("WICKETD: ", style::service())];
+        let mut spans = vec![Span::styled("You are here: ", style::service())];
+        spans.extend_from_slice(&location_spans);
+        spans.push(Span::styled(" | ", style::divider()));
+        spans.push(Span::styled("WICKETD: ", style::service()));
         spans.extend_from_slice(&wicketd_spans);
         spans.push(Span::styled(" | ", style::divider()));
         spans.push(Span::styled("MGS: ", style::service()));
@@ -220,6 +225,41 @@ impl MainScreen {
     }
 }
 
+fn location_spans(location: &GetLocationResponse) -> Vec<Span<'static>> {
+    // We reuse `style::connected()` and `style::delayed()` in these spans to
+    // match the wicketd/mgs connection statuses that follow us in the status
+    // bar.
+    let mut spans = Vec::new();
+    if let Some(id) = location.sled_id.as_ref() {
+        spans.push(Span::styled(
+            format!("Sled {}", id.slot),
+            style::connected(),
+        ));
+    } else if let Some(baseboard) = location.sled_baseboard.as_ref() {
+        spans.push(Span::styled(
+            format!("Sled {}", baseboard.identifier()),
+            style::connected(),
+        ));
+    } else {
+        spans.push(Span::styled("Sled UNKNOWN", style::delayed()));
+    };
+    spans.push(Span::styled("/", style::divider()));
+    if let Some(id) = location.switch_id.as_ref() {
+        spans.push(Span::styled(
+            format!("Switch {}", id.slot),
+            style::connected(),
+        ));
+    } else if let Some(baseboard) = location.switch_baseboard.as_ref() {
+        spans.push(Span::styled(
+            format!("Switch {}", baseboard.identifier()),
+            style::connected(),
+        ));
+    } else {
+        spans.push(Span::styled("Switch UNKNOWN", style::delayed()));
+    };
+    spans
+}
+
 /// The mechanism for selecting panes
 pub struct Sidebar {
     panes: StatefulList<&'static str>,

wicket/src/wicketd.rs

@@ -11,8 +11,8 @@ use tokio::sync::mpsc::{self, Sender, UnboundedSender};
 use tokio::time::{interval, Duration, MissedTickBehavior};
 use wicketd_client::types::{
     AbortUpdateOptions, ClearUpdateStateOptions, GetInventoryParams,
-    GetInventoryResponse, IgnitionCommand, SpIdentifier, SpType,
-    StartUpdateOptions,
+    GetInventoryResponse, GetLocationResponse, IgnitionCommand, SpIdentifier,
+    SpType, StartUpdateOptions,
 };
 
 use crate::events::EventReportMap;
@@ -114,6 +114,7 @@ impl WicketdManager {
         self.poll_artifacts_and_event_reports();
         self.poll_rack_setup_config();
         self.poll_rack_setup_status();
+        self.poll_location();
 
         loop {
             tokio::select! {
@@ -342,6 +343,61 @@ impl WicketdManager {
         });
     }
 
+    fn poll_location(&self) {
+        let log = self.log.clone();
+        let tx = self.events_tx.clone();
+        let addr = self.wicketd_addr;
+        tokio::spawn(async move {
+            let client = create_wicketd_client(&log, addr, WICKETD_TIMEOUT);
+            let mut ticker = interval(WICKETD_POLL_INTERVAL * 2);
+            let mut prev = None;
+            ticker.set_missed_tick_behavior(MissedTickBehavior::Delay);
+            loop {
+                ticker.tick().await;
+                // TODO: We should really be using ETAGs here
+                let location = match client.get_location().await {
+                    Ok(val) => val.into_inner(),
+                    Err(err) => {
+                        warn!(
+                            log,
+                            "Failed to fetch location of wicketd";
+                            "err" => #%err,
+                        );
+                        continue;
+                    }
+                };
+
+                // Only send a new event if the config has changed
+                if Some(&location) == prev.as_ref() {
+                    continue;
+                }
+                prev = Some(location.clone());
+
+                // If every field of `location` is filled in, we don't need to
+                // poll any more - wicketd can't move around while it's running.
+                // Check this prior to sending the event to avoid an extra
+                // clone.
+                let GetLocationResponse {
+                    sled_baseboard,
+                    sled_id,
+                    switch_baseboard,
+                    switch_id,
+                } = &location;
+
+                let location_fully_provided = sled_baseboard.is_some()
+                    && sled_id.is_some()
+                    && switch_baseboard.is_some()
+                    && switch_id.is_some();
+
+                let _ = tx.send(Event::WicketdLocation(location));
+
+                if location_fully_provided {
+                    break;
+                }
+            }
+        });
+    }
+
     fn poll_rack_setup_config(&self) {
         let log = self.log.clone();
         let tx = self.events_tx.clone();

wicketd-client/src/lib.rs

@@ -47,6 +47,7 @@ progenitor::generate_api!(
         CurrentRssUserConfigInsensitive = { derives = [ PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize ] },
         CurrentRssUserConfigSensitive = { derives = [ PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize ] },
         CurrentRssUserConfig = { derives = [ PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize ] },
+        GetLocationResponse = { derives = [ PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize ] },
     },
     replace = {
         Duration = std::time::Duration,
@@ -65,3 +66,29 @@ progenitor::generate_api!(
 
 /// A type alias for errors returned by this crate.
 pub type ClientError = crate::Error<crate::types::Error>;
+
+impl types::Baseboard {
+    pub fn identifier(&self) -> &str {
+        match &self {
+            Self::Gimlet { identifier, .. } => &identifier,
+            Self::Pc { identifier, .. } => &identifier,
+            Self::Unknown => "unknown",
+        }
+    }
+
+    pub fn model(&self) -> &str {
+        match self {
+            Self::Gimlet { model, .. } => &model,
+            Self::Pc { model, .. } => &model,
+            Self::Unknown => "unknown",
+        }
+    }
+
+    pub fn revision(&self) -> i64 {
+        match self {
+            Self::Gimlet { revision, .. } => *revision,
+            Self::Pc { .. } => 0,
+            Self::Unknown => 0,
+        }
+    }
+}

wicketd/src/context.rs

@@ -11,18 +11,25 @@ use crate::MgsHandle;
 use anyhow::anyhow;
 use anyhow::bail;
 use anyhow::Result;
+use gateway_client::types::SpIdentifier;
 use sled_hardware::Baseboard;
 use slog::info;
 use std::net::Ipv6Addr;
 use std::net::SocketAddrV6;
 use std::sync::Arc;
 use std::sync::Mutex;
+use std::sync::OnceLock;
 
 /// Shared state used by API handlers
 pub struct ServerContext {
     pub mgs_handle: MgsHandle,
     pub mgs_client: gateway_client::Client,
     pub(crate) log: slog::Logger,
+    /// Our cached copy of what MGS's `/local/switch-id` endpoint returns; it
+    /// identifies whether we're connected to switch 0 or 1 and cannot change
+    /// (plugging us into a different switch would require powering off our sled
+    /// and physically moving it).
+    pub(crate) local_switch_id: OnceLock<SpIdentifier>,
     pub(crate) bootstrap_peers: BootstrapPeers,
     pub(crate) update_tracker: Arc<UpdateTracker>,
     pub(crate) baseboard: Option<Baseboard>,
@@ -66,4 +73,35 @@ impl ServerContext {
             Ok(ip)
         }
     }
+
+    pub(crate) async fn local_switch_id(&self) -> Option<SpIdentifier> {
+        // Do we already have it cached from a previous invocation?
+        if let Some(&switch_id) = self.local_switch_id.get() {
+            return Some(switch_id);
+        }
+
+        // We don't have a cached switch ID; try to fetch it from MGS. We
+        // might be racing ourself (if this function is being called multiple
+        // times concurrently), but that's fine: all invocations can query MGS,
+        // and only one will succeed in setting the cache.
+        match self.mgs_client.sp_local_switch_id().await {
+            Ok(response) => {
+                let switch_id = response.into_inner();
+
+                // Ignore failures on set - that just means we lost the race and
+                // another concurrent call to us already set it.
+                _ = self.local_switch_id.set(switch_id);
+
+                Some(switch_id)
+            }
+            Err(err) => {
+                slog::warn!(
+                    self.log,
+                    "Failed to fetch local switch ID from MGS";
+                    "err" => #%err,
+                );
+                None
+            }
+        }
+    }
 }