so damn close with the component join table but it doesn't compile

Author: david-crespo

common/src/sql/dbinit.sql

@@ -1433,6 +1433,48 @@ CREATE TABLE omicron.public.system_update (
     version STRING(40) NOT NULL
 );
 
+-- TODO: wtf are the values here
+CREATE TYPE omicron.public.device_type AS ENUM (
+    'disk'
+);
+
+/*
+ * Component updates. Associated with at least one system_update through
+ * system_update_component_update.
+ */
+CREATE TABLE omicron.public.component_update (
+    /* Identity metadata (asset) */
+    id UUID PRIMARY KEY,
+    time_created TIMESTAMPTZ NOT NULL,
+    time_modified TIMESTAMPTZ NOT NULL,
+
+    -- On component updates there's no device ID because the update can apply to
+    -- multiple instances of a given device kind
+
+    version STRING(40) NOT NULL,
+    device_type omicron.public.device_type NOT NULL,
+    parent_id UUID
+);
+
+/*
+ * Associate system updates with component updates. Not done with a
+ * system_update_id field on component_update because the same component update
+ * may be part of more than one system update.
+ * 
+ * TODO: is the one-to-many association necessary? Things would be simpler if we
+ * created a new component_update for every (system update, component update).
+ * Downsides: less flexibility, possibly a _lot_ of duplication, depending how
+ * often component updates are actually unique. I suspect many system updates
+ * will only change a couple of components, which means most component updates
+ * will appear in more than one system update.
+ */
+CREATE TABLE omicron.public.system_update_component_update (
+    system_update_id UUID NOT NULL,
+    component_update_id UUID NOT NULL,
+
+    PRIMARY KEY (system_update_id, component_update_id)
+);
+
 /*******************************************************************/
 
 /*

nexus/db-model/src/schema.rs

@@ -645,6 +645,35 @@ table! {
     }
 }
 
+table! {
+    component_update (id) {
+        id -> Uuid,
+        name -> Text,
+        description -> Text,
+        time_created -> Timestamptz,
+        time_modified -> Timestamptz,
+
+        version -> Text,
+        device_type -> crate::DeviceTypeEnum,
+        // parent component update ID
+        // TODO: spell out the whole horrible name?
+        parent_id -> Uuid,
+    }
+}
+
+table! {
+    system_update_component_update (system_update_id, component_update_id) {
+        system_update_id -> Uuid,
+        component_update_id -> Uuid,
+    }
+}
+
+allow_tables_to_appear_in_same_query!(
+    system_update,
+    component_update,
+    system_update_component_update,
+);
+
 allow_tables_to_appear_in_same_query!(ip_pool_range, ip_pool);
 joinable!(ip_pool_range -> ip_pool (ip_pool_id));
 

nexus/db-model/src/system_update.rs

@@ -2,10 +2,14 @@
 // 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::schema::system_update;
+use crate::{
+    impl_enum_type,
+    schema::{component_update, system_update},
+};
 use db_macros::Asset;
 use nexus_types::{external_api::views, identity::Asset};
 use serde::{Deserialize, Serialize};
+use uuid::Uuid;
 
 #[derive(
     Queryable,
@@ -34,3 +38,58 @@ impl From<SystemUpdate> for views::SystemUpdate {
         }
     }
 }
+
+// TODO: more specific name than device_type, maybe update_device_type
+
+impl_enum_type!(
+    #[derive(SqlType, Debug, QueryId)]
+    #[diesel(postgres_type(name = "device_type"))]
+    pub struct DeviceTypeEnum;
+
+    #[derive(Copy, Clone, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
+    #[diesel(sql_type = DeviceTypeEnum)]
+    pub enum DeviceType;
+
+    // Enum values
+    Disk => b"disk"
+);
+
+impl From<DeviceType> for views::DeviceType {
+    fn from(device_type: DeviceType) -> Self {
+        match device_type {
+            DeviceType::Disk => views::DeviceType::Disk,
+        }
+    }
+}
+
+#[derive(
+    Queryable,
+    Insertable,
+    Selectable,
+    Clone,
+    Debug,
+    Asset,
+    Serialize,
+    Deserialize,
+)]
+#[diesel(table_name = component_update)]
+pub struct ComponentUpdate {
+    #[diesel(embed)]
+    identity: ComponentUpdateIdentity,
+    pub version: String,
+    pub device_type: DeviceType,
+    pub parent_id: Option<Uuid>,
+}
+
+impl From<ComponentUpdate> for views::ComponentUpdate {
+    fn from(component_update: ComponentUpdate) -> Self {
+        Self {
+            identity: component_update.identity(),
+            // TODO: figure out how to ser/de semver versions
+            // version: system_update.version,
+            version: views::SemverVersion::new(1, 0, 0),
+            device_type: component_update.device_type.into(),
+            parent_id: component_update.parent_id,
+        }
+    }
+}

nexus/src/app/update.rs

@@ -12,7 +12,7 @@ use crate::db::lookup::LookupPath;
 use crate::db::model::UpdateArtifactKind;
 use hex;
 use omicron_common::api::external::{
-    DataPageParams, Error, LookupResult, PaginationOrder,
+    DataPageParams, Error, ListResultVec, LookupResult, PaginationOrder,
 };
 use omicron_common::api::internal::nexus::UpdateArtifact;
 use rand::Rng;
@@ -290,4 +290,17 @@ impl super::Nexus {
             .await?;
         Ok(db_system_update)
     }
+
+    pub async fn system_update_list_components(
+        &self,
+        opctx: &OpContext,
+        update_id: &Uuid,
+    ) -> ListResultVec<db::model::ComponentUpdate> {
+        let (authz_update, ..) = LookupPath::new(opctx, &self.db_datastore)
+            .system_update_id(*update_id)
+            .fetch()
+            .await?;
+
+        self.db_datastore.components_list(opctx, &authz_update).await
+    }
 }

nexus/src/db/datastore/update.rs

@@ -10,12 +10,12 @@ use crate::context::OpContext;
 use crate::db;
 use crate::db::error::public_error_from_diesel_pool;
 use crate::db::error::ErrorHandler;
-use crate::db::model::UpdateAvailableArtifact;
+use crate::db::model::{ComponentUpdate, UpdateAvailableArtifact};
 use async_bb8_diesel::AsyncRunQueryDsl;
 use diesel::prelude::*;
-use omicron_common::api::external::CreateResult;
-use omicron_common::api::external::DeleteResult;
-use omicron_common::api::external::InternalContext;
+use omicron_common::api::external::{
+    CreateResult, DeleteResult, InternalContext, ListResultVec,
+};
 
 impl DataStore {
     pub async fn update_available_artifact_upsert(
@@ -56,4 +56,31 @@ impl DataStore {
             .map_err(|e| public_error_from_diesel_pool(e, ErrorHandler::Server))
             .internal_context("deleting outdated available artifacts")
     }
+
+    pub async fn components_list(
+        &self,
+        opctx: &OpContext,
+        authz_update: &authz::SystemUpdate,
+    ) -> ListResultVec<ComponentUpdate> {
+        // TODO: what's the right permission here?
+        opctx.authorize(authz::Action::Read, &authz::FLEET).await?;
+
+        use db::schema::component_update::dsl as component_update;
+        use db::schema::system_update_component_update::dsl as join_table;
+
+        component_update::component_update
+            .inner_join(
+                join_table::system_update_component_update.on(
+                    join_table::component_update_id
+                        .eq(component_update::id)
+                        .and(
+                            join_table::system_update_id.eq(authz_update.id()),
+                        ),
+                ),
+            )
+            .select(ComponentUpdate::as_select())
+            .load_async(self.pool_authorized(opctx).await?)
+            .await
+            .map_err(|e| public_error_from_diesel_pool(e, ErrorHandler::Server))
+    }
 }

nexus/src/external_api/http_entrypoints.rs

@@ -5165,9 +5165,13 @@ async fn system_update_components_list(
     let path = path_params.into_inner();
     let handler = async {
         let opctx = OpContext::for_external_api(&rqctx).await?;
-        let _system_update =
-            nexus.system_update_fetch_by_id(&opctx, &path.update_id).await?;
-        Ok(HttpResponseOk(ResultsPage { items: vec![], next_page: None }))
+        let components = nexus
+            .system_update_list_components(&opctx, &path.update_id)
+            .await?
+            .into_iter()
+            .map(|i| i.into())
+            .collect();
+        Ok(HttpResponseOk(ResultsPage { items: components, next_page: None }))
     };
     apictx.external_latencies.instrument_dropshot_handler(&rqctx, handler).await
 }

nexus/types/src/external_api/views.rs

@@ -466,16 +466,15 @@ pub struct SystemUpdate {
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum DeviceType {
-    Sled,
+    Disk,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
 pub struct ComponentUpdate {
-    // note this is the ID of the component, not the update. Does the component
-    // update also have an ID?
-    pub component_id: Uuid,
+    #[serde(flatten)]
+    pub identity: AssetIdentityMetadata,
+
     // pub name: Name, // hmmm. who would name this?
-    pub device_id: String,
     pub device_type: DeviceType,
     pub version: SemverVersion,
     // TODO: parent ID doesn't need to be optional if we say top-level