resource

type APIFinalizer ¶

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

An APIFinalizer adds and removes finalizers to and from a resource.

func NewAPIFinalizer(c client.Client, finalizer string) *APIFinalizer

func (a *APIFinalizer) AddFinalizer(ctx context.Context, obj Object) error

func (a *APIFinalizer) RemoveFinalizer(ctx context.Context, obj Object) error

type APIPatchingApplicator ¶

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

An APIPatchingApplicator applies changes to an object by either creating or patching it in a Kubernetes API server.

func NewAPIPatchingApplicator(c client.Client) *APIPatchingApplicator

func (a *APIPatchingApplicator) Apply(ctx context.Context, o client.Object, ao ...ApplyOption) error

type APIUpdatingApplicator ¶

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

An APIUpdatingApplicator applies changes to an object by either creating or updating it in a Kubernetes API server.

func NewAPIUpdatingApplicator(c client.Client) *APIUpdatingApplicator

func (a *APIUpdatingApplicator) Apply(ctx context.Context, o client.Object, ao ...ApplyOption) error

type AnnotationChangedPredicate ¶

type AnnotationChangedPredicate struct {
	predicate.Funcs
	// contains filtered or unexported fields
}

AnnotationChangedPredicate implements a default update predicate function on annotation change by ignoring the given annotation keys, if any.

This predicate extends controller-runtime's AnnotationChangedPredicate by being able to ignore certain annotations.

func (a AnnotationChangedPredicate) Update(e event.UpdateEvent) bool

type Applicator ¶

type Applicator interface {
	Apply(ctx context.Context, obj client.Object, o ...ApplyOption) error
}

An Applicator applies changes to an object.

type ApplicatorWithRetry ¶

type ApplicatorWithRetry struct {
	Applicator
	// contains filtered or unexported fields
}

An ApplicatorWithRetry applies changes to an object, retrying on transient failures.

func NewApplicatorWithRetry(applicator Applicator, shouldRetry shouldRetryFunc, backoff *wait.Backoff) *ApplicatorWithRetry

If backoff is nil, then retry.DefaultRetry is used as the default.

func (awr *ApplicatorWithRetry) Apply(ctx context.Context, c client.Object, opts ...ApplyOption) error

type ApplyFn ¶

type ApplyFn func(context.Context, client.Object, ...ApplyOption) error

An ApplyFn is a function that satisfies the Applicator interface.

func (fn ApplyFn) Apply(ctx context.Context, o client.Object, ao ...ApplyOption) error

type ApplyOption ¶

type ApplyOption func(ctx context.Context, current, desired runtime.Object) error

An ApplyOption is called before patching the current object to match the desired object. ApplyOptions are not called if no current object exists.

func AllowUpdateIf(fn func(current, desired runtime.Object) bool) ApplyOption

func ConnectionSecretMustBeControllableBy(u types.UID) ApplyOption

func MustBeControllableBy(u types.UID) ApplyOption

func StoreCurrentRV(origRV *string) ApplyOption

func UpdateFn(fn func(current, desired runtime.Object)) ApplyOption

type AttributeReferencer ¶

type AttributeReferencer interface {
	// GetStatus retries the referenced resource, as well as other non-managed
	// resources (like a `Provider`) and reports their readiness for use as a
	// referenced resource.
	GetStatus(ctx context.Context, res CanReference, r client.Reader) ([]ReferenceStatus, error)

	// Build retrieves the referenced resource, as well as other non-managed
	// resources (like a `Provider`), and builds the referenced attribute,
	// returning it as a string value.
	Build(ctx context.Context, res CanReference, r client.Reader) (value string, err error)

	// Assign accepts a managed resource object, and assigns the given value to
	// its corresponding property.
	Assign(res CanReference, value string) error
}

An AttributeReferencer resolves cross-resource attribute references. See https://github.com/crossplane/crossplane/blob/main/design/one-pager-cross-resource-referencing.md for more information.

type CanReference ¶

type CanReference runtime.Object

A CanReference is a resource that can reference another resource in its spec in order to automatically resolve corresponding spec field values by inspecting the referenced resource.

type Claim ¶

type Claim = CompositeClaim

A Claim of a composite resource (XR).

type ClaimReferencer ¶

type ClaimReferencer interface {
	SetClaimReference(r *reference.Claim)
	GetClaimReference() *reference.Claim
}

A ClaimReferencer may reference a resource claim.

type ClientApplicator ¶

type ClientApplicator struct {
	client.Client
	Applicator
}

A ClientApplicator may be used to build a single 'client' that satisfies both client.Client and Applicator.

type Composed ¶

type Composed interface {
	Object

	Conditioned
	ConnectionSecretWriterTo
	ReconciliationObserver
}

Composed resources can be a composed into a Composite resource.

type ComposedResourcesReferencer ¶

type ComposedResourcesReferencer interface {
	SetResourceReferences(refs []corev1.ObjectReference)
	GetResourceReferences() []corev1.ObjectReference
}

A ComposedResourcesReferencer may reference the resources it composes.

type Composite ¶

type Composite interface {
	Object

	CompositionSelector
	CompositionReferencer
	CompositionUpdater
	CompositionRevisionReferencer
	CompositionRevisionSelector
	ComposedResourcesReferencer

	Conditioned
	ReconciliationObserver
}

A Composite resource (or XR) is composed of other resources.

type CompositeClaim ¶

type CompositeClaim interface {
	Object

	CompositionSelector
	CompositionReferencer
	CompositionUpdater
	CompositionRevisionReferencer
	CompositionRevisionSelector
	CompositeResourceDeleter
	CompositeResourceReferencer
	LocalConnectionSecretWriterTo

	Conditioned
	ConnectionDetailsPublishedTimer
	ReconciliationObserver
}

A CompositeClaim of a composite resource (XR).

type CompositeClaimKind ¶

type CompositeClaimKind schema.GroupVersionKind

A CompositeClaimKind contains the type metadata for a kind of composite resource claim.

type CompositeKind ¶

type CompositeKind schema.GroupVersionKind

A CompositeKind contains the type metadata for a kind of composite resource.

type CompositeResourceDeleter ¶

type CompositeResourceDeleter interface {
	SetCompositeDeletePolicy(policy *xpv1.CompositeDeletePolicy)
	GetCompositeDeletePolicy() *xpv1.CompositeDeletePolicy
}

A CompositeResourceDeleter creates a composite, and controls the policy used to delete the composite.

type CompositeResourceReferencer ¶

type CompositeResourceReferencer interface {
	SetResourceReference(r *reference.Composite)
	GetResourceReference() *reference.Composite
}

A CompositeResourceReferencer can reference a composite resource.

type CompositionReferencer ¶

type CompositionReferencer interface {
	SetCompositionReference(ref *corev1.ObjectReference)
	GetCompositionReference() *corev1.ObjectReference
}

A CompositionReferencer may reference a composition of resources.

type CompositionRevisionReferencer ¶

type CompositionRevisionReferencer interface {
	SetCompositionRevisionReference(ref *corev1.LocalObjectReference)
	GetCompositionRevisionReference() *corev1.LocalObjectReference
}

A CompositionRevisionReferencer may reference a specific revision of a composition of resources.

type CompositionRevisionSelector ¶

type CompositionRevisionSelector interface {
	SetCompositionRevisionSelector(selector *metav1.LabelSelector)
	GetCompositionRevisionSelector() *metav1.LabelSelector
}

A CompositionRevisionSelector may reference a set of composition revisions.

type CompositionSelector ¶

type CompositionSelector interface {
	SetCompositionSelector(s *metav1.LabelSelector)
	GetCompositionSelector() *metav1.LabelSelector
}

A CompositionSelector may select a composition of resources.

type CompositionUpdater ¶

type CompositionUpdater interface {
	SetCompositionUpdatePolicy(p *xpv1.UpdatePolicy)
	GetCompositionUpdatePolicy() *xpv1.UpdatePolicy
}

A CompositionUpdater uses a composition, and may update which revision of that composition it uses.

type Conditioned ¶

type Conditioned interface {
	SetConditions(c ...xpv1.Condition)
	GetCondition(ct xpv1.ConditionType) xpv1.Condition
}

A Conditioned may have conditions set or retrieved. Conditions are typically indicate the status of both a resource and its reconciliation process.

