feat(mongodb): delete private network

Author: jremy42

internal/services/mongodb/helpers.go

@@ -1,20 +1,15 @@
 package mongodb
 
 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/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 (
@@ -31,7 +26,7 @@ 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
+// newAPIWithZone returns a new mongoDB 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 {
@@ -60,7 +55,7 @@ func newAPIWithRegion(d *schema.ResourceData, m interface{}) (*mongodb.API, scw.
 	return newAPI(m), region, nil
 }
 
-// NewAPIWithZoneAndID returns a Redis API with zone and ID extracted from the state
+// NewAPIWithZoneAndID returns a mongoDB API with zone and ID extracted from the state
 func NewAPIWithZoneAndID(m interface{}, id string) (*mongodb.API, scw.Zone, string, error) {
 	zone, ID, err := zonal.ParseID(id)
 	if err != nil {
@@ -81,18 +76,6 @@ func NewAPIWithRegionAndID(m interface{}, id string) (*mongodb.API, scw.Region,
 	return newAPI(m), region, ID, nil
 }
 
-func NewAPIWithID(m interface{}, id string) (*mongodb.API, scw.Region, string, error) {
-	zone, ID, err := zonal.ParseID(id)
-	if err != nil {
-		return nil, "", "", err
-	}
-	region, err := zone.Region()
-	if err != nil {
-		return nil, "", "", err
-	}
-	return newAPI(m), region, ID, nil
-}
-
 func waitForInstance(ctx context.Context, api *mongodb.API, region scw.Region, id string, timeout time.Duration) (*mongodb.Instance, error) {
 	retryInterval := defaultWaitMongodbInstanceRetryInterval
 	if transport.DefaultWaitRetryInterval != nil {
@@ -120,26 +103,3 @@ func waitForSnapshot(ctx context.Context, api *mongodb.API, region scw.Region, i
 		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())
-}

internal/services/mongodb/instance.go

@@ -3,7 +3,6 @@ package mongodb
 import (
 	"context"
 	"errors"
-	"strings"
 	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
@@ -13,12 +12,10 @@ import (
 	"github.com/scaleway/scaleway-sdk-go/scw"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/dsf"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/httperrors"
-	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/regional"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/zonal"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/services/account"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
-	"github.com/scaleway/terraform-provider-scaleway/v2/internal/verify"
 )
 
 func ResourceInstance() *schema.Resource {
@@ -106,58 +103,6 @@ func ResourceInstance() *schema.Resource {
 					"version",
 				},
 			},
-			//endpoint
-			"private_network": {
-				Type:        schema.TypeSet,
-				Optional:    true,
-				Description: "Private network specs details",
-				Set:         privateNetworkSetHash,
-				DiffSuppressFunc: func(k, oldValue, newValue string, _ *schema.ResourceData) bool {
-					// Check if the key is for the 'id' attribute
-					if strings.HasSuffix(k, "id") {
-						return locality.ExpandID(oldValue) == locality.ExpandID(newValue)
-					}
-					// For all other attributes, don't suppress the diff
-					return false
-				},
-				Elem: &schema.Resource{
-					Schema: map[string]*schema.Schema{
-						"id": {
-							Type:             schema.TypeString,
-							Required:         true,
-							ValidateDiagFunc: verify.IsUUIDorUUIDWithLocality(),
-							Description:      "UUID of the private network to be connected to the cluster",
-						},
-						"ips": {
-							Type:     schema.TypeList,
-							Optional: true,
-							Computed: true,
-							Elem: &schema.Schema{
-								Type:         schema.TypeString,
-								ValidateFunc: validation.IsCIDR,
-							},
-							Description: "List of IPv4 addresses of the private network with a CIDR notation",
-						},
-						"port": {
-							Type:        schema.TypeInt,
-							Computed:    true,
-							Description: "The port of your load balancer service",
-						},
-						"dns_records": {
-							Type:        schema.TypeString,
-							Computed:    true,
-							Description: "The DNS record of your endpoint",
-						},
-						// computed
-						"endpoint_id": {
-							Type:        schema.TypeString,
-							Computed:    true,
-							Description: "UUID of the endpoint to be connected to the cluster",
-						},
-						"zone": zonal.ComputedSchema(),
-					},
-				},
-			},
 			// Computed
 			"public_network": {
 				Type:        schema.TypeList,
@@ -272,19 +217,6 @@ func ResourceInstanceCreate(ctx context.Context, d *schema.ResourceData, m inter
 			createReq.Tags = types.ExpandStrings(tags)
 		}
 
-		pn, pnExists := d.GetOk("private_network")
-		if pnExists {
-			pnSpecs, err := expandPrivateNetwork(pn.(*schema.Set).List())
-			if err != nil {
-				return diag.FromErr(err)
-			}
-			createReq.Endpoints = pnSpecs
-		} else {
-			epSpecs := make([]*mongodb.EndpointSpec, 0, 1)
-			spec := &mongodb.EndpointSpecPublicDetails{}
-			createReq.Endpoints = append(epSpecs, &mongodb.EndpointSpec{Public: spec})
-		}
-
 		res, err = mongodbAPI.CreateInstance(createReq, scw.WithContext(ctx))
 		if err != nil {
 			return diag.FromErr(err)
@@ -333,10 +265,6 @@ func ResourceInstanceRead(ctx context.Context, d *schema.ResourceData, m interfa
 		_ = d.Set("volume_size_in_gb", int(instance.Volume.Size/scw.GB))
 	}
 
-	privateNetworkEndpoints, privateNetworkExists := flattenPrivateNetwork(instance.Endpoints)
-	if privateNetworkExists {
-		_ = d.Set("private_network", privateNetworkEndpoints)
-	}
 	publicNetworkEndpoint, publicNetworkExists := flattenPublicNetwork(instance.Endpoints)
 	if publicNetworkExists {
 		_ = d.Set("public_network", publicNetworkEndpoint)

internal/services/mongodb/types.go

@@ -2,43 +2,8 @@ package mongodb
 
 import (
 	mongodb "github.com/scaleway/scaleway-sdk-go/api/mongodb/v1alpha1"
-	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
 )
 
-func expandPrivateNetwork(data []interface{}) ([]*mongodb.EndpointSpec, error) {
-	if data == nil {
-		return nil, nil
-	}
-	epSpecs := make([]*mongodb.EndpointSpec, 0, len(data))
-	for _, rawPN := range data {
-		pn := rawPN.(map[string]interface{})
-		pnID := locality.ExpandID(pn["id"].(string))
-
-		spec := &mongodb.EndpointSpecPrivateNetworkDetails{
-			PrivateNetworkID: pnID,
-		}
-		epSpecs = append(epSpecs, &mongodb.EndpointSpec{PrivateNetwork: spec})
-	}
-	return epSpecs, nil
-}
-
-func flattenPrivateNetwork(endpoints []*mongodb.Endpoint) (interface{}, bool) {
-	pnFlat := []map[string]interface{}(nil)
-	for _, endpoint := range endpoints {
-		if endpoint.PrivateNetwork == nil {
-			continue
-		}
-		pnFlat = append(pnFlat, map[string]interface{}{
-			"endpoint_id": endpoint.ID,
-			"id":          endpoint.PrivateNetwork.PrivateNetworkID,
-			"ips":         endpoint.IPs,
-			"port":        endpoint.Port,
-			"dns_records": endpoint.DNSRecords,
-		})
-	}
-	return pnFlat, len(pnFlat) != 0
-}
-
 func flattenPublicNetwork(endpoints []*mongodb.Endpoint) (interface{}, bool) {
 	publicFlat := []map[string]interface{}(nil)
 	for _, endpoint := range endpoints {