lots of case DB stuff

Author: hawkw

ereport/types/src/lib.rs

@@ -32,6 +32,7 @@ pub struct Ereport {
     Serialize,
     Deserialize,
     JsonSchema,
+    Hash,
 )]
 #[repr(transparent)]
 #[serde(from = "u64", into = "u64")]
@@ -103,7 +104,16 @@ impl TryFrom<i64> for Ena {
 
 /// Unique identifier for an ereport.
 #[derive(
-    Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, PartialOrd, Ord,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    PartialOrd,
+    Ord,
+    Hash,
 )]
 pub struct EreportId {
     pub restart_id: EreporterRestartUuid,

nexus/db-model/src/alert_class.rs

@@ -4,6 +4,7 @@
 
 use super::impl_enum_type;
 use nexus_types::external_api::views;
+use omicron_common::api::external::Error;
 use serde::de::{self, Deserialize, Deserializer};
 use serde::ser::{Serialize, Serializer};
 use std::fmt;
@@ -104,6 +105,22 @@ impl From<nexus_types::fm::AlertClass> for AlertClass {
     }
 }
 
+impl TryFrom<AlertClass> for nexus_types::fm::AlertClass {
+    type Error = Error;
+
+    fn try_from(input: AlertClass) -> Result<Self, Self::Error> {
+        use nexus_types::fm::AlertClass as Out;
+        match input {
+            AlertClass::PsuRemoved => Ok(Out::PsuRemoved),
+            AlertClass::PsuInserted => Ok(Out::PsuInserted),
+            class => Err(Error::invalid_value(
+                "alert_class",
+                format!("'{class}' is not a FM alert class"),
+            )),
+        }
+    }
+}
+
 impl fmt::Display for AlertClass {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.as_str())

nexus/db-model/src/fm.rs

@@ -19,6 +19,13 @@ use chrono::{DateTime, Utc};
 use nexus_db_schema::schema::{fm_sitrep, fm_sitrep_history};
 use omicron_uuid_kinds::{CollectionKind, OmicronZoneKind, SitrepKind};
 
