feat: wiring in RackHarwareType with rack-firmware management

This wires in the new `RackHardwareType` and `RackHardwareClass` in with the `rack-firmware` management flows, such that the flow is now:

```
admin-cli rack-firmware create <rack-hardware-type> ...
```

...to associate a given rack firmware bundle with an expected rack type. And then, when you:

```
admin-cli rack-firmare apply <rack-id> ....
```

...the backend will now check to make sure the:
- The `RackFirmwareType` of the given `RackId` (based on its configured `RackCapabilitiesSet`) matches the configured `RackFirmwareType` for the firmware.
- The `RackHardwareClass` of the given `RackId` (based on its configured `RackCapabilitesSet`) matches the configured `firmware_type` (`<dev|prod>`) for the firmware.

I also introduced a `RackHardwareType::Any` in here, as if to say "I don't care what the hardware is, just apply the firmware", e.g.

```
admin-cli rack-firmware create any ....
```

...which will associate that firmware with `RackFirmwareType::Any`, so when you go to `rack-firmware apply`, it will apply to `::Any` hardware.

Improved the `rack-firmware list` API call as well with a filtering.

Tests included!

Signed-off-by: Chet Nichols III <chetn@nvidia.com>

Author: chet

crates/admin-cli/src/rack_firmware/create/args.rs

@@ -18,13 +18,16 @@
 use std::path::PathBuf;
 
 use ::rpc::admin_cli::CarbideCliError;
+use ::rpc::forge::RackHardwareType;
 use clap::Parser;
 
 #[derive(Parser, Debug)]
 pub struct Args {
-    #[clap(help = "Path to JSON configuration file")]
+    #[clap(help = "Rack hardware type for this firmware configuration.")]
+    pub rack_hardware_type: RackHardwareType,
+    #[clap(help = "Path to JSON configuration file.")]
     pub json_file: PathBuf,
-    #[clap(help = "Artifactory token for downloading firmware files")]
+    #[clap(help = "Artifactory token for downloading firmware files.")]
     pub artifactory_token: String,
 }
 
@@ -40,11 +43,12 @@ impl TryFrom<Args> for rpc::forge::RackFirmwareCreateRequest {
             ))
         })?;
 
-        // Check that the JSON is valid
+        // Check that the JSON is valid.
         serde_json::from_str::<serde_json::Value>(&config_json)
             .map_err(|e| CarbideCliError::GenericError(format!("Invalid JSON in file: {}", e)))?;
 
         Ok(Self {
+            rack_hardware_type: args.rack_hardware_type as i32,
             config_json,
             artifactory_token: args.artifactory_token,
         })

crates/admin-cli/src/rack_firmware/create/cmd.rs

@@ -16,6 +16,8 @@
  */
 
 use ::rpc::admin_cli::{CarbideCliError, OutputFormat};
+use ::rpc::forge::RackHardwareType;
+use prettytable::{Table, row};
 
 use super::args::Args;
 use crate::rpc::ApiClient;
