Merge branch 'master' into feat/cockpit-alert-waiters

Author: jremy42

.github/workflows/codeql-analysis.yml

@@ -42,7 +42,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -53,7 +53,7 @@ jobs:
     # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
     # If this step fails, then you should remove it and run the build manually (see below)
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
+      uses: github/codeql-action/autobuild@v4
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -67,4 +67,4 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4

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
@@ -499,7 +505,7 @@ type OS struct {
 	// Deprecated: CompatibleServerTypes: list of compatible server types. Deprecated.
 	CompatibleServerTypes *[]string `json:"compatible_server_types,omitempty"`
 
-	// ReleaseNotesURL: url of the release notes for the OS image or softwares pre-installed.
+	// ReleaseNotesURL: url of the release notes for the OS image or software pre-installed.
 	ReleaseNotesURL string `json:"release_notes_url"`
 
 	// Description: a summary of the OS image content and configuration.
@@ -1430,6 +1436,59 @@ func (s *API) GetServer(req *GetServerRequest, opts ...scw.RequestOption) (*Serv
 	return &resp, nil
 }
 
+// WaitForServerRequest is used by WaitForServer method.
+type WaitForServerRequest struct {
+	Zone          scw.Zone
+	ServerID      string
+	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() (any, 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
@@ -1531,7 +1590,7 @@ func (s *API) RebootServer(req *RebootServerRequest, opts ...scw.RequestOption)
 	return &resp, nil
 }
 
-// ReinstallServer: Reinstall an existing Apple silicon server (specified by its server ID) from a new image (OS). All the data on the disk is deleted and all configuration is reset to the defailt configuration values of the image (OS).
+// ReinstallServer: Reinstall an existing Apple silicon server (specified by its server ID) from a new image (OS). All the data on the disk is deleted and all configuration is reset to the default configuration values of the image (OS).
 func (s *API) ReinstallServer(req *ReinstallServerRequest, opts ...scw.RequestOption) (*Server, error) {
 	var err error
 
@@ -1681,6 +1740,56 @@ func (s *PrivateNetworkAPI) GetServerPrivateNetwork(req *PrivateNetworkAPIGetSer
 	return &resp, nil
 }
 
+// WaitForServerPrivateNetworkRequest is used by WaitForServerPrivateNetwork method.
+type WaitForServerPrivateNetworkRequest struct {
+	Zone             scw.Zone
+	ServerID         string
+	PrivateNetworkID string
+	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() (any, 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/audit_trail/v1alpha1/audit_trail_sdk.go

@@ -448,6 +448,8 @@ const (
 	ResourceTypeIamRule                  = ResourceType("iam_rule")
 	ResourceTypeIamSaml                  = ResourceType("iam_saml")
 	ResourceTypeIamSamlCertificate       = ResourceType("iam_saml_certificate")
+	ResourceTypeIamScim                  = ResourceType("iam_scim")
+	ResourceTypeIamScimToken             = ResourceType("iam_scim_token")
 	ResourceTypeSecretManagerSecret      = ResourceType("secret_manager_secret")
 	ResourceTypeSecretManagerVersion     = ResourceType("secret_manager_version")
 	ResourceTypeKeyManagerKey            = ResourceType("key_manager_key")
@@ -513,6 +515,8 @@ func (enum ResourceType) Values() []ResourceType {
 		"iam_rule",
 		"iam_saml",
 		"iam_saml_certificate",
+		"iam_scim",
+		"iam_scim_token",
 		"secret_manager_secret",
 		"secret_manager_version",
 		"key_manager_key",

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
@@ -1531,10 +1537,10 @@ type BMCAccess struct {
 	// URL: URL to access to the server console.
 	URL string `json:"url"`
 
-	// Login: the login to use for the BMC (Baseboard Management Controller) access authentification.
+	// Login: the login to use for the BMC (Baseboard Management Controller) access authentication.
 	Login string `json:"login"`
 
-	// Password: the password to use for the BMC (Baseboard Management Controller) access authentification.
+	// Password: the password to use for the BMC (Baseboard Management Controller) access authentication.
 	Password string `json:"password"`
 
 	// ExpiresAt: the date after which the BMC (Baseboard Management Controller) access will be closed.
@@ -2285,6 +2291,59 @@ func (s *API) GetServer(req *GetServerRequest, opts ...scw.RequestOption) (*Serv
 	return &resp, nil
 }
 
+// WaitForServerRequest is used by WaitForServer method.
+type WaitForServerRequest struct {
+	Zone          scw.Zone
+	ServerID      string
+	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() (any, 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