Add vGPU policy support (#633)

Signed-off-by: Adam Jasinski <jasinskia@vmware.com>

Author: Adam Jasinski

.changes/v2.22.0/633-features.md

@@ -0,0 +1,2 @@
+* Add type `VgpuProfile` and its methods `GetAllVgpuProfiles`, `GetVgpuProfilesByProviderVdc`, `GetVgpuProfileById`, `GetVgpuProfileByName`, `GetVgpuProfileByTenantFacingName`, `Update` and `Refresh` for managing vGPU profiles [GH-633]
+* Update `ComputePolicyV2` type with new fields for managing vGPU policies [GH-633]

govcd/openapi_endpoints.go

@@ -138,6 +138,9 @@ var endpointMinApiVersions = map[string]string{
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointServiceAccountGrant:      "37.0", // VCD 10.4.0+
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointImportableTransportZones: "33.0",
 	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVCenterDistributedSwitch: "33.0",
+
+	// Endpoint for managing vGPU profiles
+	types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVgpuProfile: "36.2",
 }
 
 // endpointElevatedApiVersions endpoint elevated API versions

govcd/vgpu_profile.go

@@ -0,0 +1,155 @@
+package govcd
+
+/*
+ * Copyright 2023 VMware, Inc.  All rights reserved.  Licensed under the Apache v2 License.
+ */
+
+import (
+	"fmt"
+	"net/url"
+
+	"github.com/vmware/go-vcloud-director/v2/types/v56"
+)
+
+// VgpuProfile defines a vGPU profile which is fetched from vCenter
+type VgpuProfile struct {
+	VgpuProfile *types.VgpuProfile
+	client      *Client
+}
+
+// GetAllVgpuProfiles gets all vGPU profiles that are available to VCD
+func (client *VCDClient) GetAllVgpuProfiles(queryParameters url.Values) ([]*VgpuProfile, error) {
+	return getAllVgpuProfiles(queryParameters, &client.Client)
+}
+
+// GetVgpuProfilesByProviderVdc gets all vGPU profiles that are available to a specific provider VDC
+func (client *VCDClient) GetVgpuProfilesByProviderVdc(providerVdcUrn string) ([]*VgpuProfile, error) {
+	queryParameters := url.Values{}
+	queryParameters = queryParameterFilterAnd(fmt.Sprintf("pvdcId==%s", providerVdcUrn), queryParameters)
+	return client.GetAllVgpuProfiles(queryParameters)
+}
+
+// GetVgpuProfileById gets a vGPU profile by ID
+func (client *VCDClient) GetVgpuProfileById(vgpuProfileId string) (*VgpuProfile, error) {
+	return getVgpuProfileById(vgpuProfileId, &client.Client)
+}
+
+// GetVgpuProfileByName gets a vGPU profile by name
+func (client *VCDClient) GetVgpuProfileByName(vgpuProfileName string) (*VgpuProfile, error) {
+	return getVgpuProfileByFilter("name", vgpuProfileName, &client.Client)
+}
+
+// GetVgpuProfileByTenantFacingName gets a vGPU profile by its tenant facing name
+func (client *VCDClient) GetVgpuProfileByTenantFacingName(tenantFacingName string) (*VgpuProfile, error) {
+	return getVgpuProfileByFilter("tenantFacingName", tenantFacingName, &client.Client)
+}
+
+// Update updates a vGPU profile with new parameters
+func (profile *VgpuProfile) Update(newProfile *types.VgpuProfile) error {
+	client := profile.client
+	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVgpuProfile
+	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
+	if err != nil {
+		return err
+	}
+
+	urlRef, err := client.OpenApiBuildEndpoint(endpoint, "/", profile.VgpuProfile.Id)
+	if err != nil {
+		return err
+	}
+
+	err = client.OpenApiPutItemSync(minimumApiVersion, urlRef, nil, newProfile, nil, nil)
+	if err != nil {
+		return err
+	}
+
+	// We need to refresh here, as PUT returns the original struct instead of the updated one
+	err = profile.Refresh()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Refresh updates the current state of the vGPU profile
+func (profile *VgpuProfile) Refresh() error {
+	var err error
+	newProfile, err := getVgpuProfileById(profile.VgpuProfile.Id, profile.client)
+	if err != nil {
+		return err
+	}
+	profile.VgpuProfile = newProfile.VgpuProfile
+
+	return nil
+}
+
+func getVgpuProfileByFilter(filter, filterValue string, client *Client) (*VgpuProfile, error) {
+	queryParameters := url.Values{}
+	queryParameters = queryParameterFilterAnd(fmt.Sprintf("%s==%s", filter, filterValue), queryParameters)
+	vgpuProfiles, err := getAllVgpuProfiles(queryParameters, client)
+	if err != nil {
+		return nil, err
+	}
+
+	vgpuProfile, err := oneOrError(filter, filterValue, vgpuProfiles)
+	if err != nil {
+		return nil, err
+	}
+
+	return vgpuProfile, nil
+}
+
+func getVgpuProfileById(vgpuProfileId string, client *Client) (*VgpuProfile, error) {
+	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVgpuProfile
+	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	urlRef, err := client.OpenApiBuildEndpoint(endpoint, "/", vgpuProfileId)
+	if err != nil {
+		return nil, err
+	}
+
+	profile := &VgpuProfile{
+		client: client,
+	}
+	err = client.OpenApiGetItem(minimumApiVersion, urlRef, nil, &profile.VgpuProfile, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return profile, nil
+}
+
+func getAllVgpuProfiles(queryParameters url.Values, client *Client) ([]*VgpuProfile, error) {
+	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointVgpuProfile
+	minimumApiVersion, err := client.checkOpenApiEndpointCompatibility(endpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	urlRef, err := client.OpenApiBuildEndpoint(endpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	responses := []*types.VgpuProfile{{}}
+
+	err = client.OpenApiGetAllItems(minimumApiVersion, urlRef, queryParameters, &responses, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	wrappedVgpuProfiles := make([]*VgpuProfile, len(responses))
+	for index, response := range responses {
+		wrappedVgpuProfile := &VgpuProfile{
+			client:      client,
+			VgpuProfile: response,
+		}
+		wrappedVgpuProfiles[index] = wrappedVgpuProfile
+	}
+
+	return wrappedVgpuProfiles, nil
+}

types/v56/constants.go

@@ -482,6 +482,9 @@ const (
 	OpenApiEndpointServiceAccountGrant = "deviceLookup/grant"
 	OpenApiEndpointTokens              = "tokens/"
 	OpenApiEndpointServiceAccounts     = "serviceAccounts/"
+
+	// OpenApiEndpointVgpuProfile is used to query vGPU profiles
+	OpenApiEndpointVgpuProfile = "vgpuProfiles"
 )
 
 // Header keys to run operations in tenant context

types/v56/openapi.go

@@ -221,6 +221,8 @@ type VdcComputePolicyV2 struct {
 	IsVgpuPolicy           bool                     `json:"isVgpuPolicy,omitempty"`
 	PvdcNamedVmGroupsMap   []PvdcNamedVmGroupsMap   `json:"pvdcNamedVmGroupsMap,omitempty"`
 	PvdcLogicalVmGroupsMap []PvdcLogicalVmGroupsMap `json:"pvdcLogicalVmGroupsMap,omitempty"`
+	PvdcVgpuClustersMap    []PvdcVgpuClustersMap    `json:"pvdcVgpuClustersMap,omitempty"`
+	VgpuProfiles           []VgpuProfile            `json:"vgpuProfiles,omitempty"`
 }
 
 // PvdcNamedVmGroupsMap is a combination of a reference to a Provider VDC and a list of references to Named VM Groups.
@@ -237,6 +239,11 @@ type PvdcLogicalVmGroupsMap struct {
 	Pvdc            OpenApiReference  `json:"pvdc,omitempty"`
 }
 
+type PvdcVgpuClustersMap struct {
+	Clusters []string         `json:"clusters,omitempty"`
+	Pvdc     OpenApiReference `json:"pvdc,omitempty"`
+}
+
 // OpenApiReference is a generic reference type commonly used throughout OpenAPI endpoints
 type OpenApiReference struct {
 	Name string `json:"name,omitempty"`
@@ -672,3 +679,14 @@ type OpenApiMetadataTypedValue struct {
 	Value interface{} `json:"value,omitempty"` // The Value is anything because it depends on the Type field.
 	Type  string      `json:"type,omitempty"`
 }
+
+// VgpuProfile uniquely represents a type of vGPU
+// vGPU Profiles are fetched from your NVIDIA GRID GPU enabled Clusters in vCenter.
+type VgpuProfile struct {
+	Id                 string `json:"id"`
+	Name               string `json:"name"`
+	TenantFacingName   string `json:"tenantFacingName"`
+	Instructions       string `json:"instructions,omitempty"`
+	AllowMultiplePerVm bool   `json:"allowMultiplePerVm"`
+	Count              int    `json:"count,omitempty"`
+}