feat: use the node VM category value to set the nodes providerID if it exists

Author: abhay-nutanix

internal/constants/constants.go

@@ -33,4 +33,7 @@ const (
 	CustomHostNameLabel string = "nutanix.com/prism-host-name"
 
 	PrismCentralService string = "PRISM_CENTRAL"
+
+	// AhvMetroCategoryKeyPrefix is the prefix for the ahvMetro category key.
+	AhvMetroCategoryKeyPrefix string = "ahvMetro"
 )

internal/testing/mock/constants.go

@@ -34,6 +34,7 @@ const (
 	MockVMNamePoweredOnClusterCategories = "mock-vm-poweredon-cluster-categories"
 	MockVMNameDpOffload                  = "mock-vm-dp-offload"
 	MockVMNameSecondaryIPs               = "mock-vm-secondary-ips"
+	MockVMNameAhvMetro                   = "mock-vm-ahvmetro"
 
 	MockSecondaryIP1 = "2.2.2.2"
 	MockSecondaryIP2 = "3.3.3.3"
@@ -65,6 +66,9 @@ const (
 	MockVMPoweredOnClusterCategoriesUUID = "00000000-0000-0000-0000-000000000105"
 	MockVMDpOffloadUUID                  = "00000000-0000-0000-0000-000000000106"
 	MockVMSecondaryIPsUUID               = "00000000-0000-0000-0000-000000000107"
+	MockVMAhvMetroUUID                   = "00000000-0000-0000-0000-000000000108"
 	MockCategoryRegionUUID               = "00000000-0000-0000-0000-000000000200"
 	MockCategoryZoneUUID                 = "00000000-0000-0000-0000-000000000201"
+	MockCategoryAhvMetroUUID             = "00000000-0000-0000-0000-000000000202"
+	MockAhvMetroTargetVMUUID             = "00000000-0000-0000-0000-000000000999"
 )

internal/testing/mock/mock_environment.go

@@ -86,6 +86,9 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 	// Create categories with consistent UUIDs
 	regionCategory := getDefaultCategory(MockDefaultRegion, MockCategoryRegionUUID, MockRegion)
 	zoneCategory := getDefaultCategory(MockDefaultZone, MockCategoryZoneUUID, MockZone)
+	// ahvMetro category key format: ahvMetro-<clusterName>-<vmName>
+	ahvMetroCategoryKey := "ahvMetro-" + MockCluster + "-" + MockVMNameAhvMetro
+	ahvMetroCategory := getDefaultCategory(ahvMetroCategoryKey, MockCategoryAhvMetroUUID, MockAhvMetroTargetVMUUID)
 
 	// Create VMs with consistent UUIDs
 	poweredOnVM := getDefaultVM(MockVMNamePoweredOn, MockVMPoweredOnUUID, cluster, host)
@@ -181,6 +184,16 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 		return nil, err
 	}
 
