feat(configurenmxc): optimize nmxc fabric state

Cargo.toml

@@ -27,7 +27,7 @@ authors = ["NVIDIA Carbide Engineering <carbide-dev@exchange.nvidia.com>"]
 [workspace.dependencies]
 clap = { version = "4", features = ["derive", "env"] }
 libredfish = { git = "https://github.com/NVIDIA/libredfish.git", tag = "v0.44.2" }
-librms = { git = "https://github.com/NVIDIA/nv-rms-client.git", tag = "v0.0.12-rc1" }
+librms = { git = "https://github.com/NVIDIA/nv-rms-client.git", tag = "v0.0.12-rc2" }
 ansi-to-html = "0.2.2"
 
 tokio = { version = "1", features = ["full", "tracing"] }

crates/api-model/src/rack.rs

@@ -456,20 +456,30 @@ impl Display for RackMaintenanceState {
 
 /// Sub-states of `RackMaintenanceState::ConfigureNmxCluster`.
 ///
-/// `Start` selects a primary switch and asks RMS to configure the
-/// NMX cluster. `WaitForFabricStatus` polls
+/// `Start` advances into the NMX cluster sequence. `DisableScaleUpFabricState`
+/// disables ScaleUpFabric state on all scoped switches before
+/// `ConfigureScaleUpFabricManager` selects, persists, and configures only the
+/// primary switch. `WaitForFabricStatus` polls
 /// `GetScaleUpFabricServicesStatus` and persists the per-switch
 /// `fabric_manager_status` before advancing.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ConfigureNmxClusterState {
     Start,
+    DisableScaleUpFabricState,
+    ConfigureScaleUpFabricManager,
     WaitForFabricStatus,
 }
 
 impl Display for ConfigureNmxClusterState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ConfigureNmxClusterState::Start => write!(f, "Start"),
+            ConfigureNmxClusterState::DisableScaleUpFabricState => {
+                write!(f, "DisableScaleUpFabricState")
+            }
+            ConfigureNmxClusterState::ConfigureScaleUpFabricManager => {
+                write!(f, "ConfigureScaleUpFabricManager")
+            }
             ConfigureNmxClusterState::WaitForFabricStatus => write!(f, "WaitForFabricStatus"),
         }
     }

crates/api-test-helper/src/mock_rms.rs

@@ -170,6 +170,10 @@ pub struct MockRmsApi {
         Mutex<VecDeque<Result<rms::ConfigureScaleUpFabricManagerResponse, RackManagerError>>>,
     configure_scale_up_fabric_manager_calls: Mutex<Vec<rms::ConfigureScaleUpFabricManagerRequest>>,
 
+    set_scale_up_fabric_state_responses:
+        Mutex<VecDeque<Result<rms::SetScaleUpFabricStateResponse, RackManagerError>>>,
+    set_scale_up_fabric_state_calls: Mutex<Vec<rms::SetScaleUpFabricStateRequest>>,
+
     enable_scale_up_fabric_telemetry_interface_responses: Mutex<
         VecDeque<Result<rms::EnableScaleUpFabricTelemetryInterfaceResponse, RackManagerError>>,
     >,
@@ -253,6 +257,8 @@ impl MockRmsApi {
             poll_job_status_calls: Default::default(),
             configure_scale_up_fabric_manager_responses: Default::default(),
             configure_scale_up_fabric_manager_calls: Default::default(),
+            set_scale_up_fabric_state_responses: Default::default(),
+            set_scale_up_fabric_state_calls: Default::default(),
             enable_scale_up_fabric_telemetry_interface_responses: Default::default(),
             enable_scale_up_fabric_telemetry_interface_calls: Default::default(),
             version_responses: Default::default(),
@@ -504,6 +510,14 @@ impl MockRmsApi {
         rms::ConfigureScaleUpFabricManagerRequest,
         rms::ConfigureScaleUpFabricManagerResponse
     );
+    impl_enqueue_inspect!(
+        enqueue_set_scale_up_fabric_state,
+        set_scale_up_fabric_state_calls,
+        set_scale_up_fabric_state_responses,
+        set_scale_up_fabric_state_calls,
+        rms::SetScaleUpFabricStateRequest,
+        rms::SetScaleUpFabricStateResponse
+    );
     impl_enqueue_inspect!(
         enqueue_enable_scale_up_fabric_telemetry_interface,
         enable_scale_up_fabric_telemetry_interface_calls,
@@ -828,6 +842,54 @@ impl RmsApi for MockRmsApi {
         self.get_firmware_job_status_calls.lock().await.push(cmd);
         pop_or_err(&mut self.get_firmware_job_status_responses.lock().await)
     }
+    async fn add_firmware_object(
+        &self,
+        _cmd: rms::AddFirmwareObjectRequest,
+    ) -> Result<rms::FirmwareObject, RackManagerError> {
+        Ok(rms::FirmwareObject::default())
+    }
+    async fn get_firmware_object(
+        &self,
+        _cmd: rms::GetFirmwareObjectRequest,
+    ) -> Result<rms::FirmwareObject, RackManagerError> {
+        Ok(rms::FirmwareObject::default())
+    }
+    async fn list_firmware_objects(
+        &self,
+        _cmd: rms::ListFirmwareObjectsRequest,
+    ) -> Result<rms::ListFirmwareObjectsResponse, RackManagerError> {
+        Ok(rms::ListFirmwareObjectsResponse::default())
+    }
+    async fn delete_firmware_object(
+        &self,
+        _cmd: rms::DeleteFirmwareObjectRequest,
+    ) -> Result<rms::OperationResponse, RackManagerError> {
+        Ok(rms::OperationResponse::default())
+    }
+    async fn set_default_firmware_object(
+        &self,
+        _cmd: rms::SetDefaultFirmwareObjectRequest,
+    ) -> Result<rms::FirmwareObject, RackManagerError> {
+        Ok(rms::FirmwareObject::default())
+    }
+    async fn apply_firmware_object(
+        &self,
+        _cmd: rms::ApplyFirmwareObjectRequest,
+    ) -> Result<rms::ApplyFirmwareObjectResponse, RackManagerError> {
+        Ok(rms::ApplyFirmwareObjectResponse::default())
+    }
+    async fn apply_switch_system_image(
+        &self,
+        _cmd: rms::ApplySwitchSystemImageRequest,
+    ) -> Result<rms::ApplySwitchSystemImageResponse, RackManagerError> {
+        Ok(rms::ApplySwitchSystemImageResponse::default())
+    }
+    async fn get_firmware_object_history(
+        &self,
+        _cmd: rms::GetFirmwareObjectHistoryRequest,
+    ) -> Result<rms::GetFirmwareObjectHistoryResponse, RackManagerError> {
+        Ok(rms::GetFirmwareObjectHistoryResponse::default())
+    }
     async fn list_firmware_on_switch(
         &self,
         cmd: rms::ListFirmwareOnSwitchCommand,
@@ -895,6 +957,13 @@ impl RmsApi for MockRmsApi {
                 .await,
         )
     }
+    async fn set_scale_up_fabric_state(
+        &self,
+        cmd: rms::SetScaleUpFabricStateRequest,
+    ) -> Result<rms::SetScaleUpFabricStateResponse, RackManagerError> {
+        self.set_scale_up_fabric_state_calls.lock().await.push(cmd);
+        pop_or_err(&mut self.set_scale_up_fabric_state_responses.lock().await)
+    }
     async fn enable_scale_up_fabric_telemetry_interface(
         &self,
         cmd: rms::EnableScaleUpFabricTelemetryInterfaceRequest,