fix: fix sqlserverflexalpha

stackit/internal/wait/sqlserverflexalpha/wait.go

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package sqlserverflexalpha
 
 import (
@@ -28,145 +26,355 @@ const (
 	InstanceStateTerminating = "TERMINATING"
 )
 
-// APIClientInstanceInterface Interface needed for tests
-type APIClientInstanceInterface interface {
-	GetInstanceRequestExecute(ctx context.Context, projectId, region, instanceId string) (*sqlserverflex.GetInstanceResponse, error)
+// APIClientInterface Interface needed for tests
+type APIClientInterface interface {
+	GetInstanceRequestExecute(
+		ctx context.Context,
+		projectId, region, instanceId string,
+	) (*sqlserverflex.GetInstanceResponse, error)
+	GetDatabaseRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		databaseName string,
+	) (*sqlserverflex.GetDatabaseResponse, error)
+	GetUserRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) (*sqlserverflex.GetUserResponse, error)
+
+	ListRolesRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) (*sqlserverflex.ListRolesResponse, error)
+
+	ListUsersRequest(ctx context.Context, projectId string, region string, instanceId string) sqlserverflex.ApiListUsersRequestRequest
+
+	ListUsersRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) (*sqlserverflex.ListUserResponse, error)
 }
 
 // APIClientUserInterface Interface needed for tests
 type APIClientUserInterface interface {
-	DeleteUserRequestExecute(ctx context.Context, projectId string, region string, instanceId string, userId int64) error
+	DeleteUserRequestExecute(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+		userId int64,
+	) error
 }
 
 // CreateInstanceWaitHandler will wait for instance creation
-func CreateInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
-	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
-		s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-		if err != nil {
-			// TODO: catch 502, 503 and 504
-			return false, nil, err
-		}
-		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
-			return false, nil, nil
-		}
-		switch strings.ToLower(string(*s.Status)) {
-		case strings.ToLower(InstanceStateSuccess):
-			if *s.Network.AccessScope == "SNA" {
-				if s.Network.InstanceAddress == nil {
-					tflog.Info(ctx, "Waiting for instance_address")
-					return false, nil, nil
-				}
-				if s.Network.RouterAddress == nil {
-					tflog.Info(ctx, "Waiting for router_address")
-					return false, nil, nil
-				}
+func CreateInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+			if err != nil {
+				return false, nil, err
 			}
-			return true, s, nil
-		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
-			return true, s, fmt.Errorf("create failed for instance with id %s", instanceId)
-		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
-			tflog.Info(ctx, "request is being handled", map[string]interface{}{
-				"status": *s.Status,
-			})
-			return false, nil, nil
-		default:
-			tflog.Info(ctx, "Wait (create) received unknown status", map[string]interface{}{
-				"instanceId": instanceId,
-				"status":     s.Status,
-			})
-			return false, s, nil
-		}
-	})
+			if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
+				return false, nil, nil
+			}
+			switch strings.ToLower(string(*s.Status)) {
+			case strings.ToLower(InstanceStateSuccess):
+				if s.Network != nil && s.Network.AccessScope != nil && *s.Network.AccessScope == "SNA" {
+					if s.Network.InstanceAddress == nil {
+						tflog.Info(ctx, "Waiting for instance_address")
+						return false, nil, nil
+					}
+					if s.Network.RouterAddress == nil {
+						tflog.Info(ctx, "Waiting for router_address")
+						return false, nil, nil
+					}
+				}
+
+				tflog.Info(ctx, "trying to get roles")
+				time.Sleep(10 * time.Second)
+				_, rolesErr := a.ListRolesRequestExecute(ctx, projectId, region, instanceId)
+				if rolesErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(rolesErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, rolesErr
+					}
+					tflog.Info(
+						ctx, "wait for get-roles to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+
+				tflog.Info(ctx, "trying to get users")
+				time.Sleep(10 * time.Second)
+				_, usersErr := a.ListUsersRequestExecute(ctx, projectId, region, instanceId)
+				if usersErr != nil {
+					var oapiErr *oapierror.GenericOpenAPIError
+					ok := errors.As(usersErr, &oapiErr)
+					if !ok {
+						return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+					}
+					if oapiErr.StatusCode != http.StatusInternalServerError {
+						tflog.Info(
+							ctx, "got error from api", map[string]interface{}{
+								"error": rolesErr.Error(),
+							},
+						)
+						return false, nil, usersErr
+					}
+					tflog.Info(
+						ctx, "wait for get-users to work hack", map[string]interface{}{},
+					)
+					time.Sleep(10 * time.Second)
+					return false, nil, nil
+				}
+				return true, s, nil
+			case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
+				return true, nil, fmt.Errorf("create failed for instance with id %s", instanceId)
+			case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
+				tflog.Info(
+					ctx, "request is being handled", map[string]interface{}{
+						"status": *s.Status,
+					},
+				)
+				time.Sleep(10 * time.Second)
+				return false, nil, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (create) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return true, nil, errors.New("unknown status received")
+			}
+		},
+	)
 	return handler
 }
 
 // UpdateInstanceWaitHandler will wait for instance update
