change: update NICo to use RMS fw object management API

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.3" }
-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-rc3" }
 ansi-to-html = "0.2.2"
 
 tokio = { version = "1", features = ["full", "tracing"] }

crates/admin-cli/src/cfg/cli_options.rs

@@ -24,9 +24,9 @@ use crate::{
     ib_partition, instance, instance_type, inventory, ip, ipxe_template, jump, machine,
     machine_interfaces, machine_validation, managed_host, managed_switch, mlx, network_devices,
     network_security_group, network_segment, nvl_logical_partition, nvl_partition,
-    nvlink_nmxc_endpoints, operating_system, os_image, ping, power_shelf, rack, rack_firmware,
-    redfish, resource_pool, rms, route_server, scout_stream, set, site_explorer, sku, ssh, switch,
-    tenant, tenant_keyset, tpm_ca, trim_table, version, vpc, vpc_peering, vpc_prefix,
+    nvlink_nmxc_endpoints, operating_system, os_image, ping, power_shelf, rack, redfish,
+    resource_pool, rms, route_server, scout_stream, set, site_explorer, sku, ssh, switch, tenant,
+    tenant_keyset, tpm_ca, trim_table, version, vpc, vpc_peering, vpc_prefix,
 };
 
 #[derive(Parser, Debug)]
@@ -308,13 +308,6 @@ pub enum CliCommand {
     #[clap(about = "Rack Management", subcommand)]
     Rack(rack::Cmd),
 
-    #[clap(
-        about = "Rack Firmware configuration management",
-        subcommand,
-        visible_alias = "rack-fw"
-    )]
-    RackFirmware(rack_firmware::Cmd),
-
     #[clap(about = "RMS Actions")]
     Rms(rms::args::RmsAction),
 

crates/admin-cli/src/component_manager/update_firmware/args.rs

@@ -15,12 +15,15 @@
  * limitations under the License.
  */
 
+use std::path::PathBuf;
+
 use clap::{Args as ClapArgs, Parser, Subcommand};
 
 use crate::component_manager::common::{
     ComputeTrayComponentArg, MachineTargetArgs, NvSwitchComponentArg, PowerShelfComponentArg,
     PowerShelfTargetArgs, RackTargetArgs, SwitchTargetArgs,
 };