+	// VM with ahvMetro category - the category value contains the target vmUUID for providerID
+	ahvMetroVM := getDefaultVM(MockVMNameAhvMetro, MockVMAhvMetroUUID, cluster, host)
+	ahvMetroVM.Categories = []vmmModels.CategoryReference{
+		{ExtId: ahvMetroCategory.ExtId},
+	}
+	ahvMetroNode, err := createNodeForVM(ctx, kClient, ahvMetroVM)
+	if err != nil {
+		return nil, err
+	}
+
 	return &MockEnvironment{
 		managedMockMachines: map[string]*vmmModels.Vm{
 			*poweredOnVM.ExtId:                  poweredOnVM,
@@ -191,6 +204,7 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 			*filteredAddressesVM.ExtId:          filteredAddressesVM,
 			*dpOffloadVM.ExtId:                  dpOffloadVM,
 			*secondaryIPsVM.ExtId:               secondaryIPsVM,
+			*ahvMetroVM.ExtId:                   ahvMetroVM,
 		},
 		managedMockClusters: map[string]*clusterModels.Cluster{
 			*cluster.ExtId:           cluster,
@@ -201,8 +215,9 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 			*host.ExtId: host,
 		},
 		managedMockCategories: map[string]*prismModels.Category{
-			*regionCategory.ExtId: regionCategory,
-			*zoneCategory.ExtId:   zoneCategory,
+			*regionCategory.ExtId:   regionCategory,
+			*zoneCategory.ExtId:     zoneCategory,
+			*ahvMetroCategory.ExtId: ahvMetroCategory,
 		},
 		managedNodes: map[string]*v1.Node{
 			MockVMNamePoweredOn:                  poweredOnNode,
@@ -215,6 +230,7 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 			MockVMNameFilteredNodeAddresses:      filteredAddressesNode,
 			MockVMNameDpOffload:                  dpOffloadNode,
 			MockVMNameSecondaryIPs:               secondaryIPsNode,
+			MockVMNameAhvMetro:                   ahvMetroNode,
 		},
 		vmNameToExtId: map[string]string{
 			MockVMNamePoweredOn:                  *poweredOnVM.ExtId,
@@ -225,6 +241,7 @@ func CreateMockEnvironment(ctx context.Context, kClient *fake.Clientset) (*MockE
 			MockVMNamePoweredOnClusterCategories: *poweredOnVMClusterCategories.ExtId,
 			MockVMNameDpOffload:                  *dpOffloadVM.ExtId,
 			MockVMNameSecondaryIPs:               *secondaryIPsVM.ExtId,
+			MockVMNameAhvMetro:                   *ahvMetroVM.ExtId,
 		},
 	}, nil
 }

pkg/provider/manager.go

@@ -123,15 +123,26 @@ func (n *nutanixManager) getInstanceMetadata(ctx context.Context, node *v1.Node)
 		return nil, err
 	}
 
-	providerID, err := n.generateProviderID(ctx, vmUUID)
+	nClient, err := n.nutanixClient.Get()
 	if err != nil {
 		return nil, err
 	}
-	nClient, err := n.nutanixClient.Get()
+	vm, err := nClient.GetVM(ctx, vmUUID)
 	if err != nil {
 		return nil, err
 	}
-	vm, err := nClient.GetVM(ctx, vmUUID)
+
+	// Check for ahvMetro category to determine the providerID vmUUID
+	providerVMUUID, err := n.getVMUUIDFromAhvMetroCategory(ctx, nClient, vm)
+	if err != nil {
+		return nil, err
+	}
+	if providerVMUUID == "" {
+		// No ahvMetro category found, use the SystemUUID as before
+		providerVMUUID = vmUUID
+	}
+
+	providerID, err := n.generateProviderID(ctx, providerVMUUID)
 	if err != nil {
 		return nil, err
 	}
@@ -614,6 +625,61 @@ func (n *nutanixManager) getTopologyInfoFromVM(ctx context.Context, nClient inte
 	return nil
 }
 