type ConnectionDetailsPublishedTimer ¶

type ConnectionDetailsPublishedTimer interface {
	SetConnectionDetailsLastPublishedTime(t *metav1.Time)
	GetConnectionDetailsLastPublishedTime() *metav1.Time
}

A ConnectionDetailsPublishedTimer can record the last time its connection details were published.

type ConnectionSecretOwner ¶

type ConnectionSecretOwner interface {
	Object

	ConnectionSecretWriterTo
}

A ConnectionSecretOwner is a Kubernetes object that owns a connection secret.

type ConnectionSecretWriterTo ¶

type ConnectionSecretWriterTo interface {
	SetWriteConnectionSecretToReference(r *xpv1.SecretReference)
	GetWriteConnectionSecretToReference() *xpv1.SecretReference
}

A ConnectionSecretWriterTo may write a connection secret to an arbitrary namespace.

type EnqueueRequestForProviderConfig ¶

type EnqueueRequestForProviderConfig struct{}

EnqueueRequestForProviderConfig enqueues a reconcile.Request for a referenced ProviderConfig.

func (e *EnqueueRequestForProviderConfig) Create(_ context.Context, evt event.CreateEvent, q RateLimitingInterface)

func (e *EnqueueRequestForProviderConfig) Delete(_ context.Context, evt event.DeleteEvent, q RateLimitingInterface)

func (e *EnqueueRequestForProviderConfig) Generic(_ context.Context, evt event.GenericEvent, q RateLimitingInterface)

func (e *EnqueueRequestForProviderConfig) Update(_ context.Context, evt event.UpdateEvent, q RateLimitingInterface)

type EnvLookupFn ¶

type EnvLookupFn func(string) string

EnvLookupFn looks up an environment variable.

type EnvironmentConfigReferencer ¶

type EnvironmentConfigReferencer interface {
	SetEnvironmentConfigReferences(refs []corev1.ObjectReference)
	GetEnvironmentConfigReferences() []corev1.ObjectReference
}

An EnvironmentConfigReferencer references a list of EnvironmentConfigs.

type ErrorIs ¶

type ErrorIs func(err error) bool

An ErrorIs function returns true if an error satisfies a particular condition.

type Finalizer ¶

type Finalizer interface {
	AddFinalizer(ctx context.Context, obj Object) error
	RemoveFinalizer(ctx context.Context, obj Object) error
}

A Finalizer manages the finalizers on the resource.

func NewNopFinalizer() Finalizer

type FinalizerFns ¶

type FinalizerFns struct {
	AddFinalizerFn    func(ctx context.Context, obj Object) error
	RemoveFinalizerFn func(ctx context.Context, obj Object) error
}

A FinalizerFns satisfy the Finalizer interface.

func (f FinalizerFns) AddFinalizer(ctx context.Context, obj Object) error

func (f FinalizerFns) RemoveFinalizer(ctx context.Context, obj Object) error

type LateInitializer ¶

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

LateInitializer contains functions to late initialize two fields with varying types. The main purpose of LateInitializer is to be able to report whether anything different from the original value has been returned after all late initialization calls.

func NewLateInitializer() *LateInitializer

func (li *LateInitializer) IsChanged() bool

func (li *LateInitializer) LateInitializeBoolPtr(org *bool, from *bool) *bool

func (li *LateInitializer) LateInitializeInt64Ptr(org *int64, from *int64) *int64

func (li *LateInitializer) LateInitializeStringPtr(org *string, from *string) *string

func (li *LateInitializer) LateInitializeTimePtr(org *metav1.Time, from *time.Time) *metav1.Time

func (li *LateInitializer) SetChanged()

type LegacyComposite ¶

type LegacyComposite interface {
	Composite
	ClaimReferencer
	ConnectionSecretWriterTo
	ConnectionDetailsPublishedTimer
}

A LegacyComposite is a Crossplane v1 style legacy XR.

type LegacyManaged ¶

type LegacyManaged interface {
	Managed
	ConnectionSecretWriterTo
	ProviderConfigReferencer
	Orphanable
}

