add status condition for migration status

Author: egegunes

e2e-tests/tests/upgrade-minor/05-assert.yaml

@@ -1,6 +1,6 @@
 apiVersion: kuttl.dev/v1beta1
 kind: TestAssert
-timeout: 120
+timeout: 180
 ---
 kind: StatefulSet
 apiVersion: apps/v1
@@ -125,6 +125,20 @@ metadata:
   name: upgrade-minor
   generation: 1
 status:
+  conditions:
+  - type: ReadyForBackup
+    status: "True"
+  - type: PGBackRestRepoHostReady    
+    status: "True"
+  - type: PGBackRestReplicaRepoReady
+    status: "True"
+  - type: PGBackRestReplicaCreate
+    status: "True"
+  - type: ProxyAvailable
+    status: "True"
+  - type: APIGroupMigration
+    reason: APIGroupMigrationCompleted
+    status: "True"
   pgbouncer:
     ready: 3
     size: 3

e2e-tests/tests/upgrade-minor/99-remove-cluster-gracefully.yaml

@@ -16,6 +16,8 @@ commands:
 
       source ../../functions
 
+      kubectl -n ${NAMESPACE} patch postgrescluster upgrade-minor --type=json -p='[{"op": "remove", "path": "/metadata/finalizers"}]'
+      kubectl -n ${NAMESPACE} delete postgrescluster upgrade-minor || true
       remove_all_finalizers
       check_operator_panic
       destroy_operator

percona/controller/pgcluster/controller.go

@@ -385,6 +385,15 @@ func (r *PGClusterReconciler) Reconcile(ctx context.Context, request reconcile.R
 		return reconcile.Result{}, errors.Wrap(err, "check patroni version from instance pods")
 	}
 
+	if err := r.reconcileOwnerRefMigrationStatus(ctx, cr); err != nil {
+		if errors.Is(err, errOwnerRefMigrationInProgress) {
+			return reconcile.Result{
+				RequeueAfter: 5 * time.Second,
+			}, nil
+		}
+		return reconcile.Result{}, errors.Wrap(err, "reconcile owner ref migration status")
+	}
+
 	return ctrl.Result{}, nil
 }
 

percona/controller/pgcluster/owner_ref_migration.go

