fix(loadbalancer) reset legacy waiter to origin/main

Author: cgoetz-inovex

services/loadbalancer/wait/wait.go

@@ -2,11 +2,12 @@ package wait
 
 import (
 	"context"
-	"errors"
 	"fmt"
+	"net/http"
 	"strings"
 	"time"
 
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
 	"github.com/stackitcloud/stackit-sdk-go/core/wait"
 	"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
 )
@@ -36,44 +37,59 @@ type APIClientInterface interface {
 // CreateLoadBalancerWaitHandler will wait for load balancer creation
 // Deprecated: Will be removed after 2026-09-30. Move to the packages generated for each available API version instead
 func CreateLoadBalancerWaitHandler(ctx context.Context, a APIClientInterface, projectId, region, instanceName string) *wait.AsyncActionHandler[loadbalancer.LoadBalancer] {
-	waitConfig := wait.WaiterHelper[loadbalancer.LoadBalancer, loadbalancer.LoadBalancerStatus]{
-		FetchInstance: func() (*loadbalancer.LoadBalancer, error) {
-			return a.GetLoadBalancerExecute(ctx, projectId, region, instanceName)
-		},
-		GetState: func(r *loadbalancer.LoadBalancer) (loadbalancer.LoadBalancerStatus, error) {
-			if r == nil || r.Status == nil {
-				return "", errors.New("response or status is nil")
-			}
-			var sb strings.Builder
-			if r.Errors != nil && len(*r.Errors) > 0 {
-				for _, err := range *r.Errors {
-					sb.WriteString(fmt.Sprintf("%s: %s; ", *err.Type, *err.Description))
-				}
-				return "", fmt.Errorf("create failed for instance with name %s, got status %s and errors: %s", instanceName, *r.Status, sb.String())
+	handler := wait.New(func() (waitFinished bool, response *loadbalancer.LoadBalancer, err error) {
+		s, err := a.GetLoadBalancerExecute(ctx, projectId, region, instanceName)
+		if err != nil {
+			return false, nil, err
+		}
+		if s == nil || s.Name == nil || *s.Name != instanceName || s.Status == nil {
+			return false, nil, nil
+		}
+
+		var errors []string
+		if s.Errors != nil && len(*s.Errors) > 0 {
+			for _, err := range *s.Errors {
+				errors = append(errors, fmt.Sprintf("%s: %s", *err.Type, *err.Description))
 			}
-			return *r.Status, nil
-		},
-		ActiveState: []loadbalancer.LoadBalancerStatus{loadbalancer.LOADBALANCERSTATUS_READY},
-		ErrorState:  []loadbalancer.LoadBalancerStatus{loadbalancer.LOADBALANCERSTATUS_ERROR, loadbalancer.LOADBALANCERSTATUS_TERMINATING},
-	}
-	handler := wait.New(waitConfig.Wait())
+			return true, s, fmt.Errorf("create failed for instance with name %s, got status %s and errors: %s", instanceName, *s.Status, strings.Join(errors, ";"))
+		}
+
+		switch *s.Status {
+		case loadbalancer.LOADBALANCERSTATUS_READY:
+			return true, s, nil
+		case loadbalancer.LOADBALANCERSTATUS_UNSPECIFIED:
+			return false, nil, nil
+		case loadbalancer.LOADBALANCERSTATUS_PENDING:
+			return false, nil, nil
+		case loadbalancer.LOADBALANCERSTATUS_TERMINATING:
+			return true, s, fmt.Errorf("create failed for instance with name %s, got status %s", instanceName, InstanceStatusTerminating)
+		case loadbalancer.LOADBALANCERSTATUS_ERROR:
+			return true, s, fmt.Errorf("create failed for instance with name %s, got status %s", instanceName, InstanceStatusError)
+		default:
+			return true, s, fmt.Errorf("instance with name %s has unexpected status %s", instanceName, *s.Status)
+		}
+	})
 	handler.SetTimeout(45 * time.Minute)
 	return handler
 }
 
 // DeleteLoadBalancerWaitHandler will wait for load balancer deletion
 // Deprecated: Will be removed after 2026-09-30. Move to the packages generated for each available API version instead
 func DeleteLoadBalancerWaitHandler(ctx context.Context, a APIClientInterface, projectId, region, instanceId string) *wait.AsyncActionHandler[struct{}] {
-	waitConfig := wait.WaiterHelper[struct{}, loadbalancer.LoadBalancerStatus]{
-		FetchInstance: func() (*struct{}, error) {
-			_, err := a.GetLoadBalancerExecute(ctx, projectId, region, instanceId)
-			return &struct{}{}, err
-		},
-		GetState: func(_ *struct{}) (loadbalancer.LoadBalancerStatus, error) {
-			return "", nil
-		},
-	}
-	handler := wait.New(waitConfig.Wait())
+	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
+		_, err = a.GetLoadBalancerExecute(ctx, projectId, region, instanceId)
+		if err == nil {
+			return false, nil, nil
+		}
+		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
+		if !ok {
+			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+		}
+		if oapiErr.StatusCode != http.StatusNotFound {
+			return false, nil, err
+		}
+		return true, nil, nil
+	})
 	handler.SetTimeout(15 * time.Minute)
 	return handler
 }