multiphase

package

Go to main page

Versions in this module

v3

v3.0.9

Sep 23, 2026

v3.0.8

Sep 1, 2026

Changes in this version

type DefaultMultiPhaseDiff

+ func (h *DefaultMultiPhaseDiff[S]) As[D client.Object]() MultiPhaseDiff[D]

type DefaultMultiPhaseRead

+ func (h *DefaultMultiPhaseRead[S]) As[D client.Object]() MultiPhaseRead[D]

type DefaultMultiPhaseStepReconcilerAction

+ func (h *DefaultMultiPhaseStepReconcilerAction[K, S]) As[D client.Object]() MultiPhaseStepReconcilerAction[K, D]

type DefaultMultiPhaseStepReconcilerActionWithDiff

+ func (h *DefaultMultiPhaseStepReconcilerActionWithDiff[K, S]) AsWithDiff[D client.Object]() MultiPhaseStepReconcilerActionWithDiff[K, D]

type MultiPhaseDiff

+ func DiffAs[S, D client.Object](in MultiPhaseDiff[S]) MultiPhaseDiff[D]

type MultiPhaseRead

+ func ReadAs[S, D client.Object](in MultiPhaseRead[S]) MultiPhaseRead[D]

type MultiPhaseStepReconcilerAction

+ func As[K object.MultiPhaseObject, S, D client.Object](in MultiPhaseStepReconcilerAction[K, S]) MultiPhaseStepReconcilerAction[K, D]

type MultiPhaseStepReconcilerActionWithDiff

+ func AsWithDiff[K object.MultiPhaseObject, S, D client.Object](in MultiPhaseStepReconcilerActionWithDiff[K, S]) MultiPhaseStepReconcilerActionWithDiff[K, D]

v3.0.7

Aug 23, 2026

v3.0.6

Aug 21, 2026

v3.0.4

Aug 20, 2026

v3.0.2

Aug 20, 2026

Changes in this version

+ func CleanupReadLastAppliedAnnotations[T client.Object](ctx context.Context, c client.Client, read MultiPhaseRead[T], ...) (cleaned int)

+ type DefaultMultiPhaseStepReconcilerActionWithDiff struct

+ func (h *DefaultMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObject]) Diff(ctx context.Context, o k8sObject, read MultiPhaseRead[k8sStepObject], ...) (diff MultiPhaseDiff[k8sStepObject], res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObject]) OnDiff(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ type MultiPhaseStepReconcilerActionWithDiff interface

+ OnDiff func(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func NewMultiPhaseStepReconcilerActionWithDiff[k8sObject object.MultiPhaseObject, k8sStepObject client.Object](client client.Client, phaseName shared.PhaseName, ...) (...)

+ func NewObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject object.MultiPhaseObject, k8sStepObjectSrc client.Object, ...](in MultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc]) MultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectDst]

+ type ObjectMultiPhaseStepReconcilerActionWithDiff struct

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Apply(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Configure(ctx context.Context, req reconcile.Request, o k8sObject, logger *logrus.Entry) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Delete(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Diff(ctx context.Context, o k8sObject, read MultiPhaseRead[k8sStepObjectDst], ...) (diff MultiPhaseDiff[k8sStepObjectDst], res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) GetPhaseName() shared.PhaseName

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnDiff(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnError(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnSuccess(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerActionWithDiff[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Read(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (read MultiPhaseRead[k8sStepObjectDst], res reconcile.Result, err error)

v3.0.0

Aug 19, 2026

Changes in this version

+ func ClassifyObjects[T client.Object](ctx context.Context, c client.Client, expectedObjects []T, currentObjects []T, ...) (creates []T, updates []T, deletes []T, diffStrs []string, err error)

+ func PopulateDiff[T client.Object](diff MultiPhaseDiff[T], creates, updates, deletes []T, diffStrs []string)

+ type BasicMultiPhaseReconcilerAction struct

+ func (h *BasicMultiPhaseReconcilerAction[k8sObject]) Configure(ctx context.Context, req reconcile.Request, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *BasicMultiPhaseReconcilerAction[k8sObject]) Delete(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (err error)

+ func (h *BasicMultiPhaseReconcilerAction[k8sObject]) OnError(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ func (h *BasicMultiPhaseReconcilerAction[k8sObject]) OnSuccess(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (res reconcile.Result, err error)

+ func (h *BasicMultiPhaseReconcilerAction[k8sObject]) Read(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (res reconcile.Result, err error)

+ type DefaultMultiPhaseDiff struct

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) AddDiff(diff string)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) AddObjectToCreate(o k8sStepObject)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) AddObjectToDelete(o k8sStepObject)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) AddObjectToUpdate(o k8sStepObject)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) Diff() string

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) GetObjectsToApply() []k8sStepObject

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) GetObjectsToCreate() []k8sStepObject

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) GetObjectsToDelete() []k8sStepObject

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) GetObjectsToUpdate() []k8sStepObject

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) IsDiff() bool

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) NeedCreate() bool

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) NeedDelete() bool

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) NeedUpdate() bool

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) SetObjectsToCreate(objects []k8sStepObject)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) SetObjectsToDelete(objects []k8sStepObject)

