fix(cockpit): remove WaitForAlert and keep only WaitForPreconfiguredAlerts

Author: jremy42

api/cockpit/v1/cockpit_utils.go

@@ -13,60 +13,6 @@ const (
 	defaultTimeout       = 5 * time.Minute
 )
 
-// WaitForAlertRequest is used by WaitForAlert method.
-type WaitForAlertRequest struct {
-	Region        scw.Region
-	AlertID       string
-	Timeout       *time.Duration
-	RetryInterval *time.Duration
-}
-
-// WaitForAlert waits for the alert to be in a "terminal state" before returning.
-// This function can be used to wait for an alert to be enabled or disabled.
-func (s *RegionalAPI) WaitForAlert(req *WaitForAlertRequest, opts ...scw.RequestOption) (*Alert, error) {
-	timeout := defaultTimeout
-	if req.Timeout != nil {
-		timeout = *req.Timeout
-	}
-	retryInterval := defaultRetryInterval
-	if req.RetryInterval != nil {
-		retryInterval = *req.RetryInterval
-	}
-
-	terminalStatus := map[AlertStatus]struct{}{
-		AlertStatusEnabled:  {},
-		AlertStatusDisabled: {},
-	}
-
-	alert, err := async.WaitSync(&async.WaitSyncConfig{
-		Get: func() (any, bool, error) {
-			// List all alerts and find the one with matching ID
-			res, err := s.ListAlerts(&RegionalAPIListAlertsRequest{
-				Region: req.Region,
-			}, opts...)
-			if err != nil {
-				return nil, false, err
-			}
-
-			// Find the alert by ID
-			for _, alert := range res.Alerts {
-				if alert.ID == req.AlertID {
-					_, isTerminal := terminalStatus[alert.RuleStatus]
-					return alert, isTerminal, nil
-				}
-			}
-
-			return nil, false, errors.New("alert not found")
-		},
-		Timeout:          timeout,
-		IntervalStrategy: async.LinearIntervalStrategy(retryInterval),
-	})
-	if err != nil {
-		return nil, errors.Wrap(err, "waiting for alert failed")
-	}
-	return alert.(*Alert), nil
-}
-
 // WaitForPreconfiguredAlertsRequest is used by WaitForPreconfiguredAlerts method.
 type WaitForPreconfiguredAlertsRequest struct {
 	Region             scw.Region
@@ -90,17 +36,14 @@ func (s *RegionalAPI) WaitForPreconfiguredAlerts(req *WaitForPreconfiguredAlerts
 		retryInterval = *req.RetryInterval
 	}
 
-	// For enabling/disabling, accept transitional states as terminal
 	var terminalStatus map[AlertStatus]struct{}
 	switch req.TargetStatus {
 	case AlertStatusEnabled:
-		// Accept both enabled and enabling as terminal states
 		terminalStatus = map[AlertStatus]struct{}{
 			AlertStatusEnabled:  {},
 			AlertStatusEnabling: {},
 		}
 	case AlertStatusDisabled:
-		// Accept both disabled and disabling as terminal states
 		terminalStatus = map[AlertStatus]struct{}{
 			AlertStatusDisabled:  {},
 			AlertStatusDisabling: {},
@@ -113,7 +56,6 @@ func (s *RegionalAPI) WaitForPreconfiguredAlerts(req *WaitForPreconfiguredAlerts
 
 	result, err := async.WaitSync(&async.WaitSyncConfig{
 		Get: func() (any, bool, error) {
-			// List all preconfigured alerts for the project
 			res, err := s.ListAlerts(&RegionalAPIListAlertsRequest{
 				Region:          req.Region,
 				ProjectID:       req.ProjectID,
@@ -123,15 +65,13 @@ func (s *RegionalAPI) WaitForPreconfiguredAlerts(req *WaitForPreconfiguredAlerts
 				return nil, false, err
 			}
 
-			// Create a map of rule ID to alert
 			alertsByRuleID := make(map[string]*Alert)
 			for _, alert := range res.Alerts {
 				if alert.PreconfiguredData != nil && alert.PreconfiguredData.PreconfiguredRuleID != "" {
 					alertsByRuleID[alert.PreconfiguredData.PreconfiguredRuleID] = alert
 				}
 			}
 
-			// Check if all requested alerts are in terminal state
 			var matchedAlerts []*Alert
 			for _, ruleID := range req.PreconfiguredRules {
 				alert, found := alertsByRuleID[ruleID]
@@ -141,14 +81,12 @@ func (s *RegionalAPI) WaitForPreconfiguredAlerts(req *WaitForPreconfiguredAlerts
 
 				_, isTerminal := terminalStatus[alert.RuleStatus]
 				if !isTerminal {
-					// At least one alert is not in terminal state, continue waiting
 					return nil, false, nil
 				}
 
 				matchedAlerts = append(matchedAlerts, alert)
 			}
 
-			// All alerts are in terminal state
 			return matchedAlerts, true, nil
 		},
 		Timeout:          timeout,
@@ -159,4 +97,3 @@ func (s *RegionalAPI) WaitForPreconfiguredAlerts(req *WaitForPreconfiguredAlerts
 	}
 	return result.([]*Alert), nil
 }
-

api/cockpit/v1/sweepers/sweepers.go

@@ -57,6 +57,7 @@ func SweepGrafanaUser(scwClient *scw.Client) error {
 			continue
 		}
 
+		//nolint:staticcheck // Deprecated functions are still functional and needed for sweepers
 		listGrafanaUsers, err := cockpitAPI.ListGrafanaUsers(&cockpit.GlobalAPIListGrafanaUsersRequest{
 			ProjectID: project.ID,
 		}, scw.WithAllPages())
@@ -65,6 +66,7 @@ func SweepGrafanaUser(scwClient *scw.Client) error {
 		}
 
 		for _, grafanaUser := range listGrafanaUsers.GrafanaUsers {
+			//nolint:staticcheck // Deprecated functions are still functional and needed for sweepers
 			err = cockpitAPI.DeleteGrafanaUser(&cockpit.GlobalAPIDeleteGrafanaUserRequest{
 				ProjectID:     project.ID,
 				GrafanaUserID: grafanaUser.ID,

api/domain/v2beta1/domain_utils.go

@@ -58,7 +58,6 @@ func (s *API) WaitForDNSZone(
 				listReq.DNSZone = &req.DNSZone
 			}
 
-			// listing dnsZone zones and take the first one
 			DNSZones, err := s.ListDNSZones(listReq, opts...)
 			if err != nil {
 				return nil, false, err
@@ -108,7 +107,6 @@ func (s *API) WaitForDNSRecordExist(
 
 	dns, err := async.WaitSync(&async.WaitSyncConfig{
 		Get: func() (any, bool, error) {
-			// listing dns zone records and take the first one
 			DNSRecords, err := s.ListDNSZoneRecords(&ListDNSZoneRecordsRequest{
 				Name:    req.RecordName,
 				Type:    req.RecordType,
@@ -157,7 +155,6 @@ func (s *RegistrarAPI) WaitForOrderDomain(
 		retryInterval = *req.RetryInterval
 	}
 
-	// Terminal statuses indicating success or error.
 	terminalStatuses := map[DomainStatus]struct{}{
 		DomainStatusActive:      {},
 		DomainStatusExpired:     {},
@@ -205,7 +202,6 @@ type WaitForAutoRenewStatusRequest struct {
 // WaitForAutoRenewStatus polls the domain until its auto‑renew feature reaches a terminal state
 // (either "enabled" or "disabled"). It uses GetDomain() to fetch the current status.
 func (s *RegistrarAPI) WaitForAutoRenewStatus(req *WaitForAutoRenewStatusRequest, opts ...scw.RequestOption) (*Domain, error) {
-	// Use default timeout and retry interval if not provided.
 	timeout := defaultTimeout
 	if req.Timeout != nil {
 		timeout = *req.Timeout
@@ -215,7 +211,6 @@ func (s *RegistrarAPI) WaitForAutoRenewStatus(req *WaitForAutoRenewStatusRequest
 		retryInterval = *req.RetryInterval
 	}
 
-	// Terminal statuses for auto_renew: enabled or disabled.
 	terminalStatuses := map[DomainFeatureStatus]struct{}{
 		DomainFeatureStatusEnabled:  {},
 		DomainFeatureStatusDisabled: {},
@@ -257,7 +252,6 @@ type WaitForDNSSECStatusRequest struct {
 // WaitForDNSSECStatus polls the domain until its DNSSEC feature reaches a terminal state
 // (either "enabled" or "disabled"). It uses GetDomain() to fetch the current status.
 func (s *RegistrarAPI) WaitForDNSSECStatus(req *WaitForDNSSECStatusRequest, opts ...scw.RequestOption) (*Domain, error) {
-	// Use default timeout and retry interval if not provided.
 	timeout := defaultTimeout
 	if req.Timeout != nil {
 		timeout = *req.Timeout
@@ -267,7 +261,6 @@ func (s *RegistrarAPI) WaitForDNSSECStatus(req *WaitForDNSSECStatusRequest, opts
 		retryInterval = *req.RetryInterval
 	}
 
-	// Terminal statuses for DNSSEC: enabled or disabled.
 	terminalStatuses := map[DomainFeatureStatus]struct{}{
 		DomainFeatureStatusEnabled:  {},
 		DomainFeatureStatusDisabled: {},
@@ -277,15 +270,13 @@ func (s *RegistrarAPI) WaitForDNSSECStatus(req *WaitForDNSSECStatusRequest, opts
 
 	domainResult, err := async.WaitSync(&async.WaitSyncConfig{
 		Get: func() (any, bool, error) {
-			// Retrieve the domain.
 			resp, err := s.GetDomain(&RegistrarAPIGetDomainRequest{
 				Domain: req.Domain,
 			}, opts...)
 			if err != nil {
 				return nil, false, err
 			}
 
-			// Check the current DNSSEC status.
 			lastStatus = resp.Dnssec.Status
 			if _, isTerminal := terminalStatuses[resp.Dnssec.Status]; isTerminal {
 				return resp, true, nil