Merge pull request #3825 from Azure/revert-3787-cs-97-pull-in-cluster-service-data

Revert "Migrate all clusters, nodepools, and externalauth to contain all fields"

Author: openshift-merge-bot[bot]

frontend/pkg/frontend/cluster.go

@@ -818,17 +818,13 @@ func mergeToInternalCluster(csCluster *arohcpv1alpha1.Cluster, internalCluster *
 // merges the states together, and returns the internal representation.
 // TODO remove the header it takes and collapse that to some general error handling.
 func (f *Frontend) readInternalClusterFromClusterService(ctx context.Context, oldInternalCluster *api.HCPOpenShiftCluster) (*api.HCPOpenShiftCluster, error) {
-	return readInternalClusterFromClusterService(ctx, f.clusterServiceClient, oldInternalCluster, f.azureLocation)
-}
-
-func readInternalClusterFromClusterService(ctx context.Context, clusterServiceClient ocm.ClusterServiceClientSpec, oldInternalCluster *api.HCPOpenShiftCluster, azureLocation string) (*api.HCPOpenShiftCluster, error) {
-	oldClusterServiceCluster, err := clusterServiceClient.GetCluster(ctx, oldInternalCluster.ServiceProviderProperties.ClusterServiceID)
+	oldClusterServiceCluster, err := f.clusterServiceClient.GetCluster(ctx, oldInternalCluster.ServiceProviderProperties.ClusterServiceID)
 	if err != nil {
 		return nil, utils.TrackError(err)
 	}
 
 	// TODO this overwrite will transformed into a "set" function as we transition fields to ownership in cosmos
-	oldInternalCluster, err = mergeToInternalCluster(oldClusterServiceCluster, oldInternalCluster, azureLocation)
+	oldInternalCluster, err = mergeToInternalCluster(oldClusterServiceCluster, oldInternalCluster, f.azureLocation)
 	if err != nil {
 		return nil, utils.TrackError(err)
 	}

frontend/pkg/frontend/external_auth.go

@@ -723,11 +723,7 @@ func (f *Frontend) getInternalExternalAuthFromStorage(ctx context.Context, resou
 // readInternalExternalAuthFromClusterService takes an internal ExternalAuth read from cosmos, retrieves the corresponding cluster-service data,
 // merges the states together, and returns the internal representation.
 func (f *Frontend) readInternalExternalAuthFromClusterService(ctx context.Context, oldInternalExternalAuth *api.HCPOpenShiftClusterExternalAuth) (*api.HCPOpenShiftClusterExternalAuth, error) {
-	return readInternalExternalAuthFromClusterService(ctx, f.clusterServiceClient, oldInternalExternalAuth, f.azureLocation)
-}
-
-func readInternalExternalAuthFromClusterService(ctx context.Context, clusterServiceClient ocm.ClusterServiceClientSpec, oldInternalExternalAuth *api.HCPOpenShiftClusterExternalAuth, azureLocation string) (*api.HCPOpenShiftClusterExternalAuth, error) {
-	oldClusterServiceExternalAuth, err := clusterServiceClient.GetExternalAuth(ctx, oldInternalExternalAuth.ServiceProviderProperties.ClusterServiceID)
+	oldClusterServiceExternalAuth, err := f.clusterServiceClient.GetExternalAuth(ctx, oldInternalExternalAuth.ServiceProviderProperties.ClusterServiceID)
 	if err != nil {
 		return nil, utils.TrackError(err)
 	}

frontend/pkg/frontend/frontend.go

@@ -139,7 +139,7 @@ func (f *Frontend) Run(ctx context.Context, stop <-chan struct{}) {
 	// before we start the http handler (this should ensure we readiness checks until this is complete), we will do a cosmos
 	// data migration to our new storage keys.
 	logger.Info("starting cosmos data migration")
-	MigrateCosmosOrDie(ctx, f.dbClient, f.clusterServiceClient, f.azureLocation)
+	MigrateCosmosOrDie(ctx, f.dbClient)
 	logger.Info("completed cosmos data migration")
 
 	logger.Info(fmt.Sprintf("listening on %s", f.listener.Addr().String()))
@@ -163,6 +163,88 @@ func (f *Frontend) Run(ctx context.Context, stop <-chan struct{}) {
 	}
 }
 
+// MigrateCosmosOrDie if migration fails, we panic and exit the process.  This makes it very detectable.
+func MigrateCosmosOrDie(ctx context.Context, cosmosClient database.DBClient) {
+	// This is a temporary change. Once deployed to production, we will remove this content and leave it empty
+	// for the next small migration we need to do.  Once datasets are large, we will start doing this inside of the backend.
+
+	subscriptionIterator, err := cosmosClient.Subscriptions().List(ctx, nil)
+	if err != nil {
+		panic(err)
+	}
+	for _, subscription := range subscriptionIterator.Items(ctx) {
+		if _, err := cosmosClient.Subscriptions().Get(ctx, subscription.ResourceID.Name); err != nil {
+			panic(err)
+		}
+	}
+	if err := subscriptionIterator.GetError(); err != nil {
+		panic(err)
+	}
+
+	subscriptionIterator, err = cosmosClient.Subscriptions().List(ctx, nil)
+	if err != nil {
+		panic(err)
+	}
+	for _, subscription := range subscriptionIterator.Items(ctx) {
+		clusterIterator, err := cosmosClient.HCPClusters(subscription.ResourceID.Name, "").List(ctx, nil)
+		if err != nil {
+			panic(err)
+		}
+		for _, cluster := range clusterIterator.Items(ctx) {
+			_, err := cosmosClient.HCPClusters(cluster.ID.SubscriptionID, cluster.ID.ResourceGroupName).Get(ctx, cluster.ID.Name)
+			if err != nil {
+				panic(err)
+			}
+
+			nodePoolIterator, err := cosmosClient.HCPClusters(cluster.ID.SubscriptionID, cluster.ID.ResourceGroupName).NodePools(cluster.ID.Name).List(ctx, nil)
+			if err != nil {
+				panic(err)
+			}
+			for _, nodePool := range nodePoolIterator.Items(ctx) {
+				_, err := cosmosClient.HCPClusters(nodePool.ID.SubscriptionID, nodePool.ID.ResourceGroupName).NodePools(nodePool.ID.Parent.Name).Get(ctx, nodePool.ID.Name)
+				if err != nil {
+					panic(err)
+				}
+			}
+			if err := nodePoolIterator.GetError(); err != nil {
+				panic(err)
+			}
+
+			externalAuthIterator, err := cosmosClient.HCPClusters(cluster.ID.SubscriptionID, cluster.ID.ResourceGroupName).ExternalAuth(cluster.ID.Name).List(ctx, nil)
+			if err != nil {
+				panic(err)
+			}
+			for _, externalAuth := range externalAuthIterator.Items(ctx) {
+				_, err := cosmosClient.HCPClusters(externalAuth.ID.SubscriptionID, externalAuth.ID.ResourceGroupName).ExternalAuth(externalAuth.ID.Parent.Name).Get(ctx, externalAuth.ID.Name)
+				if err != nil {
+					panic(err)
+				}
+			}
+			if err := externalAuthIterator.GetError(); err != nil {
+				panic(err)
+			}
+		}
+		if err := clusterIterator.GetError(); err != nil {
+			panic(err)
+		}
+
+		operationIterator, err := cosmosClient.Operations(subscription.ResourceID.Name).List(ctx, nil)
+		if err != nil {
+			panic(err)
+		}
+		for _, operation := range operationIterator.Items(ctx) {
+			_, err := cosmosClient.Operations(operation.ResourceID.SubscriptionID).Get(ctx, operation.ResourceID.Name)
+			if err != nil {
+				panic(err)
+			}
+		}
+		if err := operationIterator.GetError(); err != nil {
+			panic(err)
+		}
+	}
+
+}
+
 func (f *Frontend) Join() {
 	<-f.done
 }

frontend/pkg/frontend/migrate_cosmos.go

@@ -771,17 +771,13 @@ func (f *Frontend) getInternalNodePoolFromStorage(ctx context.Context, resourceI
 // readInternalNodePoolFromClusterService takes an internal NodePool read from cosmos, retrieves the corresponding cluster-service data,
 // merges the states together, and returns the internal representation.
 func (f *Frontend) readInternalNodePoolFromClusterService(ctx context.Context, oldInternalNodePool *api.HCPOpenShiftClusterNodePool) (*api.HCPOpenShiftClusterNodePool, error) {
-	return readInternalNodePoolFromClusterService(ctx, f.clusterServiceClient, oldInternalNodePool, f.azureLocation)
-}
-
-func readInternalNodePoolFromClusterService(ctx context.Context, clusterServiceClient ocm.ClusterServiceClientSpec, oldInternalNodePool *api.HCPOpenShiftClusterNodePool, azureLocation string) (*api.HCPOpenShiftClusterNodePool, error) {
-	oldClusterServiceNodePool, err := clusterServiceClient.GetNodePool(ctx, oldInternalNodePool.ServiceProviderProperties.ClusterServiceID)
+	oldClusterServiceNodePool, err := f.clusterServiceClient.GetNodePool(ctx, oldInternalNodePool.ServiceProviderProperties.ClusterServiceID)
 	if err != nil {
 		return nil, utils.TrackError(err)
 	}
 
 	// TODO this overwrite will transformed into a "set" function as we transition fields to ownership in cosmos
-	oldInternalNodePool, err = mergeToInternalNodePool(oldClusterServiceNodePool, oldInternalNodePool, azureLocation)
+	oldInternalNodePool, err = mergeToInternalNodePool(oldClusterServiceNodePool, oldInternalNodePool, f.azureLocation)
 	if err != nil {
 		return nil, utils.TrackError(err)
 	}

frontend/pkg/frontend/node_pool.go

@@ -15,7 +15,6 @@
 package database
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/Azure/ARO-HCP/internal/api"
@@ -37,7 +36,7 @@ func InternalToCosmosCluster(internalObj *api.HCPOpenShiftCluster) (*HCPCluster,
 			ResourceType: internalObj.ID.ResourceType.String(),
 		},
 		HCPClusterProperties: HCPClusterProperties{
-			ResourceDocument: &ResourceDocument{
+			ResourceDocument: ResourceDocument{
 				ResourceID:        internalObj.ID,
 				InternalID:        internalObj.ServiceProviderProperties.ClusterServiceID,
 				ActiveOperationID: internalObj.ServiceProviderProperties.ActiveOperationID,
@@ -51,7 +50,6 @@ func InternalToCosmosCluster(internalObj *api.HCPOpenShiftCluster) (*HCPCluster,
 			},
 		},
 	}
-	cosmosObj.IntermediateResourceDoc = cosmosObj.ResourceDocument
 
 	// some pieces of data in the internalCluster conflict with ResourceDocument fields.  We may evolve over time, but for
 	// now avoid persisting those.
@@ -118,35 +116,28 @@ func CosmosToInternalCluster(cosmosObj *HCPCluster) (*api.HCPOpenShiftCluster, e
 	if cosmosObj == nil {
 		return nil, nil
 	}
-	resourceDoc := cosmosObj.ResourceDocument
-	if resourceDoc == nil {
-		resourceDoc = cosmosObj.IntermediateResourceDoc
-	}
-	if resourceDoc == nil {
-		return nil, fmt.Errorf("resource document cannot be nil")
-	}
 
 	tempInternalAPI := cosmosObj.InternalState.InternalAPI
 	internalObj := &tempInternalAPI
 
 	// some pieces of data are stored on the ResourceDocument, so we need to restore that data
 	internalObj.TrackedResource = arm.TrackedResource{
 		Resource: arm.Resource{
-			ID:         resourceDoc.ResourceID,
-			Name:       resourceDoc.ResourceID.Name,
-			Type:       resourceDoc.ResourceID.ResourceType.String(),
-			SystemData: resourceDoc.SystemData,
+			ID:         cosmosObj.ResourceID,
+			Name:       cosmosObj.ResourceID.Name,
+			Type:       cosmosObj.ResourceID.ResourceType.String(),
+			SystemData: cosmosObj.SystemData,
 		},
 		Location: cosmosObj.InternalState.InternalAPI.Location,
-		Tags:     resourceDoc.Tags,
+		Tags:     cosmosObj.Tags,
 	}
-	internalObj.Identity = toInternalIdentity(resourceDoc.Identity)
-	internalObj.SystemData = resourceDoc.SystemData
-	internalObj.Tags = copyTags(resourceDoc.Tags)
-	internalObj.ServiceProviderProperties.ProvisioningState = resourceDoc.ProvisioningState
+	internalObj.Identity = toInternalIdentity(cosmosObj.Identity)
+	internalObj.SystemData = cosmosObj.SystemData
+	internalObj.Tags = copyTags(cosmosObj.Tags)
+	internalObj.ServiceProviderProperties.ProvisioningState = cosmosObj.ProvisioningState
 	internalObj.ServiceProviderProperties.CosmosUID = cosmosObj.ID
-	internalObj.ServiceProviderProperties.ClusterServiceID = resourceDoc.InternalID
-	internalObj.ServiceProviderProperties.ActiveOperationID = resourceDoc.ActiveOperationID
+	internalObj.ServiceProviderProperties.ClusterServiceID = cosmosObj.InternalID
+	internalObj.ServiceProviderProperties.ActiveOperationID = cosmosObj.ActiveOperationID
 
 	// This is not the place for validation, but during such a transition we need to ensure we fail quickly and certainly
 	// This flow happens when reading both old and new data.  The old data should *always* have the internalID set