single view for ereports to make fetching planning input easier

Author: hawkw

nexus/db-model/src/ereport.rs

@@ -2,6 +2,7 @@
 // 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/.
 
+use super::impl_enum_type;
 use crate::SpMgsSlot;
 use crate::SpType;
 use crate::typed_uuid::DbTypedUuid;
@@ -12,9 +13,9 @@ use diesel::pg::Pg;
 use diesel::prelude::*;
 use diesel::serialize::{self, ToSql};
 use diesel::sql_types;
-use nexus_db_schema::schema::{host_ereport, sp_ereport};
+use nexus_db_schema::schema::{ereport, host_ereport, sp_ereport};
 use nexus_types::fm::ereport::{
-    Ena, Ereport, EreportId, EreportMetadata, Reporter,
+    self as fm, Ena, EreportId, EreportMetadata, Reporter,
 };
 use omicron_uuid_kinds::{EreporterRestartKind, OmicronZoneKind, SledKind};
 use serde::{Deserialize, Serialize};
@@ -62,6 +63,133 @@ where
     }
 }
 
+impl_enum_type!(
+    EreporterKindEnum:
+
+    #[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
+    pub enum EreporterKind;
+
+    // Enum values
+    Sp => b"sp"
+    Host => b"host"
+);
+
+#[derive(Clone, Debug, Queryable, Selectable)]
+#[diesel(table_name = ereport)]
+pub struct Ereport {
+    pub restart_id: DbTypedUuid<EreporterRestartKind>,
+    pub ena: DbEna,
+    pub time_collected: DateTime<Utc>,
+    pub collector_id: DbTypedUuid<OmicronZoneKind>,
+    pub reporter_kind: EreporterKind,
+
+    // The physical location of the reporting SP.
+    //
+    /// SP location: the type of SP slot (sled, switch, power shelf).
+    ///
+    /// This is always known, as SPs are indexed by physical location when
+    /// collecting ereports from MGS.
+    pub sp_type: Option<SpType>,
+    /// SP location: the slot number.
+    ///
+    /// This is always known, as SPs are indexed by physical location when
+    /// collecting ereports from MGS.
+    pub sp_slot: Option<SpMgsSlot>,
+    pub sled_id: Option<DbTypedUuid<SledKind>>,
+
+    /// SP VPD identity: the baseboard part number of the reporting SP.
+    ///
+    /// This is nullable, as the ereport may have been generated in a condition
+    /// where the SP was unable to determine its own part number. Consider that
+    /// "I don't know what I am!" is an error condition for which we might want
+    /// to generate an ereport!
+    pub part_number: Option<String>,
+    /// SP VPD identity: the baseboard serial number of the reporting SP.
+    ///
+    /// This is nullable, as the ereport may have been generated in a condition
+    /// where the SP was unable to determine its own serial number. Consider that
+    /// "I don't know who I am!" is an error condition for which we might want
+    /// to generate an ereport!
+    pub serial_number: Option<String>,
+    /// The ereport class, which indicates the category of event reported.
+    ///
+    /// This is nullable, as it is extracted from the report JSON, and reports
+    /// missing class information must still be ingested.
+    pub class: Option<String>,
+
+    pub report: serde_json::Value,
+}
+
+impl TryFrom<Ereport> for fm::Ereport {
+    type Error = anyhow::Error;
+    fn try_from(ereport: Ereport) -> Result<Self, Self::Error> {
+        let reporter = match &ereport {
+            Ereport {
+                reporter_kind: EreporterKind::Sp,
+                sp_slot: Some(slot),
+                sp_type: Some(sp_type),
+                ..
+            } => Reporter::Sp { sp_type: (*sp_type).into(), slot: slot.0 },
+            Ereport {
+                reporter_kind: EreporterKind::Sp,
+                sp_slot,
+                sp_type,
+                ..
+            } => {
+                anyhow::bail!(
+                    "an ereport with reporter_kind='sp' should have a slot \
+                    and sp_type, but found sp_slot={sp_slot:?}, \
+                    sp_type={sp_type:?}",
+                );
+            }
+            Ereport {
+                reporter_kind: EreporterKind::Host,
+                sled_id: Some(sled_id),
+                ..
+            } => Reporter::HostOs { sled: (*sled_id).into() },
+            Ereport {
+                reporter_kind: EreporterKind::Host,
+                sled_id: None,
+                ..
+            } => {
+                anyhow::bail!(
+                    "an ereport with reporter_kind='host' should have a \
+                     non-null sled UUID"
+                );
+            }
+        };
+
+        let Ereport {
+            restart_id,
+            ena,
+            reporter_kind: _,
+            time_collected,
+            collector_id,
+            part_number,
+            serial_number,
+            sp_type: _,
+            sp_slot: _,
+            sled_id: _,
+            class,
+            report,
+        } = ereport;
+        Ok(fm::Ereport {
+            id: EreportId { restart_id: restart_id.into(), ena: ena.into() },
+            part_number,
+            serial_number,
+            class,
+            metadata: EreportMetadata {
+                time_collected,
+                // The `ereport` view only contains ereports which haven't been deleted
+                time_deleted: None,
+                collector_id: collector_id.into(),
+            },
+            reporter,
+            report,
+        })
+    }
+}
+
 #[derive(Clone, Debug, Insertable, Queryable, Selectable)]
 #[diesel(table_name = sp_ereport)]
 pub struct SpEreport {
@@ -109,7 +237,7 @@ pub struct SpEreport {
     pub report: serde_json::Value,
 }
 
-impl From<SpEreport> for Ereport {
+impl From<SpEreport> for fm::Ereport {
     fn from(sp_report: SpEreport) -> Self {
         let SpEreport {
             restart_id,
@@ -124,7 +252,7 @@ impl From<SpEreport> for Ereport {
             class,
             report,
         } = sp_report;
-        Ereport {
+        fm::Ereport {
             id: EreportId { restart_id: restart_id.into(), ena: ena.into() },
             part_number,
             serial_number,
@@ -167,7 +295,7 @@ pub struct HostEreport {
     pub part_number: Option<String>,
 }
 
-impl From<HostEreport> for Ereport {
+impl From<HostEreport> for fm::Ereport {
     fn from(host_report: HostEreport) -> Self {
         let HostEreport {
             restart_id,
@@ -181,8 +309,11 @@ impl From<HostEreport> for Ereport {
             report,
             part_number,
         } = host_report;
-        Ereport {
-            id: EreportId { restart_id: restart_id.into(), ena: ena.into() },
+        fm::Ereport {
+            id: fm::EreportId {
+                restart_id: restart_id.into(),
+                ena: ena.into(),
+            },
             part_number,
             serial_number: Some(sled_serial),
             class,

nexus/db-queries/src/db/datastore/ereport.rs

@@ -8,6 +8,7 @@ use super::DataStore;
 use crate::authz;
 use crate::context::OpContext;
 use crate::db::datastore::RunnableQuery;
+use crate::db::model;
 use crate::db::model::DbEna;
 use crate::db::model::HostEreport;
 use crate::db::model::SpEreport;
@@ -24,6 +25,7 @@ use diesel::prelude::*;
 use nexus_db_errors::ErrorHandler;
 use nexus_db_errors::public_error_from_diesel;
 use nexus_db_lookup::DbConnection;
+use nexus_db_schema::schema::ereport::dsl;
 use nexus_db_schema::schema::host_ereport::dsl as host_dsl;
 use nexus_db_schema::schema::sp_ereport::dsl as sp_dsl;
 use nexus_types::fm::ereport::{Ereport, Reporter};
@@ -101,33 +103,21 @@ impl DataStore {
         let restart_id = id.restart_id.into_untyped_uuid();
         let ena = DbEna::from(id.ena);
 
-        if let Some(report) = sp_dsl::sp_ereport
-            .filter(sp_dsl::restart_id.eq(restart_id))
-            .filter(sp_dsl::ena.eq(ena))
-            .filter(sp_dsl::time_deleted.is_null())
-            .select(SpEreport::as_select())
-            .first_async(&*conn)
-            .await
-            .optional()
-            .map_err(|e| public_error_from_diesel(e, ErrorHandler::Server))?
-        {
-            return Ok(report.into());
-        }
-
-        if let Some(report) = host_dsl::host_ereport
-            .filter(host_dsl::restart_id.eq(restart_id))
-            .filter(host_dsl::ena.eq(ena))
-            .filter(host_dsl::time_deleted.is_null())
-            .select(HostEreport::as_select())
+        let ereport = dsl::ereport
+            .filter(dsl::restart_id.eq(restart_id))
+            .filter(dsl::ena.eq(ena))
+            .select(model::Ereport::as_select())
             .first_async(&*conn)
             .await
             .optional()
             .map_err(|e| public_error_from_diesel(e, ErrorHandler::Server))?
-        {
-            return Ok(report.into());
-        }
+            .ok_or_else(|| {
+                Error::non_resourcetype_not_found(format!("ereport {id}"))
+            })?;
 
-        Err(Error::non_resourcetype_not_found(format!("ereport {id}")))
+        ereport.try_into().map_err(|e: anyhow::Error| Error::InternalError {
+            internal_message: e.to_string(),
+        })
     }
 
     pub async fn host_ereports_fetch_matching(
@@ -492,7 +482,9 @@ mod tests {
     use super::*;
     use crate::db::explain::ExplainableAsync;
     use crate::db::pub_test_utils::TestDatabase;
+    use nexus_types::fm::ereport::Ena;
     use omicron_test_utils::dev;
+    use omicron_uuid_kinds::OmicronZoneUuid;
 
     #[tokio::test]
     async fn explain_sp_latest_ereport_id() {
@@ -596,4 +588,105 @@ mod tests {
         db.terminate().await;
         logctx.cleanup_successful();
     }
+
+    #[tokio::test]
+    async fn test_fetch_ereports_by_view() {
+        let logctx = dev::test_setup_log("test_fetch_ereports_by_view");
+        let db = TestDatabase::new_with_datastore(&logctx.log).await;
+        let (opctx, datastore) = (db.opctx(), db.datastore());
+
+        let host_restart_id = EreporterRestartUuid::new_v4();
+        let sled_id = SledUuid::new_v4();
+        let host_ena = Ena(2);
+        let host_ereport = HostEreport {
+            restart_id: host_restart_id.into(),
+            ena: host_ena.into(),
+            time_deleted: None,
+
+            time_collected: Utc::now(),
+            collector_id: OmicronZoneUuid::new_v4().into(),
+
+            sled_id: sled_id.into(),
+            sled_serial: "BRM6900420".to_string(),
+            part_number: Some("fakegimlet".to_string()),
+            class: Some("my.cool.ereport".to_string()),
+
+            report: serde_json::json!({
+                "computer": "very gone",
+                "badness": 10000,
+            }),
+        };
+
+        let (created, _) = datastore
+            .host_ereports_insert(&opctx, sled_id, vec![host_ereport])
+            .await
+            .expect("host ereport should be inserted");
+        assert_eq!(created, 1);
+
+        let sp_restart_id = EreporterRestartUuid::new_v4();
+        let sp_ena = Ena(2); // same ENA!
+        let sp_type = SpType::Sled;
+        let slot = 19u16;
+        let sp_ereport = SpEreport {
+            restart_id: sp_restart_id.into(),
+            ena: sp_ena.into(),
+            time_deleted: None,
+
+            time_collected: Utc::now(),
+            collector_id: OmicronZoneUuid::new_v4().into(),
+
+            sp_type,
+            sp_slot: slot.into(),
+            // pretend to be the same sled
+            serial_number: Some("BRM6900420".to_string()),
+            part_number: Some("fakegimlet".to_string()),
+            class: Some("my.cool.sp.ereport".to_string()),
+
+            report: serde_json::json!({
+                "hello": "world",
+                "im_a_sp": true,
+            }),
+        };
+
+        let (created, _) = datastore
+            .sp_ereports_insert(&opctx, sp_type, slot, vec![sp_ereport])
+            .await
+            .expect("SP ereport should be inserted");
+        assert_eq!(created, 1);
+
+        let fetched_host_ereport = datastore
+            .ereport_fetch(
+                &opctx,
+                ereport_types::EreportId {
+                    restart_id: host_restart_id,
+                    ena: host_ena,
+                },
+            )
+            .await
+            .expect("host ereport fetch should succeed");
+        dbg!(&fetched_host_ereport);
+        assert_eq!(
+            fetched_host_ereport.reporter,
+            Reporter::HostOs { sled: sled_id }
+        );
+
+        let fetched_sp_ereport = datastore
+            .ereport_fetch(
+                &opctx,
+                ereport_types::EreportId {
+                    restart_id: sp_restart_id,
+                    ena: sp_ena,
+                },
+            )
+            .await
+            .expect("SP ereport fetch should succeed");
+        dbg!(&fetched_sp_ereport);
+        assert_eq!(
+            fetched_sp_ereport.reporter,
+            Reporter::Sp { sp_type: sp_type.into(), slot }
+        );
+
+        db.terminate().await;
+        logctx.cleanup_successful();
+    }
 }

nexus/db-schema/src/enums.rs

@@ -42,6 +42,7 @@ define_enums! {
     DnsGroupEnum => "dns_group",
     DownstairsClientStopRequestReasonEnum => "downstairs_client_stop_request_reason_type",
     DownstairsClientStoppedReasonEnum => "downstairs_client_stopped_reason_type",
+    EreporterKindEnum => "ereporter_kind",
     FailureDomainEnum => "failure_domain",
     HwM2SlotEnum => "hw_m2_slot",
     HwPowerStateEnum => "hw_power_state",
@@ -109,3 +110,4 @@ define_enums! {
     WebhookDeliveryAttemptResultEnum => "webhook_delivery_attempt_result",
     ZoneTypeEnum => "zone_type",
 }
+