refactor(machine): separate Machine fields into config/status

Add `MachineConfig` and `MachineStatus` to the `forge.Machine`
proto message and corresponding structs to `carbide-api-model`.

Protobuf changes:

- Add `MachineConfig`
- Add `MachineStatus`
- Populate both messages in the `From<Machine>` RPC conversion while
  maintaining compatibility with rest-api.  rest-api consumers are unaffected
  until a follow-up PR migrates them. See #2793
- Mark all moved fields `[deprecated = true]` with a `TODO` to reserve
  the field numbers once rest-api is updated.

Model Changes:

- Extract `MachineConfig` (`config.rs`) and `MachineStatus` (`status.rs`)
  from the flat `Machine` struct; callers updated throughout the workspace.
- No deprecated copies in the Rust model — all internal callsites use the
  new paths (`machine.config.X`, `machine.status.X`).

Author: ianderson-nvidia

crates/admin-cli/src/main.rs

@@ -17,6 +17,9 @@
 
 // CLI enums variants can be rather large, we are ok with that.
 #![allow(clippy::large_enum_variant)]
+// The deprecated fields on `rpc::forge::Machine` must still be read here for
+// backwards-compat. See https://github.com/NVIDIA/infra-controller/issues/2793
+#![allow(deprecated)]
 
 use std::fs::File;
 use std::io::Write;

crates/api-core/src/attestation/mod.rs

