Revert "conditions for Storage and Database objects" (#202)

Author: kobzonega

internal/controllers/constants/constants.go

@@ -19,20 +19,13 @@ const (
 	OldStorageInitializedCondition  = "StorageReady"
 	OldDatabaseInitializedCondition = "TenantInitialized"
 
-	StoragePreparedCondition    = "StoragePrepared"
-	StorageInitializedCondition = "StorageInitialized"
-	StorageProvisionedCondition = "StorageProvisioned"
-	StoragePausedCondition      = "StoragePaused"
-	StorageReadyCondition       = "StorageReady"
-
-	DatabasePreparedCondition    = "DatabasePrepared"
-	DatabaseInitializedCondition = "DatabaseInitialized"
-	DatabaseProvisionedCondition = "DatabaseProvisioned"
+	StoragePausedCondition       = "StoragePaused"
+	StorageInitializedCondition  = "StorageInitialized"
 	DatabasePausedCondition      = "DatabasePaused"
-	DatabaseReadyCondition       = "DatabaseReady"
+	DatabaseInitializedCondition = "DatabaseInitialized"
 
-	NodeSetPreparedCondition    = "NodeSetPrepared"
-	NodeSetProvisionedCondition = "NodeSetProvisioned"
+	NodeSetPreparedCondition    = "NodeSetPreparing"
+	NodeSetProvisionedCondition = "NodeSetProvisioning"
 	NodeSetReadyCondition       = "NodeSetReady"
 	NodeSetPausedCondition      = "NodeSetPaused"
 

internal/controllers/database/init.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	corev1 "k8s.io/api/core/v1"
+	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/types"
@@ -16,58 +17,94 @@ import (
 	"github.com/ydb-platform/ydb-kubernetes-operator/internal/resources"
 )
 
-func (r *Reconciler) setInitDatabaseCompleted(
+func (r *Reconciler) processSkipInitPipeline(
 	ctx context.Context,
 	database *resources.DatabaseBuilder,
-	message string,
 ) (bool, ctrl.Result, error) {
-	meta.SetStatusCondition(&database.Status.Conditions, metav1.Condition{
-		Type:    DatabaseInitializedCondition,
-		Status:  metav1.ConditionTrue,
-		Reason:  ReasonCompleted,
-		Message: message,
-	})
-	return r.updateStatus(ctx, database, StatusUpdateRequeueDelay)
+	r.Log.Info("running step processSkipInitPipeline")
+	r.Log.Info("Database initialization disabled (with annotation), proceed with caution")
+
+	r.Recorder.Event(
+		database,
+		corev1.EventTypeWarning,
+		"SkippingInit",
+		"Skipping database creation due to skip annotation present, be careful!",
+	)
+
+	return r.setInitDatabaseCompleted(
+		ctx,
+		database,
+		"Database creation not performed because initialization is skipped",
+	)
 }
 
-func (r *Reconciler) setInitPipelineStatus(
+func (r *Reconciler) setInitialStatus(
 	ctx context.Context,
 	database *resources.DatabaseBuilder,
 ) (bool, ctrl.Result, error) {
-	if database.Status.State == DatabasePreparing {
+	r.Log.Info("running step setInitialStatus")
+
+	if meta.IsStatusConditionTrue(database.Status.Conditions, OldDatabaseInitializedCondition) {
 		meta.SetStatusCondition(&database.Status.Conditions, metav1.Condition{
 			Type:    DatabaseInitializedCondition,
-			Status:  metav1.ConditionFalse,
-			Reason:  ReasonInProgress,
-			Message: "Database has not been initialized yet",
+			Status:  "True",
+			Reason:  ReasonCompleted,
+			Message: "Database initialized successfully",
 		})
-		database.Status.State = DatabaseInitializing
-		return r.updateStatus(ctx, database, StatusUpdateRequeueDelay)
+		database.Status.State = DatabaseReady
+		return r.updateStatus(ctx, database)
 	}
 
-	// This block is special internal logic that skips all Database initialization.
 	if value, ok := database.Annotations[v1alpha1.AnnotationSkipInitialization]; ok && value == v1alpha1.AnnotationValueTrue {
-		r.Log.Info("Database initialization disabled (with annotation), proceed with caution")
-		r.Recorder.Event(
-			database,
-			corev1.EventTypeWarning,
-			"SkippingInit",
-			"Skipping initialization due to skip annotation present, be careful!",
-		)
-		return r.setInitDatabaseCompleted(ctx, database, "Database initialization not performed because initialization is skipped")
+		if meta.FindStatusCondition(database.Status.Conditions, DatabaseInitializedCondition) == nil ||
+			meta.IsStatusConditionFalse(database.Status.Conditions, DatabaseInitializedCondition) {
+			return r.processSkipInitPipeline(ctx, database)
+		}
+		return Stop, ctrl.Result{RequeueAfter: DefaultRequeueDelay}, nil
 	}
 
-	if meta.IsStatusConditionTrue(database.Status.Conditions, OldDatabaseInitializedCondition) {
-		return r.setInitDatabaseCompleted(ctx, database, "Database initialized successfully")
+	if database.Status.State == DatabasePending ||
+		meta.FindStatusCondition(database.Status.Conditions, DatabaseInitializedCondition) == nil {
+		meta.SetStatusCondition(&database.Status.Conditions, metav1.Condition{
+			Type:    DatabaseInitializedCondition,
+			Status:  "False",
+			Reason:  ReasonInProgress,
+			Message: "Database has not been initialized yet",
+		})
+		database.Status.State = DatabasePreparing
+		return r.updateStatus(ctx, database)
 	}
 
 	return Continue, ctrl.Result{Requeue: false}, nil
 }
 
-func (r *Reconciler) initializeTenant(
+func (r *Reconciler) setInitDatabaseCompleted(
+	ctx context.Context,
+	database *resources.DatabaseBuilder,
+	message string,
+) (bool, ctrl.Result, error) {
+	meta.SetStatusCondition(&database.Status.Conditions, metav1.Condition{
+		Type:    DatabaseInitializedCondition,
+		Status:  "True",
+		Reason:  ReasonCompleted,
+		Message: message,
+	})
+	database.Status.State = DatabaseProvisioning
+
+	return r.updateStatus(ctx, database)
+}
+
+func (r *Reconciler) initializeDatabase(
 	ctx context.Context,
 	database *resources.DatabaseBuilder,
 ) (bool, ctrl.Result, error) {
+	r.Log.Info("running step initializeDatabase")
+
+	if database.Status.State == DatabasePreparing {
+		database.Status.State = DatabaseInitializing
+		return r.updateStatus(ctx, database)
+	}
+
 	path := database.GetDatabasePath()
 	var storageUnits []v1alpha1.StorageUnit
 	var shared bool
@@ -86,27 +123,43 @@ func (r *Reconciler) initializeTenant(
 			Namespace: database.Spec.ServerlessResources.SharedDatabaseRef.Namespace,
 		}, sharedDatabaseCr)
 		if err != nil {
+			if apierrors.IsNotFound(err) {
+				r.Recorder.Event(
+					database,
+					corev1.EventTypeWarning,
+					"Pending",
+					fmt.Sprintf(
+						"Database (%s/%s) not found.",
+						database.Spec.ServerlessResources.SharedDatabaseRef.Name,
+						database.Spec.ServerlessResources.SharedDatabaseRef.Namespace,
+					),
+				)
+				return Stop, ctrl.Result{RequeueAfter: SharedDatabaseAwaitRequeueDelay}, nil
+			}
 			r.Recorder.Event(
 				database,
 				corev1.EventTypeWarning,
-				"ControllerError",
+				"Pending",
 				fmt.Sprintf(
-					"Failed to get Database %s resource, error: %s",
+					"Failed to get Database (%s, %s) resource, error: %s",
 					database.Spec.ServerlessResources.SharedDatabaseRef.Name,
+					database.Spec.ServerlessResources.SharedDatabaseRef.Namespace,
 					err,
 				),
 			)
 			return Stop, ctrl.Result{RequeueAfter: SharedDatabaseAwaitRequeueDelay}, err
 		}
 
-		if !meta.IsStatusConditionTrue(sharedDatabaseCr.Status.Conditions, DatabaseProvisionedCondition) {
+		if sharedDatabaseCr.Status.State != "Ready" {
 			r.Recorder.Event(
 				database,
 				corev1.EventTypeWarning,
-				"InitializingTenant",
+				"Pending",
 				fmt.Sprintf(
-					"Referenced shared Database %s is not Provisioned",
+					"Referenced shared Database (%s, %s) in a bad state: %s != Ready",
 					database.Spec.ServerlessResources.SharedDatabaseRef.Name,
+					database.Spec.ServerlessResources.SharedDatabaseRef.Namespace,
+					sharedDatabaseCr.Status.State,
 				),
 			)
 			return Stop, ctrl.Result{RequeueAfter: SharedDatabaseAwaitRequeueDelay}, err
@@ -157,22 +210,24 @@ func (r *Reconciler) initializeTenant(
 		r.Recorder.Event(
 			database,
 			corev1.EventTypeWarning,
-			"InitializingTenant",
+			"InitializingFailed",
 			fmt.Sprintf("Error creating tenant %s: %s", tenant.Path, err),
 		)
-		meta.SetStatusCondition(&database.Status.Conditions, metav1.Condition{
-			Type:   DatabaseInitializedCondition,
-			Status: metav1.ConditionFalse,
-			Reason: ReasonInProgress,
-		})
-		return r.updateStatus(ctx, database, DatabaseInitializationRequeueDelay)
+		return Stop, ctrl.Result{RequeueAfter: DatabaseInitializationRequeueDelay}, err
 	}
-
 	r.Recorder.Event(
 		database,
 		corev1.EventTypeNormal,
-		"InitializingTenant",
+		"Initialized",
 		fmt.Sprintf("Tenant %s created", tenant.Path),
 	)
+
+	r.Recorder.Event(
+		database,
+		corev1.EventTypeNormal,
+		"DatabaseReady",
+		"Database is initialized",
+	)
+
 	return r.setInitDatabaseCompleted(ctx, database, "Database initialized successfully")
 }