controller

package

Go to main page

Versions in this module

v0

v0.1.9

Jun 17, 2024

v0.1.8

Jun 17, 2024

v0.1.7

Jun 13, 2024

v0.1.6

Feb 5, 2024

v0.1.5

Jan 23, 2024

v0.1.4

Jan 15, 2024

v0.1.3

Nov 7, 2023

Changes in this version

+ const BaseAnnotation

+ const ReadyCondition

+ const RunningPhase

+ const ShortenError

+ const StartingPhase

+ var ErrWhenAddFinalizer = errors.Sentinel("Error when add finalizer")

+ var ErrWhenCallConfigureFromReconciler = errors.Sentinel("Error when call 'configure' from reconciler")

+ var ErrWhenCallCreateFromReconciler = errors.Sentinel("Error when call 'create' from reconciler")

+ var ErrWhenCallDeleteFromReconciler = errors.Sentinel("Error when call 'delete' from reconciler")

+ var ErrWhenCallDiffFromReconciler = errors.Sentinel("Error when call 'diff' from reconciler")

+ var ErrWhenCallOnSuccessFromReconciler = errors.Sentinel("Error when call 'onSuccess' from reconciler")

+ var ErrWhenCallReadFromReconciler = errors.Sentinel("Error when call 'read' from reconciler")

+ var ErrWhenCallStepReconcilerFromReconciler = errors.Sentinel("Error when call 'reconcile' from step reconciler")

+ var ErrWhenCallUpdateFromReconciler = errors.Sentinel("Error when call 'update' from reconciler")

+ var ErrWhenDeleteFinalizer = errors.Sentinel("Error when delete finalizer")

+ var ErrWhenGetObjectFromReconciler = errors.Sentinel("Error when get object from reconciler")

+ var ErrWhenGetObjectStatus = errors.Sentinel("Error when get object status")

+ func SetupIndexerWithManager(mgr ctrl.Manager, indexers ...Indexer) (err error)

+ type BaseReconciler struct

+ Log *logrus.Entry

+ Recorder record.EventRecorder

+ type BasicController struct

+ func (h *BasicController) Reconcile(context.Context, reconcile.Request) (res reconcile.Result, err error)

+ func (h *BasicController) SetupWithManager(mgr ctrl.Manager) error

+ type BasicMultiPhaseDiff struct

+ func (h *BasicMultiPhaseDiff) AddDiff(diff string)

+ func (h *BasicMultiPhaseDiff) Diff() string

+ func (h *BasicMultiPhaseDiff) GetObjectsToCreate() []client.Object

+ func (h *BasicMultiPhaseDiff) GetObjectsToDelete() []client.Object

+ func (h *BasicMultiPhaseDiff) GetObjectsToUpdate() []client.Object

+ func (h *BasicMultiPhaseDiff) IsDiff() bool

+ func (h *BasicMultiPhaseDiff) NeedCreate() bool

+ func (h *BasicMultiPhaseDiff) NeedDelete() bool

+ func (h *BasicMultiPhaseDiff) NeedUpdate() bool

+ func (h *BasicMultiPhaseDiff) SetObjectsToCreate(objects []client.Object)

+ func (h *BasicMultiPhaseDiff) SetObjectsToDelete(objects []client.Object)

+ func (h *BasicMultiPhaseDiff) SetObjectsToUpdate(objects []client.Object)

+ type BasicMultiPhaseRead struct

+ func (h *BasicMultiPhaseRead) GetCurrentObjects() []client.Object

+ func (h *BasicMultiPhaseRead) GetExpectedObjects() []client.Object

+ func (h *BasicMultiPhaseRead) SetCurrentObjects(objects []client.Object)

+ func (h *BasicMultiPhaseRead) SetExpectedObjects(objects []client.Object)

+ type BasicMultiPhaseReconciler struct

+ func (h *BasicMultiPhaseReconciler) Reconcile(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject, ...) (res ctrl.Result, err error)

+ type BasicMultiPhaseReconcilerAction struct

