ratelimiter

Documentation

Overview

Package ratelimiter contains suggested default ratelimiters for Crossplane.

Index

• func LimitRESTConfig(cfg *rest.Config, rps int) *rest.Config
• type BucketRateLimiter
  • func NewGlobal(rps int) *BucketRateLimiter
• type ControllerRateLimiter
  • func NewController() ControllerRateLimiter
• type RateLimiter
• type Reconciler
  • func NewReconciler(name string, r reconcile.Reconciler, l RateLimiter) *Reconciler
  • func (r *Reconciler) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error)

Functions

func LimitRESTConfig

func LimitRESTConfig(cfg *rest.Config, rps int) *rest.Config

LimitRESTConfig returns a copy of the supplied REST config with rate limits derived from the supplied rate of reconciles per second.

Types

type BucketRateLimiter

type BucketRateLimiter = workqueue.TypedBucketRateLimiter[string]

BucketRateLimiter for a standard crossplane reconciler.

func NewGlobal

func NewGlobal(rps int) *BucketRateLimiter

NewGlobal returns a token bucket rate limiter meant for limiting the number of average total requeues per second for all controllers registered with a controller manager. The bucket size (i.e. allowed burst) is rps * 10.

type ControllerRateLimiter

type ControllerRateLimiter = workqueue.TypedRateLimiter[reconcile.Request]

ControllerRateLimiter to work with sigs.k8s.io/controller-runtime/pkg/controller.Options.

func NewController

func NewController() ControllerRateLimiter

NewController returns a rate limiter that takes the maximum delay between the passed rate limiter and a per-item exponential backoff limiter. The exponential backoff limiter has a base delay of 1s and a maximum of 60s.

type RateLimiter

type RateLimiter = workqueue.TypedRateLimiter[string]

RateLimiter for a standard crossplane reconciler.

type Reconciler

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

A Reconciler rate limits an inner, wrapped Reconciler. Requests that are rate limited immediately return RequeueAfter: d without calling the wrapped Reconciler, where d is imposed by the rate limiter.

func NewReconciler

func NewReconciler(name string, r reconcile.Reconciler, l RateLimiter) *Reconciler

NewReconciler wraps the supplied Reconciler, ensuring requests are passed to it no more frequently than the supplied RateLimiter allows. Multiple uniquely named Reconcilers can share the same RateLimiter.

func (*Reconciler) Reconcile

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

Reconcile the supplied request subject to rate limiting.