Add VM Group and Logical VM Group support to facilitate VM Placement Policy creation; Update Compute Policies to v2.0.0

.changes/v2.17.0/502-improvements.md

@@ -1,2 +1,4 @@
-* Updated VDC Compute Policies retrieval methods `AdminVdc.GetAllAssignedVdcComputePolicies` and `Org.GetAllVdcComputePolicies` 
-  from OpenAPI v1.0.0 to v2.0.0, this version supports more filtering options like `isVgpuPolicy`[GH-502]
+* Created new VDC Compute Policies CRUD methods using OpenAPI v2.0.0:
+  `VCDClient.GetVdcComputePolicyV2ById`, `VCDClient.GetAllVdcComputePoliciesV2`, `VCDClient.CreateVdcComputePolicyV2`,
+  `VdcComputePolicyV2.Update`, `VdcComputePolicyV2.Delete` and `AdminVdc.GetAllAssignedVdcComputePoliciesV2`.
+  This version supports more filtering options like `isVgpuPolicy` [GH-502], [GH-504]

.changes/v2.17.0/504-bug-fixes.md

@@ -0,0 +1 @@
+* Changed `VdcComputePolicy.Description` to a non-omitempty pointer, to be able to send null values to VCD to set empty descriptions. [GH-504]

.changes/v2.17.0/504-deprecations.md

@@ -0,0 +1,3 @@
+* Deprecated OpenAPI v1.0.0 VDC Compute Policies CRUD methods in favor of v2.0.0 ones:
+  `Client.GetVdcComputePolicyById`, `Client.GetAllVdcComputePolicies`, `Client.CreateVdcComputePolicy`
+  `VdcComputePolicy.Update`, `VdcComputePolicy.Delete` and `AdminVdc.GetAllAssignedVdcComputePolicies` [GH-504]

.changes/v2.17.0/504-features.md

@@ -0,0 +1,2 @@
+* Added new methods `VCDClient.GetVmGroupById`, `VCDClient.GetVmGroupByNamedVmGroupIdAndProviderVdcUrn` and `VCDClient.GetVmGroupByNameAndProviderVdcUrn` to retrieve VM Groups. These are useful to create VM Placement Policies [GH-504]
+* Added new methods `VCDClient.GetLogicalVmGroupById`, `VCDClient.CreateLogicalVmGroup` and `LogicalVmGroup.Delete` to manage Logical VM Groups. These are useful to create VM Placement Policies [GH-504]

govcd/api_vcd_test.go