A LegacyManaged is a cluster-scoped Kubernetes object representing a concrete managed resource, with namespaced connection secret referencers and untyped provider config reference. Deprecated: new namespace-scoped MRs should implement ModernManaged.

type LegacyManagedList ¶

type LegacyManagedList interface {
	client.ObjectList

	// GetItems returns the list of managed resources.
	GetItems() []LegacyManaged
}

A LegacyManagedList is a list of managed resources. Deprecated: new types should implement ManagedList.

type LegacyProviderConfigUsage ¶

type LegacyProviderConfigUsage interface {
	ProviderConfigUsage
	RequiredProviderConfigReferencer
}

A LegacyProviderConfigUsage is a ProviderConfigUsage that has an untyped reference to a provider config. Deprecated: new PCUs should implement TypedProviderConfigUsage.

type LegacyProviderConfigUsageTracker ¶

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

A LegacyProviderConfigUsageTracker tracks usages of a by creating or updating the appropriate LegacyProviderConfigUsage.

func NewLegacyProviderConfigUsageTracker(c client.Client, of LegacyProviderConfigUsage) *LegacyProviderConfigUsageTracker

func (u *LegacyProviderConfigUsageTracker) Track(ctx context.Context, mg LegacyManaged) error

type LocalConnectionSecretOwner ¶

type LocalConnectionSecretOwner interface {
	runtime.Object
	metav1.Object

	LocalConnectionSecretWriterTo
}

A LocalConnectionSecretOwner may create and manage a connection secret in its own namespace.

type LocalConnectionSecretWriterTo ¶

type LocalConnectionSecretWriterTo interface {
	SetWriteConnectionSecretToReference(r *xpv1.LocalSecretReference)
	GetWriteConnectionSecretToReference() *xpv1.LocalSecretReference
}

A LocalConnectionSecretWriterTo may write a connection secret to its own namespace.

type Manageable ¶

type Manageable interface {
	SetManagementPolicies(p xpv1.ManagementPolicies)
	GetManagementPolicies() xpv1.ManagementPolicies
}

A Manageable resource may specify a ManagementPolicies.

type Managed ¶

type Managed interface {
	Object
	Manageable
	Conditioned
}

A Managed is a Kubernetes object representing a concrete managed resource (e.g. a CloudSQL instance).

type ManagedKind ¶

type ManagedKind schema.GroupVersionKind

A ManagedKind contains the type metadata for a kind of managed resource.

type ManagedList ¶

type ManagedList interface {
	client.ObjectList

	// GetItems returns the list of managed resources.
	GetItems() []Managed
}

A ManagedList is a list of managed resources.

type ManagedResourceReferencer ¶

type ManagedResourceReferencer interface {
	SetResourceReference(r *corev1.ObjectReference)
	GetResourceReference() *corev1.ObjectReference
}

A ManagedResourceReferencer may reference a concrete managed resource.

type ModernManaged ¶

type ModernManaged interface {
	Managed
	LocalConnectionSecretWriterTo
	TypedProviderConfigReferencer
}

A ModernManaged is a Kubernetes object representing a concrete managed resource with local connection secret references and typed provider config reference.

type Object ¶

type Object interface {
	metav1.Object
	runtime.Object
}

An Object is a Kubernetes object.

type Orphanable ¶

type Orphanable interface {
	SetDeletionPolicy(p xpv1.DeletionPolicy)
	GetDeletionPolicy() xpv1.DeletionPolicy
}

An Orphanable resource may specify a DeletionPolicy.

type PredicateFn ¶

type PredicateFn func(obj runtime.Object) bool

A PredicateFn returns true if the supplied object should be reconciled. Deprecated: This type will be removed soon. Please use controller-runtime's predicate.NewPredicateFuncs instead.

type ProviderConfig ¶

type ProviderConfig interface {
	Object

	UserCounter
	Conditioned
}

A ProviderConfig configures a Crossplane provider.

type ProviderConfigKinds ¶

type ProviderConfigKinds struct {
	Config    schema.GroupVersionKind
	Usage     schema.GroupVersionKind
	UsageList schema.GroupVersionKind
}

ProviderConfigKinds contains the type metadata for a kind of provider config.

type ProviderConfigReferencer ¶

