CLOUDP-285946: Add support for flex Clusters to "atlas cluster upgrade" (#3469)

Author: andreaangiolillo

internal/cli/clusters/update_test.go

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build unit
+
 package clusters
 
 import (

internal/cli/clusters/upgrade.go

@@ -16,6 +16,7 @@ package clusters
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/cli"
@@ -27,10 +28,15 @@ import (
 	"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/usage"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
+	atlasv2 "go.mongodb.org/atlas-sdk/v20241113002/admin"
 	atlas "go.mongodb.org/atlas/mongodbatlas"
 )
 
-const upgradeTemplate = "Upgrading cluster '{{.Name}}'.\n"
+const (
+	upgradeTemplate     = "Upgrading cluster '{{.Name}}'.\n"
+	replicaSetNodeCount = 3
+	replicaSetPriority  = 7
+)
 
 type UpgradeOpts struct {
 	cli.ProjectOpts
@@ -42,6 +48,7 @@ type UpgradeOpts struct {
 	filename                     string
 	enableTerminationProtection  bool
 	disableTerminationProtection bool
+	isFlexCluster                bool
 	tag                          map[string]string
 	fs                           afero.Fs
 	store                        store.AtlasSharedClusterGetterUpgrader
@@ -56,6 +63,28 @@ func (opts *UpgradeOpts) initStore(ctx context.Context) func() error {
 }
 
 func (opts *UpgradeOpts) Run() error {
+	if opts.isFlexCluster {
+		return opts.RunFlexCluster()
+	}
+
+	return opts.RunSharedCluster()
+}
+
+func (opts *UpgradeOpts) RunFlexCluster() error {
+	cluster, err := opts.atlasTenantClusterUpgradeRequest20240805()
+	if err != nil {
+		return err
+	}
+
+	r, err := opts.store.UpgradeFlexCluster(opts.ConfigProjectID(), cluster)
+	if err != nil {
+		return err
+	}
+
+	return opts.Print(r)
+}
+
+func (opts *UpgradeOpts) RunSharedCluster() error {
 	cluster, err := opts.cluster()
 	if err != nil {
 		return err
@@ -72,18 +101,125 @@ func (opts *UpgradeOpts) Run() error {
 	return opts.Print(r)
 }
 
+func (opts *UpgradeOpts) atlasTenantClusterUpgradeRequest20240805() (*atlasv2.AtlasTenantClusterUpgradeRequest20240805, error) {
+	var cluster *atlasv2.AtlasTenantClusterUpgradeRequest20240805
+	if opts.filename != "" {
+		err := file.Load(opts.fs, opts.filename, &cluster)
+		if err != nil {
+			return nil, err
+		}
+
+		cluster.Name = opts.name
+
+		return cluster, nil
+	}
+
+	flexClusterDescription, err := opts.store.FlexCluster(opts.ConfigProjectID(), opts.name)
+	if err != nil {
+		return nil, err
+	}
+
+	return opts.newAtlasTenantClusterUpgradeRequestFromFlexClusterDescription(flexClusterDescription), nil
+}
+
+func (opts *UpgradeOpts) newAtlasTenantClusterUpgradeRequestFromFlexClusterDescription(flexCluster *atlasv2.FlexClusterDescription20241113) *atlasv2.AtlasTenantClusterUpgradeRequest20240805 {
+	mdbVersion := flexCluster.MongoDBVersion
+	if opts.mdbVersion != "" {
+		mdbVersion = &opts.mdbVersion
+	}
+
+	terminationProtectionEnabled := flexCluster.GetTerminationProtectionEnabled()
+	if opts.disableTerminationProtection {
+		terminationProtectionEnabled = false
+	}
+
+	if opts.enableTerminationProtection {
+		terminationProtectionEnabled = true
+	}
+
+	var tags []atlasv2.ResourceTag
+	if flexCluster.Tags != nil {
+		tags = flexCluster.GetTags()
+	}
+
+	if len(opts.tag) > 0 {
+		newTags := newResourceTags(opts.tag)
+		tags = append(tags, *newTags...)
+	}
+
+	backupEnabled := false
+	if settings, ok := flexCluster.GetBackupSettingsOk(); ok {
+		backupEnabled = settings.GetEnabled()
+	}
+
+	flexGroupID, _ := flexCluster.GetGroupIdOk()
+	versionRelease, _ := flexCluster.GetVersionReleaseSystemOk()
+	flexClusterType, _ := flexCluster.GetClusterTypeOk()
+
+	return &atlasv2.AtlasTenantClusterUpgradeRequest20240805{
+		BackupEnabled:                &backupEnabled,
+		ClusterType:                  flexClusterType,
+		GroupId:                      flexGroupID,
+		MongoDBVersion:               mdbVersion,
+		Name:                         flexCluster.GetName(),
+		Tags:                         &tags,
+		TerminationProtectionEnabled: &terminationProtectionEnabled,
+		VersionReleaseSystem:         versionRelease,
+		ReplicationSpecs:             opts.newReplicationSpecFromOpts(flexCluster),
+	}
+}
+
+func (opts *UpgradeOpts) newReplicationSpecFromOpts(flexCluster *atlasv2.FlexClusterDescription20241113) *[]atlasv2.ReplicationSpec20240805 {
+	if opts.tier == "" {
+		return nil
+	}
+
+	diskSizeGb := 0.0
+	backingProviderName := ""
+	regionN := ""
+	if settings, ok := flexCluster.GetProviderSettingsOk(); ok {
+		diskSizeGb = settings.GetDiskSizeGB()
+		backingProviderName = settings.GetBackingProviderName()
+		regionN = settings.GetRegionName()
+	}
+
+	if opts.diskSizeGB != 0 {
+		diskSizeGb = opts.diskSizeGB
+	}
+
+	replicaSetCount := replicaSetNodeCount
+	priority := replicaSetPriority
+
+	replicaSpec := atlasv2.ReplicationSpec20240805{
+		RegionConfigs: &[]atlasv2.CloudRegionConfig20240805{
+			{
+				ElectableSpecs: &atlasv2.HardwareSpec20240805{
+					InstanceSize: &opts.tier,
+					DiskSizeGB:   &diskSizeGb,
+					NodeCount:    &replicaSetCount,
+				},
+				ProviderName: &backingProviderName,
+				RegionName:   &regionN,
+				Priority:     &priority,
+			},
+		},
+	}
+
+	return &[]atlasv2.ReplicationSpec20240805{replicaSpec}
+}
+
 func (opts *UpgradeOpts) cluster() (*atlas.Cluster, error) {
 	var cluster *atlas.Cluster
 	if opts.filename != "" {
 		err := file.Load(opts.fs, opts.filename, &cluster)
 		if err != nil {
 			return nil, err
 		}
-		if opts.name == "" {
-			opts.name = cluster.Name
-		}
+		cluster.Name = opts.name
+
 		return cluster, nil
 	}
+
 	return opts.store.AtlasSharedCluster(opts.ProjectID, opts.name)
 }
 
@@ -129,6 +265,26 @@ func isTenant(instanceSizeName string) bool {
 		instanceSizeName == atlasM5
 }
 
+// newIsFlexCluster sets the opts.isFlexCluster that indicates if the cluster to create is
+// a FlexCluster. The function calls the AtlasSharedAPI to get the cluster, and it sets the opts.isFlexCluster = true
+// in the event of a cannotUseFlexWithClusterApisErrorCode.
+func (opts *UpgradeOpts) newIsFlexCluster() error {
+	_, err := opts.store.AtlasSharedCluster(opts.ConfigProjectID(), opts.name)
+	var errorResponse *atlas.ErrorResponse
+	ok := errors.As(err, &errorResponse)
+	if !ok {
+		opts.isFlexCluster = false
+		return err
+	}
+
+	if errorResponse.ErrorCode != cannotUseFlexWithClusterApisErrorCode {
+		return err
+	}
+
+	opts.isFlexCluster = true
+	return nil
+}
+
 // UpgradeBuilder builds a cobra.Command that can run as:
 // atlas cluster(s) upgrade [clusterName] --projectId projectId [--tier M#] [--diskSizeGB N] [--mdbVersion] [--tag key=value].
 func UpgradeBuilder() *cobra.Command {
@@ -152,6 +308,7 @@ func UpgradeBuilder() *cobra.Command {
 				opts.ValidateProjectID,
 				opts.initStore(cmd.Context()),
 				opts.InitOutput(cmd.OutOrStdout(), upgradeTemplate),
+				opts.newIsFlexCluster,
 			)
 		},
 		RunE: func(_ *cobra.Command, _ []string) error {

internal/cli/clusters/upgrade_test.go

@@ -21,13 +21,15 @@ import (
 
 	"github.com/golang/mock/gomock"
 	"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/mocks"
+	"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/pointer"
 	"github.com/spf13/afero"
+	atlasv2 "go.mongodb.org/atlas-sdk/v20241113002/admin"
 	"go.mongodb.org/atlas/mongodbatlas"
 )
 
 const atlasM10 = "M10"
 
-func TestUpgrade_Run(t *testing.T) {
+func TestUpgrade_RunSharedCluster(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	mockStore := mocks.NewMockAtlasSharedClusterGetterUpgrader(ctrl)
 
@@ -154,3 +156,111 @@ func TestUpgrade_Run(t *testing.T) {
 		}
 	})
 }
+
+func TestUpgrade_RunFlexCluster(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	mockStore := mocks.NewMockAtlasSharedClusterGetterUpgrader(ctrl)
+	expected := &atlasv2.FlexClusterDescription20241113{
+		Name: pointer.Get("Test"),
+	}
+
+	t.Run("flags run", func(t *testing.T) {
+		upgradeOpts := &UpgradeOpts{
+			name:          "Test",
+			tier:          atlasM10,
+			diskSizeGB:    10,
+			mdbVersion:    "6.0",
+			store:         mockStore,
+			isFlexCluster: true,
+		}
+
+		mockStore.
+			EXPECT().
+			FlexCluster(upgradeOpts.ProjectID, upgradeOpts.name).
+			Return(expected, nil).
+			Times(1)
+
+		mockStore.
+			EXPECT().
+			UpgradeFlexCluster(upgradeOpts.ProjectID, upgradeOpts.newAtlasTenantClusterUpgradeRequestFromFlexClusterDescription(expected)).
+			Return(expected, nil).
+			Times(1)
+
+		if err := upgradeOpts.Run(); err != nil {
+			t.Fatalf("Run() unexpected error: %v", err)
+		}
+	})
+
+	t.Run("file run", func(t *testing.T) {
+		appFS := afero.NewMemMapFs()
+		// create test file
+		fileYML := `
+{
+  "backupEnabled": false,
+  "clusterType": "REPLICASET",
+  "name": "Test",
+  "replicationSpecs": [
+    {
+      "regionConfigs": [
+        {
+          "electableSpecs": {
+            "diskSizeGB": 10,
+            "instanceSize": "M10",
+            "nodeCount": 3
+          },
+          "priority": 7,
+          "providerName": "AWS",
+          "regionName": "US_EAST_1"
+		}
+      ]
+    }
+  ],
+  "terminationProtectionEnabled": false,
+  "versionReleaseSystem": "LTS"
+}`
+		fileName := "atlas_cluster_flex_upgrade_test.json"
+		_ = afero.WriteFile(appFS, fileName, []byte(fileYML), 0600)
+
+		upgradeOpts := &UpgradeOpts{
+			filename:      fileName,
+			fs:            appFS,
+			store:         mockStore,
+			isFlexCluster: true,
+			name:          "Test",
+		}
+
+		reqBody := &atlasv2.AtlasTenantClusterUpgradeRequest20240805{
+			BackupEnabled:                pointer.Get(false),
+			Name:                         "Test",
+			VersionReleaseSystem:         pointer.Get("LTS"),
+			ClusterType:                  pointer.Get("REPLICASET"),
+			TerminationProtectionEnabled: pointer.Get(false),
+			ReplicationSpecs: &[]atlasv2.ReplicationSpec20240805{
+				{
+					RegionConfigs: &[]atlasv2.CloudRegionConfig20240805{
+						{
+							Priority:     pointer.Get(7),
+							RegionName:   pointer.Get("US_EAST_1"),
+							ProviderName: pointer.Get("AWS"),
+							ElectableSpecs: &atlasv2.HardwareSpec20240805{
+								DiskSizeGB:   pointer.Get(10.0),
+								InstanceSize: pointer.Get("M10"),
+								NodeCount:    pointer.Get(3),
+							},
+						},
+					},
+				},
+			},
+		}
+
+		mockStore.
+			EXPECT().
+			UpgradeFlexCluster(upgradeOpts.ConfigProjectID(), reqBody).
+			Return(expected, nil).
+			Times(1)
+
+		if err := upgradeOpts.Run(); err != nil {
+			t.Fatalf("Run() unexpected error: %v", err)
+		}
+	})
+}