Active active regions datasource

.github/workflows/terraform_provider_pr.yml

@@ -140,7 +140,7 @@ jobs:
 
   go_test_smoke_misc:
     name: go test smoke misc
-    needs: [go_build]
+    needs: [ go_build ]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
@@ -149,18 +149,17 @@ jobs:
           go-version-file: go.mod
       - run: EXECUTE_TESTS=true make testacc TESTARGS='-run="TestAccResourceRedisCloud(PrivateServiceConnect_CRUDI|AclRule_CRUDI)"'
 
-  # TODO: remove this after release
-  # qpf = query performance factor
-  go_test_smoke_qpf:
-    name: go test smoke qpf
-    needs: [ go_build ]
+  # TODO: remove, temporary: tests the subscription regions
+  go_test_smoke_aa_sub_regions:
+    name: go test smoke aa sub regions
+    needs: [go_build]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - uses: actions/setup-go@0aaccfd150d50ccaeb58ebd88d36e91967a5f35b # v5.4.0
         with:
           go-version-file: go.mod
-      - run: EXECUTE_TESTS=true make testacc TESTARGS='-run="TestAccResourceRedisCloudProDatabase_qpf.*"'
+      - run: EXECUTE_TESTS=true make testacc TESTARGS='-run="TestAccResourceRedisCloudActiveActiveSubscriptionRegions_CRUDI"'
 
   tfproviderlint:
     name: tfproviderlint

go.mod

