managed

package
v1.16.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: May 10, 2024 License: Apache-2.0 Imports: 29 Imported by: 1,078

Documentation

Overview

Package managed provides a reconciler that manages the lifecycle of a resource in an external system.

Index

Constants

View Source
const (
	// FinalizerName is the string that is used as finalizer on managed resource
	// objects.
	FinalizerName = "finalizer.managedresource.crossplane.io"
)

Variables

This section is empty.

Functions

func ControllerName

func ControllerName(kind string) string

ControllerName returns the recommended name for controllers that use this package to reconcile a particular kind of managed resource.

Types

type APISecretPublisher

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

An APISecretPublisher publishes ConnectionDetails by submitting a Secret to a Kubernetes API server.

func NewAPISecretPublisher

func NewAPISecretPublisher(c client.Client, ot runtime.ObjectTyper) *APISecretPublisher

NewAPISecretPublisher returns a new APISecretPublisher.

func (*APISecretPublisher) PublishConnection

PublishConnection publishes the supplied ConnectionDetails to a Secret in the same namespace as the supplied Managed resource. It is a no-op if the secret already exists with the supplied ConnectionDetails.

func (*APISecretPublisher) UnpublishConnection

UnpublishConnection is no-op since PublishConnection only creates resources that will be garbage collected by Kubernetes when the managed resource is deleted.

type APISimpleReferenceResolver added in v0.8.0

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

An APISimpleReferenceResolver resolves references from one managed resource to others by calling the referencing resource's ResolveReferences method, if any.

func NewAPISimpleReferenceResolver added in v0.8.0

func NewAPISimpleReferenceResolver(c client.Client) *APISimpleReferenceResolver

NewAPISimpleReferenceResolver returns a ReferenceResolver that resolves references from one managed resource to others by calling the referencing resource's ResolveReferences method, if any.

func (*APISimpleReferenceResolver) ResolveReferences added in v0.8.0

func (a *APISimpleReferenceResolver) ResolveReferences(ctx context.Context, mg resource.Managed) error

ResolveReferences of the supplied managed resource by calling its ResolveReferences method, if any.

type ConnectionDetails

type ConnectionDetails map[string][]byte

ConnectionDetails created or updated during an operation on an external resource, for example usernames, passwords, endpoints, ports, etc.

type ConnectionDetailsFetcher added in v0.16.0

type ConnectionDetailsFetcher interface {
	FetchConnection(ctx context.Context, so resource.ConnectionSecretOwner) (ConnectionDetails, error)
}

A ConnectionDetailsFetcher fetches connection details for the supplied Connection Secret owner.

type ConnectionPublisher

type ConnectionPublisher interface {
	// PublishConnection details for the supplied Managed resource. Publishing
	// must be additive; i.e. if details (a, b, c) are published, subsequently
	// publicing details (b, c, d) should update (b, c) but not remove a.
	PublishConnection(ctx context.Context, so resource.ConnectionSecretOwner, c ConnectionDetails) (published bool, err error)

	// UnpublishConnection details for the supplied Managed resource.
	UnpublishConnection(ctx context.Context, so resource.ConnectionSecretOwner, c ConnectionDetails) error
}

A ConnectionPublisher manages the supplied ConnectionDetails for the supplied Managed resource. ManagedPublishers must handle the case in which the supplied ConnectionDetails are empty.

type ConnectionPublisherFns

type ConnectionPublisherFns struct {
	PublishConnectionFn   func(ctx context.Context, o resource.ConnectionSecretOwner, c ConnectionDetails) (bool, error)
	UnpublishConnectionFn func(ctx context.Context, o resource.ConnectionSecretOwner, c ConnectionDetails) error
}

ConnectionPublisherFns is the pluggable struct to produce objects with ConnectionPublisher interface.

func (ConnectionPublisherFns) PublishConnection

PublishConnection details for the supplied Managed resource.

func (ConnectionPublisherFns) UnpublishConnection

UnpublishConnection details for the supplied Managed resource.

type CriticalAnnotationUpdateFn added in v0.13.1

