refactor(instance): extract block helpers to a package

Author: Codelax

internal/services/instance/helpers_instance.go

@@ -20,6 +20,7 @@ import (
 	"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/services/block"
+	"github.com/scaleway/terraform-provider-scaleway/v2/internal/services/instance/instancehelpers"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/transport"
 	"github.com/scaleway/terraform-provider-scaleway/v2/internal/types"
 )
@@ -40,7 +41,6 @@ const (
 	defaultInstancePlacementGroupTimeout    = 1 * time.Minute
 	defaultInstanceIPTimeout                = 1 * time.Minute
 	defaultInstanceIPReverseDNSTimeout      = 10 * time.Minute
-	defaultInstanceRetryInterval            = 5 * time.Second
 
 	defaultInstanceSnapshotWaitTimeout = 1 * time.Hour
 
@@ -148,7 +148,7 @@ func serverStateExpand(rawState string) (instance.ServerState, error) {
 	return apiState, nil
 }
 
-func reachState(ctx context.Context, api *BlockAndInstanceAPI, zone scw.Zone, serverID string, toState instance.ServerState) error {
+func reachState(ctx context.Context, api *instancehelpers.BlockAndInstanceAPI, zone scw.Zone, serverID string, toState instance.ServerState) error {
 	response, err := api.GetServer(&instance.GetServerRequest{
 		Zone:     zone,
 		ServerID: serverID,
@@ -180,7 +180,7 @@ func reachState(ctx context.Context, api *BlockAndInstanceAPI, zone scw.Zone, se
 	// We need to check that all volumes are ready
 	for _, volume := range response.Server.Volumes {
 		if volume.VolumeType == block.BlockVolumeType {
-			_, err := api.blockAPI.WaitForVolumeAndReferences(&blockSDK.WaitForVolumeAndReferencesRequest{
+			_, err := api.BlockAPI.WaitForVolumeAndReferences(&blockSDK.WaitForVolumeAndReferencesRequest{
 				VolumeID:      volume.ID,
 				Zone:          zone,
 				RetryInterval: transport.DefaultWaitRetryInterval,
@@ -351,7 +351,7 @@ func (ph *privateNICsHandler) detach(ctx context.Context, o interface{}, timeout
 				PrivateNicID:  p.ID,
 				Zone:          ph.zone,
 				Timeout:       &timeout,
-				RetryInterval: scw.TimeDurationPtr(defaultInstanceRetryInterval),
+				RetryInterval: scw.TimeDurationPtr(instancehelpers.DefaultInstanceRetryInterval),
 			})
 			if err != nil && !httperrors.Is404(err) {
 				return err
@@ -455,7 +455,7 @@ func retryUpdateReverseDNS(ctx context.Context, instanceAPI *instance.API, req *
 
 	for {
 		select {
-		case <-time.After(defaultInstanceRetryInterval):
+		case <-time.After(instancehelpers.DefaultInstanceRetryInterval):
 			_, err := instanceAPI.UpdateIP(req, scw.WithContext(ctx))
 			if err != nil && IsIPReverseDNSResolveError(err) {
 				continue
@@ -495,8 +495,8 @@ func instanceIPHasMigrated(d *schema.ResourceData) bool {
 	return false
 }
 
-func instanceServerAdditionalVolumeTemplate(api *BlockAndInstanceAPI, zone scw.Zone, volumeID string) (*instance.VolumeServerTemplate, error) {
-	vol, err := api.GetUnknownVolume(&GetUnknownVolumeRequest{
+func instanceServerAdditionalVolumeTemplate(api *instancehelpers.BlockAndInstanceAPI, zone scw.Zone, volumeID string) (*instance.VolumeServerTemplate, error) {
+	vol, err := api.GetUnknownVolume(&instancehelpers.GetUnknownVolumeRequest{
 		VolumeID: locality.ExpandID(volumeID),
 		Zone:     zone,
 	})
@@ -507,7 +507,7 @@ func instanceServerAdditionalVolumeTemplate(api *BlockAndInstanceAPI, zone scw.Z
 	return vol.VolumeTemplate(), nil
 }
 
-func prepareRootVolume(rootVolumeI map[string]any, serverType *instance.ServerType, image string) *UnknownVolume {
+func prepareRootVolume(rootVolumeI map[string]any, serverType *instance.ServerType, image string) *instancehelpers.UnknownVolume {
 	rootVolumeIsBootVolume := types.ExpandBoolPtr(types.GetMapValue[bool](rootVolumeI, "boot"))
 	rootVolumeType := types.GetMapValue[string](rootVolumeI, "volume_type")
 	sizeInput := types.GetMapValue[int](rootVolumeI, "size_in_gb")
@@ -528,7 +528,7 @@ func prepareRootVolume(rootVolumeI map[string]any, serverType *instance.ServerTy
 		rootVolumeSize = scw.SizePtr(scw.Size(uint64(sizeInput) * gb))
 	}
 
-	return &UnknownVolume{
+	return &instancehelpers.UnknownVolume{
 		Name:               rootVolumeName,
 		ID:                 rootVolumeID,
 		InstanceVolumeType: instance.VolumeVolumeType(rootVolumeType),

internal/services/instance/helpers_instance_block.go

@@ -1,279 +1,10 @@
 package instance
 
 import (
-	"errors"
-
-	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
-	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/api/marketplace/v2"
-	"github.com/scaleway/scaleway-sdk-go/scw"
-	"github.com/scaleway/terraform-provider-scaleway/v2/internal/locality/zonal"
-	"github.com/scaleway/terraform-provider-scaleway/v2/internal/meta"
 )
 
-type BlockAndInstanceAPI struct {
-	*instance.API
-	blockAPI *block.API
-}
-
-type GetUnknownVolumeRequest struct {
-	VolumeID string
-	Zone     scw.Zone
-}
-
-type ResizeUnknownVolumeRequest struct {
-	VolumeID string
-	Zone     scw.Zone
-	Size     *scw.Size
-}
-
-type DeleteUnknownVolumeRequest struct {
-	VolumeID string
-	Zone     scw.Zone
-}
-
-type UnknownVolume struct {
-	Zone     scw.Zone
-	ID       string
-	Name     string
-	Size     *scw.Size
-	ServerID *string
-	Boot     *bool
-
-	// Iops is set for Block volume only, use IsBlockVolume
-	// Can be nil if not available in the Block API.
-	Iops *uint32
-
-	InstanceVolumeType instance.VolumeVolumeType
-}
-
-// VolumeTemplate returns a template to be used for servers requests.
-func (volume *UnknownVolume) VolumeTemplate() *instance.VolumeServerTemplate {
-	template := &instance.VolumeServerTemplate{}
-
-	if volume.ID != "" {
-		template.ID = &volume.ID
-		if !volume.IsBlockVolume() {
-			template.Name = &volume.Name
-		}
-	} else {
-		template.VolumeType = volume.InstanceVolumeType
-		template.Size = volume.Size
-	}
-
-	if volume.Boot != nil {
-		template.Boot = volume.Boot
-	}
-
-	if volume.IsBlockVolume() {
-		template.VolumeType = volume.InstanceVolumeType
-	}
-
-	return template
-}
-
-// IsLocal returns true if the volume is a local volume
-func (volume *UnknownVolume) IsLocal() bool {
-	return !volume.IsBlockVolume() && volume.InstanceVolumeType == instance.VolumeVolumeTypeLSSD
-}
-
-// IsBlockVolume is true if volume is managed by block API
-func (volume *UnknownVolume) IsBlockVolume() bool {
-	return volume.InstanceVolumeType == instance.VolumeVolumeTypeSbsVolume
-}
-
-// IsAttached returns true if the volume is attached to a server
-func (volume *UnknownVolume) IsAttached() bool {
-	return volume.ServerID != nil && *volume.ServerID != ""
-}
-
-type UnknownSnapshot struct {
-	Zone       scw.Zone
-	ID         string
-	Name       string
-	VolumeType instance.VolumeVolumeType
-}
-
-func (api *BlockAndInstanceAPI) GetUnknownVolume(req *GetUnknownVolumeRequest, opts ...scw.RequestOption) (*UnknownVolume, error) {
-	getVolumeResponse, err := api.API.GetVolume(&instance.GetVolumeRequest{
-		Zone:     req.Zone,
-		VolumeID: req.VolumeID,
-	}, opts...)
-	notFoundErr := &scw.ResourceNotFoundError{}
-
-	if err != nil && !errors.As(err, &notFoundErr) {
-		return nil, err
-	}
-
-	if getVolumeResponse != nil {
-		vol := &UnknownVolume{
-			Zone:               getVolumeResponse.Volume.Zone,
-			ID:                 getVolumeResponse.Volume.ID,
-			Name:               getVolumeResponse.Volume.Name,
-			Size:               &getVolumeResponse.Volume.Size,
-			InstanceVolumeType: getVolumeResponse.Volume.VolumeType,
-		}
-		if getVolumeResponse.Volume.Server != nil {
-			vol.ServerID = &getVolumeResponse.Volume.Server.ID
-		}
-
-		return vol, nil
-	}
-
-	blockVolume, err := api.blockAPI.GetVolume(&block.GetVolumeRequest{
-		Zone:     req.Zone,
-		VolumeID: req.VolumeID,
-	}, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	vol := &UnknownVolume{
-		Zone:               blockVolume.Zone,
-		ID:                 blockVolume.ID,
-		Name:               blockVolume.Name,
-		Size:               &blockVolume.Size,
-		InstanceVolumeType: instance.VolumeVolumeTypeSbsVolume,
-	}
-	if blockVolume.Specs != nil {
-		vol.Iops = blockVolume.Specs.PerfIops
-	}
-
-	for _, ref := range blockVolume.References {
-		if ref.ProductResourceType == "instance_server" {
-			vol.ServerID = &ref.ProductResourceID
-		}
-	}
-
-	return vol, nil
-}
-
-func (api *BlockAndInstanceAPI) ResizeUnknownVolume(req *ResizeUnknownVolumeRequest, opts ...scw.RequestOption) error {
-	unknownVolume, err := api.GetUnknownVolume(&GetUnknownVolumeRequest{
-		VolumeID: req.VolumeID,
-		Zone:     req.Zone,
-	}, opts...)
-	if err != nil {
-		return err
-	}
-
-	if unknownVolume.IsBlockVolume() {
-		_, err = api.blockAPI.UpdateVolume(&block.UpdateVolumeRequest{
-			Zone:     req.Zone,
-			VolumeID: req.VolumeID,
-			Size:     req.Size,
-		}, opts...)
-	} else {
-		_, err = api.API.UpdateVolume(&instance.UpdateVolumeRequest{
-			Zone:     req.Zone,
-			VolumeID: req.VolumeID,
-			Size:     req.Size,
-		}, opts...)
-	}
-
-	return err
-}
-
-func (api *BlockAndInstanceAPI) DeleteUnknownVolume(req *DeleteUnknownVolumeRequest, opts ...scw.RequestOption) error {
-	unknownVolume, err := api.GetUnknownVolume(&GetUnknownVolumeRequest{
-		VolumeID: req.VolumeID,
-		Zone:     req.Zone,
-	}, opts...)
-	if err != nil {
-		return err
-	}
-
-	if unknownVolume.IsBlockVolume() {
-		err = api.blockAPI.DeleteVolume(&block.DeleteVolumeRequest{
-			Zone:     req.Zone,
-			VolumeID: req.VolumeID,
-		}, opts...)
-	} else {
-		err = api.API.DeleteVolume(&instance.DeleteVolumeRequest{
-			Zone:     req.Zone,
-			VolumeID: req.VolumeID,
-		}, opts...)
-	}
-
-	return err
-}
-
-type GetUnknownSnapshotRequest struct {
-	Zone       scw.Zone
-	SnapshotID string
-}
-
-func (api *BlockAndInstanceAPI) GetUnknownSnapshot(req *GetUnknownSnapshotRequest, opts ...scw.RequestOption) (*UnknownSnapshot, error) {
-	getSnapshotResponse, err := api.GetSnapshot(&instance.GetSnapshotRequest{
-		Zone:       req.Zone,
-		SnapshotID: req.SnapshotID,
-	}, opts...)
-	notFoundErr := &scw.ResourceNotFoundError{}
-
-	if err != nil && !errors.As(err, &notFoundErr) {
-		return nil, err
-	}
-
-	if getSnapshotResponse != nil {
-		snap := &UnknownSnapshot{
-			Zone:       getSnapshotResponse.Snapshot.Zone,
-			ID:         getSnapshotResponse.Snapshot.ID,
-			Name:       getSnapshotResponse.Snapshot.Name,
-			VolumeType: getSnapshotResponse.Snapshot.VolumeType,
-		}
-
-		return snap, nil
-	}
-
-	blockSnapshot, err := api.blockAPI.GetSnapshot(&block.GetSnapshotRequest{
-		Zone:       req.Zone,
-		SnapshotID: req.SnapshotID,
-	}, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	snap := &UnknownSnapshot{
-		Zone:       blockSnapshot.Zone,
-		ID:         blockSnapshot.ID,
-		Name:       blockSnapshot.Name,
-		VolumeType: instance.VolumeVolumeTypeSbsSnapshot,
-	}
-
-	return snap, nil
-}
-
-func NewBlockAndInstanceAPI(client *scw.Client) *BlockAndInstanceAPI {
-	instanceAPI := instance.NewAPI(client)
-	blockAPI := block.NewAPI(client)
-
-	return &BlockAndInstanceAPI{
-		API:      instanceAPI,
-		blockAPI: blockAPI,
-	}
-}
-
-// newAPIWithZone returns a new instance API and the zone for a Create request
-func instanceAndBlockAPIWithZone(d *schema.ResourceData, m interface{}) (*BlockAndInstanceAPI, scw.Zone, error) {
-	zone, err := meta.ExtractZone(d, m)
-	if err != nil {
-		return nil, "", err
-	}
-
-	return NewBlockAndInstanceAPI(meta.ExtractScwClient(m)), zone, nil
-}
-
-// NewAPIWithZoneAndID returns an instance API with zone and ID extracted from the state
-func instanceAndBlockAPIWithZoneAndID(m interface{}, zonedID string) (*BlockAndInstanceAPI, scw.Zone, string, error) {
-	zone, ID, err := zonal.ParseID(zonedID)
-	if err != nil {
-		return nil, "", "", err
-	}
-
-	return NewBlockAndInstanceAPI(meta.ExtractScwClient(m)), zone, ID, nil
-}
-
 func volumeTypeToMarketplaceFilter(volumeType instance.VolumeVolumeType) marketplace.LocalImageType {
 	switch volumeType {
 	case instance.VolumeVolumeTypeSbsVolume: