feat(instance): add support for snapshot

scaleway/helpers_instance.go

@@ -23,6 +23,8 @@ const (
 	defaultInstanceSecurityGroupRuleTimeout = 1 * time.Minute
 	defaultInstancePlacementGroupTimeout    = 1 * time.Minute
 	defaultInstanceIPTimeout                = 1 * time.Minute
+
+	defaultInstanceSnapshotWaitTimeout = 1 * time.Hour
 )
 
 // instanceAPIWithZone returns a new instance API and the zone for a Create request
@@ -133,6 +135,19 @@ func reachState(ctx context.Context, instanceAPI *instance.API, zone scw.Zone, s
 		return fmt.Errorf("don't know how to reach state %s from state %s for server %s", toState, fromState, serverID)
 	}
 
+	// We need to check that all volumes are ready
+	for _, volume := range response.Server.Volumes {
+		if volume.State != instance.VolumeStateAvailable {
+			_, err = instanceAPI.WaitForVolume(&instance.WaitForVolumeRequest{
+				Zone:     zone,
+				VolumeID: volume.ID,
+			})
+			if err != nil {
+				return err
+			}
+		}
+	}
+
 	for _, a := range actions {
 		err = instanceAPI.ServerActionAndWait(&instance.ServerActionAndWaitRequest{
 			ServerID: serverID,

scaleway/provider.go

@@ -64,6 +64,7 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_instance_security_group":       resourceScalewayInstanceSecurityGroup(),
 				"scaleway_instance_security_group_rules": resourceScalewayInstanceSecurityGroupRules(),
 				"scaleway_instance_server":               resourceScalewayInstanceServer(),
+				"scaleway_instance_snapshot":             resourceScalewayInstanceSnapshot(),
 				"scaleway_instance_placement_group":      resourceScalewayInstancePlacementGroup(),
 				"scaleway_instance_private_nic":          resourceScalewayInstancePrivateNIC(),
 				"scaleway_iot_hub":                       resourceScalewayIotHub(),

scaleway/resource_instance_snapshot.go

@@ -0,0 +1,162 @@
+package scaleway
+
+import (
+	"context"
+	"time"
+
+	"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"
+	"github.com/scaleway/scaleway-sdk-go/api/instance/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func resourceScalewayInstanceSnapshot() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceScalewayInstanceSnapshotCreate,
+		ReadContext:   resourceScalewayInstanceSnapshotRead,
+		UpdateContext: resourceScalewayInstanceSnapshotUpdate,
+		DeleteContext: resourceScalewayInstanceSnapshotDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Timeouts: &schema.ResourceTimeout{
+			Default: schema.DefaultTimeout(defaultInstanceSnapshotWaitTimeout),
+		},
+		SchemaVersion: 0,
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				Description: "The name of the snapshot",
+			},
+			"volume_id": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				Description:  "ID of the volume to take a snapshot from",
+				ValidateFunc: validationUUIDorUUIDWithLocality(),
+			},
+			"type": {
+				Type:        schema.TypeString,
+				Required:    true,
+				ForceNew:    true,
+				Description: "The volume type of the snapshot",
+				ValidateFunc: validation.StringInSlice([]string{
+					instance.VolumeVolumeTypeBSSD.String(),
+					instance.VolumeVolumeTypeLSSD.String(),
+				}, false),
+			},
+			"size_in_gb": {
+				Type:        schema.TypeInt,
+				Computed:    true,
+				Description: "The size of the snapshot in gigabyte",
+			},
+			"created_at": {
+				Type:        schema.TypeString,
+				Computed:    true,
+				Description: "The date and time of the creation of the Kubernetes cluster",
+			},
+			"zone":            zoneSchema(),
+			"organization_id": organizationIDSchema(),
+			"project_id":      projectIDSchema(),
+		},
+	}
+}
+
+func resourceScalewayInstanceSnapshotCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	instanceAPI, zone, err := instanceAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	req := &instance.CreateSnapshotRequest{
+		Zone:     zone,
+		Project:  expandStringPtr(d.Get("project_id")),
+		Name:     expandOrGenerateString(d.Get("name"), "snap"),
+		VolumeID: expandZonedID(d.Get("volume_id").(string)).ID,
+	}
+
+	res, err := instanceAPI.CreateSnapshot(req, scw.WithContext(ctx))
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	d.SetId(newZonedIDString(zone, res.Snapshot.ID))
+	return resourceScalewayInstanceSnapshotRead(ctx, d, meta)
+}
+
+func resourceScalewayInstanceSnapshotRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	instanceAPI, zone, id, err := instanceAPIWithZoneAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	snapshot, err := instanceAPI.GetSnapshot(&instance.GetSnapshotRequest{
+		SnapshotID: id,
+		Zone:       zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		if is404Error(err) {
+			d.SetId("")
+			return nil
+		}
+		return diag.FromErr(err)
+	}
+
+	_ = d.Set("name", snapshot.Snapshot.Name)
+	_ = d.Set("created_at", snapshot.Snapshot.CreationDate.Format(time.RFC3339))
+	_ = d.Set("type", snapshot.Snapshot.VolumeType.String())
+
+	return nil
+}
+
+func resourceScalewayInstanceSnapshotUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	//instanceAPI, zone, id, err := instanceAPIWithZoneAndID(meta, d.Id())
+	//if err != nil {
+	//	return diag.FromErr(err)
+	//}
+
+	//if d.HasChange("name") {
+	//	newName := d.Get("name").(string)
+	//
+	//	_, err = instanceAPI.UpdateSnapshot(&instance.UpdateSnapshotRequest{
+	//		SnapshotID: id,
+	//		Zone:       zone,
+	//		Name:       &newName,
+	//	}, scw.WithContext(ctx))
+	//	if err != nil {
+	//		return diag.FromErr(fmt.Errorf("couldn't update snapshot: %s", err))
+	//	}
+	//}
+
+	return resourceScalewayInstanceSnapshotRead(ctx, d, meta)
+}
+
+func resourceScalewayInstanceSnapshotDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	instanceAPI, zone, id, err := instanceAPIWithZoneAndID(meta, d.Id())
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	_, err = instanceAPI.WaitForSnapshot(&instance.WaitForSnapshotRequest{
+		SnapshotID: id,
+		Zone:       zone,
+	})
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	err = instanceAPI.DeleteSnapshot(&instance.DeleteSnapshotRequest{
+		SnapshotID: id,
+		Zone:       zone,
+	}, scw.WithContext(ctx))
+	if err != nil {
+		if !is404Error(err) {
+			return diag.FromErr(err)
+		}
+	}
+
+	return nil
+}