@@ -53,6 +53,7 @@ pub async fn get_ek_cert_by_machine_id(
 
     // obtain an ek cert
     let tpm_ek_cert = machine
+        .status
         .hardware_info
         .as_ref()
         .ok_or_else(|| CarbideError::internal("Hardware Info not found.".to_string()))?

crates/api-core/src/dpa/handler.rs

@@ -201,7 +201,7 @@ async fn handle_dpa_message(services: Arc<Api>, message: SetVni, topic: String)
 
     let machine = machine.unwrap();
 
-    let cur_spx_status_observations = machine.spx_status_observation.unwrap_or_default();
+    let cur_spx_status_observations = machine.status.spx_status_observation.unwrap_or_default();
     let mut new_spx_status_observations = MachineSpxStatusObservation::default();
 
     let mut add_new_observation = true;

crates/api-core/src/ethernet_virtualization.rs

@@ -332,10 +332,15 @@ pub async fn admin_network(
     // If we loop through the machine interfaces for the host snapshot and look for
     // that combo, the segment_id of that interface should be the network segment we want,
     // but checking against known admin segments adds a little bit of defense.
-    let interface = snapshot.host_snapshot.interfaces.iter().find(|interface| {
-        interface.attached_dpu_machine_id.as_ref() == Some(dpu_machine_id)
-            && admin_segment_ids.contains(&interface.segment_id)
-    });
+    let interface = snapshot
+        .host_snapshot
+        .status
+        .interfaces
+        .iter()
+        .find(|interface| {
+            interface.attached_dpu_machine_id.as_ref() == Some(dpu_machine_id)
+                && admin_segment_ids.contains(&interface.segment_id)
+        });
 
     let host_machine_id = snapshot.host_snapshot.id;
     let Some(interface) = interface else {
@@ -351,6 +356,7 @@ pub async fn admin_network(
     // still disables the admin DHCP path on non-primary DPUs via is_primary_dpu.
     let active_interface = snapshot
         .host_snapshot
+        .status
         .interfaces
         .iter()
         .find(|interface| {

crates/api-core/src/handlers/attestation.rs

@@ -58,7 +58,7 @@ pub(crate) async fn trigger_machine_attestation(
                 id: format!("{}", machine_id),
             }));
         }
-        1 => &machines[0].bmc_info,
+        1 => &machines[0].status.bmc_info,
         _ => {
             return Err(Status::from(CarbideError::Internal {
                 message: format!("Found more than one machine for machine id {}", machine_id),

crates/api-core/src/handlers/bmc_endpoint_explorer.rs

@@ -594,6 +594,7 @@ pub(crate) async fn admin_power_control(
 
             if let Some(power_state) = snapshot
                 .host_snapshot
+                .status
                 .power_options
                 .map(|x| x.desired_power_state)
                 && power_state == model::power_manager::PowerState::On
@@ -1091,13 +1092,13 @@ pub(crate) async fn validate_and_complete_bmc_endpoint_request(
                     id: machine_id.to_string(),
                 })?;
 
-            let bmc_ip = machine.bmc_info.ip.as_ref().ok_or_else(|| {
+            let bmc_ip = machine.status.bmc_info.ip.as_ref().ok_or_else(|| {
                 CarbideError::internal(format!(
                     "Machine found for {machine_id} but BMC IP is missing"
                 ))
             })?;
 
-            let bmc_mac_address = machine.bmc_info.mac.ok_or_else(|| {
+            let bmc_mac_address = machine.status.bmc_info.mac.ok_or_else(|| {
                 CarbideError::internal(format!("BMC endpoint for {bmc_ip} ({machine_id}) found but does not have associated MAC"))
             })?;
 

crates/api-core/src/handlers/component_manager.rs

@@ -571,7 +571,7 @@ async fn group_machine_ids_by_rack(
         let machine = machines_by_id
             .get(machine_id)
             .ok_or_else(|| Status::not_found(format!("machine {machine_id} not found")))?;
-        let rack_id = machine.rack_id.clone().ok_or_else(|| {
+        let rack_id = machine.config.rack_id.clone().ok_or_else(|| {
             Status::failed_precondition(format!(
                 "machine {machine_id} is not associated with a rack"
             ))
@@ -585,6 +585,7 @@ async fn group_machine_ids_by_rack(
 /// Returns whether the machine is a rack-scale server (today just GB200, but will later include other SKUs)
 fn is_rack_scale_server(machine: &Machine) -> bool {
     machine
+        .status
         .hardware_info
         .as_ref()
         .is_some_and(|hw| hw.is_gbx00())
@@ -1126,15 +1127,15 @@ async fn resolve_compute_tray_endpoints(
             continue;
         };
 
-        let Some(bmc_mac) = machine.bmc_info.mac else {
+        let Some(bmc_mac) = machine.status.bmc_info.mac else {
             unresolved.push(UnresolvedDevice {
                 id: machine_id,
                 reason: "BMC MAC not available".into(),
             });
             continue;
         };
 
-        let Some(bmc_ip) = machine.bmc_info.ip else {
+        let Some(bmc_ip) = machine.status.bmc_info.ip else {
             unresolved.push(UnresolvedDevice {
                 id: machine_id,
                 reason: "BMC IP not configured".into(),

crates/api-core/src/handlers/dpf.rs

@@ -49,7 +49,7 @@ pub(crate) async fn modify_dpf_state(
             id: machine_id.to_string(),
         })?;
 
-    if !request.dpf_enabled && machine_snapshot.host_snapshot.dpf.used_for_ingestion {
+    if !request.dpf_enabled && machine_snapshot.host_snapshot.config.dpf.used_for_ingestion {
         return Err(CarbideError::FailedPrecondition(format!(
             "Cannot disable DPF for host {}: machine was ingested via DPF.",
             machine_id

crates/api-core/src/handlers/dpu.rs

@@ -104,6 +104,7 @@ pub(crate) async fn get_managed_host_network_config_inner(
 
     let primary_dpu_snapshot = snapshot
         .host_snapshot
+        .status
         .interfaces
         .iter()
         .find(|x| x.primary_interface)
@@ -190,6 +191,7 @@ pub(crate) async fn get_managed_host_network_config_inner(
 
     let booturl_override = if snapshot
         .host_snapshot
+        .status
         .hardware_info
         .as_ref()
         .map(|h| h.machine_type)
@@ -927,7 +929,7 @@ pub(crate) async fn record_dpu_network_status(
                 id: dpu_machine_id.to_string(),
             })?;
 
-        if snapshot.host_snapshot.dpf.used_for_ingestion {
+        if snapshot.host_snapshot.config.dpf.used_for_ingestion {
             // DPF-managed DPUs don't use this upgrade path. Clear any stale flag so the DPU
             // doesn't keep receiving upgrade signals after the host was switched to DPF.
             if dpu_machine.needs_agent_upgrade() {

crates/api-core/src/handlers/instance.rs

@@ -893,16 +893,16 @@ pub(crate) async fn invoke_power(
         log_tenant_organization_id(instance.config.tenant.tenant_organization_id.as_str());
     }
 
-    let bmc_ip =
-        snapshot
-            .host_snapshot
-            .bmc_info
-            .ip
-            .as_ref()
-            .ok_or_else(|| CarbideError::NotFoundError {
-                kind: "bmc_ip",
-                id: machine_id.to_string(),
-            })?;
+    let bmc_ip = snapshot
+        .host_snapshot
+        .status
+        .bmc_info
+        .ip
+        .as_ref()
+        .ok_or_else(|| CarbideError::NotFoundError {
+            kind: "bmc_ip",
+            id: machine_id.to_string(),
+        })?;
 
     let run_provisioning_instructions_on_every_boot = snapshot
         .instance
@@ -1030,6 +1030,7 @@ pub(crate) async fn invoke_power(
     let bmc_mac_address =
         snapshot
             .host_snapshot
+            .status
             .bmc_info
             .mac
             .ok_or_else(|| CarbideError::NotFoundError {
@@ -1045,7 +1046,7 @@ pub(crate) async fn invoke_power(
         .redfish_pool
         .create_client(
             &bmc_ip,
-            snapshot.host_snapshot.bmc_info.port,
+            snapshot.host_snapshot.status.bmc_info.port,
             RedfishAuth::Key(CredentialKey::BmcCredentials {
                 credential_type: BmcCredentialType::BmcRoot { bmc_mac_address },
             }),