feat: update generated APIs

Author: scaleway-bot

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/cockpit/v1/cockpit_sdk.go

@@ -381,6 +381,51 @@ func (enum *ListPlansRequestOrderBy) UnmarshalJSON(data []byte) error {
 	return nil
 }
 
+type ListProductsRequestOrderBy string
+
+const (
+	ListProductsRequestOrderByCreatedAtAsc    = ListProductsRequestOrderBy("created_at_asc")
+	ListProductsRequestOrderByCreatedAtDesc   = ListProductsRequestOrderBy("created_at_desc")
+	ListProductsRequestOrderByDisplayNameAsc  = ListProductsRequestOrderBy("display_name_asc")
+	ListProductsRequestOrderByDisplayNameDesc = ListProductsRequestOrderBy("display_name_desc")
+	ListProductsRequestOrderByFamilyNameAsc   = ListProductsRequestOrderBy("family_name_asc")
+	ListProductsRequestOrderByFamilyNameDesc  = ListProductsRequestOrderBy("family_name_desc")
+)
+
+func (enum ListProductsRequestOrderBy) String() string {
+	if enum == "" {
+		// return default value if empty
+		return string(ListProductsRequestOrderByCreatedAtAsc)
+	}
+	return string(enum)
+}
+
+func (enum ListProductsRequestOrderBy) Values() []ListProductsRequestOrderBy {
+	return []ListProductsRequestOrderBy{
+		"created_at_asc",
+		"created_at_desc",
+		"display_name_asc",
+		"display_name_desc",
+		"family_name_asc",
+		"family_name_desc",
+	}
+}
+
+func (enum ListProductsRequestOrderBy) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf(`"%s"`, enum)), nil
+}
+
+func (enum *ListProductsRequestOrderBy) UnmarshalJSON(data []byte) error {
+	tmp := ""
+
+	if err := json.Unmarshal(data, &tmp); err != nil {
+		return err
+	}
+
+	*enum = ListProductsRequestOrderBy(ListProductsRequestOrderBy(tmp).String())
+	return nil
+}
+
 type ListTokensRequestOrderBy string
 
 const (
@@ -757,6 +802,17 @@ type Plan struct {
 	MonthlyPrice uint32 `json:"monthly_price"`
 }
 
+// Product: product.
+type Product struct {
+	Name string `json:"name"`
+
+	DisplayName string `json:"display_name"`
+
+	FamilyName string `json:"family_name"`
+
+	ResourceTypes []string `json:"resource_types"`
+}
+
 // Token: Token.
 type Token struct {
 	// ID: ID of the token.
@@ -1162,6 +1218,32 @@ func (r *ListPlansResponse) UnsafeAppend(res any) (uint64, error) {
 	return uint64(len(results.Plans)), nil
 }
 
+// ListProductsResponse: list products response.
+type ListProductsResponse struct {
+	ProductsList []*Product `json:"products_list"`
+
+	TotalCount uint64 `json:"total_count"`
+}
+
+// UnsafeGetTotalCount should not be used
+// Internal usage only
+func (r *ListProductsResponse) UnsafeGetTotalCount() uint64 {
+	return r.TotalCount
+}
+
+// UnsafeAppend should not be used
+// Internal usage only
+func (r *ListProductsResponse) UnsafeAppend(res any) (uint64, error) {
+	results, ok := res.(*ListProductsResponse)
+	if !ok {
+		return 0, errors.New("%T type cannot be appended to type %T", res, r)
+	}
+
+	r.ProductsList = append(r.ProductsList, results.ProductsList...)
+	r.TotalCount += uint64(len(results.ProductsList))
+	return uint64(len(results.ProductsList)), nil
+}
+
 // ListTokensResponse: Response returned when listing tokens.
 type ListTokensResponse struct {
 	// TotalCount: total count of tokens matching the request.
@@ -1429,6 +1511,22 @@ type RegionalAPIListDataSourcesRequest struct {
 	Types []DataSourceType `json:"-"`
 }
 
+// RegionalAPIListProductsRequest: List all Scaleway products that send metrics and/or logs to Cockpit.
+type RegionalAPIListProductsRequest struct {
+	// Region: region to target. If none is passed will use default region from the config.
+	Region scw.Region `json:"-"`
+
+	// Page: page number to return from the paginated results.
+	Page *int32 `json:"-"`
+
+	// PageSize: number of products to return per page.
+	PageSize *uint32 `json:"-"`
+
+	// OrderBy: sort order for products in the response.
+	// Default value: created_at_asc
+	OrderBy ListProductsRequestOrderBy `json:"-"`
+}
+
 // RegionalAPIListTokensRequest: List tokens.
 type RegionalAPIListTokensRequest struct {
 	// Region: region to target. If none is passed will use default region from the config.
@@ -2257,6 +2355,44 @@ func (s *RegionalAPI) DeleteToken(req *RegionalAPIDeleteTokenRequest, opts ...sc
 	return nil
 }
 
+// ListProducts: List all Scaleway products that send metrics and/or logs to Cockpit.
+func (s *RegionalAPI) ListProducts(req *RegionalAPIListProductsRequest, opts ...scw.RequestOption) (*ListProductsResponse, error) {
+	var err error
+
+	if req.Region == "" {
+		defaultRegion, _ := s.client.GetDefaultRegion()
+		req.Region = defaultRegion
+	}
+
+	defaultPageSize, exist := s.client.GetDefaultPageSize()
+	if (req.PageSize == nil || *req.PageSize == 0) && exist {
+		req.PageSize = &defaultPageSize
+	}
+
+	query := url.Values{}
+	parameter.AddToQuery(query, "page", req.Page)
+	parameter.AddToQuery(query, "page_size", req.PageSize)
+	parameter.AddToQuery(query, "order_by", req.OrderBy)
+
+	if fmt.Sprint(req.Region) == "" {
+		return nil, errors.New("field Region cannot be empty in request")
+	}
+
+	scwReq := &scw.ScalewayRequest{
+		Method: "GET",
+		Path:   "/cockpit/v1/regions/" + fmt.Sprint(req.Region) + "/products",
+		Query:  query,
+	}
+
+	var resp ListProductsResponse
+
+	err = s.client.Do(scwReq, &resp, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resp, nil
+}
+
 // GetAlertManager: Retrieve information about the Alert manager which is unique per Project and region. By default the Alert manager is disabled.
 // The output returned displays a URL to access the Alert manager, and whether the Alert manager and managed alerts are enabled.
 func (s *RegionalAPI) GetAlertManager(req *RegionalAPIGetAlertManagerRequest, opts ...scw.RequestOption) (*AlertManager, error) {