scaleway/resource_instance_snapshot_test.go

@@ -0,0 +1,88 @@
+package scaleway
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+)
+
+func TestAccScalewayInstanceSnapshot_BlockVolume(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	resource.Test(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayInstanceVolumeDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_instance_volume" "main" {
+						type       = "b_ssd"
+						size_in_gb = 20
+					}
+
+					resource "scaleway_instance_snapshot" "main" {
+						volume_id = scaleway_instance_volume.main.id
+						type = "b_ssd"
+					}`,
+			},
+		},
+	})
+}
+
+func TestAccScalewayInstanceSnapshot_Server(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	resource.Test(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayInstanceVolumeDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_instance_server" "main" {
+						image = "ubuntu_focal"
+						type = "DEV1-S"
+					}
+
+					resource "scaleway_instance_snapshot" "main" {
+						volume_id = scaleway_instance_server.main.root_volume.0.volume_id
+						type = "l_ssd"
+					}`,
+			},
+		},
+	})
+}
+
+func TestAccScalewayInstanceSnapshot_ServerWithBlockVolume(t *testing.T) {
+	tt := NewTestTools(t)
+	defer tt.Cleanup()
+	resource.Test(t, resource.TestCase{
+		PreCheck:          func() { testAccPreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      testAccCheckScalewayInstanceVolumeDestroy(tt),
+		Steps: []resource.TestStep{
+			{
+				Config: `
+					resource "scaleway_instance_volume" "block" {
+						type       = "b_ssd"
+						size_in_gb = 10
+					}
+
+					resource "scaleway_instance_server" "main" {
+						image = "ubuntu_focal"
+						type = "DEV1-S"
+
+						additional_volume_ids = [
+							scaleway_instance_volume.block.id
+						]
+					}
+
+					resource "scaleway_instance_snapshot" "main" {
+						volume_id = scaleway_instance_volume.block.id
+						type = "b_ssd"
+					}`,
+			},
+		},
+	})
+}