feat(mongodb): resource instance

Author: jremy42

internal/services/mongodb/cluster_data_source.go

@@ -0,0 +1,87 @@
+package redis
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scaleway/scaleway-sdk-go/api/redis/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/datasource"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/verify"
+)
+
+func DataSourceCluster() *schema.Resource {
+	// Generate datasource schema from resource
+	dsSchema := datasource.SchemaFromResourceSchema(ResourceCluster().Schema)
+	// Set 'Optional' schema elements
+	datasource.AddOptionalFieldsToSchema(dsSchema, "name", "zone", "project_id")
+
+	dsSchema["name"].ConflictsWith = []string{"cluster_id"}
+	dsSchema["cluster_id"] = &schema.Schema{
+		Type:             schema.TypeString,
+		Optional:         true,
+		Description:      "The ID of the Redis cluster",
+		ConflictsWith:    []string{"name"},
+		ValidateDiagFunc: verify.IsUUIDorUUIDWithLocality(),
+	}
+
+	return &schema.Resource{
+		ReadContext: DataSourceClusterRead,
+		Schema:      dsSchema,
+	}
+}
+
+func DataSourceClusterRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
+	api, zone, err := newAPIWithZone(d, m)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	clusterID, ok := d.GetOk("cluster_id")
+	if !ok {
+		clusterName := d.Get("name").(string)
+		res, err := api.ListClusters(&redis.ListClustersRequest{
+			Zone:      zone,
+			Name:      types.ExpandStringPtr(clusterName),
+			ProjectID: types.ExpandStringPtr(d.Get("project_id")),
+		}, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+
+		foundCluster, err := datasource.FindExact(
+			res.Clusters,
+			func(s *redis.Cluster) bool { return s.Name == clusterName },
+			clusterName,
+		)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+
+		clusterID = foundCluster.ID
+	}
+
+	zonedID := datasource.NewZonedID(clusterID, zone)
+	d.SetId(zonedID)
+	err = d.Set("cluster_id", zonedID)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	// Check if cluster exist as Read will return nil if resource does not exist
+	// clusterID may be zoned if using name in data source
+	getReq := &redis.GetClusterRequest{
+		Zone:      zone,
+		ClusterID: locality.ExpandID(clusterID.(string)),
+	}
+	_, err = api.GetCluster(getReq, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(fmt.Errorf("no clusters found with the id %s", clusterID))
+	}
+
+	return ResourceInstanceRead(ctx, d, m)
+}

internal/services/mongodb/cluster_data_source_test.go

@@ -0,0 +1,50 @@
+package redis_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/acctest"
+)
+
+func TestAccDataSourceCluster_Basic(t *testing.T) {
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+	latestRedisVersion := getLatestVersion(tt)
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { acctest.PreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      isClusterDestroyed(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_redis_cluster" "test" {
+    					name = "test_redis_datasource_terraform"
+    					version = "%s"
+    					node_type = "RED1-micro"
+    					user_name = "my_initial_user"
+    					password = "thiZ_is_v&ry_s3cret"
+					}
+
+					data "scaleway_redis_cluster" "test" {
+						name = scaleway_redis_cluster.test.name
+					}
+
+					data "scaleway_redis_cluster" "test2" {
+						cluster_id = scaleway_redis_cluster.test.id
+					}
+				`, latestRedisVersion),
+				Check: resource.ComposeTestCheckFunc(
+					isClusterPresent(tt, "scaleway_redis_cluster.test"),
+
+					resource.TestCheckResourceAttr("data.scaleway_redis_cluster.test", "name", "test_redis_datasource_terraform"),
+					resource.TestCheckResourceAttrSet("data.scaleway_redis_cluster.test", "id"),
+
+					resource.TestCheckResourceAttr("data.scaleway_redis_cluster.test2", "name", "test_redis_datasource_terraform"),
+					resource.TestCheckResourceAttrSet("data.scaleway_redis_cluster.test2", "id"),
+				),
+			},
+		},
+	})
+}

internal/services/mongodb/helpers.go

@@ -0,0 +1,92 @@
+package redis
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	mongodb "github.com/scaleway/scaleway-sdk-go/api/mongodb/v1alpha1"
+	"github.com/scaleway/scaleway-sdk-go/api/redis/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/zonal"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/meta"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/transport"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
+)
+
+const (
+	defaultRedisClusterTimeout           = 15 * time.Minute
+	defaultWaitRedisClusterRetryInterval = 5 * time.Second
+)
+
+func newAPI(m interface{}) *mongodb.API {
+	return mongodb.NewAPI(meta.ExtractScwClient(m))
+}
+
+// newAPIWithZone returns a new Redis API and the zone for a Create request
+func newAPIWithZone(d *schema.ResourceData, m interface{}) (*mongodb.API, scw.Zone, error) {
+	zone, err := meta.ExtractZone(d, m)
+	if err != nil {
+		return nil, "", err
+	}
+	return newAPI(m), zone, nil
+}
+
+// NewAPIWithZoneAndID returns a Redis API with zone and ID extracted from the state
+func NewAPIWithZoneAndID(m interface{}, id string) (*redis.API, scw.Zone, string, error) {
+	zone, ID, err := zonal.ParseID(id)
+	if err != nil {
+		return nil, "", "", err
+	}
+	return newAPI(m), zone, ID, nil
+}
+
+func waitForInstance(ctx context.Context, api *mongodb.API, zone scw.Zone, id string, timeout time.Duration) (*redis.Cluster, error) {
+	retryInterval := defaultWaitRedisClusterRetryInterval
+	if transport.DefaultWaitRetryInterval != nil {
+		retryInterval = *transport.DefaultWaitRetryInterval
+	}
+
+	return api.WaitForInstance()
+}
+
+func waitForCluster(ctx context.Context, api *redis.API, zone scw.Zone, id string, timeout time.Duration) (*redis.Cluster, error) {
+	retryInterval := defaultWaitRedisClusterRetryInterval
+	if transport.DefaultWaitRetryInterval != nil {
+		retryInterval = *transport.DefaultWaitRetryInterval
+	}
+
+	return api.WaitForCluster(&redis.WaitForClusterRequest{
+		Zone:          zone,
+		Timeout:       scw.TimeDurationPtr(timeout),
+		ClusterID:     id,
+		RetryInterval: &retryInterval,
+	}, scw.WithContext(ctx))
+}
+
+func privateNetworkSetHash(v interface{}) int {
+	var buf bytes.Buffer
+
+	m := v.(map[string]interface{})
+	if pnID, ok := m["id"]; ok {
+		buf.WriteString(locality.ExpandID(pnID))
+	}
+
+	if serviceIPs, ok := m["service_ips"]; ok {
+		// Sort the service IPs before generating the hash.
+		ips := serviceIPs.([]interface{})
+		sort.Slice(ips, func(i, j int) bool {
+			return ips[i].(string) < ips[j].(string)
+		})
+
+		for i, item := range ips {
+			buf.WriteString(fmt.Sprintf("%d-%s-", i, item.(string)))
+		}
+	}
+
+	return types.StringHashcode(buf.String())
+}