Cloudwatch: Refactor dimension values resource request (#57346)

* refactor dimension values backend

* fix test file name

pkg/tsdb/cloudwatch/models/request/dimension_keys_request.go

@@ -0,0 +1,57 @@
+package request
+
+import (
+	"net/url"
+
+	"github.com/grafana/grafana/pkg/tsdb/cloudwatch/constants"
+)
+
+type DimensionKeysRequestType uint32
+
+const (
+	StandardDimensionKeysRequest DimensionKeysRequestType = iota
+	FilterDimensionKeysRequest
+	CustomMetricDimensionKeysRequest
+)
+
+type DimensionKeysRequest struct {
+	*ResourceRequest
+	Namespace       string
+	MetricName      string
+	DimensionFilter []*Dimension
+}
+
+func (q *DimensionKeysRequest) Type() DimensionKeysRequestType {
+	if _, exist := constants.NamespaceMetricsMap[q.Namespace]; !exist {
+		return CustomMetricDimensionKeysRequest
+	}
+
+	if len(q.DimensionFilter) > 0 {
+		return FilterDimensionKeysRequest
+	}
+
+	return StandardDimensionKeysRequest
+}
+
+func GetDimensionKeysRequest(parameters url.Values) (*DimensionKeysRequest, error) {
+	resourceRequest, err := getResourceRequest(parameters)
+	if err != nil {
+		return nil, err
+	}
+
+	request := &DimensionKeysRequest{
+		ResourceRequest: resourceRequest,
+		Namespace:       parameters.Get("namespace"),
+		MetricName:      parameters.Get("metricName"),
+		DimensionFilter: []*Dimension{},
+	}
+
+	dimensions, err := parseDimensionFilter(parameters.Get("dimensionFilters"))
+	if err != nil {
+		return nil, err
+	}
+
+	request.DimensionFilter = dimensions
+
+	return request, nil
+}

pkg/tsdb/cloudwatch/models/request/dimension_keys_request_test.go

@@ -0,0 +1,72 @@
+package request
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDimensionKeyRequest(t *testing.T) {
+	t.Run("Should parse parameters without dimension filter", func(t *testing.T) {
+		request, err := GetDimensionKeysRequest(map[string][]string{
+			"region":     {"us-east-1"},
+			"namespace":  {"AWS/EC2"},
+			"metricName": {"CPUUtilization"}},
+		)
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+	})
+
+	t.Run("Should parse parameters with single valued dimension filter", func(t *testing.T) {
+		request, err := GetDimensionKeysRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionFilters": {"{\"InstanceId\": \"i-1234567890abcdef0\"}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 1, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
+	})
+
+	t.Run("Should parse parameters with multi-valued dimension filter", func(t *testing.T) {
+		request, err := GetDimensionKeysRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionFilters": {"{\"InstanceId\": [\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"]}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 2, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
+		assert.Equal(t, "InstanceId", request.DimensionFilter[1].Name)
+		assert.Equal(t, "i-1234567890abcdef1", request.DimensionFilter[1].Value)
+	})
+
+	t.Run("Should parse parameters with wildcard dimension filter", func(t *testing.T) {
+		request, err := GetDimensionKeysRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionFilters": {"{\"InstanceId\": [\"*\"]}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 1, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "", request.DimensionFilter[0].Value)
+	})
+}

pkg/tsdb/cloudwatch/models/request/dimension_values_request.go

@@ -0,0 +1,37 @@
+package request
+
+import (
+	"net/url"
+)
+
+type DimensionValuesRequest struct {
+	*ResourceRequest
+	Namespace       string
+	MetricName      string
+	DimensionKey    string
+	DimensionFilter []*Dimension
+}
+
+func GetDimensionValuesRequest(parameters url.Values) (*DimensionValuesRequest, error) {
+	resourceRequest, err := getResourceRequest(parameters)
+	if err != nil {
+		return nil, err
+	}
+
+	request := &DimensionValuesRequest{
+		ResourceRequest: resourceRequest,
+		Namespace:       parameters.Get("namespace"),
+		MetricName:      parameters.Get("metricName"),
+		DimensionKey:    parameters.Get("dimensionKey"),
+		DimensionFilter: []*Dimension{},
+	}
+
+	dimensions, err := parseDimensionFilter(parameters.Get("dimensionFilters"))
+	if err != nil {
+		return nil, err
+	}
+
+	request.DimensionFilter = dimensions
+
+	return request, nil
+}

pkg/tsdb/cloudwatch/models/request/dimension_values_rquest_test.go

@@ -0,0 +1,78 @@
+package request
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDimensionValuesRequest(t *testing.T) {
+	t.Run("Should parse parameters without dimension filter", func(t *testing.T) {
+		request, err := GetDimensionValuesRequest(map[string][]string{
+			"region":       {"us-east-1"},
+			"namespace":    {"AWS/EC2"},
+			"metricName":   {"CPUUtilization"},
+			"dimensionKey": {"InstanceId"}},
+		)
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, "InstanceId", request.DimensionKey)
+	})
+
+	t.Run("Should parse parameters with single valued dimension filter", func(t *testing.T) {
+		request, err := GetDimensionValuesRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionKey":     {"InstanceId"},
+			"dimensionFilters": {"{\"InstanceId\": \"i-1234567890abcdef0\"}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 1, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionKey)
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
+	})
+
+	t.Run("Should parse parameters with multi-valued dimension filter", func(t *testing.T) {
+		request, err := GetDimensionValuesRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionKey":     {"InstanceId"},
+			"dimensionFilters": {"{\"InstanceId\": [\"i-1234567890abcdef0\", \"i-1234567890abcdef1\"]}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 2, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionKey)
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "i-1234567890abcdef0", request.DimensionFilter[0].Value)
+		assert.Equal(t, "InstanceId", request.DimensionFilter[1].Name)
+		assert.Equal(t, "i-1234567890abcdef1", request.DimensionFilter[1].Value)
+	})
+
+	t.Run("Should parse parameters with wildcard dimension filter", func(t *testing.T) {
+		request, err := GetDimensionValuesRequest(map[string][]string{
+			"region":           {"us-east-1"},
+			"namespace":        {"AWS/EC2"},
+			"metricName":       {"CPUUtilization"},
+			"dimensionFilters": {"{\"InstanceId\": [\"*\"]}"},
+		})
+		require.NoError(t, err)
+		assert.Equal(t, "us-east-1", request.Region)
+		assert.Equal(t, "AWS/EC2", request.Namespace)
+		assert.Equal(t, "CPUUtilization", request.MetricName)
+		assert.Equal(t, 1, len(request.DimensionFilter))
+		assert.Equal(t, "InstanceId", request.DimensionFilter[0].Name)
+		assert.Equal(t, "", request.DimensionFilter[0].Value)
+	})
+}

pkg/tsdb/cloudwatch/models/request/resource_request.go

@@ -0,0 +1,22 @@
+package request
+
+import (
+	"fmt"
+	"net/url"
+)
+
+type ResourceRequest struct {
+	Region string
+}
+
+func getResourceRequest(parameters url.Values) (*ResourceRequest, error) {
+	request := &ResourceRequest{
+		Region: parameters.Get("region"),
+	}
+
+	if request.Region == "" {
+		return nil, fmt.Errorf("region is required")
+	}
+
+	return request, nil
+}

pkg/tsdb/cloudwatch/models/request/resource_request_test.go

@@ -0,0 +1,16 @@
+package request
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestResourceRequest(t *testing.T) {
+	t.Run("Should return an error if region is not provided", func(t *testing.T) {
+		request, err := GetDimensionValuesRequest(map[string][]string{})
+		require.Nil(t, request)
+		assert.Equal(t, "region is required", err.Error())
+	})
+}

pkg/tsdb/cloudwatch/models/request/types.go

@@ -0,0 +1,6 @@
+package request
+
+type Dimension struct {
+	Name  string
+	Value string
+}

pkg/tsdb/cloudwatch/models/request/utils.go

@@ -0,0 +1,44 @@
+package request
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+func parseDimensionFilter(dimensionFilter string) ([]*Dimension, error) {
+	dimensionFilters := map[string]interface{}{}
+	dimensionFilterJson := []byte(dimensionFilter)
+	if len(dimensionFilterJson) > 0 {
+		err := json.Unmarshal(dimensionFilterJson, &dimensionFilters)
+		if err != nil {
+			return nil, fmt.Errorf("error unmarshaling dimensionFilters: %v", err)
+		}
+	}
+
+	dimensions := []*Dimension{}
+	addDimension := func(key string, value string) {
+		d := &Dimension{
+			Name: key,
+		}
+		// if value is not specified or a wildcard is used, simply don't use the value field
+		if value != "" && value != "*" {
+			d.Value = value
+		}
+		dimensions = append(dimensions, d)
+	}
+
+	for k, v := range dimensionFilters {
+		// due to legacy, value can be a string, a string slice or nil
+		if vv, ok := v.(string); ok {
+			addDimension(k, vv)
+		} else if vv, ok := v.([]interface{}); ok {
+			for _, v := range vv {
+				addDimension(k, v.(string))
+			}
+		} else if v == nil {
+			addDimension(k, "")
+		}
+	}
+
+	return dimensions, nil
+}