[omdb] TUI for inspecting support bundles (#8034)

Adds the `omdb nexus sb inspect` command, which includes a dashboard
that can be used inspect support bundles.

- `dev-tools/omdb/src/bin/omdb/nexus.rs` includes the integration of
this command. Support bundles may be accessed by: UUID, path, or by
"most recently created".
- `dev-tools/support-bundle-reader-lib` exposes a dashboard for actually
running a TUI. This TUI acts on a dynamic `SupportBundleAccessor` trait,
which can implement a file-opening and file-reader interface, regardless
of where the support bundle is stored.
- `dev-tools/support-bundle-reader-lib/src/dashboard.rs` actually
implements the ratatui interface, which allows users to inspect parts of
the support bundle, and optionally dump the contents of the bundles to
stdout.


![image](https://github.com/user-attachments/assets/9b6e7df6-3123-497c-bc81-0e33b747bf5f)

Author: smklein

Cargo.lock

@@ -49,6 +49,7 @@ members = [
     "dev-tools/releng",
     "dev-tools/repl-utils",
     "dev-tools/repo-depot-standalone",
+    "dev-tools/support-bundle-reader-lib",
     "dev-tools/xtask",
     "dns-server",
     "dns-server-api",
@@ -200,6 +201,7 @@ default-members = [
     "dev-tools/releng",
     "dev-tools/repl-utils",
     "dev-tools/repo-depot-standalone",
+    "dev-tools/support-bundle-reader-lib",
     # Do not include xtask in the list of default members, because this causes
     # hakari to not work as well and build times to be longer.
     # See omicron#4392.
@@ -695,6 +697,7 @@ strum = { version = "0.26", features = [ "derive" ] }
 subprocess = "0.2.9"
 subtle = "2.6.1"
 supports-color = "3.0.2"
+support-bundle-reader-lib = { path = "dev-tools/support-bundle-reader-lib" }
 swrite = "0.1.0"
 sync-ptr = "0.1.1"
 libsw = { version = "3.4.0", features = ["tokio"] }

Cargo.toml

@@ -59,6 +59,7 @@ slog.workspace = true
 slog-error-chain.workspace = true
 steno.workspace = true
 strum.workspace = true
+support-bundle-reader-lib.workspace = true
 supports-color.workspace = true
 tabled.workspace = true
 textwrap.workspace = true

dev-tools/omdb/Cargo.toml

@@ -501,6 +501,8 @@ enum SupportBundleCommands {
     GetIndex(SupportBundleIndexArgs),
     /// View a file within a support bundle
     GetFile(SupportBundleFileArgs),
+    /// Creates a dashboard for viewing the contents of a support bundle
+    Inspect(SupportBundleInspectArgs),
 }
 
 #[derive(Debug, Args)]
@@ -523,6 +525,23 @@ struct SupportBundleFileArgs {
     output: Option<Utf8PathBuf>,
 }
 
+#[derive(Debug, Args)]
+struct SupportBundleInspectArgs {
+    /// A specific bundle to inspect.
+    ///
+    /// If none is supplied, the latest active bundle is used.
+    /// Mutually exclusive with "path".
+    #[arg(short, long)]
+    id: Option<SupportBundleUuid>,
+
+    /// A local bundle file to inspect.
+    ///
+    /// If none is supplied, the latest active bundle is used.
+    /// Mutually exclusive with "id".
+    #[arg(short, long)]
+    path: Option<Utf8PathBuf>,
+}
+
 impl NexusArgs {
     /// Run a `omdb nexus` subcommand.
     pub(crate) async fn run_cmd(
@@ -737,6 +756,9 @@ impl NexusArgs {
             NexusCommands::SupportBundles(SupportBundleArgs {
                 command: SupportBundleCommands::GetFile(args),
             }) => cmd_nexus_support_bundles_get_file(&client, args).await,
+            NexusCommands::SupportBundles(SupportBundleArgs {
+                command: SupportBundleCommands::Inspect(args),
+            }) => cmd_nexus_support_bundles_inspect(&client, args).await,
         }
     }
 }
@@ -3880,3 +3902,16 @@ async fn cmd_nexus_support_bundles_get_file(
     })?;
     Ok(())
 }
+
+/// Runs `omdb nexus support-bundles inspect`
+async fn cmd_nexus_support_bundles_inspect(
+    client: &nexus_client::Client,
+    args: &SupportBundleInspectArgs,
+) -> Result<(), anyhow::Error> {
+    support_bundle_reader_lib::run_dashboard(
+        client,
+        args.id,
+        args.path.as_ref(),
+    )
+    .await
+}

dev-tools/omdb/src/bin/omdb/nexus.rs

@@ -0,0 +1,23 @@
+[package]
+name = "support-bundle-reader-lib"
+version = "0.1.0"
+edition = "2021"
+license = "MPL-2.0"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow.workspace = true
+async-trait.workspace = true
+bytes.workspace = true
+camino.workspace = true
+crossterm.workspace = true
+futures.workspace = true
+nexus-client.workspace = true
+omicron-workspace-hack.workspace = true
+omicron-uuid-kinds.workspace = true
+ratatui.workspace = true
+reqwest.workspace = true
+tokio.workspace = true
+zip.workspace = true

dev-tools/support-bundle-reader-lib/Cargo.toml

@@ -0,0 +1,243 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+//! APIs to help access bundles
+
+use crate::index::SupportBundleIndex;
+use anyhow::Context as _;
+use anyhow::Result;
+use async_trait::async_trait;
+use bytes::Buf;
+use bytes::Bytes;
+use camino::Utf8Path;
+use camino::Utf8PathBuf;
+use futures::Stream;
+use futures::StreamExt;
+use omicron_uuid_kinds::GenericUuid;
+use omicron_uuid_kinds::SupportBundleUuid;
+use std::io;
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+use tokio::io::AsyncRead;
+use tokio::io::ReadBuf;
+
+/// An I/O source which can read to a buffer
+///
+/// This describes access to individual files within the bundle.
+pub trait FileAccessor: AsyncRead + Unpin {}
+impl<T: AsyncRead + Unpin + ?Sized> FileAccessor for T {}
+
+pub type BoxedFileAccessor<'a> = Box<dyn FileAccessor + 'a>;
+
+/// Describes how the support bundle's data and metadata are accessed.
+#[async_trait]
+pub trait SupportBundleAccessor {
+    /// Access the index of a support bundle
+    async fn get_index(&self) -> Result<SupportBundleIndex>;
+
+    /// Access a file within the support bundle
+    async fn get_file<'a>(
+        &mut self,
+        path: &Utf8Path,
+    ) -> Result<BoxedFileAccessor<'a>>
+    where
+        Self: 'a;
+}
+
+pub struct StreamedFile<'a> {
+    client: &'a nexus_client::Client,
+    id: SupportBundleUuid,
+    path: Utf8PathBuf,
+    stream: Option<Pin<Box<dyn Stream<Item = reqwest::Result<Bytes>> + Send>>>,
+    buffer: Bytes,
+}
+
+impl<'a> StreamedFile<'a> {
+    fn new(
+        client: &'a nexus_client::Client,
+        id: SupportBundleUuid,
+        path: Utf8PathBuf,
+    ) -> Self {
+        Self { client, id, path, stream: None, buffer: Bytes::new() }
+    }
+
+    // NOTE: This is a distinct method from "new", because ideally some day we could
+    // use range requests to stream out portions of the file.
+    //
+    // This means that we would potentially want to restart the stream with a different position.
+    async fn start_stream(&mut self) -> Result<()> {
+        // TODO: Add range headers, for range requests? Though this
+        // will require adding support to Progenitor + Nexus too.
+        let stream = self
+            .client
+            .support_bundle_download_file(
+                self.id.as_untyped_uuid(),
+                self.path.as_str(),
+            )
+            .await
+            .with_context(|| {
+                format!(
+                    "downloading support bundle file {}: {}",
+                    self.id, self.path
+                )
+            })?
+            .into_inner_stream();
+
+        self.stream = Some(Box::pin(stream));
+        Ok(())
+    }
+}
+
+impl AsyncRead for StreamedFile<'_> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        while self.buffer.is_empty() {
+            match futures::ready!(
+                self.stream
+                    .as_mut()
+                    .expect("Stream must be initialized before polling")
+                    .as_mut()
+                    .poll_next(cx)
+            ) {
+                Some(Ok(bytes)) => {
+                    self.buffer = bytes;
+                }
+                Some(Err(e)) => {
+                    return Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        e,
+                    )));
+                }
+                None => return Poll::Ready(Ok(())), // EOF
+            }
+        }
+
+        let to_copy = std::cmp::min(self.buffer.len(), buf.remaining());
+        buf.put_slice(&self.buffer[..to_copy]);
+        self.buffer.advance(to_copy);
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+/// Access to a support bundle from the internal API
+pub struct InternalApiAccess<'a> {
+    client: &'a nexus_client::Client,
+    id: SupportBundleUuid,
+}
+
+impl<'a> InternalApiAccess<'a> {
+    pub fn new(
+        client: &'a nexus_client::Client,
+        id: SupportBundleUuid,
+    ) -> Self {
+        Self { client, id }
+    }
+}
+
+// Access for: The nexus internal API
+#[async_trait]
+impl<'c> SupportBundleAccessor for InternalApiAccess<'c> {
+    async fn get_index(&self) -> Result<SupportBundleIndex> {
+        let stream = self
+            .client
+            .support_bundle_index(self.id.as_untyped_uuid())
+            .await
+            .with_context(|| {
+                format!("downloading support bundle index {}", self.id)
+            })?
+            .into_inner_stream();
+        let s = utf8_stream_to_string(stream).await?;
+
+        Ok(SupportBundleIndex::new(&s))
+    }
+
+    async fn get_file<'a>(
+        &mut self,
+        path: &Utf8Path,
+    ) -> Result<BoxedFileAccessor<'a>>
+    where
+        'c: 'a,
+    {
+        let mut file =
+            StreamedFile::new(self.client, self.id, path.to_path_buf());
+        file.start_stream()
+            .await
+            .with_context(|| "failed to start stream in get_file")?;
+        Ok(Box::new(file))
+    }
+}
+
+pub struct LocalFileAccess {
+    archive: zip::read::ZipArchive<std::fs::File>,
+}
+
+impl LocalFileAccess {
+    pub fn new(path: &Utf8Path) -> Result<Self> {
+        let file = std::fs::File::open(path)?;
+        Ok(Self { archive: zip::read::ZipArchive::new(file)? })
+    }
+}
+
+// Access for: Local zip files
+#[async_trait]
+impl SupportBundleAccessor for LocalFileAccess {
+    async fn get_index(&self) -> Result<SupportBundleIndex> {
+        let names: Vec<&str> = self.archive.file_names().collect();
+        let all_names = names.join("\n");
+        Ok(SupportBundleIndex::new(&all_names))
+    }
+
+    async fn get_file<'a>(
+        &mut self,
+        path: &Utf8Path,
+    ) -> Result<BoxedFileAccessor<'a>> {
+        let mut file = self.archive.by_name(path.as_str())?;
+        let mut buf = Vec::new();
+        std::io::copy(&mut file, &mut buf)?;
+
+        Ok(Box::new(AsyncZipFile { buf, copied: 0 }))
+    }
+}
+
+// We're currently buffering the entire file into memory, mostly because dealing with the lifetime
+// of ZipArchive and ZipFile objects is so difficult.
+pub struct AsyncZipFile {
+    buf: Vec<u8>,
+    copied: usize,
+}
+
+impl AsyncRead for AsyncZipFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let to_copy =
+            std::cmp::min(self.buf.len() - self.copied, buf.remaining());
+        if to_copy == 0 {
+            return Poll::Ready(Ok(()));
+        }
+        let src = &self.buf[self.copied..];
+        buf.put_slice(&src[..to_copy]);
+        self.copied += to_copy;
+        Poll::Ready(Ok(()))
+    }
+}
+
+async fn utf8_stream_to_string(
+    mut stream: impl futures::Stream<Item = reqwest::Result<bytes::Bytes>>
+    + std::marker::Unpin,
+) -> Result<String> {
+    let mut bytes = Vec::new();
+    while let Some(chunk) = stream.next().await {
+        let chunk = chunk?;
+        bytes.extend_from_slice(&chunk);
+    }
+    Ok(String::from_utf8(bytes)?)
+}