@@ -3,7 +3,7 @@ module github.com/RedisLabs/terraform-provider-rediscloud
 go 1.22.4
 
 require (
-	github.com/RedisLabs/rediscloud-go-api v0.25.0
+	github.com/RedisLabs/rediscloud-go-api v0.26.0
 	github.com/bflad/tfproviderlint v0.31.0
 	github.com/hashicorp/go-cty v1.5.0
 	github.com/hashicorp/terraform-plugin-sdk/v2 v2.36.1

go.sum

@@ -4,8 +4,8 @@ github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migc
 github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
 github.com/ProtonMail/go-crypto v1.1.3 h1:nRBOetoydLeUb4nHajyO2bKqMLfWQ/ZPwkXqXxPxCFk=
 github.com/ProtonMail/go-crypto v1.1.3/go.mod h1:rA3QumHc/FZ8pAHreoekgiAbzpNsfQAosU5td4SnOrE=
-github.com/RedisLabs/rediscloud-go-api v0.25.0 h1:44q7fPxjkS94slkUxZCueaDB5i+axxjkFqOXIx3D44M=
-github.com/RedisLabs/rediscloud-go-api v0.25.0/go.mod h1:3/oVb71rv2OstFRYEc65QCIbfwnJTgZeQhtPCcdHook=
+github.com/RedisLabs/rediscloud-go-api v0.26.0 h1:ka6CN2O+Ti6igkfH8lDT9Ua1/ksEh2H5dj1GF/pnKKQ=
+github.com/RedisLabs/rediscloud-go-api v0.26.0/go.mod h1:3/oVb71rv2OstFRYEc65QCIbfwnJTgZeQhtPCcdHook=
 github.com/agext/levenshtein v1.2.2 h1:0S/Yg6LYmFJ5stwQeRp6EeOcCbj7xiqQSdNelsXvaqE=
 github.com/agext/levenshtein v1.2.2/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
 github.com/apparentlymart/go-textseg/v12 v12.0.0/go.mod h1:S/4uRK2UtaQttw1GenVJEynmyUenKwP++x/+DdGV/Ec=

provider/datasource_rediscloud_active_active_subscription.go

@@ -155,7 +155,7 @@ func dataSourceRedisCloudActiveActiveSubscriptionRead(ctx context.Context, d *sc
 
 	var filters []func(method *subscriptions.Subscription) bool
 
-	// Filter to AA subscriptions only (active-active subs) come from the same endpoint
+	// Filter to AA subscriptions only (pro subs come from the same endpoint)
 	filters = append(filters, func(sub *subscriptions.Subscription) bool {
 		return redis.StringValue(sub.DeploymentType) == "active-active"
 	})

provider/datasource_rediscloud_active_active_subscription_regions.go

@@ -0,0 +1,163 @@
+package provider
+
+import (
+	"context"
+	"fmt"
+	"github.com/RedisLabs/rediscloud-go-api/redis"
+	"github.com/RedisLabs/rediscloud-go-api/service/subscriptions"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+func dataSourceRedisCloudActiveActiveSubscriptionRegions() *schema.Resource {
+	return &schema.Resource{
+		Description: "Gets a list of regions in the specified Active-Active subscription.",
+		ReadContext: dataSourceRedisCloudActiveActiveRegionsRead,
+
+		Schema: map[string]*schema.Schema{
+			"subscription_name": {
+				Description: "The name of the subscription",
+				Type:        schema.TypeString,
+				Required:    true,
+			},
+			"regions": {
+				Description: "A list of regions from an active active subscription",
+				Type:        schema.TypeList,
+				Computed:    true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"region": {
+							Description: "Deployment region as defined by cloud provider",
+							Type:        schema.TypeString,
+							Computed:    true,
+						},
+						"networking_deployment_cidr": {
+							Description: "Deployment CIDR mask",
+							Type:        schema.TypeString,
+							Computed:    true,
+						},
+						"vpc_id": {
+							Description: "VPC ID for the region",
+							Computed:    true,
+							Type:        schema.TypeString,
+						},
+						"databases": {
+							Description: "A list of databases found in the region",
+							Computed:    true,
+							Type:        schema.TypeList,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"database_id": {
+										Description: "A numeric id for the database",
+										Type:        schema.TypeInt,
+										Computed:    true,
+									},
+									"database_name": {
+										Description: "A meaningful name to identify the database",
+										Type:        schema.TypeString,
+										Computed:    true,
+									},
+									"write_operations_per_second": {
+										Description: "Write operations per second for the database",
+										Type:        schema.TypeInt,
+										Computed:    true,
+									},
+									"read_operations_per_second": {
+										Description: "Read operations per second for the database",
+										Type:        schema.TypeInt,
+										Computed:    true,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceRedisCloudActiveActiveRegionsRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	var diags diag.Diagnostics
+	api := meta.(*apiClient)
+
+	subs, err := api.client.Subscription.List(ctx)
+
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	var filters []func(method *subscriptions.Subscription) bool
+
+	// Filter to active-active subscriptions only (pro subs come from the same endpoint)
+	filters = append(filters, func(sub *subscriptions.Subscription) bool {
+		return redis.StringValue(sub.DeploymentType) == "active-active"
+	})
+
+	// Filter down to requested subscription by name
+	if name, ok := d.GetOk("subscription_name"); ok {
+		filters = append(filters, func(sub *subscriptions.Subscription) bool {
+			return redis.StringValue(sub.Name) == name
+		})
+	}
+
+	subs = filterSubscriptions(subs, filters)
+
+	if len(subs) == 0 {
+		return diag.Errorf("Your query returned no results. Please change your search criteria and try again.")
+	}
+
+	if len(subs) > 1 {
+		return diag.Errorf("Your query returned more than one result. Please change try a more specific search criteria and try again.")
+	}
+
+	sub := subs[0]
+
+	regions, err := api.client.Subscription.ListActiveActiveRegions(ctx, *sub.ID)
+
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	if len(regions) == 0 {
+		return diag.Errorf("Your query returned no results. Please change your search criteria and try again.")
+	}
+
+	var genericRegions = flattenActiveActiveRegions(regions)
+
+	id := fmt.Sprintf("%d-active-active-regions", *sub.ID)
+	d.SetId(id)
+
+	if err := d.Set("regions", genericRegions); err != nil {
+		return diag.FromErr(err)
+	}
+
+	return diags
+}
+
+// generifies the region/db data so it can be put into the terraform schema
+func flattenActiveActiveRegions(regionList []*subscriptions.ActiveActiveRegion) []map[string]interface{} {
+	var rl []map[string]interface{}
+	for _, currentRegion := range regionList {
+
+		var dbs []map[string]interface{}
+		for _, db := range currentRegion.Databases {
+			dbMap := map[string]interface{}{
+				"database_id":                 db.DatabaseId,
+				"database_name":               db.DatabaseName,
+				"write_operations_per_second": db.WriteOperationsPerSecond,
+				"read_operations_per_second":  db.ReadOperationsPerSecond,
+			}
+			dbs = append(dbs, dbMap)
+		}
+
+		regionMap := map[string]interface{}{
+			"region":                     currentRegion.Region,
+			"networking_deployment_cidr": currentRegion.DeploymentCIDR,
+			"vpc_id":                     currentRegion.VpcId,
+			"databases":                  dbs,
+		}
+		rl = append(rl, regionMap)
+	}
+	return rl
+}

provider/datasource_rediscloud_pro_subscription.go

@@ -63,7 +63,7 @@ func dataSourceRedisCloudProSubscription() *schema.Resource {
 							Computed:    true,
 						},
 						"region": {
-							Description: "Cloud networking details, per region (single region or multiple regions for Active-Active cluster only)",
+							Description: "Cloud networking details, per region",
 							Type:        schema.TypeSet,
 							Computed:    true,
 							Elem: &schema.Resource{
@@ -231,7 +231,7 @@ func dataSourceRedisCloudProSubscriptionRead(ctx context.Context, d *schema.Reso
 
 	var filters []func(method *subscriptions.Subscription) bool
 
-	// Filter to pro subscriptions only (active-active subs) come from the same endpoint
+	// Filter to pro subscriptions only (active-active subs come from the same endpoint)
 	filters = append(filters, func(sub *subscriptions.Subscription) bool {
 		return redis.StringValue(sub.DeploymentType) != "active-active"
 	})

provider/provider.go

@@ -46,18 +46,20 @@ func New(version string) func() *schema.Provider {
 				// Note the difference in public data-source name and the file/method name.
 				// This is to help the developer relate their changes to what they would see happening in the Redis Console.
 				// <default> == flexible == pro
-				"rediscloud_subscription":                      dataSourceRedisCloudProSubscription(),
-				"rediscloud_database":                          dataSourceRedisCloudProDatabase(),
-				"rediscloud_database_modules":                  dataSourceRedisCloudDatabaseModules(),
-				"rediscloud_payment_method":                    dataSourceRedisCloudPaymentMethod(),
-				"rediscloud_regions":                           dataSourceRedisCloudRegions(),
-				"rediscloud_essentials_plan":                   dataSourceRedisCloudEssentialsPlan(),
-				"rediscloud_essentials_subscription":           dataSourceRedisCloudEssentialsSubscription(),
-				"rediscloud_essentials_database":               dataSourceRedisCloudEssentialsDatabase(),
-				"rediscloud_subscription_peerings":             dataSourceRedisCloudSubscriptionPeerings(),
-				"rediscloud_private_service_connect":           dataSourcePrivateServiceConnect(),
-				"rediscloud_private_service_connect_endpoints": dataSourcePrivateServiceConnectEndpoints(),
-				"rediscloud_active_active_subscription":        dataSourceRedisCloudActiveActiveSubscription(),
+				"rediscloud_subscription":                       dataSourceRedisCloudProSubscription(),
+				"rediscloud_database":                           dataSourceRedisCloudProDatabase(),
+				"rediscloud_database_modules":                   dataSourceRedisCloudDatabaseModules(),
+				"rediscloud_payment_method":                     dataSourceRedisCloudPaymentMethod(),
+				"rediscloud_regions":                            dataSourceRedisCloudRegions(),
+				"rediscloud_essentials_plan":                    dataSourceRedisCloudEssentialsPlan(),
+				"rediscloud_essentials_subscription":            dataSourceRedisCloudEssentialsSubscription(),
+				"rediscloud_essentials_database":                dataSourceRedisCloudEssentialsDatabase(),
+				"rediscloud_subscription_peerings":              dataSourceRedisCloudSubscriptionPeerings(),
+				"rediscloud_private_service_connect":            dataSourcePrivateServiceConnect(),
+				"rediscloud_private_service_connect_endpoints":  dataSourcePrivateServiceConnectEndpoints(),
+				"rediscloud_active_active_subscription":         dataSourceRedisCloudActiveActiveSubscription(),
+				"rediscloud_active_active_subscription_regions": dataSourceRedisCloudActiveActiveSubscriptionRegions(),
+
 				// Note the difference in public data-source name and the file/method name.
 				// active_active_subscription_database == active_active_database
 				"rediscloud_active_active_subscription_database":             dataSourceRedisCloudActiveActiveDatabase(),