feat(apple-silicon): add support vpc

Author: Laure-di

internal/services/applesilicon/server.go

@@ -2,6 +2,9 @@ package applesilicon
 
 import (
 	"context"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/meta"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/verify"
 	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
@@ -47,6 +50,55 @@ func ResourceServer() *schema.Resource {
 				Default:     false,
 				Description: "Whether or not to enable VPC access",
 			},
+			"private_network": {
+				Type:        schema.TypeSet,
+				Optional:    true,
+				Description: "The private networks to attach to the server",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"id": {
+							Type:             schema.TypeString,
+							Description:      "The private network ID",
+							Required:         true,
+							ValidateDiagFunc: verify.IsUUIDorUUIDWithLocality(),
+							StateFunc: func(i interface{}) string {
+								return locality.ExpandID(i.(string))
+							},
+						},
+						"ipam_ip_ids": {
+							Type:     schema.TypeList,
+							Optional: true,
+							Computed: true,
+							Elem: &schema.Schema{
+								Type:             schema.TypeString,
+								ValidateDiagFunc: verify.IsUUIDorUUIDWithLocality(),
+							},
+							Description: "List of IPAM IP IDs to attach to the server",
+						},
+						// computed
+						"vlan": {
+							Type:        schema.TypeInt,
+							Computed:    true,
+							Description: "The VLAN ID associated to the private network",
+						},
+						"status": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The private network status",
+						},
+						"created_at": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The date and time of the creation of the private network",
+						},
+						"updated_at": {
+							Type:        schema.TypeString,
+							Computed:    true,
+							Description: "The date and time of the last update of the private network",
+						},
+					},
+				},
+			},
 			// Computed
 			"ip": {
 				Type:        schema.TypeString,
@@ -106,6 +158,7 @@ func ResourceAppleSiliconServerCreate(ctx context.Context, d *schema.ResourceDat
 	}
 
 	res, err := asAPI.CreateServer(createReq, scw.WithContext(ctx))
+
 	if err != nil {
 		return diag.FromErr(err)
 	}
@@ -117,6 +170,20 @@ func ResourceAppleSiliconServerCreate(ctx context.Context, d *schema.ResourceDat
 		return diag.FromErr(err)
 	}
 
+	if pn, ok := d.GetOk("private_network"); ok {
+		privateNetworkAPI := applesilicon.NewPrivateNetworkAPI(meta.ExtractScwClient(m))
+		req := &applesilicon.PrivateNetworkAPISetServerPrivateNetworksRequest{
+			Zone:                       zone,
+			ServerID:                   res.ID,
+			PerPrivateNetworkIpamIPIDs: expandPrivateNetworks(pn),
+		}
+		_, err := privateNetworkAPI.SetServerPrivateNetworks(req, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+		_, err = waitForAppleSiliconPrivateNetworkServer(ctx, privateNetworkAPI, zone, res.ID, d.Timeout(schema.TimeoutCreate))
+	}
+
 	return ResourceAppleSiliconServerRead(ctx, d, m)
 }
 
@@ -126,6 +193,8 @@ func ResourceAppleSiliconServerRead(ctx context.Context, d *schema.ResourceData,
 		return diag.FromErr(err)
 	}
 
+	privateNetworkAPI := applesilicon.NewPrivateNetworkAPI(meta.ExtractScwClient(m))
+
 	res, err := asAPI.GetServer(&applesilicon.GetServerRequest{
 		Zone:     zone,
 		ServerID: ID,
@@ -149,10 +218,21 @@ func ResourceAppleSiliconServerRead(ctx context.Context, d *schema.ResourceData,
 	_ = d.Set("ip", res.IP.String())
 	_ = d.Set("vnc_url", res.VncURL)
 	_ = d.Set("vpc_status", res.VpcStatus)
-
 	_ = d.Set("zone", res.Zone.String())
 	_ = d.Set("organization_id", res.OrganizationID)
 	_ = d.Set("project_id", res.ProjectID)
+	listPrivateNetworks, err := privateNetworkAPI.ListServerPrivateNetworks(&applesilicon.PrivateNetworkAPIListServerPrivateNetworksRequest{
+		Zone:     res.Zone,
+		ServerID: &res.ID,
+	})
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	pnRegion, err := res.Zone.Region()
+	if err != nil {
+		return diag.FromErr(err)
+	}
+	_ = d.Set("private_network", flattenPrivateNetworks(pnRegion, listPrivateNetworks.ServerPrivateNetworks))
 
 	return nil
 }
@@ -163,6 +243,8 @@ func ResourceAppleSiliconServerUpdate(ctx context.Context, d *schema.ResourceDat
 		return diag.FromErr(err)
 	}
 
+	privateNetworkAPI := applesilicon.NewPrivateNetworkAPI(meta.ExtractScwClient(m))
+
 	req := &applesilicon.UpdateServerRequest{
 		Zone:     zone,
 		ServerID: ID,
@@ -175,6 +257,26 @@ func ResourceAppleSiliconServerUpdate(ctx context.Context, d *schema.ResourceDat
 	if d.HasChange("enable_vpc") {
 		enableVpc := d.Get("enable_vpc").(bool)
 		req.EnableVpc = &enableVpc
+		if !enableVpc {
+			listPrivateNetworks, err := privateNetworkAPI.ListServerPrivateNetworks(&applesilicon.PrivateNetworkAPIListServerPrivateNetworksRequest{
+				Zone:     res.Zone,
+				ServerID: &res.ID,
+			})
+			if err != nil {
+				return diag.FromErr(err)
+			}
+			for _, v := range listPrivateNetworks.ServerPrivateNetworks {
+				err = privateNetworkAPI.DeleteServerPrivateNetwork(&applesilicon.PrivateNetworkAPIDeleteServerPrivateNetworkRequest{
+					Zone:             zone,
+					ServerID:         v.ServerID,
+					PrivateNetworkID: v.PrivateNetworkID,
+				})
+				if err != nil {
+					return diag.FromErr(err)
+				}
+			}
+
+		}
 	}
 
 	_, err = asAPI.UpdateServer(req, scw.WithContext(ctx))

internal/services/applesilicon/types.go

@@ -0,0 +1,48 @@
+package applesilicon
+
+import (
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	applesilicon "github.com/scaleway/scaleway-sdk-go/api/applesilicon/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/regional"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
+)
+
+func expandPrivateNetworks(pn interface{}) map[string]*[]string {
+	privateNetworks := make(map[string]*[]string)
+
+	for _, op := range pn.(*schema.Set).List() {
+		rawPN := op.(map[string]interface{})
+		id := locality.ExpandID(rawPN["id"].(string))
+
+		ipamIPIDs := &[]string{}
+		if ipamIPs, ok := rawPN["ipam_ip_ids"]; ok && ipamIPs != nil {
+			ipamIPsList := ipamIPs.([]interface{})
+			if len(ipamIPsList) > 0 {
+				ips := make([]string, len(ipamIPsList))
+				for i, ip := range ipamIPsList {
+					ips[i] = locality.ExpandID(ip.(string))
+				}
+				ipamIPIDs = &ips
+			}
+		}
+		privateNetworks[id] = ipamIPIDs
+	}
+	return privateNetworks
+}
+
+func flattenPrivateNetworks(region scw.Region, privateNetworks []*applesilicon.ServerPrivateNetwork) interface{} {
+	flattenedPrivateNetworks := []map[string]interface{}(nil)
+	for _, privateNetwork := range privateNetworks {
+		flattenedPrivateNetworks = append(flattenedPrivateNetworks, map[string]interface{}{
+			"id":          regional.NewIDString(region, privateNetwork.PrivateNetworkID),
+			"ipam_ip_ids": regional.NewRegionalIDs(region, privateNetwork.IpamIPIDs),
+			"vlan":        types.FlattenUint32Ptr(privateNetwork.Vlan),
+			"status":      privateNetwork.Status,
+			"created_at":  types.FlattenTime(privateNetwork.CreatedAt),
+			"updated_at":  types.FlattenTime(privateNetwork.UpdatedAt),
+		})
+	}
+	return flattenedPrivateNetworks
+}

internal/services/applesilicon/waiters.go

@@ -29,3 +29,19 @@ func waitForAppleSiliconServer(ctx context.Context, api *applesilicon.API, zone
 
 	return server, err
 }
+
+func waitForAppleSiliconPrivateNetworkServer(ctx context.Context, api *applesilicon.PrivateNetworkAPI, zone scw.Zone, serverID string, timeout time.Duration) (*[]applesilicon.ServerPrivateNetwork, error) {
+	retryInterval := defaultAppleSiliconServerRetryInterval
+	if transport.DefaultWaitRetryInterval != nil {
+		retryInterval = *transport.DefaultWaitRetryInterval
+	}
+
+	privateNetwork, err := api.WaitForServerPrivateNetworks(&applesilicon.WaitForServerRequest{
+		ServerID:      serverID,
+		Zone:          zone,
+		Timeout:       scw.TimeDurationPtr(timeout),
+		RetryInterval: &retryInterval,
+	}, scw.WithContext(ctx))
+
+	return privateNetwork, err
+}