create sbs volumes for each block_volume

Author: Codelax

builder/scaleway/builder.go

@@ -79,7 +79,7 @@ func (b *Builder) Run(ctx context.Context, ui packersdk.Ui, hook packersdk.Hook)
 			Debug:        b.Config.PackerDebug,
 			DebugKeyPath: fmt.Sprintf("scw_%s.pem", b.Config.PackerBuildName),
 		},
-		new(stepRemoveVolume),
+		new(stepCreateVolume),
 		new(stepCreateServer),
 		new(stepServerInfo),
 		&communicator.StepConnect{

builder/scaleway/config_block.go

@@ -12,7 +12,9 @@ import (
 func prepareBlockVolumes(volumes []ConfigBlockVolume) *packersdk.MultiError {
 	var errs *packersdk.MultiError
 
-	for i, volume := range volumes {
+	for i := range volumes {
+		volume := &volumes[i]
+
 		if volume.Name == "" {
 			volume.Name = fmt.Sprintf("packer-%s", uuid.TimeOrderedUUID())
 		}

builder/scaleway/step_backup.go

@@ -100,7 +100,7 @@ func backupVolumesFromServer(server *instance.Server) map[string]*instance.Serve
 
 	for _, volume := range server.Volumes {
 		backupVolumes[volume.ID] = &instance.ServerActionRequestVolumeBackupTemplate{
-			VolumeType: instance.SnapshotVolumeTypeUnified,
+			//VolumeType: instance.SnapshotVolumeTypeUnified,
 		}
 	}
 	return backupVolumes

builder/scaleway/step_create_server.go

@@ -62,9 +62,10 @@ func (s *stepCreateServer) Run(ctx context.Context, state multistep.StateBag) mu
 		if createServerReq.Volumes == nil {
 			createServerReq.Volumes = make(map[string]*instance.VolumeServerTemplate)
 		}
-		for i, blockVolume := range c.BlockVolumes {
+		createdVolumes := state.Get(StateKeyCreatedVolumes).([]*instance.VolumeServerTemplate)
+		for i, blockVolume := range createdVolumes {
 			volumeIndex := strconv.FormatInt(int64(i+1), 10)
-			createServerReq.Volumes[volumeIndex] = blockVolume.VolumeTemplate()
+			createServerReq.Volumes[volumeIndex] = blockVolume
 		}
 	}
 

builder/scaleway/step_create_volume.go

@@ -0,0 +1,116 @@
+package scaleway
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/packer-plugin-sdk/multistep"
+	packersdk "github.com/hashicorp/packer-plugin-sdk/packer"
+	"github.com/scaleway/packer-plugin-scaleway/internal/httperrors"
+	block "github.com/scaleway/scaleway-sdk-go/api/block/v1alpha1"
+	"github.com/scaleway/scaleway-sdk-go/api/instance/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+const StateKeyCreatedVolumes = "created_volumes"
+
+type stepCreateVolume struct{}
+
+func (s *stepCreateVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*scw.Client)
+	blockAPI := block.NewAPI(client)
+	ui := state.Get("ui").(packersdk.Ui)
+	c := state.Get("config").(*Config)
+
+	volumeTemplates := []*instance.VolumeServerTemplate(nil)
+	for _, requestedVolume := range c.BlockVolumes {
+		volume, err := blockAPI.CreateVolume(&block.CreateVolumeRequest{
+			Zone:      scw.Zone(c.Zone),
+			Name:      requestedVolume.Name,
+			PerfIops:  scw.Uint32Ptr(5000), // TODO: configuration
+			ProjectID: c.ProjectID,
+			FromEmpty: &block.CreateVolumeRequestFromEmpty{
+				Size: scw.Size(requestedVolume.Size),
+			},
+			FromSnapshot: nil, // TODO
+			Tags:         nil, // TODO
+		}, scw.WithContext(ctx))
+		if err != nil {
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		volumeTemplates = append(volumeTemplates, &instance.VolumeServerTemplate{
+			ID:         &volume.ID,
+			VolumeType: instance.VolumeVolumeTypeSbsVolume,
+		})
+	}
+
+	state.Put(StateKeyCreatedVolumes, volumeTemplates)
+
+	return multistep.ActionContinue
+}
+
+func (s *stepCreateVolume) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packersdk.Ui)
+	c := state.Get("config").(*Config)
+
+	if !c.RemoveVolume {
+		return
+	}
+
+	blockAPI := block.NewAPI(state.Get("client").(*scw.Client))
+
+	_, serverWasCreated := state.GetOk("server_id")
+	createdVolumesI, createdVolumesExists := state.GetOk("created_volumes")
+	if !serverWasCreated && createdVolumesExists {
+		// If server was not created, we need to clean up manually created volumes
+		createdVolumes := createdVolumesI.([]*instance.VolumeServerTemplate)
+		for _, volume := range createdVolumes {
+			err := blockAPI.DeleteVolume(&block.DeleteVolumeRequest{
+				Zone:     scw.Zone(c.Zone),
+				VolumeID: *volume.ID,
+			})
+			if err != nil {
+				ui.Error(fmt.Sprintf("failed to cleanup block volume %s: %s", *volume.ID, err))
+			}
+		}
+	}
+
+	if _, ok := state.GetOk("snapshots"); !ok {
+		// volume will be detached from server only after snapshotting ... so we don't
+		// need to remove volume before snapshot step.
+		return
+	}
+
+	instanceAPI := instance.NewAPI(state.Get("client").(*scw.Client))
+
+	ui.Say("Removing Volumes ...")
+
+	volumes := state.Get("volumes").([]*instance.VolumeServer)
+	for _, volume := range volumes {
+		err := instanceAPI.DeleteVolume(&instance.DeleteVolumeRequest{
+			VolumeID: volume.ID,
+			Zone:     scw.Zone(c.Zone),
+		})
+		if err != nil && !httperrors.Is404(err) {
+			err := fmt.Errorf("error removing block volume %s: %s", volume.ID, err)
+			state.Put("error", err)
+			ui.Error(fmt.Sprintf("Error removing block volume %s: %s. (Ignored)", volume.ID, err))
+		}
+		if err == nil {
+			continue
+		}
+
+		err = blockAPI.DeleteVolume(&block.DeleteVolumeRequest{
+			Zone:     scw.Zone(c.Zone),
+			VolumeID: volume.ID,
+		})
+		if err != nil {
+			err := fmt.Errorf("error removing block volume %s: %s", volume.ID, err)
+			state.Put("error", err)
+			ui.Error(fmt.Sprintf("Error removing block volume %s: %s. (Ignored)", volume.ID, err))
+		}
+	}
+}

builder/scaleway/step_remove_volume.go

@@ -0,0 +1,27 @@
+package httperrors
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+// IsHTTPCodeError returns true if err is an http error with code statusCode
+func IsHTTPCodeError(err error, statusCode int) bool {
+	if err == nil {
+		return false
+	}
+
+	responseError := &scw.ResponseError{}
+	if errors.As(err, &responseError) && responseError.StatusCode == statusCode {
+		return true
+	}
+	return false
+}
+
+// Is404 returns true if err is an HTTP 404 error
+func Is404(err error) bool {
+	notFoundError := &scw.ResourceNotFoundError{}
+	return IsHTTPCodeError(err, http.StatusNotFound) || errors.As(err, &notFoundError)
+}