type CriticalAnnotationUpdateFn func(ctx context.Context, o client.Object) error

A CriticalAnnotationUpdateFn may be used when it is critical that annotations must be updated before returning from the Reconcile loop.

func (CriticalAnnotationUpdateFn) UpdateCriticalAnnotations added in v0.13.1

func (fn CriticalAnnotationUpdateFn) UpdateCriticalAnnotations(ctx context.Context, o client.Object) error

UpdateCriticalAnnotations of the supplied object.

type CriticalAnnotationUpdater added in v0.13.1

type CriticalAnnotationUpdater interface {
	UpdateCriticalAnnotations(ctx context.Context, o client.Object) error
}

A CriticalAnnotationUpdater is used when it is critical that annotations must be updated before returning from the Reconcile loop.

type DisabledSecretStoreManager added in v0.16.0

type DisabledSecretStoreManager struct{}

DisabledSecretStoreManager is a connection details manager that returns a proper error when API used but feature not enabled.

func (*DisabledSecretStoreManager) PublishConnection added in v0.16.0

PublishConnection returns a proper error when API used but the feature was not enabled.

func (*DisabledSecretStoreManager) UnpublishConnection added in v0.16.0

UnpublishConnection returns a proper error when API used but the feature was not enabled.

type ExternalClient

type ExternalClient interface {
	// Observe the external resource the supplied Managed resource
	// represents, if any. Observe implementations must not modify the
	// external resource, but may update the supplied Managed resource to
	// reflect the state of the external resource. Status modifications are
	// automatically persisted unless ResourceLateInitialized is true - see
	// ResourceLateInitialized for more detail.
	Observe(ctx context.Context, mg resource.Managed) (ExternalObservation, error)

	// Create an external resource per the specifications of the supplied
	// Managed resource. Called when Observe reports that the associated
	// external resource does not exist. Create implementations may update
	// managed resource annotations, and those updates will be persisted.
	// All other updates will be discarded.
	Create(ctx context.Context, mg resource.Managed) (ExternalCreation, error)

	// Update the external resource represented by the supplied Managed
	// resource, if necessary. Called unless Observe reports that the
	// associated external resource is up to date.
	Update(ctx context.Context, mg resource.Managed) (ExternalUpdate, error)

	// Delete the external resource upon deletion of its associated Managed
	// resource. Called when the managed resource has been deleted.
	Delete(ctx context.Context, mg resource.Managed) error
}

An ExternalClient manages the lifecycle of an external resource. None of the calls here should be blocking. All of the calls should be idempotent. For example, Create call should not return AlreadyExists error if it's called again with the same parameters or Delete call should not return error if there is an ongoing deletion or resource does not exist.

type ExternalClientFns

type ExternalClientFns struct {
	ObserveFn func(ctx context.Context, mg resource.Managed) (ExternalObservation, error)
	CreateFn  func(ctx context.Context, mg resource.Managed) (ExternalCreation, error)
	UpdateFn  func(ctx context.Context, mg resource.Managed) (ExternalUpdate, error)
	DeleteFn  func(ctx context.Context, mg resource.Managed) error
}

ExternalClientFns are a series of functions that satisfy the ExternalClient interface.

func (ExternalClientFns) Create

Create an external resource per the specifications of the supplied Managed resource.

func (ExternalClientFns) Delete

Delete the external resource upon deletion of its associated Managed resource.

func (ExternalClientFns) Observe

Observe the external resource the supplied Managed resource represents, if any.

func (ExternalClientFns) Update

Update the external resource represented by the supplied Managed resource, if necessary.

type ExternalConnectDisconnecter added in v0.16.0

type ExternalConnectDisconnecter interface {
	ExternalConnecter
	ExternalDisconnecter
}

An ExternalConnectDisconnecter produces a new ExternalClient given the supplied Managed resource.

func NewNopDisconnecter added in v0.16.0

func NewNopDisconnecter(c ExternalConnecter) ExternalConnectDisconnecter

NewNopDisconnecter converts an ExternalConnecter into an ExternalConnectDisconnecter with a no-op Disconnect method.

type ExternalConnectDisconnecterFns added in v0.16.0

type ExternalConnectDisconnecterFns struct {
	ConnectFn    func(ctx context.Context, mg resource.Managed) (ExternalClient, error)
	DisconnectFn func(ctx context.Context) error
}

ExternalConnectDisconnecterFns are functions that satisfy the ExternalConnectDisconnecter interface.

func (ExternalConnectDisconnecterFns) Connect added in v0.16.0

Connect to the provider specified by the supplied managed resource and produce an ExternalClient.

func (ExternalConnectDisconnecterFns) Disconnect added in v0.16.0

Disconnect from the provider and close the ExternalClient.

type ExternalConnecter

type ExternalConnecter interface {
	// Connect to the provider specified by the supplied managed resource and
	// produce an ExternalClient.
	Connect(ctx context.Context, mg resource.Managed) (ExternalClient, error)
}

An ExternalConnecter produces a new ExternalClient given the supplied Managed resource.

type ExternalConnectorFn

type ExternalConnectorFn func(ctx context.Context, mg resource.Managed) (ExternalClient, error)

An ExternalConnectorFn is a function that satisfies the ExternalConnecter interface.

func (ExternalConnectorFn) Connect

Connect to the provider specified by the supplied managed resource and produce an ExternalClient.

type ExternalCreation

type ExternalCreation struct {
	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails
}

An ExternalCreation is the result of the creation of an external resource.

type ExternalDisconnecter added in v0.16.0

type ExternalDisconnecter interface {
	// Disconnect from the provider and close the ExternalClient.
	Disconnect(ctx context.Context) error
}

An ExternalDisconnecter disconnects from a provider.

type ExternalDisconnectorFn added in v0.16.0

type ExternalDisconnectorFn func(ctx context.Context) error

An ExternalDisconnectorFn is a function that satisfies the ExternalConnecter interface.

func (ExternalDisconnectorFn) Disconnect added in v0.16.0

func (ed ExternalDisconnectorFn) Disconnect(ctx context.Context) error

Disconnect from provider and close the ExternalClient.

type ExternalObservation

type ExternalObservation struct {
	// ResourceExists must be true if a corresponding external resource exists
	// for the managed resource. Typically this is proven by the presence of an
	// external resource of the expected kind whose unique identifier matches
	// the managed resource's external name. Crossplane uses this information to
	// determine whether it needs to create or delete the external resource.
	ResourceExists bool

	// ResourceUpToDate should be true if the corresponding external resource
	// appears to be up-to-date - i.e. updating the external resource to match
	// the desired state of the managed resource would be a no-op. Keep in mind
	// that often only a subset of external resource fields can be updated.
	// Crossplane uses this information to determine whether it needs to update
	// the external resource.
	ResourceUpToDate bool

	// ResourceLateInitialized should be true if the managed resource's spec was
	// updated during its observation. A Crossplane provider may update a
	// managed resource's spec fields after it is created or updated, as long as
	// the updates are limited to setting previously unset fields, and adding
	// keys to maps. Crossplane uses this information to determine whether
	// changes to the spec were made during observation that must be persisted.
	// Note that changes to the spec will be persisted before changes to the
	// status, and that pending changes to the status may be lost when the spec
	// is persisted. Status changes will be persisted by the first subsequent
	// observation that _does not_ late initialize the managed resource, so it
	// is important that Observe implementations do not late initialize the
	// resource every time they are called.
	ResourceLateInitialized bool

	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails

	// Diff is a Debug level message that is sent to the reconciler when
	// there is a change in the observed Managed Resource. It is useful for
	// finding where the observed diverges from the desired state.
	// The string should be a cmp.Diff that details the difference.
	Diff string
}

An ExternalObservation is the result of an observation of an external resource.

type ExternalUpdate

type ExternalUpdate struct {
	// ConnectionDetails required to connect to this resource. These details
	// are a set that is collated throughout the managed resource's lifecycle -
	// i.e. returning new connection details will have no affect on old details
	// unless an existing key is overwritten. Crossplane may publish these
	// credentials to a store (e.g. a Secret).
	ConnectionDetails ConnectionDetails
}

An ExternalUpdate is the result of an update to an external resource.

type Initializer

type Initializer interface {
	Initialize(ctx context.Context, mg resource.Managed) error
}

A Initializer establishes ownership of the supplied Managed resource. This typically involves the operations that are run before calling any ExternalClient methods.

type InitializerChain

type InitializerChain []Initializer

A InitializerChain chains multiple managed initializers.

func (InitializerChain) Initialize

func (cc InitializerChain) Initialize(ctx context.Context, mg resource.Managed) error

Initialize calls each Initializer serially. It returns the first error it encounters, if any.

type InitializerFn

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

A InitializerFn is a function that satisfies the Initializer interface.

func (InitializerFn) Initialize

func (m InitializerFn) Initialize(ctx context.Context, mg resource.Managed) error

Initialize calls InitializerFn function.

type MRMetricRecorder added in v1.16.0

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

MRMetricRecorder records the lifecycle metrics of managed resources.

func NewMRMetricRecorder added in v1.16.0

func NewMRMetricRecorder() *MRMetricRecorder

NewMRMetricRecorder returns a new MRMetricRecorder which records metrics for managed resources.

func (*MRMetricRecorder) Collect added in v1.16.0

func (r *MRMetricRecorder) Collect(ch chan<- prometheus.Metric)

Collect is called by the Prometheus registry when collecting metrics. The implementation sends each collected metric via the provided channel and returns once the last metric has been sent.

func (*MRMetricRecorder) Describe added in v1.16.0

func (r *MRMetricRecorder) Describe(ch chan<- *prometheus.Desc)

Describe sends the super-set of all possible descriptors of metrics collected by this Collector to the provided channel and returns once the last descriptor has been sent.

type ManagementPoliciesChecker added in v0.20.0

type ManagementPoliciesChecker interface {
	// Validate validates the management policies.
	Validate() error
	// IsPaused returns true if the resource is paused based
	// on the management policy.
	IsPaused() bool

	// ShouldOnlyObserve returns true if only the Observe action is allowed.
	ShouldOnlyObserve() bool
	// ShouldCreate returns true if the Create action is allowed.
	ShouldCreate() bool
	// ShouldLateInitialize returns true if the LateInitialize action is
	// allowed.
	ShouldLateInitialize() bool
	// ShouldUpdate returns true if the Update action is allowed.
	ShouldUpdate() bool
	// ShouldDelete returns true if the Delete action is allowed.
	ShouldDelete() bool
}

ManagementPoliciesChecker is used to perform checks on management policies to determine specific actions are allowed, or if they are the only allowed action.

func NewManagementPoliciesResolver added in v0.20.0

func NewManagementPoliciesResolver(managementPolicyEnabled bool, managementPolicy xpv1.ManagementPolicies, deletionPolicy xpv1.DeletionPolicy, o ...ManagementPoliciesResolverOption) ManagementPoliciesChecker

NewManagementPoliciesResolver returns an ManagementPolicyChecker based on the management policies and if the management policies feature is enabled.

type ManagementPoliciesResolver added in v0.20.0

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

ManagementPoliciesResolver is used to perform management policy checks based on the management policy and if the management policy feature is enabled.

func (*ManagementPoliciesResolver) IsPaused added in v0.20.0

func (m *ManagementPoliciesResolver) IsPaused() bool

IsPaused returns true if the management policy is empty and the management policies feature is enabled.

func (*ManagementPoliciesResolver) ShouldCreate added in v0.20.0

func (m *ManagementPoliciesResolver) ShouldCreate() bool

ShouldCreate returns true if the Create action is allowed. If the management policy feature is disabled, it returns true.

func (*ManagementPoliciesResolver) ShouldDelete added in v0.20.0

func (m *ManagementPoliciesResolver) ShouldDelete() bool

ShouldDelete returns true based on the combination of the deletionPolicy and the managementPolicies. If the management policy feature is disabled, it returns true if the deletionPolicy is set to "Delete". Otherwise, it checks which field is set to a non-default value and makes a decision based on that. We need to be careful until we completely remove the deletionPolicy in favor of managementPolicies which conflict with the deletionPolicy regarding deleting of the external resource. This function implements the proposal in the Ignore Changes design doc under the "Deprecation of `deletionPolicy`".