+// getVMUUIDFromAhvMetroCategory checks if the VM has an ahvMetro category and returns its value.
+// The expected category key format is: ahvMetro-<clusterName>-<vmName>
+// The category value contains the vmUUID to be used for the providerID.
+// Returns empty string if no matching category is found.
+func (n *nutanixManager) getVMUUIDFromAhvMetroCategory(ctx context.Context, nClient interfaces.Prism, vm *vmmModels.Vm) (string, error) {
+	if vm == nil {
+		return "", fmt.Errorf("vm cannot be nil when searching for ahvMetro category")
+	}
+	if nClient == nil {
+		return "", fmt.Errorf("nutanix client cannot be nil when searching for ahvMetro category")
+	}
+
+	if vm.Cluster == nil || vm.Cluster.ExtId == nil || *vm.Cluster.ExtId == "" {
+		klog.V(1).Infof("vm %s has no cluster reference, skipping ahvMetro category lookup", *vm.Name) //nolint:typecheck
+		return "", nil
+	}
+
+	// Get the cluster name for the expected category key
+	cluster, err := nClient.GetCluster(ctx, *vm.Cluster.ExtId)
+	if err != nil {
+		return "", fmt.Errorf("failed to get cluster for ahvMetro category lookup: %v", err)
+	}
+	if cluster == nil || cluster.Name == nil {
+		return "", nil
+	}
+
+	// Build the expected category key: ahvMetro-<clusterName>-<vmName>
+	expectedCategoryKey := fmt.Sprintf("%s-%s-%s", constants.AhvMetroCategoryKeyPrefix, *cluster.Name, *vm.Name)
+	klog.V(1).Infof("looking for ahvMetro category with key: %s", expectedCategoryKey) //nolint:typecheck
+
+	// Iterate through VM categories to find the ahvMetro category
+	for _, categoryRef := range vm.Categories {
+		if categoryRef.ExtId == nil {
+			continue
+		}
+
+		category, err := nClient.GetCategory(ctx, *categoryRef.ExtId)
+		if err != nil {
+			klog.V(1).Infof("failed to get category %s: %v", *categoryRef.ExtId, err) //nolint:typecheck
+			continue
+		}
+		if category == nil || category.Key == nil || category.Value == nil {
+			continue
+		}
+
+		if *category.Key == expectedCategoryKey {
+			klog.V(1).Infof("found ahvMetro category with key %s, value (vmUUID): %s", *category.Key, *category.Value) //nolint:typecheck
+			return strings.ToLower(*category.Value), nil
+		}
+	}
+
+	klog.V(1).Infof("no ahvMetro category found for VM %s", *vm.Name) //nolint:typecheck
+	return "", nil
+}
+
 func (n *nutanixManager) hasEmptyTopologyInfo(ti config.TopologyInfo) bool {
 	if ti.Zone == "" {
 		return true

pkg/provider/manager_test.go

@@ -313,4 +313,44 @@ var _ = Describe("Test Manager", func() { // nolint:typecheck
 			Expect(err).Should(HaveOccurred())
 		})
 	})
+
+	Context("Test getVMUUIDFromAhvMetroCategory", func() {
+		It("should fail if vm is nil", func() { // nolint:typecheck
+			_, err := m.getVMUUIDFromAhvMetroCategory(ctx, nClient, nil)
+			Expect(err).Should(HaveOccurred())
+		})
+
+		It("should fail if nutanixClient is nil", func() { // nolint:typecheck
+			vm := mockEnvironment.GetVM(ctx, mock.MockVMNamePoweredOn)
+			_, err := m.getVMUUIDFromAhvMetroCategory(ctx, nil, vm)
+			Expect(err).Should(HaveOccurred())
+		})
+
+		It("should return empty string if VM has no ahvMetro category", func() { // nolint:typecheck
+			vm := mockEnvironment.GetVM(ctx, mock.MockVMNamePoweredOn)
+			Expect(vm).ToNot(BeNil())
+			vmUUID, err := m.getVMUUIDFromAhvMetroCategory(ctx, nClient, vm)
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(vmUUID).To(BeEmpty())
+		})
+
+		It("should return the ahvMetro category value when present", func() { // nolint:typecheck
+			vm := mockEnvironment.GetVM(ctx, mock.MockVMNameAhvMetro)
+			Expect(vm).ToNot(BeNil())
+			vmUUID, err := m.getVMUUIDFromAhvMetroCategory(ctx, nClient, vm)
+			Expect(err).ShouldNot(HaveOccurred())
+			// The returned value should be lowercase
+			Expect(vmUUID).To(Equal(mock.MockAhvMetroTargetVMUUID))
+		})
+
+		It("should return empty string if VM has no cluster reference", func() { // nolint:typecheck
+			vm := mockEnvironment.GetVM(ctx, mock.MockVMNamePoweredOn)
+			Expect(vm).ToNot(BeNil())
+			// Remove cluster reference
+			vm.Cluster = nil
+			vmUUID, err := m.getVMUUIDFromAhvMetroCategory(ctx, nClient, vm)
+			Expect(err).ShouldNot(HaveOccurred())
+			Expect(vmUUID).To(BeEmpty())
+		})
+	})
 })