feat(rdb): make upgrade/database/user create idempotent with no-op success messages (scaleway#5097)

Author: jremy42

internal/namespaces/rdb/v1/custom.go

@@ -73,6 +73,9 @@ func GetCommands() *core.Commands {
 	cmds.MustFind("rdb", "instance", "update").Override(instanceUpdateBuilder)
 	cmds.MustFind("rdb", "instance", "upgrade").Override(instanceUpgradeBuilder)
 
+	// Make database create idempotent
+	cmds.MustFind("rdb", "database", "create").Override(databaseCreateBuilder)
+
 	cmds.MustFind("rdb", "user", "create").Override(userCreateBuilder)
 	cmds.MustFind("rdb", "user", "list").Override(userListBuilder)
 	cmds.MustFind("rdb", "user", "update").Override(userUpdateBuilder)

internal/namespaces/rdb/v1/custom_database.go

@@ -0,0 +1,34 @@
+package rdb
+
+import (
+	"context"
+
+	"github.com/scaleway/scaleway-cli/v2/core"
+	"github.com/scaleway/scaleway-sdk-go/api/rdb/v1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
+)
+
+func databaseCreateBuilder(c *core.Command) *core.Command {
+	c.Interceptor = func(ctx context.Context, argsI any, runner core.CommandRunner) (any, error) {
+		req := argsI.(*rdb.CreateDatabaseRequest)
+		if req.Name == "" {
+			return runner(ctx, argsI)
+		}
+
+		api := rdb.NewAPI(core.ExtractClient(ctx))
+		name := req.Name
+		list, err := api.ListDatabases(&rdb.ListDatabasesRequest{
+			Region:     req.Region,
+			InstanceID: req.InstanceID,
+			Name:       &name,
+		}, scw.WithAllPages())
+
+		if err == nil && list.TotalCount > 0 {
+			return list.Databases[0], nil
+		}
+
+		return runner(ctx, argsI)
+	}
+
+	return c
+}

internal/namespaces/rdb/v1/custom_instance.go

@@ -440,15 +440,76 @@ func instanceGetBuilder(c *core.Command) *core.Command {
 	return c
 }
 
+func instanceUpgradeInterceptor(
+	ctx context.Context,
+	argsI any,
+	runner core.CommandRunner,
+) (any, error) {
+	req := argsI.(*rdbSDK.UpgradeInstanceRequest)
+	api := rdbSDK.NewAPI(core.ExtractClient(ctx))
+
+	instance, err := api.GetInstance(&rdbSDK.GetInstanceRequest{
+		Region:     req.Region,
+		InstanceID: req.InstanceID,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	if !needsUpgrade(req, instance) {
+		return &core.SuccessResult{Message: "Nothing to do!"}, nil
+	}
+
+	return runner(ctx, argsI)
+}
+
+func needsUpgrade(req *rdbSDK.UpgradeInstanceRequest, instance *rdbSDK.Instance) bool {
+	if req.NodeType != nil && *req.NodeType != "" {
+		if !strings.EqualFold(instance.NodeType, *req.NodeType) {
+			return true
+		}
+	}
+
+	if req.EnableHa != nil && *req.EnableHa && !instance.IsHaCluster {
+		return true
+	}
+
+	if instance.Volume != nil {
+		if req.VolumeType != nil && *req.VolumeType != instance.Volume.Type {
+			return true
+		}
+		if req.VolumeSize != nil && *req.VolumeSize > uint64(instance.Volume.Size) {
+			return true
+		}
+	}
+
+	if req.UpgradableVersionID != nil && *req.UpgradableVersionID != "" {
+		return true
+	}
+
+	if req.MajorUpgradeWorkflow != nil && req.MajorUpgradeWorkflow.UpgradableVersionID != "" {
+		return true
+	}
+
+	return false
+}
+
 func instanceUpgradeBuilder(c *core.Command) *core.Command {
 	c.ArgSpecs.GetByName("node-type").AutoCompleteFunc = autoCompleteNodeType
 
+	c.Interceptor = instanceUpgradeInterceptor
+
 	c.WaitFunc = func(ctx context.Context, _, respI any) (any, error) {
+		if _, ok := respI.(*core.SuccessResult); ok {
+			return respI, nil
+		}
+
+		instance := respI.(*rdbSDK.Instance)
 		api := rdbSDK.NewAPI(core.ExtractClient(ctx))
 
 		return api.WaitForInstance(&rdbSDK.WaitForInstanceRequest{
-			InstanceID:    respI.(*rdbSDK.Instance).ID,
-			Region:        respI.(*rdbSDK.Instance).Region,
+			InstanceID:    instance.ID,
+			Region:        instance.Region,
 			Timeout:       scw.TimeDurationPtr(instanceActionTimeout),
 			RetryInterval: core.DefaultRetryInterval,
 		})

internal/namespaces/rdb/v1/custom_url.go

@@ -116,22 +116,7 @@ func generateURL(ctx context.Context, argsI any) (any, error) {
 
 	// Finally we add the database if it was given
 	if args.Db != "" {
-		databases, err := api.ListDatabases(&rdb.ListDatabasesRequest{
-			Region:     args.Region,
-			InstanceID: args.InstanceID,
-			Name:       &args.Db,
-		}, scw.WithContext(ctx), scw.WithAllPages())
-		if err != nil {
-			return nil, fmt.Errorf("failed to list databases for instance %q", args.InstanceID)
-		}
-		if databases.TotalCount != 1 {
-			return nil, fmt.Errorf(
-				"expected 1 database with the name %q, got %d",
-				args.Db,
-				databases.TotalCount,
-			)
-		}
-		u = u.JoinPath(databases.Databases[0].Name)
+		u = u.JoinPath(args.Db)
 	}
 
 	return u.String(), nil

internal/namespaces/rdb/v1/custom_user.go

@@ -3,7 +3,6 @@ package rdb
 import (
 	"context"
 	"errors"
-	"fmt"
 	"reflect"
 
 	"github.com/scaleway/scaleway-cli/v2/core"
@@ -113,30 +112,42 @@ func userCreateBuilder(c *core.Command) *core.Command {
 	c.ArgsType = reflect.TypeOf(rdbCreateUserRequestCustom{})
 
 	c.Run = func(ctx context.Context, argsI any) (any, error) {
-		client := core.ExtractClient(ctx)
-		api := rdb.NewAPI(client)
-
+		api := rdb.NewAPI(core.ExtractClient(ctx))
 		customRequest := argsI.(*rdbCreateUserRequestCustom)
-		createUserRequest := customRequest.CreateUserRequest
+		req := customRequest.CreateUserRequest
+
+		if req.Name != "" {
+			name := req.Name
+			users, err := api.ListUsers(&rdb.ListUsersRequest{
+				Region:     req.Region,
+				InstanceID: req.InstanceID,
+				Name:       &name,
+			}, scw.WithAllPages())
+			if err == nil && users.TotalCount > 0 {
+				return rdbCreateUserResponseCustom{
+					User:     users.Users[0],
+					Password: "",
+				}, nil
+			}
+		}
 
-		var err error
 		if customRequest.GeneratePassword && customRequest.Password == "" {
-			createUserRequest.Password, err = passwordgenerator.GeneratePassword(21, 1, 1, 1, 1)
+			password, err := passwordgenerator.GeneratePassword(21, 1, 1, 1, 1)
 			if err != nil {
 				return nil, err
 			}
-			fmt.Printf("Your generated password is %s \n", createUserRequest.Password)
-			fmt.Printf("\n")
+			req.Password = password
+			// password is returned in the command output; avoid logging it to stdout
 		}
 
-		user, err := api.CreateUser(createUserRequest)
+		user, err := api.CreateUser(req)
 		if err != nil {
 			return nil, err
 		}
 
 		result := rdbCreateUserResponseCustom{
 			User:     user,
-			Password: createUserRequest.Password,
+			Password: req.Password,
 		}
 
 		return result, nil