@@ -0,0 +1,153 @@
+package pgcluster
+
+import (
+	"context"
+
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	"k8s.io/apimachinery/pkg/types"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/percona/percona-postgresql-operator/v2/internal/logging"
+	"github.com/percona/percona-postgresql-operator/v2/internal/naming"
+	v2 "github.com/percona/percona-postgresql-operator/v2/pkg/apis/pgv2.percona.com/v2"
+	"github.com/percona/percona-postgresql-operator/v2/pkg/apis/upstream.pgv2.percona.com/v1beta1"
+	"github.com/pkg/errors"
+)
+
+var childKinds = []schema.GroupVersionKind{
+	{Group: "apps", Version: "v1", Kind: "StatefulSet"},
+	{Group: "apps", Version: "v1", Kind: "Deployment"},
+	{Group: "", Version: "v1", Kind: "Service"},
+	{Group: "", Version: "v1", Kind: "ConfigMap"},
+	{Group: "", Version: "v1", Kind: "ServiceAccount"},
+	{Group: "", Version: "v1", Kind: "Endpoints"},
+	{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "Role"},
+	{Group: "rbac.authorization.k8s.io", Version: "v1", Kind: "RoleBinding"},
+	{Group: "batch", Version: "v1", Kind: "Job"},
+	{Group: "batch", Version: "v1", Kind: "CronJob"},
+	{Group: "policy", Version: "v1", Kind: "PodDisruptionBudget"},
+	{Group: "cert-manager.io", Version: "v1", Kind: "Certificate"},
+	{Group: "cert-manager.io", Version: "v1", Kind: "Issuer"},
+}
+
+// LegacyGVK is the GroupVersionKind of the pre-rename PostgresCluster.
+var LegacyGVK = schema.GroupVersionKind{
+	Group:   "postgres-operator.crunchydata.com",
+	Version: "v1beta1",
+	Kind:    "PostgresCluster",
+}
+
+var errOwnerRefMigrationInProgress = errors.New("owner ref migration is in progress")
+
+func (r *PGClusterReconciler) reconcileOwnerRefMigrationStatus(ctx context.Context, cr *v2.PerconaPGCluster) error {
+	log := logging.FromContext(ctx).WithName("APIGroupMigration")
+
+	if c := meta.FindStatusCondition(cr.Status.Conditions, "APIGroupMigration"); c != nil && c.Status == metav1.ConditionTrue {
+		return nil
+	}
+
+	mapper := r.Client.RESTMapper()
+	if _, err := mapper.RESTMapping(LegacyGVK.GroupKind(), LegacyGVK.Version); err != nil {
+		if meta.IsNoMatchError(err) {
+			log.Info("legacy PostgresCluster CRD not found; no need to check references", "gvk", LegacyGVK)
+			return nil
+		}
+		return errors.Wrap(err, "discover legacy PostgresCluster GVK")
+	}
+
+	err := setStatusCondition(ctx, r.Client, cr, metav1.Condition{
+		Type:               "APIGroupMigration",
+		Status:             metav1.ConditionFalse,
+		Reason:             "APIGroupMigrationInProgress",
+		Message:            "Waiting for owner references to be updated",
+		ObservedGeneration: cr.GetGeneration(),
+	})
+	if err != nil {
+		return errors.Wrap(err, "set status condition to false")
+	}
+
+	legacy := &unstructured.Unstructured{}
+	legacy.SetGroupVersionKind(LegacyGVK)
+
+	if err := r.Client.Get(ctx, types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, legacy); err != nil {
+		return client.IgnoreNotFound(err)
+	}
+
+	newPC := &v1beta1.PostgresCluster{}
+	err = r.Client.Get(ctx, types.NamespacedName{Name: cr.Name, Namespace: cr.Namespace}, newPC)
+	switch {
+	case apierrors.IsNotFound(err):
+		log.Info("new-group PostgresCluster not present yet; waiting for PerconaPGCluster reconciler to create it")
+		return errOwnerRefMigrationInProgress
+	case err != nil:
+		return errors.Wrap(err, "get new PostgresCluster")
+	}
+
+	legacyUID := legacy.GetUID()
+
+	selector := client.MatchingLabels{naming.LabelCluster: legacy.GetName()}
+	namespace := client.InNamespace(legacy.GetNamespace())
+
+	for _, gvk := range childKinds {
+		if _, err := mapper.RESTMapping(gvk.GroupKind(), gvk.Version); err != nil {
+			if meta.IsNoMatchError(err) {
+				log.V(1).Info("Skipping kind: NoMatchError", "gvk", gvk)
+				continue
+			}
+			return errors.Wrapf(err, "discover %s", gvk)
+		}
+
+		list := &unstructured.UnstructuredList{}
+		list.SetGroupVersionKind(gvk)
+		if err := r.Client.List(ctx, list, namespace, selector); err != nil {
+			return errors.Wrapf(err, "list %s", gvk.Kind)
+		}
+
+		for i := range list.Items {
+			child := &list.Items[i]
+
+			if ownedBy(child, legacyUID) {
+				log.Info("Child is still owned by legacy cluster", "child", child.GetName(), "kind", child.GetKind())
+				return errOwnerRefMigrationInProgress
+			}
+
+			log.Info("Child is updated successfully", "child", child.GetName(), "kind", child.GetKind())
+		}
+	}
+
+	err = setStatusCondition(ctx, r.Client, cr, metav1.Condition{
+		Type:               "APIGroupMigration",
+		Status:             metav1.ConditionTrue,
+		Reason:             "APIGroupMigrationCompleted",
+		Message:            "All owner references are updated",
+		ObservedGeneration: cr.GetGeneration(),
+	})
+	if err != nil {
+		return errors.Wrap(err, "set status condition to false")
+	}
+
+	return nil
+}
+
+// ownedBy reports whether the object has an ownerReference with the given UID.
+func ownedBy(obj *unstructured.Unstructured, uid types.UID) bool {
+	for _, ref := range obj.GetOwnerReferences() {
+		if ref.UID == uid {
+			return true
+		}
+	}
+	return false
+}
+
+// setStatusCondition immediately sets condition and immediately updates object in K8s.
+func setStatusCondition(ctx context.Context, cl client.Client, cr *v2.PerconaPGCluster, cond metav1.Condition) error {
+	orig := cr.DeepCopy()
+
+	meta.SetStatusCondition(&cr.Status.Conditions, cond)
+
+	return cl.Status().Patch(ctx, cr, client.MergeFrom(orig))
+}