Consumption of Generic functions

Author: Didainius

.changes/v2.23.0/644-notes.md

@@ -0,0 +1 @@
+* Add internal generic functions to handle CRUD operations for inner and outer entities [GH-644]

govcd/adminorg_ldap_test.go

@@ -8,7 +8,6 @@ package govcd
 
 import (
 	"fmt"
-	"time"
 
 	"github.com/vmware/go-vcloud-director/v2/types/v56"
 	. "gopkg.in/check.v1"
@@ -62,10 +61,6 @@ func (vcd *TestVCD) Test_LDAP(check *C) {
 		check.Assert(err, IsNil)
 	}()
 
-	sleepTime := 10 * time.Second
-	fmt.Printf("# Sleeping %s to prevent 'LDAP context not initialized' errors\n", sleepTime.String())
-	time.Sleep(sleepTime)
-
 	// Run tests requiring LDAP from here.
 	vcd.test_GroupCRUD(check)
 	vcd.test_GroupFinderGetGenericEntity(check)

govcd/generic_functions.go

@@ -40,18 +40,17 @@ func oneOrError[E any](key, name string, entitySlice []*E) (*E, error) {
 	return entitySlice[0], nil
 }
 
-// genericLocalFilter performs filtering of a type E based on a field name `fieldName` and its
+// localFilter performs filtering of a type E based on a field name `fieldName` and its
 // expected string value `expectedFieldValue`. Common use case for GetAllX methods where API does
 // not support filtering and it must be done on client side.
 //
 // Note. The field name `fieldName` must be present in a given type E (letter casing is important)
-func genericLocalFilter[E any](entities []*E, fieldName, expectedFieldValue string, entityName string) ([]*E, error) {
+func localFilter[E any](entities []*E, fieldName, expectedFieldValue string, entityName string) ([]*E, error) {
 	if len(entities) == 0 {
 		return nil, fmt.Errorf("zero entities provided for filtering")
 	}
 
 	filteredValues := make([]*E, 0)
-
 	for _, entity := range entities {
 
 		// Need to deference pointer because `reflect` package requires to work with types and not
@@ -82,15 +81,15 @@ func genericLocalFilter[E any](entities []*E, fieldName, expectedFieldValue stri
 	return filteredValues, nil
 }
 
-// genericLocalFilterOneOrError performs local filtering using `genericLocalFilter()` and
+// localFilterOneOrError performs local filtering using `genericLocalFilter()` and
 // additionally verifies that only a single result is present using `oneOrError()`. Common use case
 // for GetXByName methods where API does not support filtering and it must be done on client side.
-func genericLocalFilterOneOrError[E any](entities []*E, fieldName, expectedFieldValue string, entityName string) (*E, error) {
+func localFilterOneOrError[E any](entities []*E, fieldName, expectedFieldValue string, entityName string) (*E, error) {
 	if fieldName == "" || expectedFieldValue == "" {
 		return nil, fmt.Errorf("expected field name and value must be specified to filter %s", entityName)
 	}
 
-	filteredValues, err := genericLocalFilter(entities, fieldName, expectedFieldValue, entityName)
+	filteredValues, err := localFilter(entities, fieldName, expectedFieldValue, entityName)
 	if err != nil {
 		return nil, err
 	}

govcd/ip_space.go

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 VMware, Inc.  All rights reserved.  Licensed under the Apache v2 License.
+ * Copyright 2024 VMware, Inc.  All rights reserved.  Licensed under the Apache v2 License.
  */
 
 package govcd
@@ -27,97 +27,37 @@ type IpSpace struct {
 	vcdClient *VCDClient
 }
 
+// wrap is a hidden helper that helps to facilitate usage of generic CRUD function
+//
+//lint:ignore U1000 this method is used in generic functions, but annoys staticcheck
+func (g IpSpace) wrap(inner *types.IpSpace) *IpSpace {
+	g.IpSpace = inner
+	return &g
+}
+
 // CreateIpSpace creates IP Space with desired configuration
 func (vcdClient *VCDClient) CreateIpSpace(ipSpaceConfig *types.IpSpace) (*IpSpace, error) {
-	client := vcdClient.Client
-	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces
-	apiVersion, err := client.getOpenApiHighestElevatedVersion(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	urlRef, err := client.OpenApiBuildEndpoint(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	result := &IpSpace{
-		IpSpace:   &types.IpSpace{},
-		vcdClient: vcdClient,
-	}
-
-	err = client.OpenApiPostItem(apiVersion, urlRef, nil, ipSpaceConfig, result.IpSpace, nil)
-	if err != nil {
-		return nil, err
+	c := crudConfig{
+		endpoint:   types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces,
+		entityName: "IP Space",
 	}
-
-	return result, nil
+	outerType := IpSpace{vcdClient: vcdClient}
+	return createOuterEntity(&vcdClient.Client, outerType, c, ipSpaceConfig)
 }
 
 // GetAllIpSpaceSummaries retrieve summaries of all IP Spaces with an optional filter
 // Note. There is no API endpoint to get multiple IP Spaces with their full definitions. Only
 // "summaries" endpoint exists, but it does not include all fields. To retrieve complete structure
 // one can use `GetIpSpaceById` or `GetIpSpaceByName`
 func (vcdClient *VCDClient) GetAllIpSpaceSummaries(queryParameters url.Values) ([]*IpSpace, error) {
-	client := vcdClient.Client
-	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaceSummaries
-	apiVersion, err := client.getOpenApiHighestElevatedVersion(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	urlRef, err := client.OpenApiBuildEndpoint(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	typeResponses := []*types.IpSpace{{}}
-	err = client.OpenApiGetAllItems(apiVersion, urlRef, queryParameters, &typeResponses, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// Wrap all typeResponses into IpSpace types with client
-	results := make([]*IpSpace, len(typeResponses))
-	for sliceIndex := range typeResponses {
-		results[sliceIndex] = &IpSpace{
-			IpSpace:   typeResponses[sliceIndex],
-			vcdClient: vcdClient,
-		}
+	c := crudConfig{
+		endpoint:        types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaceSummaries,
+		entityName:      "IP Space",
+		queryParameters: queryParameters,
 	}
 
-	return results, nil
-}
-
-// GetIpSpaceById retrieves IP Space with a given ID
-func (vcdClient *VCDClient) GetIpSpaceById(id string) (*IpSpace, error) {
-	if id == "" {
-		return nil, fmt.Errorf("IP Space lookup requires ID")
-	}
-
-	client := vcdClient.Client
-	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces
-	apiVersion, err := client.getOpenApiHighestElevatedVersion(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	urlRef, err := client.OpenApiBuildEndpoint(endpoint, id)
-	if err != nil {
-		return nil, err
-	}
-
-	response := &IpSpace{
-		vcdClient: vcdClient,
-		IpSpace:   &types.IpSpace{},
-	}
-
-	err = client.OpenApiGetItem(apiVersion, urlRef, nil, response.IpSpace, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return response, nil
+	outerType := IpSpace{vcdClient: vcdClient}
+	return getAllOuterEntities[IpSpace, types.IpSpace](&vcdClient.Client, outerType, c)
 }
 
 // GetIpSpaceByName retrieves IP Space with a given name
@@ -127,39 +67,50 @@ func (vcdClient *VCDClient) GetIpSpaceByName(name string) (*IpSpace, error) {
 		return nil, fmt.Errorf("IP Space lookup requires name")
 	}
 
-	queryParameters := url.Values{}
-	queryParameters.Add("filter", "name=="+name)
+	queryParams := url.Values{}
+	queryParams.Add("filter", "name=="+name)
 
-	filteredIpSpaces, err := vcdClient.GetAllIpSpaceSummaries(queryParameters)
+	filteredEntities, err := vcdClient.GetAllIpSpaceSummaries(queryParams)
 	if err != nil {
-		return nil, fmt.Errorf("error getting IP Spaces: %s", err)
+		return nil, err
 	}
 
-	singleIpSpace, err := oneOrError("name", name, filteredIpSpaces)
+	singleIpSpace, err := oneOrError("name", name, filteredEntities)
 	if err != nil {
 		return nil, err
 	}
 
 	return vcdClient.GetIpSpaceById(singleIpSpace.IpSpace.ID)
 }
 
+func (vcdClient *VCDClient) GetIpSpaceById(id string) (*IpSpace, error) {
+	c := crudConfig{
+		entityName:     "IP Space",
+		endpoint:       types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces,
+		endpointParams: []string{id},
+	}
+
+	outerType := IpSpace{vcdClient: vcdClient}
+	return getOuterEntity[IpSpace, types.IpSpace](&vcdClient.Client, outerType, c)
+}
+
 // GetIpSpaceByNameAndOrgId retrieves IP Space with a given name in a particular Org
 // Note. Only PRIVATE IP spaces belong to Orgs
 func (vcdClient *VCDClient) GetIpSpaceByNameAndOrgId(name, orgId string) (*IpSpace, error) {
 	if name == "" || orgId == "" {
 		return nil, fmt.Errorf("IP Space lookup requires name and Org ID")
 	}
 
-	queryParameters := url.Values{}
-	queryParameters.Add("filter", "name=="+name)
-	queryParameters = queryParameterFilterAnd("orgRef.id=="+orgId, queryParameters)
+	queryParams := url.Values{}
+	queryParams.Add("filter", "name=="+name)
+	queryParams = queryParameterFilterAnd("orgRef.id=="+orgId, queryParams)
 
-	filteredIpSpaces, err := vcdClient.GetAllIpSpaceSummaries(queryParameters)
+	filteredEntities, err := vcdClient.GetAllIpSpaceSummaries(queryParams)
 	if err != nil {
-		return nil, fmt.Errorf("error getting IP Spaces: %s", err)
+		return nil, err
 	}
 
-	singleIpSpace, err := oneOrError("name", name, filteredIpSpaces)
+	singleIpSpace, err := oneOrError("name", name, filteredEntities)
 	if err != nil {
 		return nil, err
 	}
@@ -169,58 +120,21 @@ func (vcdClient *VCDClient) GetIpSpaceByNameAndOrgId(name, orgId string) (*IpSpa
 
 // Update updates IP Space with new config
 func (ipSpace *IpSpace) Update(ipSpaceConfig *types.IpSpace) (*IpSpace, error) {
-	client := ipSpace.vcdClient.Client
-	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces
-	apiVersion, err := client.getOpenApiHighestElevatedVersion(endpoint)
-	if err != nil {
-		return nil, err
-	}
-
-	ipSpaceConfig.ID = ipSpace.IpSpace.ID
-	urlRef, err := client.OpenApiBuildEndpoint(endpoint, ipSpaceConfig.ID)
-	if err != nil {
-		return nil, err
+	c := crudConfig{
+		endpoint:       types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces,
+		endpointParams: []string{ipSpace.IpSpace.ID},
+		entityName:     "IP Space",
 	}
-
-	returnIpSpace := &IpSpace{
-		IpSpace:   &types.IpSpace{},
-		vcdClient: ipSpace.vcdClient,
-	}
-
-	err = client.OpenApiPutItem(apiVersion, urlRef, nil, ipSpaceConfig, returnIpSpace.IpSpace, nil)
-	if err != nil {
-		return nil, fmt.Errorf("error updating IP Space: %s", err)
-	}
-
-	return returnIpSpace, nil
+	outerType := IpSpace{vcdClient: ipSpace.vcdClient}
+	return updateOuterEntity(&ipSpace.vcdClient.Client, outerType, c, ipSpaceConfig)
 }
 
 // Delete deletes IP Space
 func (ipSpace *IpSpace) Delete() error {
-	if ipSpace == nil || ipSpace.IpSpace == nil || ipSpace.IpSpace.ID == "" {
-		return fmt.Errorf("IP Space must have ID")
+	c := crudConfig{
+		endpoint:       types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces,
+		endpointParams: []string{ipSpace.IpSpace.ID},
+		entityName:     "IP Space",
 	}
-
-	client := ipSpace.vcdClient.Client
-	endpoint := types.OpenApiPathVersion1_0_0 + types.OpenApiEndpointIpSpaces
-	apiVersion, err := client.getOpenApiHighestElevatedVersion(endpoint)
-	if err != nil {
-		return err
-	}
-
-	urlRef, err := client.OpenApiBuildEndpoint(endpoint, ipSpace.IpSpace.ID)
-	if err != nil {
-		return err
-	}
-
-	err = client.OpenApiDeleteItem(apiVersion, urlRef, nil, nil)
-	if err != nil {
-		return err
-	}
-
-	if err != nil {
-		return fmt.Errorf("error deleting IP space: %s", err)
-	}
-
-	return nil
+	return deleteEntityById(&ipSpace.vcdClient.Client, c)
 }