feat(redis): added endpoints

scaleway/helpers_redis.go

@@ -55,9 +55,36 @@ func waitForRedisCluster(ctx context.Context, api *redis.API, zone scw.Zone, id
 	}, scw.WithContext(ctx))
 }
 
+func expandRedisPrivateNetwork(data interface{}) ([]*redis.EndpointSpec, error) {
+	if data == nil {
+		return nil, nil
+	}
+	var epSpecs []*redis.EndpointSpec
+
+	for _, rawPN := range data.([]interface{}) {
+		pn := rawPN.(map[string]interface{})
+		id := expandID(pn["id"].(string))
+		rawIPs := pn["service_ips"].([]interface{})
+		ips := []scw.IPNet(nil)
+		for _, rawIP := range rawIPs {
+			ip, err := expandIPNet(rawIP.(string))
+			if err != nil {
+				return epSpecs, err
+			}
+			ips = append(ips, ip)
+		}
+		spec := &redis.EndpointSpecPrivateNetworkSpec{
+			ID:         id,
+			ServiceIPs: ips,
+		}
+		epSpecs = append(epSpecs, &redis.EndpointSpec{PrivateNetwork: spec})
+	}
+	return epSpecs, nil
+}
+
 func expandRedisACLSpecs(i interface{}) ([]*redis.ACLRuleSpec, error) {
 	rules := []*redis.ACLRuleSpec(nil)
-
+	
 	for _, aclRule := range i.([]interface{}) {
 		rawRule := aclRule.(map[string]interface{})
 		rule := &redis.ACLRuleSpec{}
@@ -71,7 +98,7 @@ func expandRedisACLSpecs(i interface{}) ([]*redis.ACLRuleSpec, error) {
 		rule.IP = ip
 		rules = append(rules, rule)
 	}
-
+	
 	return rules, nil
 }
 
@@ -105,4 +132,39 @@ func flattenRedisSettings(settings []*redis.ClusterSetting) interface{} {
 		rawSettings[setting.Name] = setting.Value
 	}
 	return rawSettings
+
+}
+func flattenRedisPrivateNetwork(endpoints []*redis.Endpoint) (interface{}, bool) {
+	pnFlat := []map[string]interface{}(nil)
+	for _, endpoint := range endpoints {
+		if endpoint.PrivateNetwork != nil {
+			pn := endpoint.PrivateNetwork
+			pnZonedID := newZonedIDString(pn.Zone, pn.ID)
+			serviceIps := []interface{}(nil)
+			for _, ip := range pn.ServiceIPs {
+				serviceIps = append(serviceIps, ip.String())
+			}
+			pnFlat = append(pnFlat, map[string]interface{}{
+				"id":                 endpoint.ID,
+				"zone":               pn.Zone,
+				"private_network_id": pnZonedID,
+				"service_ips":        serviceIps,
+			})
+		}
+	}
+	return pnFlat, len(pnFlat) != 0
+}
+
+func flattenRedisPublicNetwork(endpoints []*redis.Endpoint) interface{} {
+	pnFlat := []map[string]interface{}(nil)
+	for _, endpoint := range endpoints {
+		if endpoint.PublicNetwork != nil {
+			pnFlat = append(pnFlat, map[string]interface{}{
+				"id":   endpoint.ID,
+				"port": endpoint.Port,
+				"ips":  endpoint.IPs,
+			})
+		}
+	}
+	return nil
 }

scaleway/resource_redis_cluster.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 	redis "github.com/scaleway/scaleway-sdk-go/api/redis/v1alpha1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
@@ -71,16 +72,6 @@ func resourceScalewayRedisCluster() *schema.Resource {
 				Description: "Whether or not TLS is enabled.",
 				ForceNew:    true,
 			},
-			"created_at": {
-				Type:        schema.TypeString,
-				Computed:    true,
-				Description: "The date and time of the creation of the Redis cluster",
-			},
-			"updated_at": {
-				Type:        schema.TypeString,
-				Computed:    true,
-				Description: "The date and time of the last update of the Redis cluster",
-			},
 			"acl": {
 				Type:        schema.TypeList,
 				Description: "List of acl rules.",
@@ -114,6 +105,75 @@ func resourceScalewayRedisCluster() *schema.Resource {
 					Type: schema.TypeString,
 				},
 			},
