Skip to content

Commit 4a8b017

Browse files
helderjshelderjs
committed
adjust flex export logic
1 parent 1c2cec2 commit 4a8b017

File tree

4 files changed

+36
-146
lines changed

4 files changed

+36
-146
lines changed

‎internal/kubernetes/operator/config_exporter.go‎

Lines changed: 23 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,6 @@ import (
3131
"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/pointer"
3232
"github.com/mongodb/mongodb-atlas-cli/atlascli/internal/store"
3333
"go.mongodb.org/atlas-sdk/v20241113004/admin"
34-
"golang.org/x/exp/maps"
3534
"k8s.io/apimachinery/pkg/runtime"
3635
"k8s.io/apimachinery/pkg/runtime/serializer/json"
3736
"k8s.io/client-go/kubernetes/scheme"
@@ -52,7 +51,6 @@ type ConfigExporter struct {
5251
credsProvider store.CredentialsGetter
5352
projectID string
5453
clusterNames []string
55-
flexClusterNames []string
5654
targetNamespace string
5755
operatorVersion string
5856
includeSecretsData bool
@@ -69,8 +67,6 @@ type Patcher interface {
6967

7068
var (
7169
ErrServerless = errors.New("serverless instance error")
72-
ErrFlex = errors.New("flex cluster error")
73-
ErrClusterNotFound = errors.New("cluster not found")
7470
ErrNoCloudManagerClusters = errors.New("can not get 'advanced clusters' object")
7571
)
7672

@@ -312,12 +308,11 @@ func (e *ConfigExporter) exportDeployments(projectName string) ([]runtime.Object
312308
var result []runtime.Object
313309

314310
if len(e.clusterNames) == 0 {
315-
clusters, flex, err := fetchClusterNames(e.dataProvider, e.projectID)
311+
clusters, err := fetchClusterNames(e.dataProvider, e.projectID)
316312
if err != nil {
317313
return nil, err
318314
}
319315
e.clusterNames = clusters
320-
e.flexClusterNames = flex
321316
}
322317

323318
credentials := credentialsName(projectName)
@@ -341,33 +336,31 @@ func (e *ConfigExporter) exportDeployments(projectName string) ([]runtime.Object
341336
continue
342337
}
343338

344-
// Try serverless cluster next
345-
serverlessCluster, err := deployment.BuildServerlessDeployments(e.dataProvider, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion)
346-
if err == nil {
347-
if serverlessCluster != nil {
348-
result = append(result, serverlessCluster)
339+
// Try flex cluster next
340+
if flexCluster, err := deployment.BuildFlexDeployments(e.dataProvider, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion); err == nil {
341+
if flexCluster != nil {
342+
result = append(result, flexCluster)
349343
}
350344
continue
351345
}
352-
return nil, fmt.Errorf("%w: %s(%s), e: %w", ErrServerless, deploymentName, e.projectID, err)
353-
}
354346

355-
for _, deploymentName := range e.flexClusterNames {
356-
flexCluster, err := deployment.BuildFlexDeployments(e.dataProvider, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion)
347+
// Try serverless cluster last
348+
serverlessCluster, err := deployment.BuildServerlessDeployments(e.dataProvider, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion)
357349
if err == nil {
358-
if flexCluster != nil {
359-
result = append(result, flexCluster)
350+
if serverlessCluster != nil {
351+
result = append(result, serverlessCluster)
360352
}
361353
continue
362354
}
363-
364-
return nil, fmt.Errorf("%w: %s(%s), e: %w", ErrFlex, deploymentName, e.projectID, err)
355+
return nil, fmt.Errorf("%w: %s(%s), e: %w", ErrServerless, deploymentName, e.projectID, err)
365356
}
366357

367358
return result, nil
368359
}
369360

370-
func fetchClusterNames(clustersProvider store.AllClustersLister, projectID string) ([]string, []string, error) {
361+
func fetchClusterNames(clustersProvider store.AllClustersLister, projectID string) ([]string, error) {
362+
result := make([]string, 0, DefaultClustersCount)
363+
371364
flexResult := make(map[string]struct{}, DefaultClustersCount)
372365
flexClusters, err := clustersProvider.ListFlexClusters(
373366
&admin.ListFlexClustersApiParams{
@@ -376,31 +369,33 @@ func fetchClusterNames(clustersProvider store.AllClustersLister, projectID strin
376369
},
377370
)
378371
if err != nil {
379-
return nil, nil, err
372+
return nil, err
380373
}
381374

382375
for _, cluster := range flexClusters.GetResults() {
383376
if reflect.ValueOf(cluster).IsZero() {
384377
continue
385378
}
379+
380+
result = append(result, cluster.GetName())
386381
flexResult[cluster.GetName()] = struct{}{}
387382
}
388383

389-
result := make([]string, 0, DefaultClustersCount)
390384
clusters, err := clustersProvider.ProjectClusters(projectID, &store.ListOptions{ItemsPerPage: maxClusters})
391385
if err != nil {
392-
return nil, nil, err
386+
return nil, err
393387
}
394388

395389
if clusters == nil {
396-
return nil, nil, ErrNoCloudManagerClusters
390+
return nil, ErrNoCloudManagerClusters
397391
}
398392

399393
for _, cluster := range clusters.GetResults() {
400394
if reflect.ValueOf(cluster).IsZero() {
401395
continue
402396
}
403397

398+
// Deduplicate non-migrated instances
404399
if _, ok := flexResult[cluster.GetName()]; ok {
405400
continue
406401
}
@@ -410,22 +405,23 @@ func fetchClusterNames(clustersProvider store.AllClustersLister, projectID strin
410405

411406
serverlessInstances, err := clustersProvider.ServerlessInstances(projectID, &store.ListOptions{ItemsPerPage: maxClusters})
412407
if err != nil {
413-
return nil, nil, err
408+
return nil, err
414409
}
415410

416411
if serverlessInstances == nil {
417-
return result, maps.Keys(flexResult), nil
412+
return result, nil
418413
}
419414

420415
for _, cluster := range serverlessInstances.GetResults() {
416+
// Deduplicate non-migrated instances
421417
if _, ok := flexResult[cluster.GetName()]; ok {
422418
continue
423419
}
424420

425421
result = append(result, *cluster.Name)
426422
}
427423

428-
return result, maps.Keys(flexResult), nil
424+
return result, nil
429425
}
430426

431427
func (e *ConfigExporter) exportDataFederation(projectName string) ([]runtime.Object, error) {

‎test/e2e/atlas/atlas_e2e_test_generator_test.go‎

Lines changed: 4 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,7 @@ type atlasE2ETestGenerator struct {
4040
projectName string
4141
clusterName string
4242
clusterRegion string
43-
serverlessName string
43+
flexName string
4444
teamName string
4545
teamID string
4646
teamUser string
@@ -413,27 +413,6 @@ func deleteOrgInvitation(t *testing.T, cliPath string, id string) {
413413
require.NoError(t, err, string(resp))
414414
}
415415

416-
func (g *atlasE2ETestGenerator) generateServerlessCluster() {
417-
g.t.Helper()
418-
419-
if g.projectID == "" {
420-
g.t.Fatal("unexpected error: project must be generated")
421-
}
422-
423-
var err error
424-
g.serverlessName, err = deployServerlessInstanceForProject(g.projectID)
425-
if err != nil {
426-
g.t.Errorf("unexpected error deploying serverless instance: %v", err)
427-
}
428-
g.t.Logf("serverlessName=%s", g.serverlessName)
429-
430-
g.t.Cleanup(func() {
431-
cliPath, err := e2e.AtlasCLIBin()
432-
require.NoError(g.t, err)
433-
deleteServerlessInstanceForProject(g.t, cliPath, g.projectID, g.serverlessName)
434-
})
435-
}
436-
437416
func (g *atlasE2ETestGenerator) generateFlexCluster() {
438417
g.t.Helper()
439418

@@ -442,14 +421,14 @@ func (g *atlasE2ETestGenerator) generateFlexCluster() {
442421
}
443422

444423
var err error
445-
g.clusterName, err = deployFlexClusterForProject(g.projectID)
424+
g.flexName, err = deployFlexClusterForProject(g.projectID)
446425
if err != nil {
447426
g.t.Fatalf("unexpected error deploying flex cluster: %v", err)
448427
}
449-
g.t.Logf("flexClusterName=%s", g.clusterName)
428+
g.t.Logf("flexClusterName=%s", g.flexName)
450429

451430
g.t.Cleanup(func() {
452-
_ = deleteClusterForProject(g.projectID, g.clusterName)
431+
_ = deleteClusterForProject(g.projectID, g.flexName)
453432
})
454433
}
455434

‎test/e2e/atlas/helper_test.go‎

Lines changed: 0 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -170,53 +170,6 @@ func splitOutput(cmd *exec.Cmd) (string, string, error) {
170170
return o.String(), e.String(), err
171171
}
172172

173-
func deployServerlessInstanceForProject(projectID string) (string, error) {
174-
cliPath, err := e2e.AtlasCLIBin()
175-
if err != nil {
176-
return "", err
177-
}
178-
clusterName, err := RandClusterName()
179-
if err != nil {
180-
return "", err
181-
}
182-
tier := e2eTier()
183-
region, err := newAvailableRegion(projectID, tier, e2eClusterProvider)
184-
if err != nil {
185-
return "", err
186-
}
187-
args := []string{
188-
serverlessEntity,
189-
"create",
190-
clusterName,
191-
"--region", region,
192-
"--provider", e2eClusterProvider,
193-
}
194-
195-
if projectID != "" {
196-
args = append(args, "--projectId", projectID)
197-
}
198-
create := exec.Command(cliPath, args...)
199-
create.Env = os.Environ()
200-
if resp, err := e2e.RunAndGetStdOut(create); err != nil {
201-
return "", fmt.Errorf("error creating serverless instance %w: %s", err, string(resp))
202-
}
203-
204-
watchArgs := []string{
205-
serverlessEntity,
206-
"watch",
207-
clusterName,
208-
}
209-
if projectID != "" {
210-
watchArgs = append(watchArgs, "--projectId", projectID)
211-
}
212-
watch := exec.Command(cliPath, watchArgs...)
213-
watch.Env = os.Environ()
214-
if resp, err := e2e.RunAndGetStdOut(watch); err != nil {
215-
return "", fmt.Errorf("error watching serverless instance %w: %s", err, string(resp))
216-
}
217-
return clusterName, nil
218-
}
219-
220173
func deployFlexClusterForProject(projectID string) (string, error) {
221174
cliPath, err := e2e.AtlasCLIBin()
222175
if err != nil {

‎test/e2e/atlas/kubernetes_config_generate_test.go‎

Lines changed: 9 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -324,8 +324,6 @@ func defaultPrivateEndpoint(generator *atlasE2ETestGenerator, independent bool)
324324
ExternalProjectRef: &akov2.ExternalProjectReference{
325325
ID: generator.projectID,
326326
},
327-
}
328-
pe.Spec.ProjectDualReference = akov2.ProjectDualReference{
329327
ConnectionSecret: &akoapi.LocalObjectReference{
330328
Name: resources.NormalizeAtlasName(strings.ToLower(generator.projectName)+"-credentials", resources.AtlasNameToKubernetesName()),
331329
},
@@ -1834,42 +1832,6 @@ func referenceAdvancedCluster(name, region, namespace, projectName string, label
18341832
}
18351833
}
18361834

1837-
func referenceServerless(name, region, namespace, projectName string, labels map[string]string) *akov2.AtlasDeployment {
1838-
dictionary := resources.AtlasNameToKubernetesName()
1839-
return &akov2.AtlasDeployment{
1840-
TypeMeta: metav1.TypeMeta{
1841-
Kind: "AtlasDeployment",
1842-
APIVersion: "atlas.mongodb.com/v1",
1843-
},
1844-
ObjectMeta: metav1.ObjectMeta{
1845-
Name: resources.NormalizeAtlasName(fmt.Sprintf("%s-%s", projectName, name), dictionary),
1846-
Namespace: namespace,
1847-
Labels: labels,
1848-
},
1849-
Spec: akov2.AtlasDeploymentSpec{
1850-
ProjectDualReference: akov2.ProjectDualReference{
1851-
ProjectRef: &akov2common.ResourceRefNamespaced{
1852-
Name: resources.NormalizeAtlasName(projectName, dictionary),
1853-
Namespace: namespace,
1854-
},
1855-
},
1856-
ServerlessSpec: &akov2.ServerlessSpec{
1857-
Name: name,
1858-
ProviderSettings: &akov2.ServerlessProviderSettingsSpec{
1859-
BackingProviderName: string(akov2provider.ProviderAWS),
1860-
ProviderName: akov2provider.ProviderServerless,
1861-
RegionName: region,
1862-
},
1863-
},
1864-
},
1865-
Status: akov2status.AtlasDeploymentStatus{
1866-
Common: akoapi.Common{
1867-
Conditions: []akoapi.Condition{},
1868-
},
1869-
},
1870-
}
1871-
}
1872-
18731835
func referenceFlex(name, region, namespace, projectName string, labels map[string]string) *akov2.AtlasDeployment {
18741836
dictionary := resources.AtlasNameToKubernetesName()
18751837
return &akov2.AtlasDeployment{
@@ -2058,10 +2020,10 @@ func checkClustersData(t *testing.T, deployments []*akov2.AtlasDeployment, clust
20582020
assert.Len(t, deployments, len(clusterNames))
20592021
var entries []string
20602022
for _, deployment := range deployments {
2061-
if deployment.Spec.ServerlessSpec != nil {
2062-
if ok := slices.Contains(clusterNames, deployment.Spec.ServerlessSpec.Name); ok {
2063-
name := deployment.Spec.ServerlessSpec.Name
2064-
expectedDeployment := referenceServerless(name, region, namespace, projectName, expectedLabels)
2023+
if deployment.Spec.FlexSpec != nil {
2024+
if ok := slices.Contains(clusterNames, deployment.Spec.FlexSpec.Name); ok {
2025+
name := deployment.Spec.FlexSpec.Name
2026+
expectedDeployment := referenceFlex(name, region, namespace, projectName, expectedLabels)
20652027
assert.Equal(t, expectedDeployment, deployment)
20662028
entries = append(entries, name)
20672029
}
@@ -2087,7 +2049,7 @@ func TestKubernetesConfigGenerate_ClustersWithBackup(t *testing.T) {
20872049
g.enableBackup = true
20882050
g.generateProject(fmt.Sprintf("kubernetes-%s", n))
20892051
g.generateCluster()
2090-
g.generateServerlessCluster()
2052+
g.generateFlexCluster()
20912053

20922054
expectedDeployment := referenceAdvancedCluster(g.clusterName, g.clusterRegion, targetNamespace, g.projectName, expectedLabels, g.mDBVer)
20932055
expectedBackupSchedule := referenceBackupSchedule(targetNamespace, g.projectName, g.clusterName, expectedLabels)
@@ -2178,7 +2140,7 @@ func TestKubernetesConfigGenerate_ClustersWithBackup(t *testing.T) {
21782140
"--clusterName",
21792141
g.clusterName,
21802142
"--clusterName",
2181-
g.serverlessName,
2143+
g.flexName,
21822144
"--targetNamespace",
21832145
targetNamespace,
21842146
"--includeSecrets")
@@ -2198,7 +2160,7 @@ func TestKubernetesConfigGenerate_ClustersWithBackup(t *testing.T) {
21982160

21992161
ds := atlasDeployments(objects)
22002162
require.Len(t, ds, 2)
2201-
checkClustersData(t, ds, []string{g.clusterName, g.serverlessName}, g.clusterRegion, targetNamespace, g.projectName, g.mDBVer)
2163+
checkClustersData(t, ds, []string{g.clusterName, g.flexName}, g.clusterRegion, targetNamespace, g.projectName, g.mDBVer)
22022164
secret, found := findSecret(objects)
22032165
require.True(t, found, "Secret is not found in results")
22042166
assert.Equal(t, targetNamespace, secret.Namespace)
@@ -2228,7 +2190,7 @@ func TestKubernetesConfigGenerate_ClustersWithBackup(t *testing.T) {
22282190
require.True(t, found, "AtlasProject is not found in results")
22292191
assert.Equal(t, targetNamespace, p.Namespace)
22302192
ds := atlasDeployments(objects)
2231-
checkClustersData(t, ds, []string{g.clusterName, g.serverlessName}, g.clusterRegion, targetNamespace, g.projectName, g.mDBVer)
2193+
checkClustersData(t, ds, []string{g.clusterName, g.flexName}, g.clusterRegion, targetNamespace, g.projectName, g.mDBVer)
22322194
secret, found := findSecret(objects)
22332195
require.True(t, found, "Secret is not found in results")
22342196
assert.Equal(t, targetNamespace, secret.Namespace)
@@ -2298,7 +2260,7 @@ func TestKubernetesConfigGenerateFlexCluster(t *testing.T) {
22982260
g.tier = e2eSharedClusterTier
22992261
g.generateFlexCluster()
23002262

2301-
expectedDeployment := referenceFlex(g.clusterName, "US_EAST_1", targetNamespace, g.projectName, expectedLabels)
2263+
expectedDeployment := referenceFlex(g.flexName, "US_EAST_1", targetNamespace, g.projectName, expectedLabels)
23022264

23032265
cliPath, err := e2e.AtlasCLIBin()
23042266
require.NoError(t, err)

0 commit comments

Comments
 (0)