@@ -31,10 +33,15 @@ pub async fn create(
     if format == OutputFormat::Json {
         println!("{}", serde_json::to_string_pretty(&result)?);
     } else {
-        println!("Created Rack firmware configuration:");
-        println!("  ID: {}", result.id);
-        println!("  Available: {}", result.available);
-        println!("  Created: {}", result.created);
+        let hw_type = RackHardwareType::try_from(result.rack_hardware_type)
+            .unwrap_or_default()
+            .as_str_name();
+        let mut table = Table::new();
+        table.add_row(row!["ID", result.id]);
+        table.add_row(row!["Hardware Type", hw_type]);
+        table.add_row(row!["Available", result.available]);
+        table.add_row(row!["Created", result.created]);
+        table.printstd();
     }
 
     Ok(())

crates/admin-cli/src/rack_firmware/get/cmd.rs

@@ -16,7 +16,8 @@
  */
 
 use ::rpc::admin_cli::{CarbideCliError, OutputFormat};
-use prettytable::{Cell, Row, Table};
+use ::rpc::forge::RackHardwareType;
+use prettytable::{Cell, Row, Table, row};
 
 use super::args::Args;
 use crate::rpc::ApiClient;
@@ -42,13 +43,18 @@ pub async fn get(
     if format == OutputFormat::Json {
         println!("{}", serde_json::to_string_pretty(&result)?);
     } else {
-        println!("Rack Firmware Configuration:");
-        println!("  ID: {}", result.id);
-        println!("  Available: {}", result.available);
-        println!("  Created: {}", result.created);
-        println!("  Updated: {}", result.updated);
-
-        // Display parsed firmware components
+        let hw_type = RackHardwareType::try_from(result.rack_hardware_type)
+            .unwrap_or_default()
+            .as_str_name();
+        let mut table = Table::new();
+        table.add_row(row!["ID", result.id]);
+        table.add_row(row!["Hardware Type", hw_type]);
+        table.add_row(row!["Available", result.available]);
+        table.add_row(row!["Created", result.created]);
+        table.add_row(row!["Updated", result.updated]);
+        table.printstd();
+
+        // Display parsed firmware components.
         if !result.parsed_components.is_empty() && result.parsed_components != "{}" {
             if let Ok(parsed) = serde_json::from_str::<serde_json::Value>(&result.parsed_components)
                 && let Some(devices) = parsed.get("devices").and_then(|d| d.as_object())

crates/admin-cli/src/rack_firmware/history/cmd.rs

@@ -16,6 +16,7 @@
  */
 
 use ::rpc::admin_cli::{CarbideCliError, OutputFormat};
+use ::rpc::forge::RackHardwareType;
 use prettytable::{Cell, Row, Table};
 
 use super::args::Args;
@@ -46,16 +47,21 @@ pub async fn history(
         table.set_titles(Row::new(vec![
             Cell::new("Rack ID"),
             Cell::new("Firmware ID"),
+            Cell::new("Hardware Type"),
             Cell::new("Firmware Type"),
             Cell::new("Applied At"),
             Cell::new("Available"),
         ]));
 
         for (rack_id, records) in &result.histories {
             for record in &records.records {
+                let hw_type = RackHardwareType::try_from(record.rack_hardware_type)
+                    .unwrap_or_default()
+                    .as_str_name();
                 table.add_row(Row::new(vec![
                     Cell::new(rack_id),
                     Cell::new(&record.firmware_id),
+                    Cell::new(hw_type),
                     Cell::new(&record.firmware_type),
                     Cell::new(&record.applied_at),
                     Cell::new(&record.firmware_available.to_string()),

crates/admin-cli/src/rack_firmware/list/args.rs

@@ -15,18 +15,25 @@
  * limitations under the License.
  */
 
+use ::rpc::forge::RackHardwareType;
 use clap::Parser;
 
 #[derive(Parser, Debug)]
 pub struct Args {
-    #[clap(long, help = "Show only available configurations")]
+    #[clap(long, help = "Show only available configurations.")]
     pub only_available: bool,
+    #[clap(help = "Filter by rack hardware type.")]
+    pub rack_hardware_type: Option<RackHardwareType>,
 }
 
-impl From<Args> for rpc::forge::RackFirmwareListRequest {
+impl From<Args> for rpc::forge::RackFirmwareSearchFilter {
     fn from(args: Args) -> Self {
         Self {
             only_available: args.only_available,
+            rack_hardware_type: args
+                .rack_hardware_type
+                .map(|t| t as i32)
+                .unwrap_or(RackHardwareType::Unspecified as i32),
         }
     }
 }

crates/admin-cli/src/rack_firmware/list/cmd.rs

@@ -16,6 +16,7 @@
  */
 
 use ::rpc::admin_cli::{CarbideCliError, OutputFormat};
+use ::rpc::forge::RackHardwareType;
 use prettytable::{Cell, Row, Table};
 
 use super::args::Args;
@@ -36,14 +37,19 @@ pub async fn list(
         let mut table = Table::new();
         table.set_titles(Row::new(vec![
             Cell::new("ID"),
+            Cell::new("Hardware Type"),
             Cell::new("Available"),
             Cell::new("Created"),
             Cell::new("Updated"),
         ]));
 
         for config in result.configs {
+            let hw_type = RackHardwareType::try_from(config.rack_hardware_type)
+                .unwrap_or_default()
+                .as_str_name();
             table.add_row(Row::new(vec![
                 Cell::new(&config.id),
+                Cell::new(hw_type),
                 Cell::new(&config.available.to_string()),
                 Cell::new(&config.created),
                 Cell::new(&config.updated),

crates/admin-cli/src/rack_firmware/tests.rs

@@ -24,6 +24,7 @@
 // Argument Parsing  - Ensure required/optional arg combinations parse correctly.
 
 use clap::{CommandFactory, Parser};
+use rpc::forge::RackHardwareType;
 
 use super::*;
 
@@ -71,6 +72,43 @@ fn parse_list_only_available() {
     }
 }
 
+// parse_list_with_hardware_type_filter ensures list parses with a
+// hardware type filter.
+#[test]
+fn parse_list_with_hardware_type_filter() {
+    let cmd = Cmd::try_parse_from(["rack-firmware", "list", "any"])
+        .expect("should parse list with hardware type filter");
+
+    match cmd {
+        Cmd::List(args) => {
+            assert!(!args.only_available);
+            assert_eq!(args.rack_hardware_type, Some(RackHardwareType::Any));
+        }
+        _ => panic!("expected List variant"),
+    }
+}
+
+// parse_create_with_hardware_type ensures create parses with
+// hardware type as first argument.
+#[test]
+fn parse_create_with_hardware_type() {
+    let cmd = Cmd::try_parse_from([
+        "rack-firmware",
+        "create",
+        "any",
+        "/tmp/test.json",
+        "test-token",
+    ])
+    .expect("should parse create with hardware type");
+
+    match cmd {
+        Cmd::Create(args) => {
+            assert_eq!(args.rack_hardware_type, RackHardwareType::Any);
+        }
+        _ => panic!("expected Create variant"),
+    }
+}
+
 // parse_create_missing_args_fails ensures create fails without required args.
 #[test]
 fn parse_create_missing_args_fails() {

crates/api-db/migrations/20260410163200_rack_firmware_hardware_type.sql

@@ -0,0 +1,7 @@
+-- Add rack_hardware_type to rack_firmware table.
+-- Defaults existing rows to 'any' (matches any rack hardware type).
+ALTER TABLE rack_firmware ADD COLUMN rack_hardware_type VARCHAR(128) NOT NULL DEFAULT 'any';
+CREATE INDEX idx_rack_firmware_rack_hardware_type ON rack_firmware(rack_hardware_type);
+
+-- Add rack_hardware_type to rack_firmware_apply_history table.
+ALTER TABLE rack_firmware_apply_history ADD COLUMN rack_hardware_type VARCHAR(128) NOT NULL DEFAULT 'any';