+			"private_network": {
+				Type:     schema.TypeList,
+				Optional: true,
+				//MaxItems:    1,
+				Description: "Private network specs details",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "UUID of the endpoint to be connected to the cluster",
+						},
+						"private_network_id": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ValidateFunc: validationUUIDorUUIDWithLocality(),
+							Description:  "UUID of the private network to be connected to the cluster",
+						},
+						"service_ips": {
+							Type:     schema.TypeList,
+							Required: true,
+							Elem: &schema.Schema{
+								Type:         schema.TypeString,
+								ValidateFunc: validation.IsCIDR,
+							},
+							Description: "List of IPv4 addresses of the private network with a CIDR notation",
+						},
+						"zone": zoneSchema(),
+					},
+				},
+			},
+			//Computed
+			"public_network": {
+				Type:        schema.TypeList,
+				Optional:    true,
+				Computed:    true,
+				MaxItems:    1,
+				Description: "Public network specs details",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"port": {
+							Type:        schema.TypeInt,
+							Computed:    true,
+							Description: "TCP port of the endpoint",
+						},
+						"ips": {
+							Type: schema.TypeList,
+							Elem: &schema.Schema{
+								Type: schema.TypeString,
+							},
+							Computed: true,
+						},
+					},
+				},
+			},
+			"created_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the creation of the Redis cluster",
+			},
+			"updated_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the last update of the Redis cluster",
+			},
 			// Common
 			"zone":       zoneSchema(),
 			"project_id": projectIDSchema(),
@@ -162,6 +222,15 @@ func resourceScalewayRedisClusterCreate(ctx context.Context, d *schema.ResourceD
 		createReq.ClusterSettings = expandRedisSettings(settings)
 	}
 
+	privN, privNExists := d.GetOk("private_network")
+	if privNExists {
+		pnSpecs, err := expandRedisPrivateNetwork(privN)
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		createReq.Endpoints = pnSpecs
+	}
+
 	res, err := redisAPI.CreateCluster(createReq, scw.WithContext(ctx))
 	if err != nil {
 		return diag.FromErr(err)
@@ -213,6 +282,13 @@ func resourceScalewayRedisClusterRead(ctx context.Context, d *schema.ResourceDat
 		_ = d.Set("tags", cluster.Tags)
 	}
 
+	//set endpoints
+	pnI, pnExists := flattenRedisPrivateNetwork(cluster.Endpoints)
+	if pnExists {
+		_ = d.Set("private_network", pnI)
+	}
+	_ = d.Set("public_network", flattenRedisPublicNetwork(cluster.Endpoints))
+
 	return nil
 }
 
@@ -289,6 +365,7 @@ func resourceScalewayRedisClusterUpdate(ctx context.Context, d *schema.ResourceD
 		if err != nil && !is404Error(err) {
 			return diag.FromErr(err)
 		}
+
 		_, err = redisAPI.MigrateCluster(&request, scw.WithContext(ctx))
 		if err != nil {
 			return diag.FromErr(err)
@@ -300,6 +377,37 @@ func resourceScalewayRedisClusterUpdate(ctx context.Context, d *schema.ResourceD
 		}
 	}
 
+	if d.HasChanges("private_network") {
+		//retrieve state
+		cluster, err := waitForRedisCluster(ctx, redisAPI, zone, ID, d.Timeout(schema.TimeoutUpdate))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+
+		// get new desired state of endpoints
+		rawNewEndpoints := d.Get("private_network")
+		newEndpoints, epErr := expandRedisPrivateNetwork(rawNewEndpoints)
+		if epErr != nil {
+			return diag.FromErr(epErr)
+		}
+
+		//send request
+		_, err = redisAPI.SetEndpoints(&redis.SetEndpointsRequest{
+			Zone:      cluster.Zone,
+			ClusterID: cluster.ID,
+			Endpoints: newEndpoints,
+		})
+		//TODO: jeter un oeil aux requests options
+		if err != nil {
+			return diag.FromErr(err)
+		}
+
+		_, err = waitForRedisCluster(ctx, redisAPI, zone, ID, d.Timeout(schema.TimeoutUpdate))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
 	_, err = waitForRedisCluster(ctx, redisAPI, zone, ID, d.Timeout(schema.TimeoutUpdate))
 	if err != nil {
 		return diag.FromErr(err)

scaleway/resource_redis_cluster_test.go

@@ -52,6 +52,9 @@ func TestAccScalewayRedisCluster_Basic(t *testing.T) {
 		Steps: []resource.TestStep{
 			{
 				Config: `
+					provider "scaleway" {
+						zone = "fr-par-1"
+					}
 					resource "scaleway_redis_cluster" "main" {
     					name = "test_redis_basic"
     					version = "6.2.6"
@@ -61,6 +64,7 @@ func TestAccScalewayRedisCluster_Basic(t *testing.T) {
 						tags = [ "test1" ]
 						cluster_size = 1
 						tls_enabled = "true"
+						zone = "fr-par-2"
 					}
 				`,
 				Check: resource.ComposeTestCheckFunc(
@@ -73,10 +77,14 @@ func TestAccScalewayRedisCluster_Basic(t *testing.T) {
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "tags.0", "test1"),
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "cluster_size", "1"),
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "tls_enabled", "true"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "zone", "fr-par-2"),
 				),
 			},
 			{
 				Config: `
+					provider "scaleway" {
+						zone = "fr-par-1"
+					}
 					resource "scaleway_redis_cluster" "main" {
     					name = "test_redis_basic_edit"
     					version = "6.2.6"
@@ -86,6 +94,7 @@ func TestAccScalewayRedisCluster_Basic(t *testing.T) {
 						tags = [ "test1", "other_tag" ]
 						cluster_size = 1
 						tls_enabled = "true"
+						zone = "fr-par-2"
 					}
 				`,
 				Check: resource.ComposeTestCheckFunc(
@@ -99,6 +108,7 @@ func TestAccScalewayRedisCluster_Basic(t *testing.T) {
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "tags.1", "other_tag"),
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "cluster_size", "1"),
 					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "tls_enabled", "true"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "zone", "fr-par-2"),
 				),
 			},
 		},
