[nexus] Populate rack during initialization

nexus/src/app/mod.rs

@@ -10,6 +10,7 @@ use crate::config;
 use crate::context::OpContext;
 use crate::db;
 use crate::populate::populate_start;
+use crate::populate::PopulateArgs;
 use crate::populate::PopulateStatus;
 use crate::saga_interface::SagaContext;
 use anyhow::anyhow;
@@ -55,15 +56,12 @@ pub struct Nexus {
     /// uuid for this nexus instance.
     id: Uuid,
 
-    /// uuid for this rack (TODO should also be in persistent storage)
+    /// uuid for this rack
     rack_id: Uuid,
 
     /// general server log
     log: Logger,
 
-    /// cached rack identity metadata
-    api_rack_identity: db::model::RackIdentity,
-
     /// persistent storage for resources in the control plane
     db_datastore: Arc<db::DataStore>,
 
@@ -140,14 +138,18 @@ impl Nexus {
             authn::Context::internal_db_init(),
             Arc::clone(&db_datastore),
         );
-        let populate_status =
-            populate_start(populate_ctx, Arc::clone(&db_datastore));
+
+        let populate_args = PopulateArgs::new(rack_id);
+        let populate_status = populate_start(
+            populate_ctx,
+            Arc::clone(&db_datastore),
+            populate_args,
+        );
 
         let nexus = Nexus {
             id: config.deployment.id,
             rack_id,
             log: log.new(o!()),
-            api_rack_identity: db::model::RackIdentity::new(rack_id),
             db_datastore: Arc::clone(&db_datastore),
             authz: Arc::clone(&authz),
             sec_client: Arc::clone(&sec_client),

nexus/src/app/rack.rs

@@ -7,59 +7,47 @@
 use crate::authz;
 use crate::context::OpContext;
 use crate::db;
+use crate::db::lookup::LookupPath;
 use crate::internal_api::params::ServicePutRequest;
-use futures::future::ready;
-use futures::StreamExt;
 use omicron_common::api::external::DataPageParams;
 use omicron_common::api::external::Error;
-use omicron_common::api::external::ListResult;
+use omicron_common::api::external::ListResultVec;
 use omicron_common::api::external::LookupResult;
-use omicron_common::api::external::LookupType;
-use omicron_common::api::external::ResourceType;
 use uuid::Uuid;
 
 impl super::Nexus {
-    pub(crate) fn as_rack(&self) -> db::model::Rack {
-        db::model::Rack {
-            identity: self.api_rack_identity.clone(),
-            initialized: true,
-            tuf_base_url: None,
-        }
-    }
-
     pub async fn racks_list(
         &self,
         opctx: &OpContext,
         pagparams: &DataPageParams<'_, Uuid>,
-    ) -> ListResult<db::model::Rack> {
-        opctx.authorize(authz::Action::Read, &authz::FLEET).await?;
-
-        if let Some(marker) = pagparams.marker {
-            if *marker >= self.rack_id {
-                return Ok(futures::stream::empty().boxed());
-            }
-        }
-
-        Ok(futures::stream::once(ready(Ok(self.as_rack()))).boxed())
+    ) -> ListResultVec<db::model::Rack> {
+        self.db_datastore.rack_list(&opctx, pagparams).await
     }
 
     pub async fn rack_lookup(
         &self,
         opctx: &OpContext,
         rack_id: &Uuid,
     ) -> LookupResult<db::model::Rack> {
-        let authz_rack = authz::Rack::new(
-            authz::FLEET,
-            *rack_id,
-            LookupType::ById(*rack_id),
-        );
-        opctx.authorize(authz::Action::Read, &authz_rack).await?;
+        let (.., db_rack) = LookupPath::new(opctx, &self.db_datastore)
+            .rack_id(*rack_id)
+            .fetch()
+            .await?;
+        Ok(db_rack)
+    }
 
-        if *rack_id == self.rack_id {
-            Ok(self.as_rack())
-        } else {
-            Err(Error::not_found_by_id(ResourceType::Rack, rack_id))
-        }
+    /// Ensures that a rack exists in the DB.
+    ///
+    /// If the rack already exists, this function is a no-op.
+    pub async fn rack_insert(
+        &self,
+        opctx: &OpContext,
+        rack_id: Uuid,
+    ) -> Result<(), Error> {
+        self.datastore()
+            .rack_insert(opctx, &db::model::Rack::new(rack_id))
+            .await?;
+        Ok(())
     }
 
     /// Marks the rack as initialized with a set of services.

nexus/src/app/test_interfaces.rs

@@ -14,6 +14,9 @@ use uuid::Uuid;
 /// Exposes additional [`Nexus`] interfaces for use by the test suite
 #[async_trait]
 pub trait TestInterfaces {
+    /// Access the Rack ID of the currently executing Nexus.
+    fn rack_id(&self) -> Uuid;
+
     /// Returns the SledAgentClient for an Instance from its id.  We may also
     /// want to split this up into instance_lookup_by_id() and instance_sled(),
     /// but after all it's a test suite special to begin with.
@@ -39,6 +42,10 @@ pub trait TestInterfaces {
 
 #[async_trait]
 impl TestInterfaces for super::Nexus {
+    fn rack_id(&self) -> Uuid {
+        self.rack_id
+    }
+
     async fn instance_sled_by_id(
         &self,
         id: &Uuid,

nexus/src/app/update.rs

@@ -24,11 +24,15 @@ use tokio::io::AsyncWriteExt;
 static BASE_ARTIFACT_DIR: &str = "/var/tmp/oxide_artifacts";
 
 impl super::Nexus {
-    fn tuf_base_url(&self) -> Option<String> {
-        self.updates_config.as_ref().map(|c| {
-            let rack = self.as_rack();
+    async fn tuf_base_url(
+        &self,
+        opctx: &OpContext,
+    ) -> Result<Option<String>, Error> {
+        let rack = self.rack_lookup(opctx, &self.rack_id).await?;
+
+        Ok(self.updates_config.as_ref().map(|c| {
             rack.tuf_base_url.unwrap_or_else(|| c.default_base_url.clone())
-        })
+        }))
     }
 
     pub async fn updates_refresh_metadata(
@@ -42,10 +46,11 @@ impl super::Nexus {
                 message: "updates system not configured".into(),
             }
         })?;
-        let base_url =
-            self.tuf_base_url().ok_or_else(|| Error::InvalidRequest {
+        let base_url = self.tuf_base_url(opctx).await?.ok_or_else(|| {
+            Error::InvalidRequest {
                 message: "updates system not configured".into(),
-            })?;
+            }
+        })?;
         let trusted_root = tokio::fs::read(&updates_config.trusted_root)
             .await
             .map_err(|e| Error::InternalError {
@@ -129,8 +134,10 @@ impl super::Nexus {
         artifact: UpdateArtifact,
     ) -> Result<Vec<u8>, Error> {
         let mut base_url =
-            self.tuf_base_url().ok_or_else(|| Error::InvalidRequest {
-                message: "updates system not configured".into(),
+            self.tuf_base_url(opctx).await?.ok_or_else(|| {
+                Error::InvalidRequest {
+                    message: "updates system not configured".into(),
+                }
             })?;
         if !base_url.ends_with('/') {
             base_url.push('/');

nexus/src/db/datastore.rs

@@ -153,6 +153,20 @@ impl DataStore {
         Ok(self.pool.pool())
     }
 
+    pub async fn rack_list(
+        &self,
+        opctx: &OpContext,
+        pagparams: &DataPageParams<'_, Uuid>,
+    ) -> ListResultVec<Rack> {
+        opctx.authorize(authz::Action::Read, &authz::FLEET).await?;
+        use db::schema::rack::dsl;
+        paginated(dsl::rack, dsl::id, pagparams)
+            .select(Rack::as_select())
+            .load_async(self.pool_authorized(opctx).await?)
+            .await
+            .map_err(|e| public_error_from_diesel_pool(e, ErrorHandler::Server))
+    }
+
     /// Stores a new rack in the database.
     ///
     /// This function is a no-op if the rack already exists.

nexus/src/external_api/http_entrypoints.rs

@@ -3252,13 +3252,15 @@ async fn hardware_racks_get(
     let query = query_params.into_inner();
     let handler = async {
         let opctx = OpContext::for_external_api(&rqctx).await?;
-        let rack_stream = nexus
+        let racks = nexus
             .racks_list(&opctx, &data_page_params_for(&rqctx, &query)?)
-            .await?;
-        let view_list = to_list::<db::model::Rack, Rack>(rack_stream).await;
+            .await?
+            .into_iter()
+            .map(|r| r.into())
+            .collect();
         Ok(HttpResponseOk(ScanById::results_page(
             &query,
-            view_list,
+            racks,
             &|_, rack: &Rack| rack.identity.id,
         )?))
     };