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

@@ -13,6 +13,7 @@ import (
 	"net/http"
 	"net/url"
 
+	"github.com/PaesslerAG/jsonpath"
 	"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 == "" {
@@ -221,7 +228,61 @@ func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) error
 			_, 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 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, err = filter(resp.Body, filters, baseSearchPaths)
+	if err != nil {
+		return err
+	}
+
+	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 {
@@ -239,6 +300,73 @@ func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) error
 	return err
 }
 
+func filter(body io.ReadCloser, filters []*AdditionalFilter, baseSearchPaths []string) (io.ReadCloser, error) {
+	if filters == nil {
+		return body, nil
+	}
+	if len(baseSearchPaths) == 0 {
+		baseSearchPaths = []string{"$."}
+	}
+
+	var res map[string]interface{}
+	b, err := io.ReadAll(body)
+	if err != nil {
+		return body, err
+	}
+	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{}
+		for _, baseSearchPath := range baseSearchPaths {
+			searchPath := fmt.Sprintf("%s.%s", baseSearchPath, 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 {
+				searchTarget := entity.(map[string]interface{})
+				val, err := jsonpath.Get(searchPath, searchTarget)
+				if err != nil {
+					continue
+				}
+				// Stringify leaf value since we support only string values in filter
+				value := fmt.Sprint(val)
+				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 body, jsonErr
+	}
+	return io.NopCloser(bytes.NewReader(filteredBody)), nil
+}
+
 // 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,66 @@ 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"}
+	filteredBody, err := filter(input, filters, baseSearchPaths)
+	if err != nil {
+		panic(err)
+	}
+	actualBytes, _ := io.ReadAll(filteredBody)
+	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, clientSideFilters []*client.AdditionalFilter) (*SubnetListIntentResponse, error)
 	ListAllNetworkSecurityRule(filter string) (*NetworkSecurityRuleListIntentResponse, error)
 	ListAllImage(filter string) (*ImageListIntentResponse, error)
 	ListAllCluster(filter string) (*ClusterListIntentResponse, error)
@@ -293,8 +293,9 @@ func (op Operations) ListSubnet(getEntitiesRequest *DSMetadata) (*SubnetListInte
 	if err != nil {
 		return nil, err
 	}
+	baseSearchPaths := []string{"metadata", "status", "status.resources"}
 
-	return subnetListIntentResponse, op.client.Do(ctx, req, subnetListIntentResponse)
+	return subnetListIntentResponse, op.client.DoWithFilters(ctx, req, subnetListIntentResponse, getEntitiesRequest.ClientSideFilters, baseSearchPaths)
 }
 
 /*UpdateSubnet Updates a subnet
@@ -938,13 +939,14 @@ func (op Operations) ListAllVM(filter string) (*VMListIntentResponse, error) {
 }
 
 // ListAllSubnet ...
-func (op Operations) ListAllSubnet(filter string) (*SubnetListIntentResponse, error) {
+func (op Operations) ListAllSubnet(filter string, clientSideFilters []*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),
+		ClientSideFilters: clientSideFilters,
 	})
 
 	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
+	ClientSideFilters []*client.AdditionalFilter `json:"-"`
 }
 
 // VMIntentResource Response object for intentful operations on a vm

examples/client-side-filters.tf

@@ -0,0 +1,41 @@
+terraform {
+  required_providers {
+    nutanix = {
+      source  = "nutanix/nutanix"
+      version = "1.3"
+    }
+  }
+}
+
+provider "nutanix" {
+  username = "admin"
+  password = "password"
+  endpoint = "pc-ip"
+  insecure = true
+  port     = 9440
+}
+
+data "nutanix_clusters" "clusters" {}
+
+output "subnet" {
+  value = data.nutanix_subnet.test
+}
+
+data "nutanix_subnet" "test" {
+  subnet_name = "nutanix-subnet"
+  additional_filter {
+    name = "name"
+    values = ["vlan.154", "nutanix-subnet"]
+  }
+
+  additional_filter {
+    name = "vlan_id"
+    values = ["154", "123"]
+  }
+
+  additional_filter {
+    name = "cluster_reference.uuid"
+    values = ["0005d304-e60e-43c3-3507-ac1f6b60292f"]
+  }
+}
+

go.mod

@@ -1,10 +1,11 @@
 module github.com/terraform-providers/terraform-provider-nutanix
 
 require (
+	github.com/PaesslerAG/jsonpath v0.1.1
 	github.com/client9/misspell v0.3.4
 	github.com/golangci/golangci-lint v1.25.0
 	github.com/hashicorp/terraform-plugin-sdk v1.7.0
-	github.com/magiconair/properties v1.8.1
+	github.com/magiconair/properties v1.8.1 // indirect
 	github.com/mitchellh/gox v1.0.1
 	github.com/spf13/cast v1.3.1
 	github.com/stretchr/testify v1.6.1

go.sum

@@ -13,6 +13,11 @@ github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/OpenPeeDeeP/depguard v1.0.1 h1:VlW4R6jmBIv3/u1JNlawEvJMM4J+dPORPaZasQee8Us=
 github.com/OpenPeeDeeP/depguard v1.0.1/go.mod h1:xsIw86fROiiwelg+jB2uM9PiKihMMmUx/1V+TNhjQvM=
+github.com/PaesslerAG/gval v1.0.0 h1:GEKnRwkWDdf9dOmKcNrar9EA1bz1z9DqPIO1+iLzhd8=
+github.com/PaesslerAG/gval v1.0.0/go.mod h1:y/nm5yEyTeX6av0OfKJNp9rBNj2XrGhAf5+v24IBN1I=
+github.com/PaesslerAG/jsonpath v0.1.0/go.mod h1:4BzmtoM/PI8fPO4aQGIusjGxGir2BzcV0grWtFzq1Y8=
+github.com/PaesslerAG/jsonpath v0.1.1 h1:c1/AToHQMVsduPAa4Vh6xp2U0evy4t8SWp8imEsylIk=
+github.com/PaesslerAG/jsonpath v0.1.1/go.mod h1:lVboNxFGal/VwW6d9JzIy56bUsYAP6tH/x80vjnCseY=
 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
 github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/agext/levenshtein v1.2.2 h1:0S/Yg6LYmFJ5stwQeRp6EeOcCbj7xiqQSdNelsXvaqE=