feat(redis): added endpoints

docs/resources/redis_cluster.md

@@ -47,6 +47,30 @@ resource "scaleway_redis_cluster" "main" {
   }
 }
 ```
+### With a private network
+```hcl
+resource "scaleway_vpc_private_network" "pn" { 
+  name = "private-network"
+}
+
+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 {
+    id          = "${scaleway_vpc_private_network.pn.id}"
+    service_ips = [
+      "10.12.1.1/20",
+    ]
+  }
+  depends_on = [
+    scaleway_vpc_private_network.pn
+  ]
+}
+```
 
 ## Arguments Reference
 
@@ -87,6 +111,24 @@ The `acl` block supports:
 
 - `settings` - (Optional) Map of settings for redis cluster. Available settings can be found by listing redis versions with scaleway API or CLI
 
+
+- `private_network` - (Optional) Describes the private network you want to connect to your cluster. If not set, a public network will be provided.
+
+The `private_network` block supports :
+- `id` - (Required) The UUID of the private network resource.
+- `service_ips` - (Required) Endpoint IPv4 addresses in [CIDR notation](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing#CIDR_notation). You must provide at least one IP per node.
+
+~> **Important:** The way to use private networks differs whether you are using redis in standalone or cluster mode.
+- Standalone mode (`cluster_size` = 1) : you can attach as many private networks as you want (each must be a separate block). If you detach your only private network, your cluster won't be reachable until you define a new private or public network. You can modify your private_network and its specs, you can have both a private and public network side by side.
+- Cluster mode (`cluster_size` > 1) : you can define a single private network as you create your cluster, you won't be able to edit or detach it afterwards, unless you create another cluster. Your `service_ips` must be listed as follows:
+```hcl
+  service_ips = [
+    "10.12.1.0/20", 
+    "10.13.1.0/20",
+    "10.14.1.0/20",
+  ]
+```
+
 ## Attributes Reference
 
 In addition to all arguments above, the following attributes are exported:

scaleway/helpers_redis.go

@@ -55,6 +55,35 @@ func waitForRedisCluster(ctx context.Context, api *redis.API, zone scw.Zone, id
 	}, scw.WithContext(ctx))
 }
 
+func expandRedisPrivateNetwork(data interface{}) ([]*redis.EndpointSpec, error) {
+	//func expandRedisPrivateNetwork(data []interface{}) ([]*redis.EndpointSpec, error) {
+	if data == nil {
+		return nil, nil
+	}
+	var epSpecs []*redis.EndpointSpec
+
+	for _, rawPN := range data.([]interface{}) {
+		//for _, rawPN := range data {
+		pn := rawPN.(map[string]interface{})
+		pnID := 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:         pnID,
+			ServiceIPs: ips,
+		}
+		epSpecs = append(epSpecs, &redis.EndpointSpec{PrivateNetwork: spec})
+	}
+	return epSpecs, nil
+}
+
 func expandRedisACLSpecs(i interface{}) ([]*redis.ACLRuleSpec, error) {
 	rules := []*redis.ACLRuleSpec(nil)
 
@@ -106,3 +135,55 @@ func flattenRedisSettings(settings []*redis.ClusterSetting) interface{} {
 	}
 	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{}{
+				"endpoint_id": endpoint.ID,
+				"zone":        pn.Zone,
+				"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 {
+			ipsFlat := []interface{}(nil)
+			for _, ip := range endpoint.IPs {
+				ipsFlat = append(ipsFlat, ip.String())
+			}
+			pnFlat = append(pnFlat, map[string]interface{}{
+				"id":   endpoint.ID,
+				"port": int(endpoint.Port),
+				"ips":  ipsFlat,
+			})
+			return pnFlat
+		}
+	}
+	return pnFlat
+}
+
+//func redisPnIdHash(pnI interface{}) int {
+//	var buf bytes.Buffer
+//	pn, ok := pnI.(map[string]interface{})
+//	if !ok {
+//		return 0
+//	}
+//	if id, ok := pn["id"]; ok {
+//		buf.WriteString(fmt.Sprintf("%v-", id.(string)))
+//	}
+//	return StringHashcode(buf.String())
+//}