lifecycle

type CacheBypasserClient ¶ added in v0.5.0

type CacheBypasserClient interface {
	client.Client
	BypassCache() client.Reader
}

func CacheBypasserClientForManager(mgr manager.Manager) CacheBypasserClient

type DeleteOption ¶

type DeleteOption interface {
	// ApplyToDeleteOptions copies the configuration of this option to the given
	// deletion options.
	ApplyToDeleteOptions(target *DeleteOptions)
}

DeleteOption is a setter for one or more deletion options.

type DeleteOptions ¶

type DeleteOptions struct {
	PropagationPolicy client.PropagationPolicy
}

DeleteOptions are the options that a deletable entity is required to support.

func (o *DeleteOptions) ApplyOptions(opts []DeleteOption)

type DeleteWithPropagationPolicy ¶

type DeleteWithPropagationPolicy client.PropagationPolicy

DeleteWithPropagationPolicy causes the deletion to use the specified propagation policy semantically.

If this option is not used, propagation policy will be determined by the entity being deleted.

func (dwpp DeleteWithPropagationPolicy) ApplyToDeleteOptions(target *DeleteOptions)

type Deleter ¶

type Deleter interface {
	// Delete removes this entity from the cluster.
	Delete(ctx context.Context, cl client.Client, opts ...DeleteOption) (bool, error)
}

Deleter is the type of an entity that can be deleted from a cluster.

type Finalizable ¶

type Finalizable interface {
	// Finalizing returns true if this entity is currently in a finalizing
	// state.
	//
	// Usually, this is indicated by the presence of a deletion timestamp in
	// Kubernetes object metadata.
	Finalizing() bool

	// AddFinalizer sets the given finalizer in object metadata. It returns true
	// if the finalizer was added, and false if it already exists.
	AddFinalizer(ctx context.Context, name string) bool

	// RemoveFinalizer removes the given finalizer from object metadata. It
	// returns true if the finalizer was removed, and false if the finalizer did
	// not exist.
	RemoveFinalizer(ctx context.Context, name string) bool
}

Finalizable is the type of an entity that supports finalizing.

type FinalizablePersister ¶

type FinalizablePersister interface {
	Finalizable
	Persister
}

FinalizablePersister is a combined interface for a finalizable entity that can be saved to the cluster.

type IgnoreNilLabelAnnotatableFrom ¶

type IgnoreNilLabelAnnotatableFrom struct {
	LabelAnnotatableFrom
}

IgnoreNilLabelAnnotatableFrom is an adapter for a label and annotation copier that makes sure its delegate has a value before copying.

func (inlaf IgnoreNilLabelAnnotatableFrom) LabelAnnotateFrom(ctx context.Context, from metav1.Object)

type IgnoreNilLoader ¶

type IgnoreNilLoader struct {
	Loader
}

IgnoreNilLoader is an adapter for a loader that makes sure the loader has a value before attempting to load from it.

This loader is useful for loading optional dependencies.

func (inl IgnoreNilLoader) Load(ctx context.Context, cl client.Client) (bool, error)

type IgnoreNilOwnable ¶

type IgnoreNilOwnable struct {
	Ownable
}

IgnoreNilOwnable is an adapter for an ownable entity that makes sure the entity has a value.

func (ino IgnoreNilOwnable) Owned(ctx context.Context, owner TypedObject) error

type IgnoreNilOwnablePersister ¶ added in v0.2.0

type IgnoreNilOwnablePersister struct {
	OwnablePersister
}

IgnoreNilOwnablePersister combines IgnoreNilOwnable and IgnoreNilPersister.

func (inop IgnoreNilOwnablePersister) Owned(ctx context.Context, owner TypedObject) error

func (inop IgnoreNilOwnablePersister) Persist(ctx context.Context, cl client.Client) error

type IgnoreNilPersister ¶

type IgnoreNilPersister struct {
	Persister
}

IgnoreNilPersister is an adapter for a persistable entity that makes sure the entity has a value.

func (inp IgnoreNilPersister) Persist(ctx context.Context, cl client.Client) error

type LabelAnnotatableFrom ¶

type LabelAnnotatableFrom interface {
	// LabelAnnotateFrom copies the labels from the given object metadata to
	// this entity.
	LabelAnnotateFrom(ctx context.Context, from metav1.Object)
}

LabelAnnotatableFrom is the type of an entity that can copy labels and annotations from the given metadata.

type Loader ¶

type Loader interface {
	// Load finds this entity in the cluster and populates any necessary fields.
	// If there was an error locating the entity, this function returns false.
	Load(ctx context.Context, cl client.Client) (bool, error)
}

Loader is the type of an entity that can be retrieved from a cluster.

func NewPredicateLoader(delegate Loader, cond func(ctx context.Context) bool) Loader

func NewPrereqLoader(delegate Loader, obj client.Object) Loader

type LoaderFunc ¶

type LoaderFunc func(ctx context.Context, cl client.Client) (bool, error)

LoaderFunc allows a function to be used as a loader.

func (lf LoaderFunc) Load(ctx context.Context, cl client.Client) (bool, error)

type Loaders ¶

type Loaders []Loader

Loaders allows multiple loaders to be loaded at once, as if they were a single entity.

func (ls Loaders) Load(ctx context.Context, cl client.Client) (bool, error)

type Ownable ¶

type Ownable interface {
	// Owned sets the ownerReferences controller for this entity to the given
	// object.
	Owned(ctx context.Context, owner TypedObject) error
}

Ownable is the type of an entity that can be a dependent of another object using the Kubernetes ownerReferences mechanism.

type OwnablePersister ¶

type OwnablePersister interface {
	Ownable
	Persister
}

OwnablePersister is a combined interface for an object that can be owned and can be saved to the cluster.

type OwnablePersisters ¶

type OwnablePersisters []OwnablePersister

OwnablePersisters allows a collection of ownable persisters to be used as a single entity.

func (ops OwnablePersisters) Owned(ctx context.Context, owner TypedObject) error

func (ops OwnablePersisters) Persist(ctx context.Context, cl client.Client) error

type Owner ¶

type Owner interface {
	// Own sets the owner of the specified dependent entity to this entity.
	Own(ctx context.Context, other Ownable) error
}

Owner is the type of an entity that can own other objects using the Kubernetes ownerReferences mechanism.

type OwnerPersister ¶

type OwnerPersister interface {
	Owner
	Persister
}

OwnerPersister is a combined interface for an object that can own other objects and can be saved to the cluster.

type OwnershipPersister ¶

type OwnershipPersister struct {
	Owner     OwnerPersister
	Dependent OwnablePersister
}

OwnershipPersister provides a lifecycle for managing the ownership of an entity or set of entities.

It first persists the owner so that its unique object ID is known. Then it sets the ownerReferences for the intended dependent. Finally, it persists all the dependents.

func (op OwnershipPersister) Persist(ctx context.Context, cl client.Client) error

type Persister ¶

type Persister interface {
	// Persist saves this entity using the given client.
	Persist(ctx context.Context, cl client.Client) error
}

Persister is the type of an entity that can be saved to a cluster.

type RequiredError ¶

type RequiredError struct {
	// Loader is the underlying loader that could not find the object.
	Loader Loader
}

RequiredError is an error reported by RequiredLoader if the target cannot be found.

func (e *RequiredError) Error() string

type RequiredLoader ¶

type RequiredLoader struct {
	Loader
}

RequiredLoader is an adapter for a loader that ensures the entity exists.

func (rl RequiredLoader) Load(ctx context.Context, cl client.Client) (bool, error)

type RetryLoader ¶

type RetryLoader interface {
	Loader

	// WithWaitOptions sets the options, like a backoff, to use, for waiting on
	// the condition.
	WithWaitOptions(opts ...retry.WaitOption) Loader
}

RetryLoader is an adapter that continually retries loading until a condition is met.

func NewRetryLoader(delegate Loader, mapper func(bool, error) (bool, error)) RetryLoader

type TypedObject ¶

type TypedObject struct {
	GVK    schema.GroupVersionKind
	Object client.Object
}

TypedObject is a Kubernetes runtime object with its resource group-version-kind attached from its schema.