+use crate::errors::{CarbideCliError, CarbideCliResult};
 
 #[derive(Parser, Debug)]
 pub struct Args {
@@ -48,8 +51,11 @@ pub struct SwitchArgs {
     #[clap(flatten)]
     pub ids: SwitchTargetArgs,
 
-    #[clap(long = "target-version", help = "Firmware target version")]
-    pub target_version: String,
+    #[clap(flatten)]
+    pub firmware_source: FirmwareSourceArgs,
+
+    #[clap(long = "force-update", help = "Force firmware update when supported")]
+    pub force_update: bool,
 
     #[clap(
         long = "component",
@@ -68,6 +74,9 @@ pub struct PowerShelfArgs {
     #[clap(long = "target-version", help = "Firmware target version")]
     pub target_version: String,
 
+    #[clap(long = "force-update", help = "Force firmware update when supported")]
+    pub force_update: bool,
+
     #[clap(
         long = "component",
         value_enum,
@@ -82,8 +91,11 @@ pub struct ComputeTrayArgs {
     #[clap(flatten)]
     pub ids: MachineTargetArgs,
 
-    #[clap(long = "target-version", help = "Firmware target version")]
-    pub target_version: String,
+    #[clap(flatten)]
+    pub firmware_source: FirmwareSourceArgs,
+
+    #[clap(long = "force-update", help = "Force firmware update when supported")]
+    pub force_update: bool,
 
     #[clap(
         long = "component",
@@ -99,32 +111,114 @@ pub struct RackArgs {
     #[clap(flatten)]
     pub ids: RackTargetArgs,
 
-    #[clap(long = "target-version", help = "Firmware target version")]
-    pub target_version: String,
+    #[clap(flatten)]
+    pub firmware_source: FirmwareSourceArgs,
+
+    #[clap(long = "force-update", help = "Force firmware update when supported")]
+    pub force_update: bool,
 }
 
-impl From<Args> for rpc::forge::UpdateComponentFirmwareRequest {
-    fn from(args: Args) -> Self {
+#[derive(ClapArgs, Debug)]
+pub struct FirmwareSourceArgs {
+    #[clap(
+        long = "target-version",
+        help = "Firmware target version for legacy direct-update paths"
+    )]
+    pub target_version: Option<String>,
+
+    #[clap(
+        long = "sot-json-file",
+        value_name = "PATH",
+        help = "SOT JSON file for RMS ApplyFirmwareObjectFromJSON"
+    )]
+    pub sot_json_file: Option<PathBuf>,
+
+    #[clap(
+        long = "access-token",
+        help = "Artifact access token; required with --sot-json-file"
+    )]
+    pub access_token: Option<String>,
+}
+
+fn resolve_firmware_source(
+    source: FirmwareSourceArgs,
+) -> CarbideCliResult<(String, Option<String>)> {
+    match (
+        source.target_version,
+        source.sot_json_file,
+        source.access_token,
+    ) {
+        (Some(_), Some(_), _) => Err(CarbideCliError::ChooseOneError(
+            "--target-version",
+            "--sot-json-file",
+        )),
+        (None, None, _) => Err(CarbideCliError::RequireOneError(
+            "--target-version",
+            "--sot-json-file",
+        )),
+        (Some(_), None, Some(_)) => Err(CarbideCliError::GenericError(
+            "--access-token requires --sot-json-file".to_string(),
+        )),
+        (Some(target_version), None, None) => {
+            if target_version.trim().is_empty() {
+                Err(CarbideCliError::GenericError(
+                    "--target-version must not be empty".to_string(),
+                ))
+            } else {
+                Ok((target_version, None))
+            }
+        }
+        (None, Some(sot_json_file), access_token) => {
+            let token = access_token.ok_or_else(|| {
+                CarbideCliError::GenericError(
+                    "--access-token is required with --sot-json-file".to_string(),
+                )
+            })?;
+            if token.trim().is_empty() {
+                return Err(CarbideCliError::GenericError(
+                    "--access-token must not be empty".to_string(),
+                ));
+            }
+
+            let config_json = std::fs::read_to_string(sot_json_file)?;
+            serde_json::from_str::<serde_json::Value>(&config_json)?;
+            Ok((config_json, Some(token)))
+        }
+    }
+}
+
+impl TryFrom<Args> for rpc::forge::UpdateComponentFirmwareRequest {
+    type Error = CarbideCliError;
+
+    fn try_from(args: Args) -> CarbideCliResult<Self> {
         match args.target {
-            Target::Switch(target) => Self {
-                target_version: target.target_version,
-                target: Some(
-                    rpc::forge::update_component_firmware_request::Target::Switches(
-                        rpc::forge::UpdateSwitchFirmwareTarget {
-                            switch_ids: Some(target.ids.into()),
-                            components: target
-                                .components
-                                .into_iter()
-                                .map(|component| {
-                                    rpc::forge::NvSwitchComponent::from(component) as i32
-                                })
-                                .collect(),
-                        },
+            Target::Switch(target) => {
+                let (target_version, access_token) =
+                    resolve_firmware_source(target.firmware_source)?;
+                Ok(Self {
+                    target_version,
+                    access_token,
+                    force_update: target.force_update,
+                    target: Some(
+                        rpc::forge::update_component_firmware_request::Target::Switches(
+                            rpc::forge::UpdateSwitchFirmwareTarget {
+                                switch_ids: Some(target.ids.into()),
+                                components: target
+                                    .components
+                                    .into_iter()
+                                    .map(|component| {
+                                        rpc::forge::NvSwitchComponent::from(component) as i32
+                                    })
+                                    .collect(),
+                            },
+                        ),
                     ),
-                ),
-            },
-            Target::PowerShelf(target) => Self {
+                })
+            }
+            Target::PowerShelf(target) => Ok(Self {
                 target_version: target.target_version,
+                access_token: None,
+                force_update: target.force_update,
                 target: Some(
                     rpc::forge::update_component_firmware_request::Target::PowerShelves(
                         rpc::forge::UpdatePowerShelfFirmwareTarget {
@@ -139,34 +233,120 @@ impl From<Args> for rpc::forge::UpdateComponentFirmwareRequest {
                         },
                     ),
                 ),
-            },
-            Target::ComputeTray(target) => Self {
-                target_version: target.target_version,
-                target: Some(
-                    rpc::forge::update_component_firmware_request::Target::ComputeTrays(
-                        rpc::forge::UpdateComputeTrayFirmwareTarget {
-                            machine_ids: Some(target.ids.into()),
-                            components: target
-                                .components
-                                .into_iter()
-                                .map(|component| {
-                                    rpc::forge::ComputeTrayComponent::from(component) as i32
-                                })
-                                .collect(),
-                        },
+            }),
+            Target::ComputeTray(target) => {
+                let (target_version, access_token) =
+                    resolve_firmware_source(target.firmware_source)?;
+                Ok(Self {
+                    target_version,
+                    access_token,
+                    force_update: target.force_update,
+                    target: Some(
+                        rpc::forge::update_component_firmware_request::Target::ComputeTrays(
+                            rpc::forge::UpdateComputeTrayFirmwareTarget {
+                                machine_ids: Some(target.ids.into()),
+                                components: target
+                                    .components
+                                    .into_iter()
+                                    .map(|component| {
+                                        rpc::forge::ComputeTrayComponent::from(component) as i32
+                                    })
+                                    .collect(),
+                            },
+                        ),
                     ),
-                ),
-            },
-            Target::Rack(target) => Self {
-                target_version: target.target_version,
-                target: Some(
-                    rpc::forge::update_component_firmware_request::Target::Racks(
-                        rpc::forge::UpdateRackFirmwareTarget {
-                            rack_ids: Some(target.ids.into()),
-                        },
+                })
+            }
+            Target::Rack(target) => {
+                let (target_version, access_token) =
+                    resolve_firmware_source(target.firmware_source)?;
+                Ok(Self {
+                    target_version,
+                    access_token,
+                    force_update: target.force_update,
+                    target: Some(
+                        rpc::forge::update_component_firmware_request::Target::Racks(
+                            rpc::forge::UpdateFirmwareObjectTarget {
+                                rack_ids: Some(target.ids.into()),
+                            },
+                        ),
                     ),
-                ),
-            },
+                })
+            }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn temp_sot_file(contents: &str) -> PathBuf {
+        let path = std::env::temp_dir().join(format!(
+            "bmm-sot-{}-{}.json",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("system time before unix epoch")
+                .as_nanos()
+        ));
+        std::fs::write(&path, contents).expect("write test SOT JSON");
+        path
+    }
+
+    #[test]
+    fn target_version_source_uses_legacy_version() {
+        let (target_version, access_token) = resolve_firmware_source(FirmwareSourceArgs {
+            target_version: Some("fw-1.0".to_string()),
+            sot_json_file: None,
+            access_token: None,
+        })
+        .expect("legacy source should resolve");
+
+        assert_eq!(target_version, "fw-1.0");
+        assert_eq!(access_token, None);
+    }
+
+    #[test]
+    fn sot_json_source_reads_file_and_sets_access_token() {
+        let path = temp_sot_file(r#"{"Id":"fw-object"}"#);
+
+        let (target_version, access_token) = resolve_firmware_source(FirmwareSourceArgs {
+            target_version: None,
+            sot_json_file: Some(path.clone()),
+            access_token: Some("token".to_string()),
+        })
+        .expect("SOT source should resolve");
+
+        assert_eq!(target_version, r#"{"Id":"fw-object"}"#);
+        assert_eq!(access_token.as_deref(), Some("token"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn access_token_without_sot_json_file_is_rejected() {
+        let err = resolve_firmware_source(FirmwareSourceArgs {
+            target_version: Some("fw-1.0".to_string()),
+            sot_json_file: None,
+            access_token: Some("token".to_string()),
+        })
+        .expect_err("access token without SOT JSON should fail");
+
+        assert!(err.to_string().contains("--access-token requires"));
+    }
+
+    #[test]
+    fn invalid_sot_json_file_is_rejected() {
+        let path = temp_sot_file("not-json");
+
+        let err = resolve_firmware_source(FirmwareSourceArgs {
+            target_version: None,
+            sot_json_file: Some(path.clone()),
+            access_token: Some("token".to_string()),
+        })
+        .expect_err("invalid SOT JSON should fail");
+
+        assert!(matches!(err, CarbideCliError::JsonError(_)));
+        let _ = std::fs::remove_file(path);
+    }
+}