+ func (h *BasicMultiPhaseReconcilerAction) Configure(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseReconcilerAction) Delete(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (err error)

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

+ func (h *BasicMultiPhaseReconcilerAction) OnSuccess(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseReconcilerAction) Read(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (res ctrl.Result, err error)

+ type BasicMultiPhaseStepReconciler struct

+ func (h *BasicMultiPhaseStepReconciler) Reconcile(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject, ...) (res ctrl.Result, err error)

+ type BasicMultiPhaseStepReconcilerAction struct

+ func (h *BasicMultiPhaseStepReconcilerAction) Configure(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) Create(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) Delete(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) Diff(ctx context.Context, o object.MultiPhaseObject, read MultiPhaseRead, ...) (diff MultiPhaseDiff, res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) GetIgnoresDiff() []patch.CalculateOption

+ func (h *BasicMultiPhaseStepReconcilerAction) GetPhaseName() shared.PhaseName

+ func (h *BasicMultiPhaseStepReconcilerAction) OnError(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) OnSuccess(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) Read(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (read MultiPhaseRead, res ctrl.Result, err error)

+ func (h *BasicMultiPhaseStepReconcilerAction) Update(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ type BasicReconciler struct

+ type BasicReconcilerAction struct

+ type BasicRemoteDiff struct

+ func (h *BasicRemoteDiff[T]) AddDiff(diff string)

+ func (h *BasicRemoteDiff[T]) Diff() string

+ func (h *BasicRemoteDiff[T]) GetObjectToCreate() T

+ func (h *BasicRemoteDiff[T]) GetObjectToUpdate() T

+ func (h *BasicRemoteDiff[T]) IsDiff() bool

+ func (h *BasicRemoteDiff[T]) NeedCreate() bool

+ func (h *BasicRemoteDiff[T]) NeedUpdate() bool

+ func (h *BasicRemoteDiff[T]) SetObjectToCreate(object T)

+ func (h *BasicRemoteDiff[T]) SetObjectToUpdate(object T)

+ type BasicRemoteExternalReconciler struct

+ func NewBasicRemoteExternalReconciler(handler apiClient) *BasicRemoteExternalReconciler[k8sObject, apiObject, apiClient]

+ func (h *BasicRemoteExternalReconciler[k8sObject, apiObject, apiClient]) Client() apiClient

+ func (h *BasicRemoteExternalReconciler[k8sObject, apiObject, apiClient]) Diff(currentOject apiObject, expectedObject apiObject, originalObject apiObject, ...) (patchResult *patch.PatchResult, err error)

+ type BasicRemoteRead struct

+ func (h *BasicRemoteRead[T]) GetCurrentObject() T

+ func (h *BasicRemoteRead[T]) GetExpectedObject() T

+ func (h *BasicRemoteRead[T]) SetCurrentObject(object T)

+ func (h *BasicRemoteRead[T]) SetExpectedObject(object T)

+ type BasicRemoteReconciler struct

+ func (h *BasicRemoteReconciler[k8sObject, apiObject, apiClient]) Reconcile(ctx context.Context, req ctrl.Request, o object.RemoteObject, ...) (res ctrl.Result, err error)

+ type BasicRemoteReconcilerAction struct

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Configure(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Create(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Delete(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Diff(ctx context.Context, o object.RemoteObject, read RemoteRead[apiObject], ...) (diff RemoteDiff[apiObject], res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) GetIgnoresDiff() []patch.CalculateOption

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) GetRemoteHandler(ctx context.Context, req ctrl.Request, o object.RemoteObject) (handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], ...)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) OnError(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) OnSuccess(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Read(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (read RemoteRead[apiObject], res ctrl.Result, err error)

+ func (h *BasicRemoteReconcilerAction[k8sObject, apiObject, apiClient]) Update(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ type Controller interface

+ Reconcile func(context.Context, reconcile.Request) (reconcile.Result, error)

+ SetupWithManager func(mgr ctrl.Manager) error

+ func NewBasicController() Controller

+ type Indexer func(mgr ctrl.Manager) error

+ type MultiPhaseDiff interface

+ AddDiff func(diff string)

+ Diff func() string

+ GetObjectsToCreate func() []client.Object

+ GetObjectsToDelete func() []client.Object

+ GetObjectsToUpdate func() []client.Object

+ IsDiff func() bool

+ NeedCreate func() bool

+ NeedDelete func() bool

+ NeedUpdate func() bool

+ SetObjectsToCreate func(objects []client.Object)

+ SetObjectsToDelete func(objects []client.Object)

+ SetObjectsToUpdate func(objects []client.Object)

+ func NewBasicMultiPhaseDiff() MultiPhaseDiff

+ type MultiPhaseRead interface

+ GetCurrentObjects func() []client.Object

+ GetExpectedObjects func() []client.Object

+ SetCurrentObjects func(objects []client.Object)

+ SetExpectedObjects func(objects []client.Object)

+ func NewBasicMultiPhaseRead() MultiPhaseRead

+ type MultiPhaseReconciler interface

+ Reconcile func(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject, ...) (res ctrl.Result, err error)

+ func NewBasicMultiPhaseReconciler(client client.Client, name string, finalizer shared.FinalizerName, ...) (multiPhaseReconciler MultiPhaseReconciler)

+ type MultiPhaseReconcilerAction interface

+ Configure func(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject) (res ctrl.Result, err error)

+ Delete func(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (err error)

+ OnError func(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

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

+ Read func(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (res ctrl.Result, err error)

+ func NewBasicMultiPhaseReconcilerAction(client client.Client, conditionName shared.ConditionName, logger *logrus.Entry, ...) (multiPhaseReconciler MultiPhaseReconcilerAction)

+ type MultiPhaseStepReconciler interface

+ Reconcile func(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject, ...) (res ctrl.Result, err error)

+ func NewBasicMultiPhaseStepReconciler(client client.Client, logger *logrus.Entry, recorder record.EventRecorder) (multiPhaseStepReconciler MultiPhaseStepReconciler)

+ type MultiPhaseStepReconcilerAction interface

+ Configure func(ctx context.Context, req ctrl.Request, o object.MultiPhaseObject) (res ctrl.Result, err error)

+ Create func(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ Delete func(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ Diff func(ctx context.Context, o object.MultiPhaseObject, read MultiPhaseRead, ...) (diff MultiPhaseDiff, res ctrl.Result, err error)

+ GetIgnoresDiff func() []patch.CalculateOption

+ GetPhaseName func() shared.PhaseName

+ OnError func(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

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

+ Read func(ctx context.Context, o object.MultiPhaseObject, data map[string]any) (read MultiPhaseRead, res ctrl.Result, err error)

+ Update func(ctx context.Context, o object.MultiPhaseObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func NewBasicMultiPhaseStepReconcilerAction(client client.Client, phaseName shared.PhaseName, ...) (multiPhaseStepReconciler MultiPhaseStepReconcilerAction)

+ type RemoteDiff interface

+ AddDiff func(diff string)

+ Diff func() string

+ GetObjectToCreate func() T

+ GetObjectToUpdate func() T

+ IsDiff func() bool

+ NeedCreate func() bool

+ NeedUpdate func() bool

+ SetObjectToCreate func(object T)

+ SetObjectToUpdate func(object T)

+ func NewBasicRemoteDiff() RemoteDiff[T]

+ type RemoteExternalReconciler interface

+ Build func(k8sO k8sObject) (object apiObject, err error)

+ Client func() apiClient

+ Create func(apiO apiObject, k8sO k8sObject) (err error)

+ Delete func(k8sO k8sObject) (err error)

+ Diff func(currentOject apiObject, expectedObject apiObject, originalObject apiObject, ...) (patchResult *patch.PatchResult, err error)

+ Get func(k8sO k8sObject) (object apiObject, err error)

+ Update func(apiO apiObject, k8sO k8sObject) (err error)

+ type RemoteRead interface

+ GetCurrentObject func() T

+ GetExpectedObject func() T

+ SetCurrentObject func(object T)

+ SetExpectedObject func(object T)

+ func NewBasicRemoteRead() RemoteRead[T]

+ type RemoteReconciler interface

+ Reconcile func(ctx context.Context, req ctrl.Request, o object.RemoteObject, ...) (res ctrl.Result, err error)

+ func NewBasicRemoteReconciler(client client.Client, name string, finalizer shared.FinalizerName, ...) (remoteReconciler RemoteReconciler[k8sObject, apiObject, apiClient])

+ type RemoteReconcilerAction interface

+ Configure func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ Create func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ Delete func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (err error)

+ Diff func(ctx context.Context, o object.RemoteObject, read RemoteRead[apiObject], ...) (diff RemoteDiff[apiObject], res ctrl.Result, err error)

+ GetIgnoresDiff func() []patch.CalculateOption

+ GetRemoteHandler func(ctx context.Context, req ctrl.Request, o object.RemoteObject) (handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], ...)

+ OnError func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

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

+ Read func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (read RemoteRead[apiObject], res ctrl.Result, err error)

+ Update func(ctx context.Context, o object.RemoteObject, data map[string]any, ...) (res ctrl.Result, err error)

+ func NewRemoteReconcilerAction(client client.Client, logger *logrus.Entry, recorder record.EventRecorder) (remoteReconciler RemoteReconcilerAction[k8sObject, apiObject, apiClient])

v0.1.2

Feb 28, 2023

v0.1.1

Feb 10, 2023

v0.1.0

Jan 25, 2023

Changes in this version

+ type K8sDiff struct

+ Diff strings.Builder

+ NeedCreate bool

+ NeedDelete bool

+ NeedUpdate bool

+ type K8sPhaseReconciler interface

+ Configure func(ctx context.Context, req ctrl.Request, resource client.Object) (res ctrl.Result, err error)

+ Create func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ Delete func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ Diff func(ctx context.Context, r client.Object, data map[string]any) (diff K8sDiff, res ctrl.Result, err error)

+ GetName func() string

+ OnError func(ctx context.Context, r client.Object, data map[string]any, currentErr error) (res ctrl.Result, err error)

+ OnSuccess func(ctx context.Context, r client.Object, data map[string]any, diff K8sDiff) (res ctrl.Result, err error)

+ Read func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ Update func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ type K8sReconciler interface

+ Configure func(ctx context.Context, req ctrl.Request, resource client.Object) (res ctrl.Result, err error)

+ Delete func(ctx context.Context, r client.Object, data map[string]any) (err error)

+ OnError func(ctx context.Context, r client.Object, data map[string]any, currentErr error) (res ctrl.Result, err error)

+ OnSuccess func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ Read func(ctx context.Context, r client.Object, data map[string]any) (res ctrl.Result, err error)

+ type StdK8sReconciler struct

+ func NewStdK8sReconciler(client client.Client, finalizer string, reconciler K8sReconciler, ...) (stdK8sReconciler *StdK8sReconciler, err error)

+ func (h *StdK8sReconciler) Reconcile(ctx context.Context, req ctrl.Request, r client.Object, ...) (res ctrl.Result, err error)

v0.0.17

Apr 7, 2022

v0.0.16

Apr 7, 2022

v0.0.15

Mar 31, 2022

v0.0.14

Mar 31, 2022

v0.0.13

Mar 31, 2022

v0.0.12

Mar 31, 2022

Changes in this version

type Reconciler

+ OnError func(ctx context.Context, r resource.Resource, data map[string]any, meta any, ...)

+ OnSuccess func(ctx context.Context, r resource.Resource, data map[string]any, meta any, ...) (err error)

v0.0.11

Mar 23, 2022

v0.0.10

Mar 23, 2022

v0.0.9

Mar 23, 2022

v0.0.8

Mar 23, 2022

v0.0.7

Mar 23, 2022

Changes in this version

type Reconciler

+ Configure func(ctx context.Context, req ctrl.Request, resource resource.Resource) (meta any, err error)

v0.0.6

Mar 17, 2022

v0.0.5

Mar 17, 2022

v0.0.4

Mar 17, 2022

v0.0.3

Mar 17, 2022

v0.0.2

Mar 17, 2022

v0.0.1

Mar 17, 2022

Changes in this version

+ type Diff struct

+ Diff string

+ NeedCreate bool

+ NeedUpdate bool

+ type Reconciler interface

+ Create func(resource client.Object, data map[string]interface{}, meta interface{}) (res ctrl.Result, err error)

+ Delete func(resource client.Object, data map[string]interface{}, meta interface{}) (res ctrl.Result, err error)

+ Diff func(resource client.Object, data map[string]interface{}) (diff Diff, err error)

+ Read func(req ctrl.Request, resource client.Object, data map[string]interface{}, ...) (err error)

+ Update func(resource client.Object, data map[string]interface{}, meta interface{}) (res ctrl.Result, err error)

+ type StdReconciler struct

+ func NewStdReconciler(client client.Client, finalizer string, reconciler Reconciler, ...) (stdReconciler *StdReconciler, err error)

+ func (h *StdReconciler) Reconcile(ctx context.Context, req ctrl.Request, resource client.Object, ...) (res ctrl.Result, err error)

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