-func UpdateInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
-	handler := wait.New(func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
-		s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-		if err != nil {
-			return false, nil, err
-		}
-		if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
-			return false, nil, nil
-		}
-		switch strings.ToLower(string(*s.Status)) {
-		case strings.ToLower(InstanceStateSuccess):
-			return true, s, nil
-		case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
-			return true, s, fmt.Errorf("update failed for instance with id %s", instanceId)
-		case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
-			tflog.Info(ctx, "request is being handled", map[string]interface{}{
-				"status": *s.Status,
-			})
-			return false, nil, nil
-		default:
-			tflog.Info(ctx, "Wait (update) received unknown status", map[string]interface{}{
-				"instanceId": instanceId,
-				"status":     s.Status,
-			})
-			return false, s, nil
-		}
-	})
-	handler.SetSleepBeforeWait(15 * time.Second)
-	handler.SetTimeout(45 * time.Minute)
+func UpdateInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+			if err != nil {
+				return false, nil, err
+			}
+			if s == nil || s.Id == nil || *s.Id != instanceId || s.Status == nil {
+				return false, nil, nil
+			}
+			switch strings.ToLower(string(*s.Status)) {
+			case strings.ToLower(InstanceStateSuccess):
+				return true, s, nil
+			case strings.ToLower(InstanceStateUnknown), strings.ToLower(InstanceStateFailed):
+				return true, s, fmt.Errorf("update failed for instance with id %s", instanceId)
+			case strings.ToLower(InstanceStatePending), strings.ToLower(InstanceStateProcessing):
+				tflog.Info(
+					ctx, "request is being handled", map[string]interface{}{
+						"status": *s.Status,
+					},
+				)
+				return false, s, nil
+			default:
+				tflog.Info(
+					ctx, "Wait (update) received unknown status", map[string]interface{}{
+						"instanceId": instanceId,
+						"status":     s.Status,
+					},
+				)
+				return false, s, nil
+			}
+		},
+	)
 	return handler
 }
 
-// PartialUpdateInstanceWaitHandler will wait for instance update
-func PartialUpdateInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
-	return UpdateInstanceWaitHandler(ctx, a, projectId, instanceId, region)
+// DeleteInstanceWaitHandler will wait for instance deletion
+func DeleteInstanceWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+) *wait.AsyncActionHandler[sqlserverflex.GetInstanceResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetInstanceResponse, err error) {
+			s, err := a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
+			if err == nil {
+				return false, s, nil
+			}
+			var oapiErr *oapierror.GenericOpenAPIError
+			ok := errors.As(err, &oapiErr)
+			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(30 * time.Minute)
+	return handler
 }
 
