112 lines
4.6 KiB
Go
112 lines
4.6 KiB
Go
package kubernetes
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"reflect"
|
|
|
|
databasev1alpha1 "git.ddupan.top/panxiao81/ayatori/api/database/v1alpha1"
|
|
"git.ddupan.top/panxiao81/ayatori/internal/database/application"
|
|
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/provisioning"
|
|
"k8s.io/apimachinery/pkg/api/equality"
|
|
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"
|
|
"sigs.k8s.io/controller-runtime/pkg/client"
|
|
)
|
|
|
|
const resourcesReadyCondition = "ResourcesReady"
|
|
|
|
type ProvisioningResources struct {
|
|
Client client.Client
|
|
Reader client.Reader
|
|
}
|
|
|
|
func (r *ProvisioningResources) Load(ctx context.Context, name string) (*application.ProvisioningRecord, error) {
|
|
// 同一组 API 事实复用映射；供应用例不持有凭据准备用例的快照或 repository。
|
|
facts, err := (&CredentialResources{Client: r.Client, Reader: r.Reader}).Load(ctx, name)
|
|
if err != nil || facts == nil {
|
|
return nil, err
|
|
}
|
|
object := &databasev1alpha1.PostgreSQLDatabase{}
|
|
if err := r.Reader.Get(ctx, types.NamespacedName{Name: name}, object); err != nil {
|
|
return nil, err
|
|
}
|
|
if object.ResourceVersion != facts.Revision {
|
|
return nil, provisioningSnapshotConflict(name)
|
|
}
|
|
record := &application.ProvisioningRecord{Target: facts.Target, Revision: facts.Revision, TenantGeneration: facts.TenantGeneration,
|
|
InstanceGeneration: facts.InstanceGeneration, Credentials: facts.Status, State: provisioningStatus(object)}
|
|
if facts.Instance == nil {
|
|
return record, nil
|
|
}
|
|
instance := &databasev1alpha1.PostgreSQLInstance{}
|
|
if err := r.Reader.Get(ctx, types.NamespacedName{Name: facts.Database.Instance}, instance); err != nil {
|
|
return nil, err
|
|
}
|
|
if string(instance.UID) != facts.Instance.Identity.UID || instance.Generation != facts.InstanceGeneration ||
|
|
(!instance.DeletionTimestamp.IsZero()) != facts.Instance.Deleting || currentReady(instance.Generation, instance.Status.Conditions) != facts.Instance.Ready {
|
|
return nil, provisioningSnapshotConflict(name)
|
|
}
|
|
mapped, err := instanceRecord(instance)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
record.InstanceTarget = mapped.Target
|
|
return record, nil
|
|
}
|
|
|
|
func provisioningStatus(object *databasev1alpha1.PostgreSQLDatabase) provisioning.State {
|
|
state := provisioning.State{RoleOID: uint32(object.Status.RoleOID), DatabaseOID: uint32(object.Status.DatabaseOID), Phase: provisioning.Pending}
|
|
if condition := meta.FindStatusCondition(object.Status.Conditions, resourcesReadyCondition); condition != nil {
|
|
state.Phase, state.Message = provisioning.Phase(condition.Reason), condition.Message
|
|
}
|
|
return state
|
|
}
|
|
|
|
func (r *ProvisioningResources) Save(ctx context.Context, record *application.ProvisioningRecord, state provisioning.State) (*application.ProvisioningRecord, error) {
|
|
object := &databasev1alpha1.PostgreSQLDatabase{}
|
|
if err := r.Reader.Get(ctx, types.NamespacedName{Name: record.Database.Identity.Name}, object); err != nil {
|
|
return nil, err
|
|
}
|
|
if object.ResourceVersion != record.Revision || string(object.UID) != record.Database.Identity.UID {
|
|
return nil, provisioningSnapshotConflict(object.Name)
|
|
}
|
|
previous := object.Status.DeepCopy()
|
|
object.Status.RoleOID, object.Status.DatabaseOID = int64(state.RoleOID), int64(state.DatabaseOID)
|
|
status := metav1.ConditionFalse
|
|
if state.Phase == provisioning.Available {
|
|
status = metav1.ConditionTrue
|
|
}
|
|
meta.SetStatusCondition(&object.Status.Conditions, metav1.Condition{Type: resourcesReadyCondition, Status: status,
|
|
Reason: string(state.Phase), Message: state.Message, ObservedGeneration: object.Generation})
|
|
if !equality.Semantic.DeepEqual(*previous, object.Status) {
|
|
if err := r.Client.Status().Update(ctx, object); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
if object.Status.RoleOID != int64(state.RoleOID) || object.Status.DatabaseOID != int64(state.DatabaseOID) {
|
|
return nil, fmt.Errorf("资源 OID 未被 API 保留；请先升级 Database CRD，未继续供应")
|
|
}
|
|
updated := *record
|
|
updated.Revision, updated.State = object.ResourceVersion, provisioningStatus(object)
|
|
return &updated, nil
|
|
}
|
|
|
|
func (r *ProvisioningResources) CheckCurrent(ctx context.Context, record *application.ProvisioningRecord) error {
|
|
current, err := r.Load(ctx, record.Database.Identity.Name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if current == nil || !reflect.DeepEqual(current, record) {
|
|
return provisioningSnapshotConflict(record.Database.Identity.Name)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func provisioningSnapshotConflict(name string) error {
|
|
return apierrors.NewConflict(databasev1alpha1.GroupVersion.WithResource("postgresqldatabases").GroupResource(), name,
|
|
fmt.Errorf("供应快照发生变化；停止本轮并重新观察"))
|
|
}
|