@@ -134,9 +134,10 @@ type TestConfig struct {
 			NetworkPool    string `yaml:"network_pool"`
 		} `yaml:"provider_vdc"`
 		NsxtProviderVdc struct {
-			Name           string `yaml:"name"`
-			StorageProfile string `yaml:"storage_profile"`
-			NetworkPool    string `yaml:"network_pool"`
+			Name                   string `yaml:"name"`
+			StorageProfile         string `yaml:"storage_profile"`
+			NetworkPool            string `yaml:"network_pool"`
+			PlacementPolicyVmGroup string `yaml:"placementPolicyVmGroup,omitempty"`
 		} `yaml:"nsxt_provider_vdc"`
 		Catalog struct {
 			Name                    string `yaml:"name,omitempty"`
@@ -1531,7 +1532,7 @@ func (vcd *TestVCD) removeLeftoverEntities(entity CleanupEntity) {
 		return
 
 	case "vdcComputePolicy":
-		policy, err := vcd.client.Client.GetVdcComputePolicyById(entity.Name)
+		policy, err := vcd.client.GetVdcComputePolicyV2ById(entity.Name)
 		if policy == nil || err != nil {
 			vcd.infoCleanup(notFoundMsg, "vdcComputePolicy", entity.Name)
 			return
@@ -1544,6 +1545,20 @@ func (vcd *TestVCD) removeLeftoverEntities(entity CleanupEntity) {
 		}
 		return
 
+	case "logicalVmGroup":
+		logicalVmGroup, err := vcd.client.GetLogicalVmGroupById(entity.Name)
+		if logicalVmGroup == nil || err != nil {
+			vcd.infoCleanup(notFoundMsg, "logicalVmGroup", entity.Name)
+			return
+		}
+		err = logicalVmGroup.Delete()
+		if err == nil {
+			vcd.infoCleanup(removedMsg, entity.EntityType, entity.Name, entity.CreatedBy)
+		} else {
+			vcd.infoCleanup(notDeletedMsg, entity.EntityType, entity.Name, err)
+		}
+		return
+
 	default:
 		// If we reach this point, we are trying to clean up an entity that
 		// we aren't prepared for yet.

govcd/openapi_endpoints.go

@@ -53,6 +53,7 @@ var endpointMinApiVersions = map[string]string{
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcGroupsDfwDefaultPolicies:        "35.0", // VCD 10.2+
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointSecurityTags:                       "36.0", // VCD 10.3+
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointNsxtRouteAdvertisement:             "34.0", // VCD 10.1+
+	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointLogicalVmGroups:                    "35.0", // VCD 10.2+
 
 	// NSX-T ALB (Advanced/AVI Load Balancer) support was introduced in 10.2
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointAlbController:                    "35.0", // VCD 10.2+

govcd/provider_vdc.go

@@ -88,6 +88,9 @@ func (vcdClient *VCDClient) GetProviderVdcExtendedById(providerVdcId string) (*P
 // On failure, returns a nil pointer and an error
 func (vcdClient *VCDClient) GetProviderVdcByName(providerVdcName string) (*ProviderVdc, error) {
 	providerVdc, err := getProviderVdcByName(vcdClient, providerVdcName, false)
+	if err != nil {
+		return nil, err
+	}
 	return providerVdc.(*ProviderVdc), err
 }
 
@@ -96,6 +99,9 @@ func (vcdClient *VCDClient) GetProviderVdcByName(providerVdcName string) (*Provi
 // On failure, returns a nil pointer and an error
 func (vcdClient *VCDClient) GetProviderVdcExtendedByName(providerVdcName string) (*ProviderVdcExtended, error) {
 	providerVdcExtended, err := getProviderVdcByName(vcdClient, providerVdcName, true)
+	if err != nil {
+		return nil, err
+	}
 	return providerVdcExtended.(*ProviderVdcExtended), err
 }
 

govcd/provider_vdc_test.go

@@ -32,12 +32,26 @@ func (vcd *TestVCD) Test_GetProviderVdc(check *C) {
 	// Common asserts
 	for _, providerVdc := range providerVdcs {
 		check.Assert(providerVdc.ProviderVdc.Name, Equals, vcd.config.VCD.NsxtProviderVdc.Name)
-		check.Assert(providerVdc.ProviderVdc.StorageProfiles.ProviderVdcStorageProfile[0].Name, Equals, vcd.config.VCD.NsxtProviderVdc.StorageProfile)
+		foundStorageProfile := false
+		for _, storageProfile := range providerVdc.ProviderVdc.StorageProfiles.ProviderVdcStorageProfile {
+			if storageProfile.Name == vcd.config.VCD.NsxtProviderVdc.StorageProfile {
+				foundStorageProfile = true
+				break
+			}
+		}
+		check.Assert(foundStorageProfile, Equals, true)
 		check.Assert(*providerVdc.ProviderVdc.IsEnabled, Equals, true)
 		check.Assert(providerVdc.ProviderVdc.ComputeCapacity, NotNil)
 		check.Assert(providerVdc.ProviderVdc.Status, Equals, 1)
 		check.Assert(len(providerVdc.ProviderVdc.NetworkPoolReferences.NetworkPoolReference), Equals, 1)
-		check.Assert(providerVdc.ProviderVdc.NetworkPoolReferences.NetworkPoolReference[0].Name, Equals, vcd.config.VCD.NsxtProviderVdc.NetworkPool)
+		foundNetworkPool := false
+		for _, networkPool := range providerVdc.ProviderVdc.NetworkPoolReferences.NetworkPoolReference {
+			if networkPool.Name == vcd.config.VCD.NsxtProviderVdc.NetworkPool {
+				foundNetworkPool = true
+				break
+			}
+		}
+		check.Assert(foundNetworkPool, Equals, true)
 		check.Assert(providerVdc.ProviderVdc.Link, NotNil)
 	}
 }
@@ -62,12 +76,26 @@ func (vcd *TestVCD) Test_GetProviderVdcExtended(check *C) {
 	for _, providerVdcExtended := range providerVdcsExtended {
 		// Basic PVDC asserts
 		check.Assert(providerVdcExtended.VMWProviderVdc.Name, Equals, vcd.config.VCD.NsxtProviderVdc.Name)
-		check.Assert(providerVdcExtended.VMWProviderVdc.StorageProfiles.ProviderVdcStorageProfile[0].Name, Equals, vcd.config.VCD.NsxtProviderVdc.StorageProfile)
+		foundStorageProfile := false
+		for _, storageProfile := range providerVdcExtended.VMWProviderVdc.StorageProfiles.ProviderVdcStorageProfile {
+			if storageProfile.Name == vcd.config.VCD.NsxtProviderVdc.StorageProfile {
+				foundStorageProfile = true
+				break
+			}
+		}
+		check.Assert(foundStorageProfile, Equals, true)
 		check.Assert(*providerVdcExtended.VMWProviderVdc.IsEnabled, Equals, true)
 		check.Assert(providerVdcExtended.VMWProviderVdc.ComputeCapacity, NotNil)
 		check.Assert(providerVdcExtended.VMWProviderVdc.Status, Equals, 1)
 		check.Assert(len(providerVdcExtended.VMWProviderVdc.NetworkPoolReferences.NetworkPoolReference), Equals, 1)
-		check.Assert(providerVdcExtended.VMWProviderVdc.NetworkPoolReferences.NetworkPoolReference[0].Name, Equals, vcd.config.VCD.NsxtProviderVdc.NetworkPool)
+		foundNetworkPool := false
+		for _, networkPool := range providerVdcExtended.VMWProviderVdc.NetworkPoolReferences.NetworkPoolReference {
+			if networkPool.Name == vcd.config.VCD.NsxtProviderVdc.NetworkPool {
+				foundNetworkPool = true
+				break
+			}
+		}
+		check.Assert(foundNetworkPool, Equals, true)
 		check.Assert(providerVdcExtended.VMWProviderVdc.Link, NotNil)
 		// Extended PVDC asserts
 		check.Assert(providerVdcExtended.VMWProviderVdc.ComputeProviderScope, Equals, "vc1")
@@ -81,6 +109,31 @@ func (vcd *TestVCD) Test_GetProviderVdcExtended(check *C) {
 	}
 }
 
+func (vcd *TestVCD) Test_GetNonExistentProviderVdc(check *C) {
+	if vcd.skipAdminTests {
+		check.Skip(fmt.Sprintf(TestRequiresSysAdminPrivileges, check.TestName()))
+	}
+
+	providerVdcExtended, err := vcd.client.GetProviderVdcExtendedByName("non-existent-pvdc")
+	check.Assert(providerVdcExtended, IsNil)
+	check.Assert(err, NotNil)
+	providerVdcExtended, err = vcd.client.GetProviderVdcExtendedById("non-existent-pvdc")
+	check.Assert(providerVdcExtended, IsNil)
+	check.Assert(err, NotNil)
+	providerVdcExtended, err = vcd.client.GetProviderVdcExtendedByHref("non-existent-pvdc")
+	check.Assert(providerVdcExtended, IsNil)
+	check.Assert(err, NotNil)
+	providerVdc, err := vcd.client.GetProviderVdcByName("non-existent-pvdc")
+	check.Assert(providerVdc, IsNil)
+	check.Assert(err, NotNil)
+	providerVdc, err = vcd.client.GetProviderVdcById("non-existent-pvdc")
+	check.Assert(providerVdc, IsNil)
+	check.Assert(err, NotNil)
+	providerVdc, err = vcd.client.GetProviderVdcByHref("non-existent-pvdc")
+	check.Assert(providerVdc, IsNil)
+	check.Assert(err, NotNil)
+}
+
 func (vcd *TestVCD) Test_GetProviderVdcConvertFromExtendedToNormal(check *C) {
 	if vcd.skipAdminTests {
 		check.Skip(fmt.Sprintf(TestRequiresSysAdminPrivileges, check.TestName()))
@@ -91,7 +144,14 @@ func (vcd *TestVCD) Test_GetProviderVdcConvertFromExtendedToNormal(check *C) {
 	providerVdc, err := providerVdcExtended.ToProviderVdc()
 	check.Assert(err, IsNil)
 	check.Assert(providerVdc.ProviderVdc.Name, Equals, vcd.config.VCD.NsxtProviderVdc.Name)
-	check.Assert(providerVdc.ProviderVdc.StorageProfiles.ProviderVdcStorageProfile[0].Name, Equals, vcd.config.VCD.NsxtProviderVdc.StorageProfile)
+	foundStorageProfile := false
+	for _, storageProfile := range providerVdc.ProviderVdc.StorageProfiles.ProviderVdcStorageProfile {
+		if storageProfile.Name == vcd.config.VCD.NsxtProviderVdc.StorageProfile {
+			foundStorageProfile = true
+			break
+		}
+	}
+	check.Assert(foundStorageProfile, Equals, true)
 	check.Assert(*providerVdc.ProviderVdc.IsEnabled, Equals, true)
 	check.Assert(providerVdc.ProviderVdc.Status, Equals, 1)
 	check.Assert(len(providerVdc.ProviderVdc.NetworkPoolReferences.NetworkPoolReference), Equals, 1)

govcd/sample_govcd_test_config.yaml

@@ -58,6 +58,9 @@ vcd:
       name: nsxTPvdc1
       storage_profile: "*"
       network_pool: "NSX-T Overlay 1"
+      # A VM Group that needs to exist in the backing vSphere. This VM Group can be used
+      # to create VM Placement Policies.
+      placementPolicyVmGroup: testVmGroup
     nsxt:
       # NSX-T manager name to be used as defined in VCD
       manager: nsxManager1

govcd/vapp_test.go

@@ -1507,7 +1507,7 @@ func (vcd *TestVCD) Test_AddNewVMWithComputeCapacity(check *C) {
 		client: vcd.org.client,
 		VdcComputePolicy: &types.VdcComputePolicy{
 			Name:        check.TestName() + "_empty",
-			Description: "Empty policy created by test",
+			Description: takeStringPointer("Empty policy created by test"),
 		},
 	}
 

govcd/vdccomputepolicy.go

@@ -6,38 +6,39 @@ package govcd
 
 import (
 	"fmt"
-	"net/http"
 	"net/url"
 
 	"github.com/vmware/go-vcloud-director/v2/types/v56"
-	"github.com/vmware/go-vcloud-director/v2/util"
 )
 
-// In UI called VM sizing policy. In API VDC compute policy
+// VdcComputePolicy defines a VDC Compute Policy, which can be a VM Sizing Policy, a VM Placement Policy or a vGPU Policy.
+// Deprecated: Use VdcComputePolicyV2 instead
 type VdcComputePolicy struct {
 	VdcComputePolicy *types.VdcComputePolicy
 	Href             string
 	client           *Client
 }
 
 // GetVdcComputePolicyById retrieves VDC compute policy by given ID
+// Deprecated: Use VCDClient.GetVdcComputePolicyV2ById instead
 func (client *Client) GetVdcComputePolicyById(id string) (*VdcComputePolicy, error) {
 	return getVdcComputePolicyById(client, id)
 }
 
 // GetVdcComputePolicyById retrieves VDC compute policy by given ID
-// Deprecated: use client.GetVdcComputePolicyById
+// Deprecated: use VCDClient.GetVdcComputePolicyV2ById
 func (org *AdminOrg) GetVdcComputePolicyById(id string) (*VdcComputePolicy, error) {
 	return getVdcComputePolicyById(org.client, id)
 }
 
 // GetVdcComputePolicyById retrieves VDC compute policy by given ID
-// Deprecated: use client.GetVdcComputePolicyById
+// Deprecated: use VCDClient.GetVdcComputePolicyV2ById
 func (org *Org) GetVdcComputePolicyById(id string) (*VdcComputePolicy, error) {
 	return getVdcComputePolicyById(org.client, id)
 }
 
 // getVdcComputePolicyById retrieves VDC compute policy by given ID
+// Deprecated: Use getVdcComputePolicyV2ById instead
 func getVdcComputePolicyById(client *Client, id string) (*VdcComputePolicy, error) {
 	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcComputePolicies
 	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
@@ -71,28 +72,30 @@ func getVdcComputePolicyById(client *Client, id string) (*VdcComputePolicy, erro
 
 // GetAllVdcComputePolicies retrieves all VDC compute policies using OpenAPI endpoint. Query parameters can be supplied to perform additional
 // filtering
+// Deprecated: use VCDClient.GetAllVdcComputePoliciesV2
 func (client *Client) GetAllVdcComputePolicies(queryParameters url.Values) ([]*VdcComputePolicy, error) {
 	return getAllVdcComputePolicies(client, queryParameters)
 }
 
 // GetAllVdcComputePolicies retrieves all VDC compute policies using OpenAPI endpoint. Query parameters can be supplied to perform additional
 // filtering
-// Deprecated: use client.GetAllVdcComputePolicies
+// Deprecated: use VCDClient.GetAllVdcComputePoliciesV2
 func (org *AdminOrg) GetAllVdcComputePolicies(queryParameters url.Values) ([]*VdcComputePolicy, error) {
 	return getAllVdcComputePolicies(org.client, queryParameters)
 }
 
 // GetAllVdcComputePolicies retrieves all VDC compute policies using OpenAPI endpoint. Query parameters can be supplied to perform additional
 // filtering
-// Deprecated: use client.GetAllVdcComputePolicies
+// Deprecated: use VCDClient.GetAllVdcComputePoliciesV2
 func (org *Org) GetAllVdcComputePolicies(queryParameters url.Values) ([]*VdcComputePolicy, error) {
 	return getAllVdcComputePolicies(org.client, queryParameters)
 }
 
 // getAllVdcComputePolicies retrieves all VDC compute policies using OpenAPI endpoint. Query parameters can be supplied to perform additional
 // filtering
+// Deprecated: use getAllVdcComputePoliciesV2
 func getAllVdcComputePolicies(client *Client, queryParameters url.Values) ([]*VdcComputePolicy, error) {
-	endpoint := types.OpenApiPathVersion2_0_0 + types.OpenApiEndpointVdcComputePolicies
+	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcComputePolicies
 	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
 	if err != nil {
 		return nil, err
@@ -123,12 +126,13 @@ func getAllVdcComputePolicies(client *Client, queryParameters url.Values) ([]*Vd
 }
 
 // CreateVdcComputePolicy creates a new VDC Compute Policy using OpenAPI endpoint
-// Deprecated: use client.CreateVdcComputePolicy
+// Deprecated: use VCDClient.CreateVdcComputePolicyV2
 func (org *AdminOrg) CreateVdcComputePolicy(newVdcComputePolicy *types.VdcComputePolicy) (*VdcComputePolicy, error) {
 	return org.client.CreateVdcComputePolicy(newVdcComputePolicy)
 }
 
 // CreateVdcComputePolicy creates a new VDC Compute Policy using OpenAPI endpoint
+// Deprecated: use VCDClient.CreateVdcComputePolicyV2
 func (client *Client) CreateVdcComputePolicy(newVdcComputePolicy *types.VdcComputePolicy) (*VdcComputePolicy, error) {
 	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcComputePolicies
 	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
@@ -155,6 +159,7 @@ func (client *Client) CreateVdcComputePolicy(newVdcComputePolicy *types.VdcCompu
 }
 
 // Update existing VDC compute policy
+// Deprecated: use VdcComputePolicyV2.Update
 func (vdcComputePolicy *VdcComputePolicy) Update() (*VdcComputePolicy, error) {
 	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcComputePolicies
 	minimumApiVersion, err := vdcComputePolicy.client.checkOpenApiEndpointCompatibility(endpoint)
@@ -185,6 +190,7 @@ func (vdcComputePolicy *VdcComputePolicy) Update() (*VdcComputePolicy, error) {
 }
 
 // Delete deletes VDC compute policy
+// Deprecated: use VdcComputePolicyV2.Delete
 func (vdcComputePolicy *VdcComputePolicy) Delete() error {
 	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcComputePolicies
 	minimumApiVersion, err := vdcComputePolicy.client.checkOpenApiEndpointCompatibility(endpoint)
@@ -212,8 +218,9 @@ func (vdcComputePolicy *VdcComputePolicy) Delete() error {
 
 // GetAllAssignedVdcComputePolicies retrieves all VDC assigned compute policies using OpenAPI endpoint. Query parameters can be supplied to perform additional
 // filtering
+// Deprecated: use AdminVdc.GetAllAssignedVdcComputePoliciesV2
 func (vdc *AdminVdc) GetAllAssignedVdcComputePolicies(queryParameters url.Values) ([]*VdcComputePolicy, error) {
-	endpoint := types.OpenApiPathVersion2_0_0 + types.OpenApiEndpointVdcAssignedComputePolicies
+	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVdcAssignedComputePolicies
 	minimumApiVersion, err := vdc.client.checkOpenApiEndpointCompatibility(endpoint)
 	if err != nil {
 		return nil, err
@@ -242,34 +249,3 @@ func (vdc *AdminVdc) GetAllAssignedVdcComputePolicies(queryParameters url.Values
 
 	return wrappedVdcComputePolicies, nil
 }
-
-// SetAssignedComputePolicies assign(set) compute policies.
-func (vdc *AdminVdc) SetAssignedComputePolicies(computePolicyReferences types.VdcComputePolicyReferences) (*types.VdcComputePolicyReferences, error) {
-	util.Logger.Printf("[TRACE] Set Compute Policies started")
-
-	if !vdc.client.IsSysAdmin {
-		return nil, fmt.Errorf("functionality requires System Administrator privileges")
-	}
-
-	adminVdcPolicyHREF, err := url.ParseRequestURI(vdc.AdminVdc.HREF)
-	if err != nil {
-		return nil, fmt.Errorf("error parsing VDC URL: %s", err)
-	}
-
-	vdcId, err := GetUuidFromHref(vdc.AdminVdc.HREF, true)
-	if err != nil {
-		return nil, fmt.Errorf("unable to get vdc ID from HREF: %s", err)
-	}
-	adminVdcPolicyHREF.Path = "/api/admin/vdc/" + vdcId + "/computePolicies"
-
-	returnedVdcComputePolicies := &types.VdcComputePolicyReferences{}
-	computePolicyReferences.Xmlns = types.XMLNamespaceVCloud
-
-	_, err = vdc.client.ExecuteRequest(adminVdcPolicyHREF.String(), http.MethodPut,
-		types.MimeVdcComputePolicyReferences, "error setting compute policies for VDC: %s", computePolicyReferences, returnedVdcComputePolicies)
-	if err != nil {
-		return nil, err
-	}
-
-	return returnedVdcComputePolicies, nil
-}