[bootstrap-agent] Refactor rack_ops (#3833)

Moves it from under `bootstrap/agent/` to just under `bootstrap/`, and
removes its dependency on `Agent`. Part of #3827.

Author: jgallagher

sled-agent/src/bin/sled-agent.rs

@@ -8,9 +8,9 @@ use camino::Utf8PathBuf;
 use clap::{Parser, Subcommand};
 use omicron_common::cmd::fatal;
 use omicron_common::cmd::CmdError;
+use omicron_sled_agent::bootstrap::RssAccessError;
 use omicron_sled_agent::bootstrap::{
-    agent as bootstrap_agent, config::Config as BootstrapConfig,
-    server as bootstrap_server,
+    config::Config as BootstrapConfig, server as bootstrap_server,
 };
 use omicron_sled_agent::rack_setup::config::SetupServiceConfig as RssConfig;
 use omicron_sled_agent::{config::Config as SledConfig, server as sled_server};
@@ -121,10 +121,7 @@ async fn do_run() -> Result<(), CmdError> {
                 match server.agent().start_rack_initialize(rss_config) {
                     // If the rack has already been initialized, we shouldn't
                     // abandon the server.
-                    Ok(_)
-                    | Err(
-                        bootstrap_agent::RssAccessError::AlreadyInitialized,
-                    ) => {}
+                    Ok(_) | Err(RssAccessError::AlreadyInitialized) => {}
                     Err(e) => {
                         return Err(CmdError::Failure(e.to_string()));
                     }

sled-agent/src/bootstrap/agent.rs

@@ -12,6 +12,7 @@ use super::hardware::HardwareMonitor;
 use super::http_entrypoints::RackOperationStatus;
 use super::params::RackInitializeRequest;
 use super::params::StartSledAgentRequest;
+use super::rack_ops::{RackInitId, RackResetId, RssAccess, RssAccessError};
 use super::secret_retriever::LrtqOrHardcodedSecretRetriever;
 use super::views::SledAgentResponse;
 use crate::config::Config as SledConfig;
@@ -49,13 +50,6 @@ use thiserror::Error;
 use tokio::sync::Mutex;
 use tokio::task::JoinHandle;
 
-mod rack_ops;
-
-pub use rack_ops::RackInitId;
-pub use rack_ops::RackResetId;
-use rack_ops::RssAccess;
-pub use rack_ops::RssAccessError;
-
 /// Describes errors which may occur while operating the bootstrap service.
 #[derive(Error, Debug)]
 pub enum BootstrapError {
@@ -852,14 +846,20 @@ impl Agent {
         self: &Arc<Self>,
         request: RackInitializeRequest,
     ) -> Result<RackInitId, RssAccessError> {
-        self.rss_access.start_initializing(self, request)
+        self.rss_access.start_initializing(
+            &self.parent_log,
+            self.ip,
+            &self.storage_resources,
+            &self.bootstore,
+            request,
+        )
     }
 
     /// Spawn a task to run rack reset.
     pub fn start_rack_reset(
         self: &Arc<Self>,
     ) -> Result<RackResetId, RssAccessError> {
-        self.rss_access.start_reset(self)
+        self.rss_access.start_reset(&self.parent_log, self.ip)
     }
 
     /// Get the status of a spawned initialize or reset operation.

sled-agent/src/bootstrap/http_entrypoints.rs

@@ -7,9 +7,9 @@
 //! Note that the bootstrap agent also communicates over Sprockets,
 //! and has a separate interface for establishing the trust quorum.
 
-use super::agent::{RackInitId, RackResetId};
 use crate::bootstrap::agent::Agent;
 use crate::bootstrap::params::RackInitializeRequest;
+use crate::bootstrap::rack_ops::{RackInitId, RackResetId};
 use crate::updates::Component;
 use dropshot::{
     endpoint, ApiDescription, HttpError, HttpResponseOk,

sled-agent/src/bootstrap/mod.rs

@@ -12,8 +12,11 @@ mod hardware;
 mod http_entrypoints;
 mod maghemite;
 pub(crate) mod params;
+mod rack_ops;
 pub(crate) mod rss_handle;
 mod secret_retriever;
 pub mod server;
 mod sprockets_server;
 mod views;
+
+pub use rack_ops::RssAccessError;

sled-agent/src/bootstrap/agent/rack_ops.rs renamed to sled-agent/src/bootstrap/rack_ops.rs

@@ -4,15 +4,18 @@
 
 //! Internal API for rack-level bootstrap agent operations.
 
-use super::Agent;
 use crate::bootstrap::http_entrypoints::RackOperationStatus;
 use crate::bootstrap::params::RackInitializeRequest;
 use crate::bootstrap::rss_handle::RssHandle;
 use crate::rack_setup::service::SetupServiceError;
+use crate::storage_manager::StorageResources;
+use bootstore::schemes::v0 as bootstore;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
+use slog::Logger;
 use std::mem;
+use std::net::Ipv6Addr;
 use std::sync::Arc;
 use std::sync::Mutex;
 use tokio::sync::oneshot;
@@ -164,9 +167,12 @@ impl RssAccess {
         }
     }
 
-    pub(super) fn start_initializing(
+    pub(crate) fn start_initializing(
         &self,
-        agent: &Arc<Agent>,
+        parent_log: &Logger,
+        global_zone_bootstrap_ip: Ipv6Addr,
+        storage_resources: &StorageResources,
+        bootstore_node_handle: &bootstore::NodeHandle,
         request: RackInitializeRequest,
     ) -> Result<RackInitId, RssAccessError> {
         let mut status = self.status.lock().unwrap();
@@ -200,10 +206,19 @@ impl RssAccess {
                 *status = RssStatus::Initializing { id, completion };
                 mem::drop(status);
 
-                let agent = Arc::clone(agent);
+                let parent_log = parent_log.clone();
+                let storage_resources = storage_resources.clone();
+                let bootstore_node_handle = bootstore_node_handle.clone();
                 let status = Arc::clone(&self.status);
                 tokio::spawn(async move {
-                    let result = rack_initialize(&agent, request).await;
+                    let result = rack_initialize(
+                        &parent_log,
+                        global_zone_bootstrap_ip,
+                        storage_resources,
+                        bootstore_node_handle,
+                        request,
+                    )
+                    .await;
                     let new_status = match result {
                         Ok(()) => RssStatus::Initialized { id: Some(id) },
                         Err(err) => RssStatus::InitializationFailed { id, err },
@@ -223,7 +238,8 @@ impl RssAccess {
 
     pub(super) fn start_reset(
         &self,
-        agent: &Arc<Agent>,
+        parent_log: &Logger,
+        global_zone_bootstrap_ip: Ipv6Addr,
     ) -> Result<RackResetId, RssAccessError> {
         let mut status = self.status.lock().unwrap();
 
@@ -255,10 +271,11 @@ impl RssAccess {
                 *status = RssStatus::Resetting { id, completion };
                 mem::drop(status);
 
-                let agent = Arc::clone(agent);
+                let parent_log = parent_log.clone();
                 let status = Arc::clone(&self.status);
                 tokio::spawn(async move {
-                    let result = rack_reset(&agent).await;
+                    let result =
+                        rack_reset(&parent_log, global_zone_bootstrap_ip).await;
                     let new_status = match result {
                         Ok(()) => {
                             RssStatus::Uninitialized { reset_id: Some(id) }
@@ -323,19 +340,25 @@ enum RssStatus {
 }
 
 async fn rack_initialize(
-    agent: &Agent,
+    parent_log: &Logger,
+    global_zone_bootstrap_ip: Ipv6Addr,
+    storage_resources: StorageResources,
+    bootstore_node_handle: bootstore::NodeHandle,
     request: RackInitializeRequest,
 ) -> Result<(), SetupServiceError> {
     RssHandle::run_rss(
-        &agent.parent_log,
+        parent_log,
         request,
-        agent.ip,
-        agent.storage_resources.clone(),
-        agent.get_bootstore_node_handle(),
+        global_zone_bootstrap_ip,
+        storage_resources,
+        bootstore_node_handle,
     )
     .await
 }
 
-async fn rack_reset(agent: &Agent) -> Result<(), SetupServiceError> {
-    RssHandle::run_rss_reset(&agent.parent_log, agent.ip).await
+async fn rack_reset(
+    parent_log: &Logger,
+    global_zone_bootstrap_ip: Ipv6Addr,
+) -> Result<(), SetupServiceError> {
+    RssHandle::run_rss_reset(parent_log, global_zone_bootstrap_ip).await
 }