chore(rest-api): Update machine gRPC call to use structured fields (config/status)

rest-api/api/pkg/api/handler/instancebatch.go

@@ -2016,7 +2016,7 @@ func allocateMachinesForBatch(
 // Returns empty string if the machine has no NVLink domain information.
 func getNVLinkDomainID(machine *cdbm.Machine) string {
 	if machine.Metadata != nil {
-		if nvlinkInfo := machine.Metadata.GetNvlinkInfo(); nvlinkInfo != nil {
+		if nvlinkInfo := machine.Metadata.GetStatus().GetNvlinkInfo(); nvlinkInfo != nil {
 			if domainUuid := nvlinkInfo.GetDomainUuid(); domainUuid != nil {
 				return domainUuid.GetValue()
 			}

rest-api/api/pkg/api/handler/instancebatch_test.go

@@ -46,9 +46,11 @@ func testBatchBuildMachineWithNVLinkDomain(t *testing.T, dbSession *cdb.Session,
 	mc := testInstanceBuildMachine(t, dbSession, ip, site, cutil.GetPtr(false), nil)
 	mc.Metadata = &cdbm.SiteControllerMachine{
 		Machine: &corev1.Machine{
-			NvlinkInfo: &corev1.MachineNVLinkInfo{
-				DomainUuid: &corev1.NVLinkDomainId{
-					Value: nvlinkDomainID,
+			Status: &corev1.MachineStatus{
+				NvlinkInfo: &corev1.MachineNVLinkInfo{
+					DomainUuid: &corev1.NVLinkDomainId{
+						Value: nvlinkDomainID,
+					},
 				},
 			},
 		},

rest-api/api/pkg/api/model/dpumachine.go

@@ -487,29 +487,30 @@ func (apd *APIDpuMachine) FromProto(protoDpuMachine *corev1.DpuMachine, ctx APID
 	if protoMachine == nil {
 		return
 	}
+	protoMachineStatus := protoMachine.GetStatus()
 
 	apd.ID = protoMachine.GetId().GetId()
 	apd.InfrastructureProviderID = ctx.InfrastructureProviderID.String()
 	apd.SiteID = ctx.SiteID.String()
 	apd.HostMachineID = ctx.HostMachineID
 
-	if protoMachine.DpuAgentVersion != nil {
-		apd.DpuAgentVersion = *protoMachine.DpuAgentVersion
+	if protoMachineStatus != nil && protoMachineStatus.DpuAgentVersion != nil {
+		apd.DpuAgentVersion = *protoMachineStatus.DpuAgentVersion
 	}
 
 	if protoMachine.BmcInfo != nil {
 		apd.BMCInfo = &APIBMCInfo{}
 		apd.BMCInfo.FromProto(protoMachine.BmcInfo)
 	}
 
-	if protoMachine.DiscoveryInfo != nil && protoMachine.DiscoveryInfo.DmiData != nil {
+	if protoMachineStatus.GetDiscoveryInfo() != nil && protoMachineStatus.GetDiscoveryInfo().DmiData != nil {
 		apd.DMIData = &APIDMIData{}
-		apd.DMIData.FromProto(protoMachine.DiscoveryInfo.DmiData)
+		apd.DMIData.FromProto(protoMachineStatus.GetDiscoveryInfo().DmiData)
 	}
 
-	if protoMachine.Interfaces != nil {
-		apd.Interfaces = make([]APIDpuMachineInterface, 0, len(protoMachine.Interfaces))
-		for _, protoInterface := range protoMachine.Interfaces {
+	if protoMachineStatus.GetInterfaces() != nil {
+		apd.Interfaces = make([]APIDpuMachineInterface, 0, len(protoMachineStatus.GetInterfaces()))
+		for _, protoInterface := range protoMachineStatus.GetInterfaces() {
 			if protoInterface != nil {
 				apdInterface := APIDpuMachineInterface{}
 				apdInterface.FromProto(protoInterface)
@@ -530,9 +531,9 @@ func (apd *APIDpuMachine) FromProto(protoDpuMachine *corev1.DpuMachine, ctx APID
 		}
 	}
 
-	if protoMachine.Health != nil {
+	if protoMachineStatus.GetHealth() != nil {
 		apd.Health = &APIMachineHealth{}
-		apd.Health.FromProto(protoMachine.Health)
+		apd.Health.FromProto(protoMachineStatus.GetHealth())
 	}
 
 	var labels cdbm.Labels
@@ -546,8 +547,8 @@ func (apd *APIDpuMachine) FromProto(protoDpuMachine *corev1.DpuMachine, ctx APID
 		apd.DpuNetworkConfig.FromProto(protoDpuMachine.DpuNetworkConfig)
 	}
 
-	if protoMachine.LastRebootTime != nil {
-		lastRebooted := protoMachine.LastRebootTime.AsTime()
+	if protoMachineStatus.GetLastRebootTime() != nil {
+		lastRebooted := protoMachineStatus.GetLastRebootTime().AsTime()
 		apd.LastRebooted = &lastRebooted
 	}
 

rest-api/api/pkg/api/model/dpumachine_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
 	cutil "github.com/NVIDIA/infra-controller/rest-api/common/pkg/util"
@@ -29,30 +30,54 @@ func TestAPIDpuMachine_FromProto(t *testing.T) {
 			Id: &corev1.MachineId{
 				Id: "test-machine-id",
 			},
-			DpuAgentVersion: cutil.GetPtr("1.0.0"),
-			BmcInfo: &corev1.BmcInfo{
-				Ip: cutil.GetPtr("10.0.0.1"),
-			},
-			DiscoveryInfo: &corev1.DiscoveryInfo{
-				DmiData: &corev1.DmiData{
-					BoardName:     "test-board-name",
-					BoardSerial:   "test-board-serial",
-					BoardVersion:  "test-board-version",
-					BiosDate:      "test-bios-date",
-					BiosVersion:   "test-bios-version",
-					ProductSerial: "test-product-serial",
-					ChassisSerial: "test-chassis-serial",
-					ProductName:   "test-product-name",
-					SysVendor:     "test-sys-vendor",
+			Status: &corev1.MachineStatus{
+				DpuAgentVersion: cutil.GetPtr("1.0.0"),
+				DiscoveryInfo: &corev1.DiscoveryInfo{
+					DmiData: &corev1.DmiData{
+						BoardName:     "test-board-name",
+						BoardSerial:   "test-board-serial",
+						BoardVersion:  "test-board-version",
+						BiosDate:      "test-bios-date",
+						BiosVersion:   "test-bios-version",
+						ProductSerial: "test-product-serial",
+						ChassisSerial: "test-chassis-serial",
+						ProductName:   "test-product-name",
+						SysVendor:     "test-sys-vendor",
+					},
 				},
-			},
-			Interfaces: []*corev1.MachineInterface{
-				{
-					Id: &corev1.MachineInterfaceId{
-						Value: "test-interface-id",
+				Interfaces: []*corev1.MachineInterface{
+					{
+						Id: &corev1.MachineInterfaceId{
+							Value: "test-interface-id",
+						},
+					},
+				},
+				Health: &corev1.HealthReport{
+					Source:     "test-health-source",
+					ObservedAt: timestamppb.New(time.Now()),
+					Successes: []*corev1.HealthProbeSuccess{
+						{
+							Id:     "test-success-id",
+							Target: cutil.GetPtr("test-success-target"),
+						},
+					},
+					Alerts: []*corev1.HealthProbeAlert{
+						{
+							Id:           "test-alert-id",
+							Target:       cutil.GetPtr("test-alert-target"),
+							InAlertSince: nil,
+							Classifications: []string{
+								"test-alert-classification",
+							},
+							Message:       "test-alert-message",
+							TenantMessage: nil,
+						},
 					},
 				},
 			},
+			BmcInfo: &corev1.BmcInfo{
+				Ip: cutil.GetPtr("10.0.0.1"),
+			},
 			Inventory: &corev1.MachineComponentInventory{
 				Components: []*corev1.MachineInventorySoftwareComponent{
 					{
@@ -62,28 +87,6 @@ func TestAPIDpuMachine_FromProto(t *testing.T) {
 					},
 				},
 			},
-			Health: &corev1.HealthReport{
-				Source:     "test-health-source",
-				ObservedAt: timestamppb.New(time.Now()),
-				Successes: []*corev1.HealthProbeSuccess{
-					{
-						Id:     "test-success-id",
-						Target: cutil.GetPtr("test-success-target"),
-					},
-				},
-				Alerts: []*corev1.HealthProbeAlert{
-					{
-						Id:           "test-alert-id",
-						Target:       cutil.GetPtr("test-alert-target"),
-						InAlertSince: nil,
-						Classifications: []string{
-							"test-alert-classification",
-						},
-						Message:       "test-alert-message",
-						TenantMessage: nil,
-					},
-				},
-			},
 			Metadata: &corev1.Metadata{
 				Labels: []*corev1.Label{
 					{
@@ -114,6 +117,10 @@ func TestAPIDpuMachine_FromProto(t *testing.T) {
 	assert.Equal(t, "test-board-version", *dpuMachine.DMIData.BoardVersion)
 	assert.Equal(t, "test-product-name", *dpuMachine.DMIData.ProductName)
 	assert.Equal(t, "test-sys-vendor", *dpuMachine.DMIData.SysVendor)
+	require.Len(t, dpuMachine.Interfaces, 1)
+	assert.Equal(t, "test-interface-id", dpuMachine.Interfaces[0].ID)
+	require.NotNil(t, dpuMachine.Health)
+	assert.Equal(t, "test-health-source", dpuMachine.Health.Source)
 }
 
 // TestAPIDpuMachine_FromProto_NilMachine guards against a panic when a

rest-api/api/pkg/api/model/machine.go

@@ -617,7 +617,7 @@ func NewAPIMachine(dbm *cdbm.Machine, dbmcs []cdbm.MachineCapability, dbmis []cd
 				apim.ScoutVersion = machine.LastScoutObservedVersion
 			}
 		}
-		for _, dpuID := range dbm.Metadata.GetAssociatedDpuMachineIds() {
+		for _, dpuID := range dbm.Metadata.GetStatus().GetAssociatedDpuMachineIds() {
 			if id := dpuID.GetId(); id != "" {
 				apim.AssociatedDpuMachineIds = append(apim.AssociatedDpuMachineIds, id)
 			}
@@ -637,43 +637,44 @@ func NewAPIMachine(dbm *cdbm.Machine, dbmcs []cdbm.MachineCapability, dbmis []cd
 
 		// Get the Machine json body
 		machine := dbm.Metadata
+		discoveryInfo := machine.GetStatus().GetDiscoveryInfo()
 		// BMCInfo
 		if machine.BmcInfo != nil {
 			apim.Metadata.BMCInfo = &APIBMCInfo{}
 			apim.Metadata.BMCInfo.FromProto(machine.BmcInfo)
 		}
 
-		if machine.DiscoveryInfo != nil {
+		if discoveryInfo != nil {
 			// DMIData
-			if machine.DiscoveryInfo.DmiData != nil {
+			if discoveryInfo.DmiData != nil {
 				apim.Metadata.DMIData = &APIDMIData{}
-				apim.Metadata.DMIData.FromProto(machine.DiscoveryInfo.DmiData)
+				apim.Metadata.DMIData.FromProto(discoveryInfo.DmiData)
 			}
 
 			// GPUInfo
-			if len(machine.DiscoveryInfo.Gpus) > 0 {
+			if len(discoveryInfo.Gpus) > 0 {
 				apim.Metadata.GPUs = []APIMachineGPUInfo{}
-				for _, gpuInfo := range machine.DiscoveryInfo.Gpus {
+				for _, gpuInfo := range discoveryInfo.Gpus {
 					lgpuInfo := APIMachineGPUInfo{}
 					lgpuInfo.FromProto(gpuInfo)
 					apim.Metadata.GPUs = append(apim.Metadata.GPUs, lgpuInfo)
 				}
 			}
 
 			// Machine Network Interface Info
-			if len(machine.DiscoveryInfo.NetworkInterfaces) > 0 {
+			if len(discoveryInfo.NetworkInterfaces) > 0 {
 				apim.Metadata.NetworkInterfaces = []APIMachineNetworkInterface{}
-				for _, nwiInfo := range machine.DiscoveryInfo.NetworkInterfaces {
+				for _, nwiInfo := range discoveryInfo.NetworkInterfaces {
 					lnwiInfo := APIMachineNetworkInterface{}
 					lnwiInfo.FromProto(nwiInfo)
 					apim.Metadata.NetworkInterfaces = append(apim.Metadata.NetworkInterfaces, lnwiInfo)
 				}
 			}
 
 			// Machine InfiniBand Interface Info
-			if len(machine.DiscoveryInfo.InfinibandInterfaces) > 0 {
+			if len(discoveryInfo.InfinibandInterfaces) > 0 {
 				apim.Metadata.InfiniBandInterfaces = []APIMachineInfiniBandInterface{}
-				for _, ibiInfo := range machine.DiscoveryInfo.InfinibandInterfaces {
+				for _, ibiInfo := range discoveryInfo.InfinibandInterfaces {
 					libiInfo := APIMachineInfiniBandInterface{}
 					libiInfo.FromProto(ibiInfo)
 					apim.Metadata.InfiniBandInterfaces = append(apim.Metadata.InfiniBandInterfaces, libiInfo)