feat: generate waiters (#2823)

Co-authored-by: Yacine Fodil <[email protected]>
Co-authored-by: Yacine FODIL <[email protected]>

Author: scaleway-bot

api/applesilicon/v1alpha1/apple_silicon_utils.go

@@ -13,53 +13,6 @@ const (
 	defaultTimeout       = 60 * time.Minute
 )
 
-// WaitForInstanceRequest is used by WaitForServer method.
-type WaitForServerRequest struct {
-	ServerID      string
-	Zone          scw.Zone
-	Timeout       *time.Duration
-	RetryInterval *time.Duration
-}
-
-// WaitForServer waits for the instance to be in a "terminal state" before returning.
-// This function can be used to wait for an instance to be ready for example.
-func (s *API) WaitForServer(req *WaitForServerRequest, opts ...scw.RequestOption) (*Server, error) {
-	timeout := defaultTimeout
-	if req.Timeout != nil {
-		timeout = *req.Timeout
-	}
-	retryInterval := defaultRetryInterval
-	if req.RetryInterval != nil {
-		retryInterval = *req.RetryInterval
-	}
-
-	terminalStatus := map[ServerStatus]struct{}{
-		ServerStatusReady: {},
-		ServerStatusError: {},
-	}
-
-	server, err := async.WaitSync(&async.WaitSyncConfig{
-		Get: func() (any, bool, error) {
-			res, err := s.GetServer(&GetServerRequest{
-				ServerID: req.ServerID,
-				Zone:     req.Zone,
-			}, opts...)
-			if err != nil {
-				return nil, false, err
-			}
-			_, isTerminal := terminalStatus[res.Status]
-
-			return res, isTerminal, nil
-		},
-		Timeout:          timeout,
-		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "waiting for server failed")
-	}
-	return server.(*Server), nil
-}
-
 func (s *PrivateNetworkAPI) WaitForServerPrivateNetworks(req *WaitForServerRequest, opts ...scw.RequestOption) ([]*ServerPrivateNetwork, error) {
 	timeout := defaultTimeout
 	if req.Timeout != nil {

api/applesilicon/v1alpha1/applesilicon_sdk.go

@@ -15,12 +15,18 @@ import (
 	"time"
 
 	"github.com/scaleway/scaleway-sdk-go/errors"
+	"github.com/scaleway/scaleway-sdk-go/internal/async"
 	"github.com/scaleway/scaleway-sdk-go/marshaler"
 	"github.com/scaleway/scaleway-sdk-go/namegenerator"
 	"github.com/scaleway/scaleway-sdk-go/parameter"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
+const (
+	defaultApplesiliconRetryInterval = 15 * time.Second
+	defaultApplesiliconTimeout       = 1 * time.Hour
+)
+
 // always import dependencies
 var (
 	_ fmt.Stringer
@@ -1430,6 +1436,58 @@ func (s *API) GetServer(req *GetServerRequest, opts ...scw.RequestOption) (*Serv
 	return &resp, nil
 }
 
+// WaitForServerRequest is used by WaitForServer method.
+type WaitForServerRequest struct {
+	GetServerRequest
+	Timeout       *time.Duration
+	RetryInterval *time.Duration
+}
+
+// WaitForServer waits for the Server to reach a terminal state.
+func (s *API) WaitForServer(req *WaitForServerRequest, opts ...scw.RequestOption) (*Server, error) {
+	timeout := defaultApplesiliconTimeout
+	if req.Timeout != nil {
+		timeout = *req.Timeout
+	}
+
+	retryInterval := defaultApplesiliconRetryInterval
+	if req.RetryInterval != nil {
+		retryInterval = *req.RetryInterval
+	}
+	transientStatuses := map[ServerStatus]struct{}{
+		ServerStatusStarting:     {},
+		ServerStatusRebooting:    {},
+		ServerStatusUpdating:     {},
+		ServerStatusLocking:      {},
+		ServerStatusUnlocking:    {},
+		ServerStatusReinstalling: {},
+		ServerStatusBusy:         {},
+	}
+
+	res, err := async.WaitSync(&async.WaitSyncConfig{
+		Get: func() (interface{}, bool, error) {
+			res, err := s.GetServer(&GetServerRequest{
+				Zone:     req.Zone,
+				ServerID: req.ServerID,
+			}, opts...)
+			if err != nil {
+				return nil, false, err
+			}
+
+			_, isTransient := transientStatuses[res.Status]
+
+			return res, !isTransient, nil
+		},
+		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
+		Timeout:          timeout,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "waiting for Server failed")
+	}
+
+	return res.(*Server), nil
+}
+
 // UpdateServer: Update the parameters of an existing Apple silicon server, specified by its server ID.
 func (s *API) UpdateServer(req *UpdateServerRequest, opts ...scw.RequestOption) (*Server, error) {
 	var err error
@@ -1681,6 +1739,54 @@ func (s *PrivateNetworkAPI) GetServerPrivateNetwork(req *PrivateNetworkAPIGetSer
 	return &resp, nil
 }
 
+// WaitForServerPrivateNetworkRequest is used by WaitForServerPrivateNetwork method.
+type WaitForServerPrivateNetworkRequest struct {
+	PrivateNetworkAPIGetServerPrivateNetworkRequest
+	Timeout       *time.Duration
+	RetryInterval *time.Duration
+}
+
+// WaitForServerPrivateNetwork waits for the ServerPrivateNetwork to reach a terminal state.
+func (s *PrivateNetworkAPI) WaitForServerPrivateNetwork(req *WaitForServerPrivateNetworkRequest, opts ...scw.RequestOption) (*ServerPrivateNetwork, error) {
+	timeout := defaultApplesiliconTimeout
+	if req.Timeout != nil {
+		timeout = *req.Timeout
+	}
+
+	retryInterval := defaultApplesiliconRetryInterval
+	if req.RetryInterval != nil {
+		retryInterval = *req.RetryInterval
+	}
+	transientStatuses := map[ServerPrivateNetworkServerStatus]struct{}{
+		ServerPrivateNetworkServerStatusAttaching: {},
+		ServerPrivateNetworkServerStatusDetaching: {},
+	}
+
+	res, err := async.WaitSync(&async.WaitSyncConfig{
+		Get: func() (interface{}, bool, error) {
+			res, err := s.GetServerPrivateNetwork(&PrivateNetworkAPIGetServerPrivateNetworkRequest{
+				Zone:             req.Zone,
+				ServerID:         req.ServerID,
+				PrivateNetworkID: req.PrivateNetworkID,
+			}, opts...)
+			if err != nil {
+				return nil, false, err
+			}
+
+			_, isTransient := transientStatuses[res.Status]
+
+			return res, !isTransient, nil
+		},
+		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
+		Timeout:          timeout,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "waiting for ServerPrivateNetwork failed")
+	}
+
+	return res.(*ServerPrivateNetwork), nil
+}
+
 // AddServerPrivateNetwork: Add an Apple silicon server to a Private Network.
 func (s *PrivateNetworkAPI) AddServerPrivateNetwork(req *PrivateNetworkAPIAddServerPrivateNetworkRequest, opts ...scw.RequestOption) (*ServerPrivateNetwork, error) {
 	var err error

api/baremetal/v1/baremetal_sdk.go

@@ -15,12 +15,18 @@ import (
 	"time"
 
 	"github.com/scaleway/scaleway-sdk-go/errors"
+	"github.com/scaleway/scaleway-sdk-go/internal/async"
 	"github.com/scaleway/scaleway-sdk-go/marshaler"
 	"github.com/scaleway/scaleway-sdk-go/namegenerator"
 	"github.com/scaleway/scaleway-sdk-go/parameter"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
+const (
+	defaultBaremetalRetryInterval = 15 * time.Second
+	defaultBaremetalTimeout       = 2 * time.Hour
+)
+
 // always import dependencies
 var (
 	_ fmt.Stringer
@@ -2285,6 +2291,58 @@ func (s *API) GetServer(req *GetServerRequest, opts ...scw.RequestOption) (*Serv
 	return &resp, nil
 }
 
+// WaitForServerRequest is used by WaitForServer method.
+type WaitForServerRequest struct {
+	GetServerRequest
+	Timeout       *time.Duration
+	RetryInterval *time.Duration
+}
+
+// WaitForServer waits for the Server to reach a terminal state.
+func (s *API) WaitForServer(req *WaitForServerRequest, opts ...scw.RequestOption) (*Server, error) {
+	timeout := defaultBaremetalTimeout
+	if req.Timeout != nil {
+		timeout = *req.Timeout
+	}
+
+	retryInterval := defaultBaremetalRetryInterval
+	if req.RetryInterval != nil {
+		retryInterval = *req.RetryInterval
+	}
+	transientStatuses := map[ServerStatus]struct{}{
+		ServerStatusDelivering: {},
+		ServerStatusStopping:   {},
+		ServerStatusStarting:   {},
+		ServerStatusDeleting:   {},
+		ServerStatusOrdered:    {},
+		ServerStatusResetting:  {},
+		ServerStatusMigrating:  {},
+	}
+
+	res, err := async.WaitSync(&async.WaitSyncConfig{
+		Get: func() (interface{}, bool, error) {
+			res, err := s.GetServer(&GetServerRequest{
+				Zone:     req.Zone,
+				ServerID: req.ServerID,
+			}, opts...)
+			if err != nil {
+				return nil, false, err
+			}
+
+			_, isTransient := transientStatuses[res.Status]
+
+			return res, !isTransient, nil
+		},
+		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
+		Timeout:          timeout,
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "waiting for Server failed")
+	}
+
+	return res.(*Server), nil
+}
+
 // CreateServer: Create a new Elastic Metal server. Once the server is created, proceed with the [installation of an OS](#post-3e949e).
 func (s *API) CreateServer(req *CreateServerRequest, opts ...scw.RequestOption) (*Server, error) {
 	var err error

api/baremetal/v1/server_utils.go

@@ -13,57 +13,6 @@ const (
 	defaultTimeout       = 2 * time.Hour
 )
 
-// WaitForServerRequest is used by WaitForServer method.
-type WaitForServerRequest struct {
-	ServerID      string
-	Zone          scw.Zone
-	Timeout       *time.Duration
-	RetryInterval *time.Duration
-}
-
-// WaitForServer wait for the server to be in a "terminal state" before returning.
-// This function can be used to wait for a server to be created.
-func (s *API) WaitForServer(req *WaitForServerRequest, opts ...scw.RequestOption) (*Server, error) {
-	timeout := defaultTimeout
-	if req.Timeout != nil {
-		timeout = *req.Timeout
-	}
-	retryInterval := defaultRetryInterval
-	if req.RetryInterval != nil {
-		retryInterval = *req.RetryInterval
-	}
-
-	terminalStatus := map[ServerStatus]struct{}{
-		ServerStatusReady:   {},
-		ServerStatusStopped: {},
-		ServerStatusError:   {},
-		ServerStatusLocked:  {},
-		ServerStatusUnknown: {},
-	}
-
-	server, err := async.WaitSync(&async.WaitSyncConfig{
-		Get: func() (any, bool, error) {
-			res, err := s.GetServer(&GetServerRequest{
-				ServerID: req.ServerID,
-				Zone:     req.Zone,
-			}, opts...)
-			if err != nil {
-				return nil, false, err
-			}
-
-			_, isTerminal := terminalStatus[res.Status]
-			return res, isTerminal, err
-		},
-		Timeout:          timeout,
-		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "waiting for server failed")
-	}
-
-	return server.(*Server), nil
-}
-
 // WaitForServerInstallRequest is used by WaitForServerInstall method.
 type WaitForServerInstallRequest struct {
 	ServerID      string