func (*ManagementPoliciesResolver) ShouldLateInitialize added in v0.20.0

func (m *ManagementPoliciesResolver) ShouldLateInitialize() bool

ShouldLateInitialize returns true if the LateInitialize action is allowed. If the management policy feature is disabled, it returns true.

func (*ManagementPoliciesResolver) ShouldOnlyObserve added in v0.20.0

func (m *ManagementPoliciesResolver) ShouldOnlyObserve() bool

ShouldOnlyObserve returns true if the Observe action is allowed and all other actions are not allowed. If the management policy feature is disabled, it returns false.

func (*ManagementPoliciesResolver) ShouldUpdate added in v0.20.0

func (m *ManagementPoliciesResolver) ShouldUpdate() bool

ShouldUpdate returns true if the Update action is allowed. If the management policy feature is disabled, it returns true.

func (*ManagementPoliciesResolver) Validate added in v0.20.0

func (m *ManagementPoliciesResolver) Validate() error

Validate checks if the management policy is valid. If the management policy feature is disabled, but uses a non-default value, it returns an error. If the management policy feature is enabled, but uses a non-supported value, it returns an error.

type ManagementPoliciesResolverOption added in v0.20.0

type ManagementPoliciesResolverOption func(*ManagementPoliciesResolver)

A ManagementPoliciesResolverOption configures a ManagementPoliciesResolver.

func WithSupportedManagementPolicies added in v0.20.0

func WithSupportedManagementPolicies(supportedManagementPolicies []sets.Set[xpv1.ManagementAction]) ManagementPoliciesResolverOption

WithSupportedManagementPolicies sets the supported management policies.

type MetricRecorder added in v1.16.0

type MetricRecorder interface {
	Describe(ch chan<- *prometheus.Desc)
	Collect(ch chan<- prometheus.Metric)
	// contains filtered or unexported methods
}

MetricRecorder records the managed resource metrics.

type NameAsExternalName

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

NameAsExternalName writes the name of the managed resource to the external name annotation field in order to be used as name of the external resource in provider.

func NewNameAsExternalName

func NewNameAsExternalName(c client.Client) *NameAsExternalName

NewNameAsExternalName returns a new NameAsExternalName.

func (*NameAsExternalName) Initialize

func (a *NameAsExternalName) Initialize(ctx context.Context, mg resource.Managed) error

Initialize the given managed resource.

type NopClient

type NopClient struct{}

A NopClient does nothing.

func (*NopClient) Create

Create does nothing. It returns an empty ExternalCreation and no error.

func (*NopClient) Delete

func (c *NopClient) Delete(_ context.Context, _ resource.Managed) error

Delete does nothing. It never returns an error.

func (*NopClient) Observe

Observe does nothing. It returns an empty ExternalObservation and no error.

func (*NopClient) Update

Update does nothing. It returns an empty ExternalUpdate and no error.

type NopConnecter

type NopConnecter struct{}

A NopConnecter does nothing.

func (*NopConnecter) Connect

Connect returns a NopClient. It never returns an error.

type NopDisconnecter added in v0.16.0

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

A NopDisconnecter converts an ExternalConnecter into an ExternalConnectDisconnecter with a no-op Disconnect method.

func (*NopDisconnecter) Connect added in v0.16.0

Connect calls the underlying ExternalConnecter's Connect method.

func (*NopDisconnecter) Disconnect added in v0.16.0

func (c *NopDisconnecter) Disconnect(_ context.Context) error

Disconnect does nothing. It never returns an error.

type NopMetricRecorder added in v1.16.0

type NopMetricRecorder struct{}

A NopMetricRecorder does nothing.

func NewNopMetricRecorder added in v1.16.0

func NewNopMetricRecorder() *NopMetricRecorder

NewNopMetricRecorder returns a MRMetricRecorder that does nothing.