-// DeleteInstanceWaitHandler will wait for instance deletion
-func DeleteInstanceWaitHandler(ctx context.Context, a APIClientInstanceInterface, projectId, instanceId, region string) *wait.AsyncActionHandler[struct{}] {
-	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
-		_, err = a.GetInstanceRequestExecute(ctx, projectId, region, instanceId)
-		if err == nil {
+// CreateDatabaseWaitHandler will wait for instance creation
+func CreateDatabaseWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, databaseName string,
+) *wait.AsyncActionHandler[sqlserverflex.GetDatabaseResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetDatabaseResponse, err error) {
+			s, err := a.GetDatabaseRequestExecute(ctx, projectId, region, instanceId, databaseName)
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("get database - could not convert error to oapierror.GenericOpenAPIError: %s", err.Error())
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				return false, nil, nil
+			}
+			if s == nil || s.Name == nil || *s.Name != databaseName {
+				return false, nil, errors.New("response did return different result")
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// CreateUserWaitHandler will wait for instance creation
+func CreateUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region string,
+	userId int64,
+) *wait.AsyncActionHandler[sqlserverflex.GetUserResponse] {
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.GetUserResponse, err error) {
+			s, err := a.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				return false, nil, nil
+			}
+			return true, s, nil
+		},
+	)
+	return handler
+}
+
+// WaitForUserWaitHandler will wait for instance creation
+func WaitForUserWaitHandler(
+	ctx context.Context,
+	a APIClientInterface,
+	projectId, instanceId, region, userName string,
+) *wait.AsyncActionHandler[sqlserverflex.ListUserResponse] {
+	startTime := time.Now()
+	timeOut := 2 * time.Minute
+
+	handler := wait.New(
+		func() (waitFinished bool, response *sqlserverflex.ListUserResponse, err error) {
+			if time.Since(startTime) > timeOut {
+				return false, nil, errors.New("ran into timeout")
+			}
+			s, err := a.ListUsersRequest(ctx, projectId, region, instanceId).Size(100).Execute()
+			if err != nil {
+				var oapiErr *oapierror.GenericOpenAPIError
+				ok := errors.As(err, &oapiErr)
+				if !ok {
+					return false, nil, fmt.Errorf("Wait (list users) could not convert error to oapierror.GenericOpenAPIError: %s", err.Error())
+				}
+				if oapiErr.StatusCode != http.StatusNotFound {
+					return false, nil, err
+				}
+				tflog.Info(
+					ctx, "Wait (list users) still waiting", map[string]interface{}{},
+				)
+
+				return false, nil, nil
+			}
+			users, ok := s.GetUsersOk()
+			if !ok {
+				return false, nil, errors.New("no users found")
+			}
+
+			for _, u := range users {
+				if u.GetUsername() == userName {
+					return true, s, nil
+				}
+			}
+			tflog.Info(
+				ctx, "Wait (list users) user still not present", map[string]interface{}{},
+			)
 			return false, nil, nil
-		}
-		var oapiErr *oapierror.GenericOpenAPIError
-		ok := errors.As(err, &oapiErr)
-		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
 }
 
 // DeleteUserWaitHandler will wait for instance deletion
 func DeleteUserWaitHandler(
 	ctx context.Context,
-	a APIClientUserInterface,
-	projectId, instanceId, region string,
+	a APIClientInterface,
+	projectId, region, instanceId string,
 	userId int64,
 ) *wait.AsyncActionHandler[struct{}] {
-	handler := wait.New(func() (waitFinished bool, response *struct{}, err error) {
-		err = a.DeleteUserRequestExecute(ctx, projectId, region, instanceId, userId)
-		if err == nil {
-			return false, nil, nil
-		}
-		var oapiErr *oapierror.GenericOpenAPIError
-		ok := errors.As(err, &oapiErr)
-		if !ok {
-			return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
-		}
+	handler := wait.New(
+		func() (waitFinished bool, response *struct{}, err error) {
+			_, err = a.GetUserRequestExecute(ctx, projectId, region, instanceId, userId)
+			if err == nil {
+				return false, nil, nil
+			}
+			var oapiErr *oapierror.GenericOpenAPIError
+			ok := errors.As(err, &oapiErr)
+			if !ok {
+				return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError")
+			}
 
-		switch oapiErr.StatusCode {
-		case http.StatusNotFound:
-			return true, nil, nil
-		case http.StatusInternalServerError:
-			tflog.Warn(ctx, "Wait handler got error 500")
-			return false, nil, nil
-		default:
-			return false, nil, err
-		}
-	})
+			switch oapiErr.StatusCode {
+			case http.StatusNotFound:
+				return true, nil, nil
+			default:
+				return false, nil, err
+			}
+		},
+	)
 	handler.SetTimeout(15 * time.Minute)
 	handler.SetSleepBeforeWait(15 * time.Second)
 	return handler