+ func (h *DefaultMultiPhaseDiff[k8sStepObject]) SetObjectsToUpdate(objects []k8sStepObject)

+ type DefaultMultiPhaseRead struct

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) AddCurrentObject(o k8sStepObject)

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) AddExpectedObject(o k8sStepObject)

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) GetCurrentObjects() []k8sStepObject

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) GetExpectedObjects() []k8sStepObject

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) SetCurrentObjects(objects []k8sStepObject)

+ func (h *DefaultMultiPhaseRead[k8sStepObject]) SetExpectedObjects(objects []k8sStepObject)

+ type DefaultMultiPhaseReconciler struct

+ func (h *DefaultMultiPhaseReconciler[k8sObject]) Reconcile(ctx context.Context, req reconcile.Request, o k8sObject, ...) (res reconcile.Result, err error)

+ type DefaultMultiPhaseStepReconciler struct

+ func (h *DefaultMultiPhaseStepReconciler[k8sObject, k8sStepObject]) Reconcile(ctx context.Context, req reconcile.Request, o k8sObject, ...) (res reconcile.Result, err error)

+ type DefaultMultiPhaseStepReconcilerAction struct

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) Apply(ctx context.Context, o k8sObject, data map[string]any, objects []k8sStepObject, ...) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) Configure(ctx context.Context, req reconcile.Request, o k8sObject, logger *logrus.Entry) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) Delete(ctx context.Context, o k8sObject, data map[string]any, objects []k8sStepObject, ...) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) Diff(ctx context.Context, o k8sObject, read MultiPhaseRead[k8sStepObject], ...) (diff MultiPhaseDiff[k8sStepObject], res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) GetPhaseName() shared.PhaseName

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) OnDiff(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) OnError(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) OnSuccess(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *DefaultMultiPhaseStepReconcilerAction[k8sObject, k8sStepObject]) Read(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (read MultiPhaseRead[k8sStepObject], res reconcile.Result, err error)

+ type MultiPhaseDiff interface

+ AddDiff func(diff string)

+ AddObjectToCreate func(o k8sStepObject)

+ AddObjectToDelete func(o k8sStepObject)

+ AddObjectToUpdate func(o k8sStepObject)

+ Diff func() string

+ GetObjectsToApply func() []k8sStepObject

+ GetObjectsToCreate func() []k8sStepObject

+ GetObjectsToDelete func() []k8sStepObject

+ GetObjectsToUpdate func() []k8sStepObject

+ IsDiff func() bool

+ NeedCreate func() bool

+ NeedDelete func() bool

+ NeedUpdate func() bool

+ SetObjectsToCreate func(objects []k8sStepObject)

+ SetObjectsToDelete func(objects []k8sStepObject)

+ SetObjectsToUpdate func(objects []k8sStepObject)

+ func NewMultiPhaseDiff[k8sStepObject client.Object]() MultiPhaseDiff[k8sStepObject]

+ func NewObjectMultiphaseDiff[k8sStepObjectSrc client.Object, k8sStepObjectDst client.Object](in MultiPhaseDiff[k8sStepObjectSrc]) MultiPhaseDiff[k8sStepObjectDst]

+ type MultiPhaseRead interface

+ AddCurrentObject func(o k8sStepObject)

+ AddExpectedObject func(o k8sStepObject)

+ GetCurrentObjects func() []k8sStepObject

+ GetExpectedObjects func() []k8sStepObject

+ SetCurrentObjects func(objects []k8sStepObject)

+ SetExpectedObjects func(objects []k8sStepObject)

+ func NewMultiPhaseRead[k8sStepObject client.Object]() MultiPhaseRead[k8sStepObject]

+ func NewObjectMultiphaseRead[k8sStepObjectSrc client.Object, k8sStepObjectDst client.Object](in MultiPhaseRead[k8sStepObjectSrc]) MultiPhaseRead[k8sStepObjectDst]

+ type MultiPhaseReconciler interface

+ Reconcile func(ctx context.Context, req reconcile.Request, o k8sObject, ...) (res reconcile.Result, err error)

+ func NewMultiPhaseReconciler[k8sObject object.MultiPhaseObject](c client.Client, name string, finalizer shared.FinalizerName, ...) (multiPhaseReconciler MultiPhaseReconciler[k8sObject])

+ type MultiPhaseReconcilerAction interface

+ Configure func(ctx context.Context, req reconcile.Request, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ Delete func(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (err error)

+ OnError func(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ OnSuccess func(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (res reconcile.Result, err error)

+ Read func(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (res reconcile.Result, err error)

+ func NewMultiPhaseReconcilerAction[k8sObject object.MultiPhaseObject](client client.Client, conditionName shared.ConditionName, ...) (multiPhaseReconciler MultiPhaseReconcilerAction[k8sObject])

+ type MultiPhaseStepReconciler interface

+ Reconcile func(ctx context.Context, req reconcile.Request, o k8sObject, ...) (res reconcile.Result, err error)

+ func NewMultiPhaseStepReconciler[k8sObject object.MultiPhaseObject, k8sStepObject client.Object](client client.Client, logger *logrus.Entry, recorder record.EventRecorder) (multiPhaseStepReconciler MultiPhaseStepReconciler[k8sObject, k8sStepObject])

+ type MultiPhaseStepReconcilerAction interface

+ Apply func(ctx context.Context, o k8sObject, data map[string]any, objects []k8sStepObject, ...) (res reconcile.Result, err error)

+ Configure func(ctx context.Context, req reconcile.Request, o k8sObject, logger *logrus.Entry) (res reconcile.Result, err error)

+ Delete func(ctx context.Context, o k8sObject, data map[string]any, objects []k8sStepObject, ...) (res reconcile.Result, err error)

+ Diff func(ctx context.Context, o k8sObject, read MultiPhaseRead[k8sStepObject], ...) (diff MultiPhaseDiff[k8sStepObject], res reconcile.Result, err error)

+ GetPhaseName func() shared.PhaseName

+ OnDiff func(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ OnError func(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ OnSuccess func(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ Read func(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (read MultiPhaseRead[k8sStepObject], res reconcile.Result, err error)

+ func NewMultiPhaseStepReconcilerAction[k8sObject object.MultiPhaseObject, k8sStepObject client.Object](client client.Client, phaseName shared.PhaseName, ...) (...)

+ func NewObjectMultiPhaseStepReconcilerAction[k8sObject object.MultiPhaseObject, k8sStepObjectSrc client.Object, ...](in MultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc]) MultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectDst]

+ type ObjectMultiPhaseDiff struct

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) AddDiff(diff string)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) AddObjectToCreate(o k8sStepObjectDst)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) AddObjectToDelete(o k8sStepObjectDst)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) AddObjectToUpdate(o k8sStepObjectDst)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) Diff() string

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) GetObjectsToApply() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) GetObjectsToCreate() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) GetObjectsToDelete() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) GetObjectsToUpdate() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) IsDiff() bool

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) NeedCreate() bool

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) NeedDelete() bool

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) NeedUpdate() bool

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) SetObjectsToCreate(objects []k8sStepObjectDst)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) SetObjectsToDelete(objects []k8sStepObjectDst)

