support-bundle: expose fm_case_id in internal API and omdb (#10245)

Create an `internal_api::views::SupportBundleInfo`, which wraps the
existing external version and adds `fm_case_id`, so we can show the case
ID in `omdb nexus support-bundles list` output.

Author: mergeconflict

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

@@ -5006,19 +5006,24 @@ async fn cmd_nexus_support_bundles_list(
     struct SupportBundleInfo {
         id: Uuid,
         time_created: DateTime<Utc>,
+        state: String,
+        fm_case_id: String,
         reason_for_creation: String,
         reason_for_failure: String,
-        state: String,
         user_comment: String,
     }
     let rows = support_bundles.into_iter().map(|sb| SupportBundleInfo {
         id: sb.id,
         time_created: sb.time_created,
+        state: format!("{:?}", sb.state),
+        fm_case_id: sb
+            .fm_case_id
+            .map(|id| id.to_string())
+            .unwrap_or_else(|| "-".to_string()),
         reason_for_creation: sb.reason_for_creation,
         reason_for_failure: sb
             .reason_for_failure
             .unwrap_or_else(|| "-".to_string()),
-        state: format!("{:?}", sb.state),
         user_comment: sb.user_comment.unwrap_or_else(|| "-".to_string()),
     });
     let table = tabled::Table::new(rows)

nexus/db-model/src/support_bundle.rs

@@ -14,6 +14,7 @@ use nexus_db_schema::schema::{
 use chrono::{DateTime, Utc};
 use nexus_types::external_api::support_bundle as support_bundle_types;
 use nexus_types::fm::ereport::{EreportFilters, EreportFiltersParams};
+use nexus_types::internal_api::views as internal_views;
 use nexus_types::support_bundle::BundleData;
 use nexus_types::support_bundle::SledSelection;
 use omicron_uuid_kinds::CaseKind;
@@ -152,6 +153,14 @@ impl From<SupportBundle> for support_bundle_types::SupportBundleInfo {
     }
 }
 
+impl From<SupportBundle> for internal_views::SupportBundleInfo {
+    fn from(bundle: SupportBundle) -> Self {
+        let fm_case_id = bundle.fm_case_id.map(Into::into);
+        let base: support_bundle_types::SupportBundleInfo = bundle.into();
+        Self { base, fm_case_id }
+    }
+}
+
 // --- Data selection tables owned by support_bundle ---
 
 /// Flags table row — tracks which payload-less data categories are selected.

nexus/lockstep-api/src/lib.rs

@@ -38,6 +38,7 @@ use nexus_types::internal_api::views::DemoSaga;
 use nexus_types::internal_api::views::MgsUpdateDriverStatus;
 use nexus_types::internal_api::views::QuiesceStatus;
 use nexus_types::internal_api::views::Saga;
+use nexus_types::internal_api::views::SupportBundleInfo;
 use nexus_types::internal_api::views::UpdateStatus;
 use nexus_types::trust_quorum::TrustQuorumConfig;
 use nexus_types_versions::latest::headers::RangeRequest;
@@ -385,10 +386,7 @@ pub trait NexusLockstepApi {
     async fn support_bundle_list(
         rqctx: RequestContext<Self::Context>,
         query_params: Query<PaginatedByTimeAndId>,
-    ) -> Result<
-        HttpResponseOk<ResultsPage<support_bundle::SupportBundleInfo>>,
-        HttpError,
-    >;
+    ) -> Result<HttpResponseOk<ResultsPage<SupportBundleInfo>>, HttpError>;
 
     /// View a support bundle
     #[endpoint {
@@ -398,7 +396,7 @@ pub trait NexusLockstepApi {
     async fn support_bundle_view(
         rqctx: RequestContext<Self::Context>,
         path_params: Path<support_bundle::SupportBundlePath>,
-    ) -> Result<HttpResponseOk<support_bundle::SupportBundleInfo>, HttpError>;
+    ) -> Result<HttpResponseOk<SupportBundleInfo>, HttpError>;
 
     /// Download the index of a support bundle
     #[endpoint {
@@ -463,7 +461,7 @@ pub trait NexusLockstepApi {
     async fn support_bundle_create(
         rqctx: RequestContext<Self::Context>,
         body: TypedBody<support_bundle::SupportBundleCreate>,
-    ) -> Result<HttpResponseCreated<support_bundle::SupportBundleInfo>, HttpError>;
+    ) -> Result<HttpResponseCreated<SupportBundleInfo>, HttpError>;
 
     /// Delete an existing support bundle
     ///
@@ -487,7 +485,7 @@ pub trait NexusLockstepApi {
         rqctx: RequestContext<Self::Context>,
         path_params: Path<support_bundle::SupportBundlePath>,
         body: TypedBody<support_bundle::SupportBundleUpdate>,
-    ) -> Result<HttpResponseOk<support_bundle::SupportBundleInfo>, HttpError>;
+    ) -> Result<HttpResponseOk<SupportBundleInfo>, HttpError>;
 
     /// Get the current clickhouse policy
     #[endpoint {

nexus/src/lockstep_api/http_entrypoints.rs

@@ -38,7 +38,8 @@ use nexus_types::external_api::path_params::{BlueprintPath, PhysicalDiskPath};
 use nexus_types::external_api::rack::RackMembershipConfigPathParams;
 use nexus_types::external_api::sled::{SledPolicy, SledSelector};
 use nexus_types::external_api::support_bundle::{
-    self, SupportBundleFilePath, SupportBundlePath, SupportBundleUpdate,
+    SupportBundleCreate, SupportBundleFilePath, SupportBundlePath,
+    SupportBundleUpdate,
 };
 use nexus_types::internal_api::params::InstanceMigrateRequest;
 use nexus_types::internal_api::params::RackInitializationRequest;
@@ -47,6 +48,7 @@ use nexus_types::internal_api::views::DemoSaga;
 use nexus_types::internal_api::views::MgsUpdateDriverStatus;
 use nexus_types::internal_api::views::QuiesceStatus;
 use nexus_types::internal_api::views::Saga;
+use nexus_types::internal_api::views::SupportBundleInfo;
 use nexus_types::internal_api::views::UpdateStatus;
 use nexus_types::internal_api::views::to_list;
 use nexus_types::trust_quorum::TrustQuorumConfig;
@@ -618,10 +620,7 @@ impl NexusLockstepApi for NexusLockstepApiImpl {
     async fn support_bundle_list(
         rqctx: RequestContext<ApiContext>,
         query_params: Query<PaginatedByTimeAndId>,
-    ) -> Result<
-        HttpResponseOk<ResultsPage<support_bundle::SupportBundleInfo>>,
-        HttpError,
-    > {
+    ) -> Result<HttpResponseOk<ResultsPage<SupportBundleInfo>>, HttpError> {
         let apictx = rqctx.context();
         let handler = async {
             let nexus = &apictx.context.nexus;
@@ -642,8 +641,11 @@ impl NexusLockstepApi for NexusLockstepApiImpl {
             Ok(HttpResponseOk(ScanByTimeAndId::results_page(
                 &query,
                 bundles,
-                &|_, bundle: &support_bundle::SupportBundleInfo| {
-                    (bundle.time_created, bundle.id.into_untyped_uuid())
+                &|_, bundle: &SupportBundleInfo| {
+                    (
+                        bundle.base.time_created,
+                        bundle.base.id.into_untyped_uuid(),
+                    )
                 },
             )?))
         };
@@ -657,8 +659,7 @@ impl NexusLockstepApi for NexusLockstepApiImpl {
     async fn support_bundle_view(
         rqctx: RequestContext<Self::Context>,
         path_params: Path<SupportBundlePath>,
-    ) -> Result<HttpResponseOk<support_bundle::SupportBundleInfo>, HttpError>
-    {
+    ) -> Result<HttpResponseOk<SupportBundleInfo>, HttpError> {
         let apictx = rqctx.context();
         let handler = async {
             let nexus = &apictx.context.nexus;
@@ -862,9 +863,8 @@ impl NexusLockstepApi for NexusLockstepApiImpl {
 
     async fn support_bundle_create(
         rqctx: RequestContext<Self::Context>,
-        body: TypedBody<support_bundle::SupportBundleCreate>,
-    ) -> Result<HttpResponseCreated<support_bundle::SupportBundleInfo>, HttpError>
-    {
+        body: TypedBody<SupportBundleCreate>,
+    ) -> Result<HttpResponseCreated<SupportBundleInfo>, HttpError> {
         let apictx = rqctx.context();
         let handler = async {
             let nexus = &apictx.context.nexus;
@@ -921,8 +921,7 @@ impl NexusLockstepApi for NexusLockstepApiImpl {
         rqctx: RequestContext<Self::Context>,
         path_params: Path<SupportBundlePath>,
         body: TypedBody<SupportBundleUpdate>,
-    ) -> Result<HttpResponseOk<support_bundle::SupportBundleInfo>, HttpError>
-    {
+    ) -> Result<HttpResponseOk<SupportBundleInfo>, HttpError> {
         let apictx = rqctx.context();
         let handler = async {
             let nexus = &apictx.context.nexus;

nexus/tests/integration_tests/support_bundles.rs

@@ -8,6 +8,7 @@ use anyhow::Context;
 use anyhow::Result;
 use dropshot::HttpErrorResponseBody;
 use dropshot::test_util::ClientTestContext;
+use futures::TryStreamExt;
 use http::StatusCode;
 use http::method::Method;
 use nexus_db_model::SupportBundleState as DbSupportBundleState;
@@ -939,3 +940,76 @@ async fn test_support_bundle_delete_failed_bundle(
         "Deleted bundle should not appear in bundle list"
     );
 }
+
+// Test that fm_case_id is exposed through the lockstep API. User-created
+// bundles should have fm_case_id: None, while FM-created bundles should
+// show their case ID.
+#[nexus_test]
+async fn test_support_bundle_fm_case_id(cptestctx: &ControlPlaneTestContext) {
+    use nexus_db_queries::db::datastore::SupportBundleCreateParams;
+    use nexus_db_queries::db::datastore::SupportBundleProvenance;
+    use nexus_types::support_bundle::BundleDataSelection;
+    use omicron_uuid_kinds::CaseUuid;
+    use omicron_uuid_kinds::GenericUuid;
+
+    let client = &cptestctx.external_client;
+    let nexus = &cptestctx.server.server_context().nexus;
+    let datastore = nexus.datastore();
+    let opctx =
+        OpContext::for_tests(cptestctx.logctx.log.clone(), datastore.clone());
+    let lockstep = cptestctx.lockstep_client();
+
+    let _disk_test =
+        DiskTestBuilder::new(&cptestctx).with_zpool_count(2).build().await;
+
+    // Create a user bundle through the external API.
+    let user_bundle = bundle_create(&client).await.unwrap();
+
+    // Create an FM bundle directly through the datastore.
+    let case_id = CaseUuid::new_v4();
+    let fm_bundle = datastore
+        .support_bundle_create(
+            &opctx,
+            SupportBundleCreateParams {
+                provenance: SupportBundleProvenance::Fm {
+                    id: SupportBundleUuid::new_v4(),
+                    case_id,
+                },
+                reason: "FM test bundle",
+                nexus_id: nexus.id(),
+                user_comment: None,
+                data_selection: BundleDataSelection::all(),
+            },
+        )
+        .await
+        .expect("Should be able to create FM bundle");
+
+    // Fetch all bundles via the lockstep API and verify fm_case_id.
+    let bundles: Vec<_> = lockstep
+        .support_bundle_list_stream(None, None)
+        .try_collect()
+        .await
+        .expect("listing bundles via lockstep API");
+
+    let user_bundle_uuid: uuid::Uuid = user_bundle.id.into_untyped_uuid();
+    let listed_user = bundles
+        .iter()
+        .find(|b| b.id == user_bundle_uuid)
+        .expect("user bundle should appear in list");
+    assert_eq!(listed_user.fm_case_id, None);
+
+    let fm_bundle_uuid: uuid::Uuid = *fm_bundle.id.as_untyped_uuid();
+    let listed_fm = bundles
+        .iter()
+        .find(|b| b.id == fm_bundle_uuid)
+        .expect("FM bundle should appear in list");
+    assert_eq!(listed_fm.fm_case_id, Some(case_id));
+
+    // Verify fm_case_id via the lockstep API get endpoint.
+    let fetched_fm = lockstep
+        .support_bundle_view(&fm_bundle_uuid)
+        .await
+        .expect("fetching FM bundle via lockstep API")
+        .into_inner();
+    assert_eq!(fetched_fm.fm_case_id, Some(case_id));
+}

nexus/types/src/internal_api/views.rs

@@ -4,6 +4,7 @@
 
 use crate::deployment::PendingMgsUpdate;
 use crate::deployment::TargetReleaseDescription;
+use crate::external_api::support_bundle::SupportBundleInfo as ExternalSupportBundleInfo;
 use crate::inventory::CabooseWhich;
 use crate::inventory::Collection;
 use crate::quiesce::SagaQuiesceStatus;
@@ -24,6 +25,7 @@ use omicron_common::api::external::Vni;
 use omicron_common::disk::M2Slot;
 use omicron_common::snake_case_result;
 use omicron_common::snake_case_result::SnakeCaseResult;
+use omicron_uuid_kinds::CaseUuid;
 use omicron_uuid_kinds::DemoSagaUuid;
 use omicron_uuid_kinds::{OmicronZoneUuid, SledUuid};
 use schemars::JsonSchema;
@@ -1249,6 +1251,18 @@ impl IdOrdItem for HeldDbClaimInfo {
     id_upcast!();
 }
 
+/// Support bundle info with internal-only fields.
+///
+/// This wraps the external API's [`ExternalSupportBundleInfo`] and extends it
+/// with fields that are only exposed through the lockstep API (e.g., for OMDB).
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct SupportBundleInfo {
+    #[serde(flatten)]
+    pub base: ExternalSupportBundleInfo,
+    /// The FM case ID that triggered creation of this bundle, if any.
+    pub fm_case_id: Option<CaseUuid>,
+}
+
 #[cfg(test)]
 mod test {
     use super::CompletedAttempt;

openapi/nexus-lockstep.json

@@ -3291,6 +3291,15 @@
           "stage0_next"
         ]
       },
+      "CaseUuid": {
+        "x-rust-type": {
+          "crate": "omicron-uuid-kinds",
+          "path": "omicron_uuid_kinds::CaseUuid",
+          "version": "*"
+        },
+        "type": "string",
+        "format": "uuid"
+      },
       "Certificate": {
         "type": "object",
         "properties": {
@@ -9166,8 +9175,18 @@
         }
       },
       "SupportBundleInfo": {
+        "description": "Support bundle info with internal-only fields.\n\nThis wraps the external API's [`ExternalSupportBundleInfo`] and extends it with fields that are only exposed through the lockstep API (e.g., for OMDB).",
         "type": "object",
         "properties": {
+          "fm_case_id": {
+            "nullable": true,
+            "description": "The FM case ID that triggered creation of this bundle, if any.",
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/CaseUuid"
+              }
+            ]
+          },
           "id": {
             "type": "string",
             "format": "uuid"