func (*NopMetricRecorder) Collect added in v1.16.0

func (r *NopMetricRecorder) Collect(_ chan<- prometheus.Metric)

Collect does nothing.

func (*NopMetricRecorder) Describe added in v1.16.0

func (r *NopMetricRecorder) Describe(_ chan<- *prometheus.Desc)

Describe does nothing.

type PollIntervalHook added in v1.14.0

type PollIntervalHook func(managed resource.Managed, pollInterval time.Duration) time.Duration

PollIntervalHook represents the function type passed to the WithPollIntervalHook option to support dynamic computation of the poll interval.

type PublisherChain

type PublisherChain []ConnectionPublisher

A PublisherChain chains multiple ManagedPublishers.

func (PublisherChain) PublishConnection

PublishConnection calls each ConnectionPublisher.PublishConnection serially. It returns the first error it encounters, if any.

func (PublisherChain) UnpublishConnection

UnpublishConnection calls each ConnectionPublisher.UnpublishConnection serially. It returns the first error it encounters, if any.

type Reconciler

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

A Reconciler reconciles managed resources by creating and managing the lifecycle of an external resource, i.e. a resource in an external system such as a cloud provider API. Each controller must watch the managed resource kind for which it is responsible.

func NewReconciler

func NewReconciler(m manager.Manager, of resource.ManagedKind, o ...ReconcilerOption) *Reconciler

NewReconciler returns a Reconciler that reconciles managed resources of the supplied ManagedKind with resources in an external system such as a cloud provider API. It panics if asked to reconcile a managed resource kind that is not registered with the supplied manager's runtime.Scheme. The returned Reconciler reconciles with a dummy, no-op 'external system' by default; callers should supply an ExternalConnector that returns an ExternalClient capable of managing resources in a real system.

func (*Reconciler) Reconcile

func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (result reconcile.Result, err error)

Reconcile a managed resource with an external resource.

type ReconcilerOption

type ReconcilerOption func(*Reconciler)

A ReconcilerOption configures a Reconciler.

func WithConnectionPublishers

func WithConnectionPublishers(p ...ConnectionPublisher) ReconcilerOption

WithConnectionPublishers specifies how the Reconciler should publish its connection details such as credentials and endpoints.

func WithCreationGracePeriod added in v0.13.1

func WithCreationGracePeriod(d time.Duration) ReconcilerOption

WithCreationGracePeriod configures an optional period during which we will wait for the external API to report that a newly created external resource exists. This allows us to tolerate eventually consistent APIs that do not immediately report that newly created resources exist when queried. All resources have a 30 second grace period by default.

func WithCriticalAnnotationUpdater added in v0.13.1

func WithCriticalAnnotationUpdater(u CriticalAnnotationUpdater) ReconcilerOption

WithCriticalAnnotationUpdater specifies how the Reconciler should update a managed resource's critical annotations. Implementations typically contain some kind of retry logic to increase the likelihood that critical annotations (like non-deterministic external names) will be persisted.

func WithExternalConnectDisconnecter added in v0.16.0

func WithExternalConnectDisconnecter(c ExternalConnectDisconnecter) ReconcilerOption

WithExternalConnectDisconnecter specifies how the Reconciler should connect and disconnect to the API used to sync and delete external resources.

func WithExternalConnecter

func WithExternalConnecter(c ExternalConnecter) ReconcilerOption

WithExternalConnecter specifies how the Reconciler should connect to the API used to sync and delete external resources.

func WithFinalizer

func WithFinalizer(f resource.Finalizer) ReconcilerOption

WithFinalizer specifies how the Reconciler should add and remove finalizers to and from the managed resource.

func WithInitializers

func WithInitializers(i ...Initializer) ReconcilerOption

WithInitializers specifies how the Reconciler should initialize a managed resource before calling any of the ExternalClient functions.

func WithLogger

func WithLogger(l logging.Logger) ReconcilerOption

WithLogger specifies how the Reconciler should log messages.

func WithManagementPolicies added in v0.20.0

func WithManagementPolicies() ReconcilerOption

WithManagementPolicies enables support for management policies.