+ func (h *ObjectMultiPhaseDiff[k8sStepObjectSrc, k8sStepObjectDst]) SetObjectsToUpdate(objects []k8sStepObjectDst)

+ type ObjectMultiPhaseRead struct

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) AddCurrentObject(o k8sStepObjectDst)

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) AddExpectedObject(o k8sStepObjectDst)

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) GetCurrentObjects() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) GetExpectedObjects() []k8sStepObjectDst

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) SetCurrentObjects(objects []k8sStepObjectDst)

+ func (h *ObjectMultiPhaseRead[k8sStepObjectSrc, k8sStepObjectDst]) SetExpectedObjects(objects []k8sStepObjectDst)

+ type ObjectMultiPhaseStepReconcilerAction struct

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Apply(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Configure(ctx context.Context, req reconcile.Request, o k8sObject, logger *logrus.Entry) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Delete(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Diff(ctx context.Context, o k8sObject, read MultiPhaseRead[k8sStepObjectDst], ...) (diff MultiPhaseDiff[k8sStepObjectDst], res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) GetPhaseName() shared.PhaseName

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnDiff(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnError(ctx context.Context, o k8sObject, data map[string]any, currentErr error, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) OnSuccess(ctx context.Context, o k8sObject, data map[string]any, ...) (res reconcile.Result, err error)

+ func (h *ObjectMultiPhaseStepReconcilerAction[k8sObject, k8sStepObjectSrc, k8sStepObjectDst]) Read(ctx context.Context, o k8sObject, data map[string]any, logger *logrus.Entry) (read MultiPhaseRead[k8sStepObjectDst], res reconcile.Result, err error)

Other modules containing this package

github.com/disaster37/operator-sdk-extra/v2

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL