libctrl

type Annotator ¶

type Annotator[T any] interface {
	WithAnnotations(entries map[string]string) T
}

type BuilderComposer ¶

type BuilderComposer func(builder ...handler.Builder) handler.Builder

BuilderComposer is a function that composes sets of handler.Builder into one handler.Builder, see `Chain` and `Parallel`.

func ChainWithMiddleware(middleware ...Middleware) BuilderComposer

func ParallelWithMiddleware(middleware ...Middleware) BuilderComposer

func WithMiddleware(composer BuilderComposer, middleware ...Middleware) BuilderComposer

type BuilderMiddleware ¶

type BuilderMiddleware func(handler.Builder) handler.Builder

BuilderMiddleware returns a new (wrapped) Builder given a Builder

func MakeBuilderMiddleware(w HandlerMiddleware) BuilderMiddleware

type Component ¶

type Component[K metav1.Object] struct {
	// contains filtered or unexported fields
}

Component represents an object in the cluster that is "related" to another i.e. a pod would be a component of a deployment (though direct ownership is not required).

func NewComponent[K metav1.Object](informers map[schema.GroupVersionResource]dynamicinformer.DynamicSharedInformerFactory, gvr schema.GroupVersionResource, indexName string, selector labels.Selector) *Component[K]

func (c *Component[K]) List(indexValue fmt.Stringer) (out []K)

type ComponentContextHandler ¶

type ComponentContextHandler[K metav1.Object] struct {
	HandlerControls
	// contains filtered or unexported fields
}

ComponentContextHandler fills the value for a ContextKey with the result of fetching a component.

func NewComponentContextHandler[K metav1.Object](ctrls HandlerControls, contextKey SettableContext[[]K], component *Component[K], owner fmt.Stringer, next handler.ContextHandler) *ComponentContextHandler[K]

func (h *ComponentContextHandler[K]) Handle(ctx context.Context)

type ContextDefaultingKey ¶

type ContextDefaultingKey[V comparable] struct {
	// contains filtered or unexported fields
}

ContextDefaultingKey is a type that is used as a key in a context.Context for a specific type of value, but returns the default value for V if unset.

func NewContextDefaultingKey[V comparable](defaultValue V) *ContextDefaultingKey[V]

func (k *ContextDefaultingKey[V]) MustValue(ctx context.Context) V

func (k *ContextDefaultingKey[V]) Value(ctx context.Context) V

func (k *ContextDefaultingKey[V]) WithValue(ctx context.Context, val V) context.Context

type ContextHandle ¶

type ContextHandle[V any] struct {
	// contains filtered or unexported fields
}

type ContextHandleDefaultingKey ¶

type ContextHandleDefaultingKey[V any] struct {
	// contains filtered or unexported fields
}

ContextHandleDefaultingKey is a type that is used as a key in a context.Context that points to a handle containing the desired value. This allows a handler higher up in the chain to carve out a spot to be filled in by other handlers. It can also be used to hold non-comparable objects by wrapping them with a pointer.

func NewContextHandleDefaultingKey[V any](defaultValue V) *ContextHandleDefaultingKey[V]

func (k *ContextHandleDefaultingKey[V]) HandleBuilder(id handler.Key) handler.Builder

func (k *ContextHandleDefaultingKey[V]) MustValue(ctx context.Context) V

func (k *ContextHandleDefaultingKey[V]) Value(ctx context.Context) V

func (k *ContextHandleDefaultingKey[V]) WithHandle(ctx context.Context) context.Context

func (k *ContextHandleDefaultingKey[V]) WithValue(ctx context.Context, val V) context.Context

type ContextKey ¶

type ContextKey[V comparable] struct{}

ContextKey is a type that is used as a key in a context.Context for a specific type of value V. It mimics the context.Context interface

func NewContextKey[V comparable]() *ContextKey[V]

func (k *ContextKey[V]) MustValue(ctx context.Context) V

func (k *ContextKey[V]) Value(ctx context.Context) (V, bool)

func (k *ContextKey[V]) WithValue(ctx context.Context, val V) context.Context

type ControlAll ¶

type ControlAll interface {
	ControlDone
	ControlRequeue
	ControlRequeueAfter
	ControlRequeueErr
	ControlRequeueAPIErr
}

type ControlDone ¶

type ControlDone interface {
	Done()
}

type ControlDoneRequeue ¶

type ControlDoneRequeue interface {
	ControlDone
	ControlRequeue
}

type ControlDoneRequeueAfter ¶

type ControlDoneRequeueAfter interface {
	ControlDone
	ControlRequeueAfter
}

type ControlDoneRequeueErr ¶

type ControlDoneRequeueErr interface {
	ControlDone
	ControlRequeueErr
}

type ControlOpt ¶

type ControlOpt func(*HandlerControls)

func WithDone(doneFunc func()) ControlOpt

func WithRequeue(requeueFunc func()) ControlOpt

func WithRequeueAfter(requeueAfterFunc func(duration time.Duration)) ControlOpt

func WithRequeueImmediate(requeueFunc func(duration time.Duration)) ControlOpt

type ControlRequeue ¶

type ControlRequeue interface {
	Requeue()
}

type ControlRequeueAPIErr ¶

type ControlRequeueAPIErr interface {
	ControlDone
	ControlRequeue
	ControlRequeueAfter
	RequeueAPIErr(err error)
}

type ControlRequeueAfter ¶

type ControlRequeueAfter interface {
	RequeueAfter(duration time.Duration)
}

type ControlRequeueErr ¶

type ControlRequeueErr interface {
	ControlRequeue
	RequeueErr(err error)
}

type EnsureComponentByHash ¶

type EnsureComponentByHash[K metav1.Object, A Annotator[A]] struct {
	ControlRequeueErr
	*HashableComponent[K]
	// contains filtered or unexported fields
}

func NewEnsureComponentByHash[K metav1.Object, A Annotator[A]](
	component *HashableComponent[K],
	owner types.NamespacedName,
	ctrls ControlRequeueErr,
	applyObj func(ctx context.Context, apply A) (K, error),
	deleteObject func(ctx context.Context, name string) error,
	newObj func(ctx context.Context) A,
) *EnsureComponentByHash[K, A]

func (e *EnsureComponentByHash[K, A]) Handle(ctx context.Context)

type FileInformer ¶

type FileInformer struct {
	// contains filtered or unexported fields
}

func NewFileInformer(watcher *fsnotify.Watcher, gvr schema.GroupVersionResource) (*FileInformer, error)

func (f *FileInformer) Informer() cache.SharedIndexInformer

func (f *FileInformer) Lister() cache.GenericLister

type FileInformerFactory ¶

type FileInformerFactory struct {
	sync.Mutex
	// contains filtered or unexported fields
}

func NewFileInformerFactory() (*FileInformerFactory, error)

func (f *FileInformerFactory) ForResource(gvr schema.GroupVersionResource) informers.GenericInformer

func (f *FileInformerFactory) Start(stopCh <-chan struct{})

func (f *FileInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[schema.GroupVersionResource]bool

type FileSharedIndexInformer ¶

type FileSharedIndexInformer struct {
	sync.Once
	sync.RWMutex
	// contains filtered or unexported fields
}

func NewFileSharedIndexInformer(fileName string, watcher *fsnotify.Watcher, defaultEventHandlerResyncPeriod time.Duration) *FileSharedIndexInformer

func (f *FileSharedIndexInformer) AddEventHandler(handler cache.ResourceEventHandler)

func (f *FileSharedIndexInformer) AddEventHandlerWithResyncPeriod(handler cache.ResourceEventHandler, resyncPeriod time.Duration)

func (f *FileSharedIndexInformer) AddIndexers(indexers cache.Indexers) error

func (f *FileSharedIndexInformer) GetController() cache.Controller

func (f *FileSharedIndexInformer) GetIndexer() cache.Indexer

func (f *FileSharedIndexInformer) GetStore() cache.Store

func (f *FileSharedIndexInformer) HasSynced() bool

func (f *FileSharedIndexInformer) LastSyncResourceVersion() string

func (f *FileSharedIndexInformer) Run(stopCh <-chan struct{})

func (f *FileSharedIndexInformer) SetWatchErrorHandler(handler cache.WatchErrorHandler) error

type HandlerControls ¶

type HandlerControls struct {
	// contains filtered or unexported fields
}

func HandlerControlsWith(opts ...ControlOpt) HandlerControls

func (c HandlerControls) Done()

func (c HandlerControls) Requeue()

func (c HandlerControls) RequeueAPIErr(err error)

func (c HandlerControls) RequeueAfter(duration time.Duration)

func (c HandlerControls) RequeueErr(err error)

type HandlerMiddleware ¶

type HandlerMiddleware func(handler.Handler) handler.Handler

HandlerMiddleware returns a new (wrapped) Handler given a Handler

type HasStatusConditions ¶

type HasStatusConditions interface {
	comparable
	metav1.Object
	FindStatusCondition(conditionType string) *metav1.Condition
	SetStatusCondition(metav1.Condition)
	GetStatusConditions() []metav1.Condition
}

HasStatusConditions is used for pausing

type HashEqualFunc ¶

type HashEqualFunc func(a, b string) bool

type HashableComponent ¶

type HashableComponent[K metav1.Object] struct {
	Component[K]
	ObjectHasher
	HashAnnotationKey string
}

HashableComponent is a Component with an annotation that stores a hash of the previous configuration the controller wrote

func NewHashableComponent[K metav1.Object](component Component[K], hasher ObjectHasher, key string) *HashableComponent[K]

type Middleware ¶

type Middleware func(BuilderComposer) BuilderComposer

Middleware operates on BuilderComposer (to wrap all underlying builders)

func MakeMiddleware(w HandlerMiddleware) Middleware

type ObjectHashFunc ¶

type ObjectHashFunc func(obj any) (string, error)

type ObjectHasher ¶

type ObjectHasher interface {
	Hash(obj any) (string, error)
	Equal(a, b string) bool
}

func NewObjectHash() ObjectHasher

func NewSecureObjectHash() ObjectHasher

type PauseHandler ¶

type PauseHandler[K HasStatusConditions] struct {
	ControlDoneRequeueErr
	PausedLabelKey string
	Object         K
	PatchStatus    func(ctx context.Context, patch K) error
	Next           handler.ContextHandler
}

func NewPauseHandler[K HasStatusConditions](ctrls ControlDoneRequeueErr,
	pausedLabelKey string,
	object K,
	patchStatus func(ctx context.Context, patch K) error,
	next handler.ContextHandler,
) *PauseHandler[K]

func (p *PauseHandler[K]) Handle(ctx context.Context)

type SelfPauseHandler ¶

type SelfPauseHandler[K HasStatusConditions] struct {
	HandlerControls
	CtxKey         *ContextDefaultingKey[K]
	PausedLabelKey string
	OwnerUID       types.UID
	Patch          func(ctx context.Context, patch K) error
	PatchStatus    func(ctx context.Context, patch K) error
}

SelfPauseHandler is used when the controller pauses itself. This is only used when the controller has no good way to tell when the bad state has been resolved (i.e. an external resource is behaving poorly).

func NewSelfPauseHandler[K HasStatusConditions](ctrls HandlerControls,
	pausedLabelKey string,
	contextKey *ContextDefaultingKey[K],
	ownerUID types.UID,
	patch, patchStatus func(ctx context.Context, patch K) error,
) *SelfPauseHandler[K]

func (p *SelfPauseHandler[K]) Handle(ctx context.Context)

type SettableContext ¶

type SettableContext[V any] interface {
	WithValue(ctx context.Context, val V) context.Context
}