@@ -298,6 +308,76 @@ func TestAccScalewayRedisCluster_Settings(t *testing.T) {
 	})
 }
 
+func TestAccScalewayRedisCluster_Endpoints(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayRedisClusterDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_redis_cluster" "main" {
+						name = "test_redis_endpoints"
+    					version = "6.2.6"
+    					node_type = "MDB-BETA-M"
+    					user_name = "my_initial_user"
+    					password = "thiZ_is_v&ry_s3cret"
+						cluster_size = 1
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayRedisExists(tt, "scaleway_redis_cluster.main"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "name", "test_redis_endpoints"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "version", "6.2.6"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "node_type", "MDB-BETA-M"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "user_name", "my_initial_user"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "password", "thiZ_is_v&ry_s3cret"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "cluster_size", "1"),
+					resource.TestCheckResourceAttrSet("scaleway_redis_cluster.main", "public_network.id"),
+					resource.TestCheckResourceAttrSet("scaleway_redis_cluster.main", "public_network.ips"),
+					resource.TestCheckResourceAttrSet("scaleway_redis_cluster.main", "public_network.port"),
+				),
+			},
+			{
+				Config: `
+					resource "scaleway_vpc_private_network" "pn" {
+    					name = "privateN"
+					}
+					resource "scaleway_redis_cluster" "main" {
+						name =			"test_redis_endpoints"
+    					version = 		"6.2.6"
+    					node_type = 	"MDB-BETA-M"
+    					user_name = 	"my_initial_user"
+    					password = 		"thiZ_is_v&ry_s3cret"
+						cluster_size = 	1
+						private_network {
+							private_network_id = "${scaleway_vpc_private_network.pn.id}"
+							service_ips = [
+								"10.12.1.0/20",
+							]
+						}
+					}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckScalewayRedisExists(tt, "scaleway_redis_cluster.main"),
+					testAccCheckScalewayRedisExists(tt, "scaleway_vpc_private_network.pn"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "name", "test_redis_endpoints"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "version", "6.2.6"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "node_type", "MDB-BETA-M"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "user_name", "my_initial_user"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "password", "thiZ_is_v&ry_s3cret"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "cluster_size", "1"),
+					resource.TestCheckResourceAttrSet("scaleway_redis_cluster.main", "private_network.id"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "private_network.id", "${scaleway_vpc_private_network.pn.id}"),
+					resource.TestCheckResourceAttr("scaleway_redis_cluster.main", "private_network.service_ips.0", "10.12.1.0/20"),
+				),
+			},
+		},
+	})
+}
+
 func testAccCheckScalewayRedisClusterDestroy(tt *TestTools) resource.TestCheckFunc {
 	return func(state *terraform.State) error {
 		for _, rs := range state.RootModule().Resources {