client-go: k8s.io/client-go/util/workqueue Index | Files

package workqueue

import "k8s.io/client-go/util/workqueue"

Package workqueue provides a simple queue that supports the following features:

* Fair: items processed in the order in which they are added.
* Stingy: a single item will not be processed multiple times concurrently,
    and if an item is added multiple times before it can be processed, it
    will only be processed once.
* Multiple consumers and producers. In particular, it is allowed for an
    item to be reenqueued while it is being processed.
* Shutdown notifications.

Index

Package Files

default_rate_limiters.go delaying_queue.go doc.go metrics.go parallelizer.go queue.go rate_limitting_queue.go

func Parallelize Uses

func Parallelize(workers, pieces int, doWorkPiece DoWorkPieceFunc)

Parallelize is a very simple framework that allow for parallelizing N independent pieces of work.

func SetProvider Uses

func SetProvider(metricsProvider MetricsProvider)

SetProvider sets the metrics provider of the metricsFactory.

type BucketRateLimiter Uses

type BucketRateLimiter struct {
    *rate.Limiter
}

BucketRateLimiter adapts a standard bucket to the workqueue ratelimiter API

func (*BucketRateLimiter) Forget Uses

func (r *BucketRateLimiter) Forget(item interface{})

func (*BucketRateLimiter) NumRequeues Uses

func (r *BucketRateLimiter) NumRequeues(item interface{}) int

func (*BucketRateLimiter) When Uses

func (r *BucketRateLimiter) When(item interface{}) time.Duration

type CounterMetric Uses

type CounterMetric interface {
    Inc()
}

CounterMetric represents a single numerical value that only ever goes up.

type DelayingInterface Uses

type DelayingInterface interface {
    Interface
    // AddAfter adds an item to the workqueue after the indicated duration has passed
    AddAfter(item interface{}, duration time.Duration)
}

DelayingInterface is an Interface that can Add an item at a later time. This makes it easier to requeue items after failures without ending up in a hot-loop.

func NewDelayingQueue Uses

func NewDelayingQueue() DelayingInterface

NewDelayingQueue constructs a new workqueue with delayed queuing ability

func NewNamedDelayingQueue Uses

func NewNamedDelayingQueue(name string) DelayingInterface

type DoWorkPieceFunc Uses

type DoWorkPieceFunc func(piece int)

type GaugeMetric Uses

type GaugeMetric interface {
    Inc()
    Dec()
}

GaugeMetric represents a single numerical value that can arbitrarily go up and down.

type Interface Uses

type Interface interface {
    Add(item interface{})
    Len() int
    Get() (item interface{}, shutdown bool)
    Done(item interface{})
    ShutDown()
    ShuttingDown() bool
}

type ItemExponentialFailureRateLimiter Uses

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

ItemExponentialFailureRateLimiter does a simple baseDelay*10^<num-failures> limit dealing with max failures and expiration are up to the caller

func (*ItemExponentialFailureRateLimiter) Forget Uses

func (r *ItemExponentialFailureRateLimiter) Forget(item interface{})

func (*ItemExponentialFailureRateLimiter) NumRequeues Uses

func (r *ItemExponentialFailureRateLimiter) NumRequeues(item interface{}) int

func (*ItemExponentialFailureRateLimiter) When Uses

func (r *ItemExponentialFailureRateLimiter) When(item interface{}) time.Duration

type ItemFastSlowRateLimiter Uses

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

ItemFastSlowRateLimiter does a quick retry for a certain number of attempts, then a slow retry after that

func (*ItemFastSlowRateLimiter) Forget Uses

func (r *ItemFastSlowRateLimiter) Forget(item interface{})

func (*ItemFastSlowRateLimiter) NumRequeues Uses

func (r *ItemFastSlowRateLimiter) NumRequeues(item interface{}) int

func (*ItemFastSlowRateLimiter) When Uses

func (r *ItemFastSlowRateLimiter) When(item interface{}) time.Duration

type MaxOfRateLimiter Uses

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

MaxOfRateLimiter calls every RateLimiter and returns the worst case response When used with a token bucket limiter, the burst could be apparently exceeded in cases where particular items were separately delayed a longer time.

func (*MaxOfRateLimiter) Forget Uses

func (r *MaxOfRateLimiter) Forget(item interface{})

func (*MaxOfRateLimiter) NumRequeues Uses

