CLOUDP-278461: Kubernetes Operator - Fixed Serverless PE export for GCP provider (#3333)

Author: igor-karpukhin

internal/kubernetes/operator/config_exporter.go

@@ -62,6 +62,7 @@ type Patcher interface {
 }
 
 var (
+	ErrServerless             = errors.New("serverless instance error")
 	ErrClusterNotFound        = errors.New("cluster not found")
 	ErrNoCloudManagerClusters = errors.New("can not get 'advanced clusters' object")
 )
@@ -282,13 +283,14 @@ func (e *ConfigExporter) exportDeployments(projectName string) ([]runtime.Object
 		}
 
 		// Try serverless cluster next
-		if serverlessCluster, err := deployment.BuildServerlessDeployments(e.dataProvider, e.featureValidator, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion); err == nil {
+		serverlessCluster, err := deployment.BuildServerlessDeployments(e.dataProvider, e.featureValidator, e.projectID, projectName, deploymentName, e.targetNamespace, e.dictionaryForAtlasNames, e.operatorVersion)
+		if err == nil {
 			if serverlessCluster != nil {
 				result = append(result, serverlessCluster)
 			}
 			continue
 		}
-		return nil, fmt.Errorf("%w: %s(%s)", ErrClusterNotFound, deploymentName, e.projectID)
+		return nil, fmt.Errorf("%w: %s(%s), e: %w", ErrServerless, deploymentName, e.projectID, err)
 	}
 	return result, nil
 }

internal/kubernetes/operator/deployment/deployment.go

@@ -506,11 +506,13 @@ func BuildServerlessDeployments(deploymentStore store.OperatorClusterStore, vali
 	}
 
 	if validator.FeatureExist(features.ResourceAtlasDeployment, featureServerlessPrivateEndpoints) {
-		privateEndpoints, err := buildServerlessPrivateEndpoints(deploymentStore, projectID, deployment.GetName())
-		if err != nil {
-			return nil, err
+		if deployment.ProviderSettings.BackingProviderName != "GCP" {
+			privateEndpoints, err := buildServerlessPrivateEndpoints(deploymentStore, projectID, deployment.GetName())
+			if err != nil {
+				return nil, err
+			}
+			atlasDeployment.Spec.ServerlessSpec.PrivateEndpoints = privateEndpoints
 		}
-		atlasDeployment.Spec.ServerlessSpec.PrivateEndpoints = privateEndpoints
 	}
 
 	return atlasDeployment, nil

internal/kubernetes/operator/deployment/deployment_test.go

@@ -522,6 +522,101 @@ func TestBuildServerlessDeployments(t *testing.T) {
 	})
 }
 
+func TestBuildServerlessDeploymentsWithGCP(t *testing.T) {
+	const projectName = "testProject-2-1"
+	const clusterName = "testCluster-2-1"
+	const targetNamespace = "test-namespace-2-1"
+
+	ctl := gomock.NewController(t)
+	clusterStore := mocks.NewMockOperatorClusterStore(ctl)
+	dictionary := resources.AtlasNameToKubernetesName()
+
+	featureValidator := mocks.NewMockFeatureValidator(ctl)
+
+	t.Run("Can import Serverless deployment", func(t *testing.T) {
+		speID := "TestPEId-1"
+		speCloudProviderEndpointID := "TestCloudProviderID-1"
+		speComment := "TestPEName-1"
+		spePrivateEndpointIPAddress := ""
+
+		spe := []atlasClustersPinned.ServerlessTenantEndpoint{
+			{
+				Id:                       &speID,
+				CloudProviderEndpointId:  &speCloudProviderEndpointID,
+				Comment:                  &speComment,
+				PrivateEndpointIpAddress: &spePrivateEndpointIPAddress,
+				ProviderName:             pointer.Get("AZURE"),
+			},
+		}
+
+		cluster := &atlasClustersPinned.ServerlessInstanceDescription{
+			Id:             pointer.Get("TestClusterID"),
+			GroupId:        pointer.Get("TestGroupID"),
+			MongoDBVersion: pointer.Get("5.0"),
+			Name:           pointer.Get(clusterName),
+			CreateDate:     pointer.Get(time.Date(2021, time.January, 1, 0, 0, 0, 0, time.UTC)),
+			ProviderSettings: atlasClustersPinned.ServerlessProviderSettings{
+				BackingProviderName: "GCP",
+				ProviderName:        pointer.Get("GCP"),
+				RegionName:          "US_EAST_1",
+			},
+			StateName:               pointer.Get(""),
+			ServerlessBackupOptions: nil,
+			ConnectionStrings:       nil,
+			Links:                   nil,
+		}
+
+		clusterStore.EXPECT().GetServerlessInstance(projectName, clusterName).Return(cluster, nil)
+		clusterStore.EXPECT().ServerlessPrivateEndpoints(projectName, clusterName).Return(spe, nil).Times(0)
+
+		expected := &akov2.AtlasDeployment{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "AtlasDeployment",
+				APIVersion: "atlas.mongodb.com/v1",
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name:      strings.ToLower(fmt.Sprintf("%s-%s", projectName, clusterName)),
+				Namespace: targetNamespace,
+				Labels: map[string]string{
+					features.ResourceVersion: resourceVersion,
+				},
+			},
+			Spec: akov2.AtlasDeploymentSpec{
+				Project: akov2common.ResourceRefNamespaced{
+					Name:      strings.ToLower(projectName),
+					Namespace: targetNamespace,
+				},
+				BackupScheduleRef: akov2common.ResourceRefNamespaced{},
+				ServerlessSpec: &akov2.ServerlessSpec{
+					Name: cluster.GetName(),
+					ProviderSettings: &akov2.ServerlessProviderSettingsSpec{
+						BackingProviderName: cluster.ProviderSettings.BackingProviderName,
+						ProviderName:        akov2provider.ProviderName(cluster.ProviderSettings.GetProviderName()),
+						RegionName:          cluster.ProviderSettings.RegionName,
+					},
+				},
+				ProcessArgs: nil,
+			},
+			Status: akov2status.AtlasDeploymentStatus{
+				Common: akoapi.Common{
+					Conditions: []akoapi.Condition{},
+				},
+			},
+		}
+
+		featureValidator.EXPECT().FeatureExist(features.ResourceAtlasDeployment, featureServerlessPrivateEndpoints).Return(true)
+
+		got, err := BuildServerlessDeployments(clusterStore, featureValidator, projectName, projectName, clusterName, targetNamespace, dictionary, resourceVersion)
+		if err != nil {
+			t.Fatalf("%v", err)
+		}
+
+		if !reflect.DeepEqual(expected, got) {
+			t.Fatalf("Serverless deployment mismatch.\r\nexp: %v\r\ngot: %v\r\n", expected, got)
+		}
+	})
+}
+
 func TestCleanTenantFields(t *testing.T) {
 	for _, tt := range []struct {
 		name   string