func WithMetricRecorder added in v1.16.0

func WithMetricRecorder(recorder MetricRecorder) ReconcilerOption

WithMetricRecorder configures the Reconciler to use the supplied MetricRecorder.

func WithPollInterval added in v0.13.0

func WithPollInterval(after time.Duration) ReconcilerOption

WithPollInterval specifies how long the Reconciler should wait before queueing a new reconciliation after a successful reconcile. The Reconciler requeues after a specified duration when it is not actively waiting for an external operation, but wishes to check whether an existing external resource needs to be synced to its Crossplane Managed resource.

func WithPollIntervalHook added in v1.14.0

func WithPollIntervalHook(hook PollIntervalHook) ReconcilerOption

WithPollIntervalHook adds a hook that can be used to configure the delay before an up-to-date resource is reconciled again after a successful reconcile. If this option is passed multiple times, only the latest hook will be used.

func WithPollJitterHook added in v1.14.0

func WithPollJitterHook(jitter time.Duration) ReconcilerOption

WithPollJitterHook adds a simple PollIntervalHook to add jitter to the poll interval used when queuing a new reconciliation after a successful reconcile. The added jitter will be a random duration between -jitter and +jitter. This option wraps WithPollIntervalHook, and is subject to the same constraint that only the latest hook will be used.

func WithReconcilerSupportedManagementPolicies added in v0.20.0

func WithReconcilerSupportedManagementPolicies(supported []sets.Set[xpv1.ManagementAction]) ReconcilerOption

WithReconcilerSupportedManagementPolicies configures which management policies are supported by the reconciler.

func WithRecorder

func WithRecorder(er event.Recorder) ReconcilerOption

WithRecorder specifies how the Reconciler should record events.

func WithReferenceResolver

func WithReferenceResolver(rr ReferenceResolver) ReconcilerOption

WithReferenceResolver specifies how the Reconciler should resolve any inter-resource references it encounters while reconciling managed resources.

func WithTimeout

func WithTimeout(duration time.Duration) ReconcilerOption

WithTimeout specifies the timeout duration cumulatively for all the calls happen in the reconciliation function. In case the deadline exceeds, reconciler will still have some time to make the necessary calls to report the error such as status update.

type ReferenceResolver

type ReferenceResolver interface {
	// ResolveReferences resolves all fields in the supplied managed resource
	// that are references to other managed resources by updating corresponding
	// fields, for example setting spec.network to the Network resource
	// specified by spec.networkRef.name.
	ResolveReferences(ctx context.Context, mg resource.Managed) error
}

A ReferenceResolver resolves references to other managed resources.

type ReferenceResolverFn

type ReferenceResolverFn func(context.Context, resource.Managed) error

A ReferenceResolverFn is a function that satisfies the ReferenceResolver interface.

func (ReferenceResolverFn) ResolveReferences

func (m ReferenceResolverFn) ResolveReferences(ctx context.Context, mg resource.Managed) error

ResolveReferences calls ReferenceResolverFn function.

type RetryingCriticalAnnotationUpdater added in v0.13.1

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

A RetryingCriticalAnnotationUpdater is a CriticalAnnotationUpdater that retries annotation updates in the face of API server errors.

func NewRetryingCriticalAnnotationUpdater added in v0.13.1

func NewRetryingCriticalAnnotationUpdater(c client.Client) *RetryingCriticalAnnotationUpdater

NewRetryingCriticalAnnotationUpdater returns a CriticalAnnotationUpdater that retries annotation updates in the face of API server errors.

func (*RetryingCriticalAnnotationUpdater) UpdateCriticalAnnotations added in v0.13.1

func (u *RetryingCriticalAnnotationUpdater) UpdateCriticalAnnotations(ctx context.Context, o client.Object) error

UpdateCriticalAnnotations updates (i.e. persists) the annotations of the supplied Object. It retries in the face of any API server error several times in order to ensure annotations that contain critical state are persisted. Pending changes to the supplied Object's spec, status, or other metadata might get reset to their current state according to the API server, e.g. in case of a conflict error.

Jump to

Keyboard shortcuts

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