func (r *MaxOfRateLimiter) NumRequeues(item interface{}) int

func (*MaxOfRateLimiter) When Uses

func (r *MaxOfRateLimiter) When(item interface{}) time.Duration

type MetricsProvider Uses

type MetricsProvider interface {
    NewDepthMetric(name string) GaugeMetric
    NewAddsMetric(name string) CounterMetric
    NewLatencyMetric(name string) SummaryMetric
    NewWorkDurationMetric(name string) SummaryMetric
    NewRetriesMetric(name string) CounterMetric
}

MetricsProvider generates various metrics used by the queue.

type RateLimiter Uses

type RateLimiter interface {
    // When gets an item and gets to decide how long that item should wait
    When(item interface{}) time.Duration
    // Forget indicates that an item is finished being retried.  Doesn't matter whether its for perm failing
    // or for success, we'll stop tracking it
    Forget(item interface{})
    // NumRequeues returns back how many failures the item has had
    NumRequeues(item interface{}) int
}

func DefaultControllerRateLimiter Uses

func DefaultControllerRateLimiter() RateLimiter

DefaultControllerRateLimiter is a no-arg constructor for a default rate limiter for a workqueue. It has both overall and per-item rate limitting. The overall is a token bucket and the per-item is exponential

func DefaultItemBasedRateLimiter Uses

func DefaultItemBasedRateLimiter() RateLimiter

func NewItemExponentialFailureRateLimiter Uses

func NewItemExponentialFailureRateLimiter(baseDelay time.Duration, maxDelay time.Duration) RateLimiter

func NewItemFastSlowRateLimiter Uses

func NewItemFastSlowRateLimiter(fastDelay, slowDelay time.Duration, maxFastAttempts int) RateLimiter

func NewMaxOfRateLimiter Uses

func NewMaxOfRateLimiter(limiters ...RateLimiter) RateLimiter

type RateLimitingInterface Uses

type RateLimitingInterface interface {
    DelayingInterface

    // AddRateLimited adds an item to the workqueue after the rate limiter says its ok
    AddRateLimited(item interface{})

    // Forget indicates that an item is finished being retried.  Doesn't matter whether its for perm failing
    // or for success, we'll stop the rate limiter from tracking it.  This only clears the `rateLimiter`, you
    // still have to call `Done` on the queue.
    Forget(item interface{})

    // NumRequeues returns back how many times the item was requeued
    NumRequeues(item interface{}) int
}

RateLimitingInterface is an interface that rate limits items being added to the queue.

func NewNamedRateLimitingQueue Uses

func NewNamedRateLimitingQueue(rateLimiter RateLimiter, name string) RateLimitingInterface

func NewRateLimitingQueue Uses

func NewRateLimitingQueue(rateLimiter RateLimiter) RateLimitingInterface

NewRateLimitingQueue constructs a new workqueue with rateLimited queuing ability Remember to call Forget! If you don't, you may end up tracking failures forever.

type SummaryMetric Uses

type SummaryMetric interface {
    Observe(float64)
}

SummaryMetric captures individual observations.

type Type Uses

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

Type is a work queue (see the package comment).

func New Uses

func New() *Type

New constructs a new work queue (see the package comment).

func NewNamed Uses

func NewNamed(name string) *Type

func (*Type) Add Uses

func (q *Type) Add(item interface{})

Add marks item as needing processing.

func (*Type) Done Uses

func (q *Type) Done(item interface{})

Done marks item as done processing, and if it has been marked as dirty again while it was being processed, it will be re-added to the queue for re-processing.

func (*Type) Get Uses

func (q *Type) Get() (item interface{}, shutdown bool)

Get blocks until it can return an item to be processed. If shutdown = true, the caller should end their goroutine. You must call Done with item when you have finished processing it.

func (*Type) Len Uses

func (q *Type) Len() int

Len returns the current queue length, for informational purposes only. You shouldn't e.g. gate a call to Add() or Get() on Len() being a particular value, that can't be synchronized properly.

func (*Type) ShutDown Uses

func (q *Type) ShutDown()

ShutDown will cause q to ignore all new items added to it. As soon as the worker goroutines have drained the existing items in the queue, they will be instructed to exit.

func (*Type) ShuttingDown Uses

func (q *Type) ShuttingDown() bool

Package workqueue imports 7 packages (graph) and is imported by 452 packages. Updated 2018-03-15. Refresh now. Tools for package owners.