type ProviderConfigReferencer interface {
	GetProviderConfigReference() *xpv1.Reference
	SetProviderConfigReference(p *xpv1.Reference)
}

A ProviderConfigReferencer may reference a provider config resource.

type ProviderConfigUsage ¶

type ProviderConfigUsage interface {
	Object
	RequiredTypedResourceReferencer
}

A ProviderConfigUsage indicates a usage of a Crossplane provider config.

type ProviderConfigUsageList ¶

type ProviderConfigUsageList interface {
	client.ObjectList

	// GetItems returns the list of provider config usages.
	GetItems() []ProviderConfigUsage
}

A ProviderConfigUsageList is a list of provider config usages.

type ProviderConfigUsageTracker ¶

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

A ProviderConfigUsageTracker tracks usages of a ProviderConfig by creating or updating the appropriate ProviderConfigUsage.

func NewProviderConfigUsageTracker(c client.Client, of TypedProviderConfigUsage) *ProviderConfigUsageTracker

func (u *ProviderConfigUsageTracker) Track(ctx context.Context, mg ModernManaged) error

type RateLimitingInterface ¶

type RateLimitingInterface = workqueue.TypedRateLimitingInterface[reconcile.Request]

RateLimitingInterface for an EnqueueRequestForProviderConfig.

type ReconciliationObserver ¶

type ReconciliationObserver interface {
	SetObservedGeneration(generation int64)
	GetObservedGeneration() int64
}

ReconciliationObserver can track data observed by resource reconciler.

type ReferenceStatus ¶

type ReferenceStatus struct {
	Name   string
	Status ReferenceStatusType
}

ReferenceStatus has the name and status of a reference.

func (r ReferenceStatus) String() string

type ReferenceStatusType ¶

type ReferenceStatusType int

ReferenceStatusType is an enum type for the possible values for a Reference Status.

const (
	ReferenceStatusUnknown ReferenceStatusType = iota
	ReferenceNotFound
	ReferenceNotReady
	ReferenceReady
)

func (t ReferenceStatusType) String() string

type RequiredProviderConfigReferencer ¶

type RequiredProviderConfigReferencer interface {
	GetProviderConfigReference() xpv1.Reference
	SetProviderConfigReference(p xpv1.Reference)
}

A RequiredProviderConfigReferencer may reference a provider config resource. Unlike ProviderConfigReferencer, the reference is required (i.e. not nil).

type RequiredTypedProviderConfigReferencer ¶

type RequiredTypedProviderConfigReferencer interface {
	GetProviderConfigReference() xpv1.ProviderConfigReference
	SetProviderConfigReference(p xpv1.ProviderConfigReference)
}

A RequiredTypedProviderConfigReferencer may reference a provider config resource. Unlike TypedProviderConfigReferencer, the reference is required (i.e. not nil).

type RequiredTypedResourceReferencer ¶

type RequiredTypedResourceReferencer interface {
	SetResourceReference(r xpv1.TypedReference)
	GetResourceReference() xpv1.TypedReference
}

A RequiredTypedResourceReferencer can reference a resource.

type Tracker ¶

type Tracker interface {
	// Track the supplied managed resource.
	Track(ctx context.Context, mg Managed) error
}

A Tracker tracks managed resources.

type TrackerFn ¶

type TrackerFn func(ctx context.Context, mg Managed) error

A TrackerFn is a function that tracks managed resources.

func (fn TrackerFn) Track(ctx context.Context, mg Managed) error

type TypedProviderConfigReferencer ¶

type TypedProviderConfigReferencer interface {
	GetProviderConfigReference() *xpv1.ProviderConfigReference
	SetProviderConfigReference(p *xpv1.ProviderConfigReference)
}

A TypedProviderConfigReferencer may reference a provider config resource with its kind.

type TypedProviderConfigUsage ¶

type TypedProviderConfigUsage interface {
	ProviderConfigUsage
	RequiredTypedProviderConfigReferencer
}

A TypedProviderConfigUsage is a ProviderConfigUsage that has a typed reference to the ProviderConfig.

type UserCounter ¶

type UserCounter interface {
	SetUsers(i int64)
	GetUsers() int64
}

A UserCounter can count how many users it has.