+mod alert_request;
+pub use alert_request::*;
+mod case;
+pub use case::*;
+mod diagnosis_engine;
+pub use diagnosis_engine::*;
+
 #[derive(Queryable, Insertable, Clone, Debug, Selectable)]
 #[diesel(table_name = fm_sitrep)]
 pub struct SitrepMetadata {

nexus/db-model/src/fm/alert_request.rs

@@ -0,0 +1,55 @@
+// 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/.
+
+//! Fault management alert requests.
+
+use crate::AlertClass;
+use crate::DbTypedUuid;
+use nexus_db_schema::schema::fm_alert_request;
+use nexus_types::fm;
+use omicron_uuid_kinds::{
+    AlertKind, CaseKind, CaseUuid, SitrepKind, SitrepUuid,
+};
+
+#[derive(Queryable, Insertable, Clone, Debug, Selectable)]
+#[diesel(table_name = fm_alert_request)]
+pub struct AlertRequest {
+    pub id: DbTypedUuid<AlertKind>,
+    pub sitrep_id: DbTypedUuid<SitrepKind>,
+    pub requested_sitrep_id: DbTypedUuid<SitrepKind>,
+    pub case_id: DbTypedUuid<CaseKind>,
+    #[diesel(column_name = "class")]
+    pub class: AlertClass,
+    pub payload: serde_json::Value,
+}
+
+impl AlertRequest {
+    pub fn new(
+        current_sitrep_id: SitrepUuid,
+        case_id: CaseUuid,
+        req: fm::AlertRequest,
+    ) -> Self {
+        let fm::AlertRequest { id, requested_sitrep_id, payload, class } = req;
+        AlertRequest {
+            id: id.into(),
+            sitrep_id: current_sitrep_id.into(),
+            requested_sitrep_id: requested_sitrep_id.into(),
+            case_id: case_id.into(),
+            class: class.into(),
+            payload,
+        }
+    }
+}
+
+impl TryFrom<AlertRequest> for fm::AlertRequest {
+    type Error = <fm::AlertClass as TryFrom<AlertClass>>::Error;
+    fn try_from(req: AlertRequest) -> Result<Self, Self::Error> {
+        Ok(fm::AlertRequest {
+            id: req.id.into(),
+            requested_sitrep_id: req.requested_sitrep_id.into(),
+            payload: req.payload,
+            class: req.class.try_into()?,
+        })
+    }
+}

nexus/db-model/src/fm/case.rs

@@ -0,0 +1,38 @@
+// 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/.
+
+//! Fault management cases.
+
+use super::DiagnosisEngine;
+use crate::DbTypedUuid;
+use crate::ereport;
+use chrono::{DateTime, Utc};
+use nexus_db_schema::schema::{fm_case, fm_ereport_in_case};
+use omicron_uuid_kinds::{CaseKind, EreporterRestartKind, SitrepKind};
+
+#[derive(Queryable, Insertable, Clone, Debug, Selectable)]
+#[diesel(table_name = fm_case)]
+pub struct CaseMetadata {
+    pub id: DbTypedUuid<CaseKind>,
+    pub sitrep_id: DbTypedUuid<SitrepKind>,
+    pub de: DiagnosisEngine,
+
+    pub created_sitrep_id: DbTypedUuid<SitrepKind>,
+    pub time_created: DateTime<Utc>,
+
+    pub time_closed: Option<DateTime<Utc>>,
+    pub closed_sitrep_id: Option<DbTypedUuid<SitrepKind>>,
+
+    pub comment: String,
+}
+
+#[derive(Queryable, Insertable, Clone, Debug, Selectable)]
+#[diesel(table_name = fm_ereport_in_case)]
+pub struct CaseEreport {
+    pub restart_id: DbTypedUuid<EreporterRestartKind>,
+    pub ena: ereport::DbEna,
+    pub case_id: DbTypedUuid<CaseKind>,
+    pub sitrep_id: DbTypedUuid<SitrepKind>,
+    pub assigned_sitrep_id: DbTypedUuid<SitrepKind>,
+}

nexus/db-model/src/fm/diagnosis_engine.rs

@@ -0,0 +1,50 @@
+// 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/.
+
+use crate::impl_enum_type;
+use nexus_types::fm;
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+impl_enum_type!(
+    DiagnosisEngineEnum:
+
+    #[derive(
+        Copy,
+        Clone,
+        Debug,
+        PartialEq,
+        Serialize,
+        Deserialize,
+        AsExpression,
+        FromSqlRow,
+    )]
+    #[serde(rename_all = "snake_case")]
+    pub enum DiagnosisEngine;
+
+    PowerShelf => b"power_shelf"
+
+);
+
+impl From<DiagnosisEngine> for fm::DiagnosisEngine {
+    fn from(de: DiagnosisEngine) -> Self {
+        match de {
+            DiagnosisEngine::PowerShelf => fm::DiagnosisEngine::PowerShelf,
+        }
+    }
+}
+
+impl From<fm::DiagnosisEngine> for DiagnosisEngine {
+    fn from(fm_de: fm::DiagnosisEngine) -> Self {
+        match fm_de {
+            fm::DiagnosisEngine::PowerShelf => DiagnosisEngine::PowerShelf,
+        }
+    }
+}
+
+impl fmt::Display for DiagnosisEngine {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fm::DiagnosisEngine::from(*self).fmt(f)
+    }
+}

nexus/db-model/src/lib.rs

@@ -41,7 +41,7 @@ mod downstairs;
 pub mod ereport;
 mod ereporter_type;
 mod external_ip;
-mod fm;
+pub mod fm;
 mod generation;
 mod identity_provider;
 mod image;
@@ -187,7 +187,7 @@ pub use downstairs::*;
 pub use ereport::Ereport;
 pub use ereporter_type::*;
 pub use external_ip::*;
-pub use fm::*;
+pub use fm::{SitrepMetadata, SitrepVersion};
 pub use generation::*;
 pub use identity_provider::*;
 pub use image::*;

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

@@ -98,6 +98,14 @@ impl DataStore {
     ) -> LookupResult<Ereport> {
         opctx.authorize(authz::Action::ListChildren, &authz::FLEET).await?;
         let conn = self.pool_connection_authorized(opctx).await?;
+        self.ereport_fetch_on_conn(&conn, id).await
+    }
+
+    pub(crate) async fn ereport_fetch_on_conn(
+        &self,
+        conn: &async_bb8_diesel::Connection<DbConnection>,
+        id: fm::EreportId,
+    ) -> LookupResult<Ereport> {
         let restart_id = id.restart_id.into_untyped_uuid();
         let ena = DbEna::from(id.ena);
 
@@ -106,7 +114,7 @@ impl DataStore {
             .filter(dsl::ena.eq(ena))
             .filter(dsl::time_deleted.is_null())
             .select(Ereport::as_select())
-            .first_async(&*conn)
+            .first_async(conn)
             .await
             .optional()
             .map_err(|e| public_error_from_diesel(e, ErrorHandler::Server))?