Add filter by cluster uuid in subnet datasource

.golangci.yml

@@ -58,6 +58,12 @@ issues:
       linters:
         - testpackage
       # part of the golangci govet package is picking up things that go vet doesn't. Seems flaky, shutting that specific error off
+    - path: client/client.go
+      linters:
+        - interfacer
+      # interfacer lint on `filter` func suggests lint changes that dont compile
+      # Details: linter suggests to convert `body` param to io.Reader since we don't use Close method, but return type requires
+      ## io.ReadCloser thus failing to compile
 
 run:
   # which dirs to skip: they won't be analyzed;

client/client.go

@@ -12,6 +12,7 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"strings"
 
 	"github.com/hashicorp/terraform-plugin-sdk/helper/logging"
 )
@@ -61,6 +62,12 @@ type Credentials struct {
 	ProxyURL    string
 }
 
+// AdditionalFilter specification for client side filters
+type AdditionalFilter struct {
+	Name   string
+	Values []string
+}
+
 // NewClient returns a new Nutanix API client.
 func NewClient(credentials *Credentials, userAgent string, absolutePath string) (*Client, error) {
 	if userAgent == "" {
@@ -239,6 +246,138 @@ func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) error
 	return err
 }
 
+func searchSlice(slice []string, key string) bool {
+	for _, v := range slice {
+		if v == key {
+			return true
+		}
+	}
+	return false
+}
+
+// DoWithFilters performs request passed and filters entities in json response
+func (c *Client) DoWithFilters(ctx context.Context, req *http.Request, v interface{}, filters []*AdditionalFilter, baseSearchPaths [][]string) error {
+	req = req.WithContext(ctx)
+	resp, err := c.client.Do(req)
+
+	if err != nil {
+		return err
+	}
+
+	defer func() {
+		if rerr := resp.Body.Close(); err == nil {
+			err = rerr
+		}
+	}()
+
+	err = CheckResponse(resp)
+
+	if err != nil {
+		return err
+	}
+
+	resp.Body = filter(resp.Body, filters, baseSearchPaths)
+
+	if v != nil {
+		if w, ok := v.(io.Writer); ok {
+			_, err = io.Copy(w, resp.Body)
+			if err != nil {
+				fmt.Printf("Error io.Copy %s", err)
+
+				return err
+			}
+		} else {
+			err = json.NewDecoder(resp.Body).Decode(v)
+			if err != nil {
+				return fmt.Errorf("error unmarshalling json: %s", err)
+			}
+		}
+	}
+
+	if c.onRequestCompleted != nil {
+		c.onRequestCompleted(req, resp, v)
+	}
+
+	return err
+}
+
+func filter(body io.ReadCloser, filters []*AdditionalFilter, baseSearchPaths [][]string) io.ReadCloser {
+	if filters == nil {
+		return body
+	}
+	var res map[string]interface{}
+	b, _ := io.ReadAll(body)
+	json.Unmarshal(b, &res)
+
+	// Full search paths
+	searchPaths := map[string][][]string{}
+
+	filterMap := map[string]*AdditionalFilter{}
+	for _, filter := range filters {
+		filterMap[filter.Name] = filter
+
+		// Build search paths by appending target search paths to base paths
+		filterSearchPaths := [][]string{}
+		if len(baseSearchPaths) == 0 {
+			searchPath := strings.Split(filter.Name, ".")
+			filterSearchPaths = append(filterSearchPaths, searchPath)
+		}
+		for _, baseSearchPath := range baseSearchPaths {
+			searchPath := append(baseSearchPath, strings.Split(filter.Name, ".")...)
+			filterSearchPaths = append(filterSearchPaths, searchPath)
+		}
+		searchPaths[filter.Name] = filterSearchPaths
+	}
+
+	// Entities that pass filters
+	var filteredEntities []interface{}
+
+	entities := res["entities"].([]interface{})
+	for _, entity := range entities {
+		filtersPassed := 0
+	filter_loop:
+		for filter, filterSearchPaths := range searchPaths {
+			for _, searchPath := range filterSearchPaths {
+				// Start searching from the entity root
+				searchTarget := entity.(map[string]interface{})
+
+				pathOk := false
+
+				// Traverse till leaf
+				for _, pathElem := range searchPath[:len(searchPath)-1] {
+					if searchTarget, pathOk = searchTarget[pathElem].(map[string]interface{}); !pathOk {
+						break
+					}
+				}
+				if !pathOk {
+					continue // Could not find the filter key in this search path
+				}
+
+				// Stringify leaf value since we support only string values in filter
+				value := fmt.Sprint(searchTarget[searchPath[len(searchPath)-1]])
+				if searchSlice(filterMap[filter].Values, value) {
+					filtersPassed++
+					continue filter_loop
+				}
+			}
+		}
+
+		// Value must pass all filters since we perform logical AND b/w filters
+		if filtersPassed == len(filters) {
+			filteredEntities = append(filteredEntities, entity)
+		}
+	}
+	res["entities"] = filteredEntities
+
+	// Convert filtered result back to io.ReadCloser
+	filteredBody, jsonErr := json.Marshal(res)
+	if jsonErr == nil {
+		return io.NopCloser(bytes.NewReader(filteredBody))
+	}
+
+	return body
+}
+
 // CheckResponse checks errors if exist errors in request
 func CheckResponse(r *http.Response) error {
 	c := r.StatusCode

client/client_test.go

@@ -3,11 +3,13 @@ package client
 import (
 	"context"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
 	"net/url"
 	"reflect"
+	"regexp"
 	"strings"
 	"testing"
 )
@@ -241,6 +243,65 @@ func TestDo_redirectLoop(t *testing.T) {
 // 	}
 // }
 
+// *********** Filters tests ***********
+
+func getEntity(name string, vlanID string, uuid string) string {
+	return fmt.Sprintf(`{"spec":{"cluster_reference":{"uuid":"%s"},"name":"%s","resources":{"vlan_id":%s}}}`, uuid, name, vlanID)
+}
+
+func removeWhiteSpace(input string) string {
+	whitespacePattern := regexp.MustCompile(`\s+`)
+	return whitespacePattern.ReplaceAllString(input, "")
+}
+
+func getFilter(name string, values []string) []*AdditionalFilter {
+	return []*AdditionalFilter{
+		{
+			Name:   name,
+			Values: values,
+		},
+	}
+}
+
+func runTest(filters []*AdditionalFilter, inputString string, expected string) bool {
+	input := io.NopCloser(strings.NewReader(inputString))
+	fmt.Println(expected)
+	baseSearchPaths := [][]string{
+		{"spec"},
+		{"spec", "resources"},
+	}
+	actualBytes, _ := io.ReadAll(filter(input, filters, baseSearchPaths))
+	actual := string(actualBytes)
+	fmt.Println(actual)
+	return actual == expected
+}
+
+func TestDoWithFilters_filter(t *testing.T) {
+	entity1 := getEntity("subnet-01", "111", "012345-111")
+	entity2 := getEntity("subnet-01", "112", "012345-112")
+	entity3 := getEntity("subnet-02", "112", "012345-111")
+	input := fmt.Sprintf(`{"entities":[%s,%s,%s]}`, entity1, entity2, entity3)
+
+	filtersList := [][]*AdditionalFilter{
+		getFilter("name", []string{"subnet-01", "subnet-03"}),
+		getFilter("vlan_id", []string{"111", "subnet-03"}),
+		getFilter("cluster_reference.uuid", []string{"111", "012345-112"}),
+	}
+	expectedList := []string{
+		removeWhiteSpace(fmt.Sprintf(`{"entities":[%s,%s]}`, entity1, entity2)),
+		removeWhiteSpace(fmt.Sprintf(`{"entities":[%s]}`, entity1)),
+		removeWhiteSpace(fmt.Sprintf(`{"entities":[%s]}`, entity2)),
+	}
+
+	for i := 0; i < len(filtersList); i++ {
+		if ok := runTest(filtersList[i], input, expectedList[i]); !ok {
+			t.Fatal()
+		}
+	}
+}
+
+// *************************************
+
 func TestClient_NewRequest(t *testing.T) {
 	type fields struct {
 		Credentials        *Credentials

client/v3/v3_service.go

@@ -57,7 +57,7 @@ type Service interface {
 	DeleteVolumeGroup(uuid string) error
 	CreateVolumeGroup(request *VolumeGroupInput) (*VolumeGroupResponse, error)
 	ListAllVM(filter string) (*VMListIntentResponse, error)
-	ListAllSubnet(filter string) (*SubnetListIntentResponse, error)
+	ListAllSubnet(filter string, additionalFilters []*client.AdditionalFilter) (*SubnetListIntentResponse, error)
 	ListAllNetworkSecurityRule(filter string) (*NetworkSecurityRuleListIntentResponse, error)
 	ListAllImage(filter string) (*ImageListIntentResponse, error)
 	ListAllCluster(filter string) (*ClusterListIntentResponse, error)
@@ -293,8 +293,12 @@ func (op Operations) ListSubnet(getEntitiesRequest *DSMetadata) (*SubnetListInte
 	if err != nil {
 		return nil, err
 	}
+	baseSearchPaths := [][]string{
+		{"spec"},
+		{"spec", "resources"},
+	}
 
-	return subnetListIntentResponse, op.client.Do(ctx, req, subnetListIntentResponse)
+	return subnetListIntentResponse, op.client.DoWithFilters(ctx, req, subnetListIntentResponse, getEntitiesRequest.AdditionalFilters, baseSearchPaths)
 }
 
 /*UpdateSubnet Updates a subnet
@@ -938,13 +942,14 @@ func (op Operations) ListAllVM(filter string) (*VMListIntentResponse, error) {
 }
 
 // ListAllSubnet ...
-func (op Operations) ListAllSubnet(filter string) (*SubnetListIntentResponse, error) {
+func (op Operations) ListAllSubnet(filter string, additionalFilters []*client.AdditionalFilter) (*SubnetListIntentResponse, error) {
 	entities := make([]*SubnetIntentResponse, 0)
 
 	resp, err := op.ListSubnet(&DSMetadata{
-		Filter: &filter,
-		Kind:   utils.StringPtr("subnet"),
-		Length: utils.Int64Ptr(itemsPerPage),
+		Filter:            &filter,
+		Kind:              utils.StringPtr("subnet"),
+		Length:            utils.Int64Ptr(itemsPerPage),
+		AdditionalFilters: additionalFilters,
 	})
 
 	if err != nil {

client/v3/v3_structs.go

@@ -2,6 +2,8 @@ package v3
 
 import (
 	"time"
+
+	"github.com/terraform-providers/terraform-provider-nutanix/client"
 )
 
 // Reference ...
@@ -583,6 +585,9 @@ type DSMetadata struct {
 
 	// The sort order in which results are returned
 	SortOrder *string `json:"sort_order,omitempty" mapstructure:"sort_order,omitempty"`
+
+	// Additional filters for client side filtering api response
+	AdditionalFilters []*client.AdditionalFilter `json:"-"`
 }
 
 // VMIntentResource Response object for intentful operations on a vm

nutanix/data_source_nutanix_subnet.go

@@ -5,6 +5,7 @@ import (
 	"log"
 
 	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/terraform-providers/terraform-provider-nutanix/client"
 	v3 "github.com/terraform-providers/terraform-provider-nutanix/client/v3"
 	"github.com/terraform-providers/terraform-provider-nutanix/utils"
 )
@@ -31,6 +32,7 @@ func dataSourceNutanixSubnet() *schema.Resource {
 				Optional:      true,
 				ConflictsWith: []string{"subnet_id"},
 			},
+			"additional_filter": DataSourceFiltersSchema(),
 			"api_version": {
 				Type:     schema.TypeString,
 				Computed: true,
@@ -283,9 +285,9 @@ func findSubnetByUUID(conn *v3.Client, uuid string) (*v3.SubnetIntentResponse, e
 	return conn.V3.GetSubnet(uuid)
 }
 
-func findSubnetByName(conn *v3.Client, name string) (*v3.SubnetIntentResponse, error) {
+func findSubnetByName(conn *v3.Client, name string, additionalFilters []*client.AdditionalFilter) (*v3.SubnetIntentResponse, error) {
 	filter := fmt.Sprintf("name==%s", name)
-	resp, err := conn.V3.ListAllSubnet(filter)
+	resp, err := conn.V3.ListAllSubnet(filter, additionalFilters)
 	if err != nil {
 		return nil, err
 	}
@@ -300,7 +302,7 @@ func findSubnetByName(conn *v3.Client, name string) (*v3.SubnetIntentResponse, e
 	}
 
 	if len(found) > 1 {
-		return nil, fmt.Errorf("your query returned more than one result. Please use subnet_id argument instead")
+		return nil, fmt.Errorf("your query returned more than one result. Please use subnet_id argument or use additional filters instead")
 	}
 
 	if len(found) == 0 {
@@ -316,6 +318,10 @@ func dataSourceNutanixSubnetRead(d *schema.ResourceData, meta interface{}) error
 
 	subnetID, iok := d.GetOk("subnet_id")
 	subnetName, nok := d.GetOk("subnet_name")
+	var additionalFilters []*client.AdditionalFilter
+	if v, ok := d.GetOk("additional_filter"); ok {
+		additionalFilters = BuildFiltersDataSource(v.(*schema.Set))
+	}
 
 	if !iok && !nok {
 		return fmt.Errorf("please provide one of subnet_id or subnet_name attributes")
@@ -327,7 +333,7 @@ func dataSourceNutanixSubnetRead(d *schema.ResourceData, meta interface{}) error
 	if iok {
 		resp, reqErr = findSubnetByUUID(conn, subnetID.(string))
 	} else {
-		resp, reqErr = findSubnetByName(conn, subnetName.(string))
+		resp, reqErr = findSubnetByName(conn, subnetName.(string), additionalFilters)
 	}
 
 	if reqErr != nil {

nutanix/data_source_nutanix_subnets.go

@@ -348,7 +348,7 @@ func dataSourceNutanixSubnetsRead(d *schema.ResourceData, meta interface{}) erro
 		req = buildDataSourceListMetadata(metadata.(*schema.Set))
 	}
 
-	resp, err := conn.V3.ListAllSubnet(utils.StringValue(req.Filter))
+	resp, err := conn.V3.ListAllSubnet(utils.StringValue(req.Filter), nil)
 	if err != nil {
 		return err
 	}