126 lines
5.1 KiB
Go
126 lines
5.1 KiB
Go
/*
|
|
Copyright 2026.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package controller
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
databasev1alpha1 "git.ddupan.top/panxiao81/postgresql-tenant-operator/api/v1alpha1"
|
|
ctrl "sigs.k8s.io/controller-runtime"
|
|
)
|
|
|
|
type instancePhaseHandler func(context.Context, *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error)
|
|
|
|
type instanceStateMachine struct {
|
|
instances PostgreSQLInstances
|
|
handlers map[databasev1alpha1.PostgreSQLInstancePhase]instancePhaseHandler
|
|
}
|
|
|
|
func newInstanceStateMachine(instances PostgreSQLInstances) *instanceStateMachine {
|
|
m := &instanceStateMachine{instances: instances}
|
|
m.handlers = map[databasev1alpha1.PostgreSQLInstancePhase]instancePhaseHandler{
|
|
databasev1alpha1.PostgreSQLInstancePhasePending: m.pending,
|
|
databasev1alpha1.PostgreSQLInstancePhaseValidating: m.validate,
|
|
databasev1alpha1.PostgreSQLInstancePhaseInitializingRegistry: m.initializeRegistry,
|
|
databasev1alpha1.PostgreSQLInstancePhaseReady: m.ready,
|
|
databasev1alpha1.PostgreSQLInstancePhaseDeleting: m.deleting,
|
|
}
|
|
return m
|
|
}
|
|
|
|
func (m *instanceStateMachine) reconcile(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
// Dispatch exactly one handler from the persisted checkpoint. A handler performs
|
|
// its state action and returns the next checkpoint for the Reconciler to save.
|
|
phase := instance.Status.Phase
|
|
if !instance.DeletionTimestamp.IsZero() {
|
|
phase = databasev1alpha1.PostgreSQLInstancePhaseDeleting
|
|
} else if phase == "" {
|
|
phase = databasev1alpha1.PostgreSQLInstancePhasePending
|
|
}
|
|
handler, found := m.handlers[phase]
|
|
if !found {
|
|
handler = m.pending
|
|
}
|
|
result, err := handler(ctx, instance)
|
|
if err != nil {
|
|
instance.Status.ObservedGeneration = instance.Generation
|
|
reason := databasev1alpha1.ReasonDependencyUnavailable
|
|
var categorized interface{ ConditionReason() string }
|
|
if errors.As(err, &categorized) {
|
|
reason = categorized.ConditionReason()
|
|
}
|
|
setFailedCondition(&instance.Status.Conditions, instance.Generation, reason, "instance dependency validation failed")
|
|
}
|
|
return result, err
|
|
}
|
|
|
|
func (m *instanceStateMachine) pending(_ context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
// Persist intent before the next reconcile opens external connections.
|
|
return advanceInstance(instance, databasev1alpha1.PostgreSQLInstancePhaseValidating,
|
|
"instance dependencies are being validated"), nil
|
|
}
|
|
|
|
func (m *instanceStateMachine) validate(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
version, err := m.instances.Validate(ctx, instance)
|
|
if err != nil {
|
|
return ctrl.Result{}, err
|
|
}
|
|
instance.Status.PostgreSQLVersion = version
|
|
return advanceInstance(instance, databasev1alpha1.PostgreSQLInstancePhaseInitializingRegistry,
|
|
"PostgreSQL registry is being initialized"), nil
|
|
}
|
|
|
|
func (m *instanceStateMachine) initializeRegistry(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
version, err := m.instances.InitializeRegistry(ctx, instance)
|
|
if err != nil {
|
|
return ctrl.Result{}, err
|
|
}
|
|
instance.Status.PostgreSQLVersion = version
|
|
instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseReady
|
|
instance.Status.ObservedGeneration = instance.Generation
|
|
setReadyCondition(&instance.Status.Conditions, instance.Generation, "instance dependencies are ready")
|
|
return ctrl.Result{RequeueAfter: time.Minute}, nil
|
|
}
|
|
|
|
func (m *instanceStateMachine) ready(ctx context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
if instance.Status.ObservedGeneration != instance.Generation {
|
|
return m.pending(ctx, instance)
|
|
}
|
|
version, err := m.instances.Validate(ctx, instance)
|
|
if err != nil {
|
|
instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseValidating
|
|
return ctrl.Result{}, err
|
|
}
|
|
instance.Status.PostgreSQLVersion = version
|
|
return ctrl.Result{RequeueAfter: time.Minute}, nil
|
|
}
|
|
|
|
func (m *instanceStateMachine) deleting(_ context.Context, instance *databasev1alpha1.PostgreSQLInstance) (ctrl.Result, error) {
|
|
m.instances.Forget(instance.Name)
|
|
instance.Status.Phase = databasev1alpha1.PostgreSQLInstancePhaseDeleting
|
|
setReconcilingCondition(&instance.Status.Conditions, instance.Generation, "instance deletion is reconciling")
|
|
return ctrl.Result{}, nil
|
|
}
|
|
|
|
func advanceInstance(instance *databasev1alpha1.PostgreSQLInstance, phase databasev1alpha1.PostgreSQLInstancePhase, message string) ctrl.Result {
|
|
instance.Status.Phase = phase
|
|
setReconcilingCondition(&instance.Status.Conditions, instance.Generation, message)
|
|
return ctrl.Result{RequeueAfter: time.Millisecond}
|
|
}
|