quotas

Documentation

Overview

Package quotas is a generated GoMock package.

Package quotas is a generated GoMock package.

Index

• type Collection
  • func NewCollection(factory LimiterFactory) *Collection
  • func (c *Collection) For(key string) Limiter
• type DynamicRateLimiter
  • func NewDynamicRateLimiter(rps RPSFunc) *DynamicRateLimiter
  • func (d *DynamicRateLimiter) Allow() bool
  • func (d *DynamicRateLimiter) Limit() rate.Limit
  • func (d *DynamicRateLimiter) Reserve() clock.Reservation
  • func (d *DynamicRateLimiter) Wait(ctx context.Context) error
• type ICollection
• type Info
• type Limiter
• type LimiterFactory
  • func NewFallbackDynamicRateLimiterFactory(primary dynamicconfig.IntPropertyFnWithDomainFilter, ...) LimiterFactory
  • func NewSimpleDynamicRateLimiterFactory(rps dynamicconfig.IntPropertyFnWithDomainFilter) LimiterFactory
• type MockLimiter
  • func NewMockLimiter(ctrl *gomock.Controller) *MockLimiter
  • func (m *MockLimiter) Allow() bool
  • func (m *MockLimiter) EXPECT() *MockLimiterMockRecorder
  • func (m *MockLimiter) Limit() rate.Limit
  • func (m *MockLimiter) Reserve() clock.Reservation
  • func (m *MockLimiter) Wait(arg0 context.Context) error
• type MockLimiterFactory
  • func NewMockLimiterFactory(ctrl *gomock.Controller) *MockLimiterFactory
  • func (m *MockLimiterFactory) EXPECT() *MockLimiterFactoryMockRecorder
  • func (m *MockLimiterFactory) GetLimiter(arg0 string) Limiter
• type MockLimiterFactoryMockRecorder
  • func (mr *MockLimiterFactoryMockRecorder) GetLimiter(arg0 interface{}) *gomock.Call
• type MockLimiterMockRecorder
  • func (mr *MockLimiterMockRecorder) Allow() *gomock.Call
  • func (mr *MockLimiterMockRecorder) Limit() *gomock.Call
  • func (mr *MockLimiterMockRecorder) Reserve() *gomock.Call
  • func (mr *MockLimiterMockRecorder) Wait(arg0 interface{}) *gomock.Call
• type MultiStageRateLimiter
  • func NewMultiStageRateLimiter(global Limiter, domainLimiters ICollection) *MultiStageRateLimiter
  • func (d *MultiStageRateLimiter) Allow(info Info) (allowed bool)
• type Policy
• type RPSFunc
• type RPSKeyFunc
• type RateLimiter
  • func NewRateLimiter(maxDispatchPerSecond *float64, ttl time.Duration, minBurst int) *RateLimiter
  • func NewSimpleRateLimiter(t *testing.T, rps int) *RateLimiter
  • func (rl *RateLimiter) Allow() bool
  • func (rl *RateLimiter) Limit() rate.Limit
  • func (rl *RateLimiter) Reserve() clock.Reservation
  • func (rl *RateLimiter) UpdateMaxDispatch(maxDispatchPerSecond *float64)
  • func (rl *RateLimiter) Wait(ctx context.Context) error

Types

type Collection

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

Collection stores a map of limiters by key

func NewCollection

func NewCollection(factory LimiterFactory) *Collection

NewCollection create a new limiter collection. Given factory is called to create new individual limiter.

func (*Collection) For

func (c *Collection) For(key string) Limiter

For retrieves limiter by a given key. If limiter for such key does not exists, it creates new one with via factory.

type DynamicRateLimiter

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

DynamicRateLimiter implements a dynamic config wrapper around the rate limiter, checks for updates to the dynamic config and updates the rate limiter accordingly

func NewDynamicRateLimiter

func NewDynamicRateLimiter(rps RPSFunc) *DynamicRateLimiter

NewDynamicRateLimiter returns a rate limiter which handles dynamic config

func (*DynamicRateLimiter) Allow

func (d *DynamicRateLimiter) Allow() bool

Allow immediately returns with true or false indicating if a rate limit token is available or not

func (*DynamicRateLimiter) Limit

func (d *DynamicRateLimiter) Limit() rate.Limit

func (*DynamicRateLimiter) Reserve

func (d *DynamicRateLimiter) Reserve() clock.Reservation

Reserve reserves a rate limit token

func (*DynamicRateLimiter) Wait

func (d *DynamicRateLimiter) Wait(ctx context.Context) error

Wait waits up till deadline for a rate limit token

type ICollection

type ICollection interface {
	For(key string) Limiter
}

type Info

type Info struct {
	Domain string
}

Info corresponds to information required to determine rate limits

type Limiter

type Limiter interface {
	// Allow attempts to allow a request to go through. The method returns
	// immediately with a true or false indicating if the request can make
	// progress
	Allow() bool

	// Wait waits till the deadline for a rate limit token to allow the request
	// to go through.
	Wait(ctx context.Context) error

	// Reserve reserves a rate limit token
	Reserve() clock.Reservation

	// Limit returns the current configured ratelimit.
	//
	// If this Limiter wraps multiple values, this is generally the "most relevant" one,
	// i.e. the one that is most likely to apply to the next request
	Limit() rate.Limit
}

Limiter corresponds to basic rate limiting functionality.

TODO: This can likely be replaced with clock.Ratelimiter, now that it exists, but it is being left as a read-only mirror for now as only these methods are currently needed in areas that currently use this Limiter.

type LimiterFactory

type LimiterFactory interface {
	// GetLimiter returns a new Limiter for the given domain
	GetLimiter(domain string) Limiter
}

LimiterFactory is used to create a Limiter for a given domain

func NewFallbackDynamicRateLimiterFactory

func NewFallbackDynamicRateLimiterFactory(
	primary dynamicconfig.IntPropertyFnWithDomainFilter,
	secondary dynamicconfig.IntPropertyFn,
) LimiterFactory

LimiterFactory is used to create a Limiter for a given domain the created Limiter will use the primary dynamic config if it is set otherwise it will use the secondary dynamic config

func NewSimpleDynamicRateLimiterFactory

func NewSimpleDynamicRateLimiterFactory(rps dynamicconfig.IntPropertyFnWithDomainFilter) LimiterFactory

NewSimpleDynamicRateLimiterFactory creates a new LimiterFactory which creates a new DynamicRateLimiter for each domain, the RPS for the DynamicRateLimiter is given by the dynamic config

type MockLimiter

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

MockLimiter is a mock of Limiter interface.

func NewMockLimiter

func NewMockLimiter(ctrl *gomock.Controller) *MockLimiter

NewMockLimiter creates a new mock instance.

func (*MockLimiter) Allow

func (m *MockLimiter) Allow() bool

Allow mocks base method.

func (*MockLimiter) EXPECT

func (m *MockLimiter) EXPECT() *MockLimiterMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockLimiter) Limit

func (m *MockLimiter) Limit() rate.Limit

Limit mocks base method.

func (*MockLimiter) Reserve

func (m *MockLimiter) Reserve() clock.Reservation

Reserve mocks base method.

func (*MockLimiter) Wait

func (m *MockLimiter) Wait(arg0 context.Context) error

Wait mocks base method.

type MockLimiterFactory

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

MockLimiterFactory is a mock of LimiterFactory interface.

func NewMockLimiterFactory

func NewMockLimiterFactory(ctrl *gomock.Controller) *MockLimiterFactory

NewMockLimiterFactory creates a new mock instance.

func (*MockLimiterFactory) EXPECT

func (m *MockLimiterFactory) EXPECT() *MockLimiterFactoryMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockLimiterFactory) GetLimiter

func (m *MockLimiterFactory) GetLimiter(arg0 string) Limiter

GetLimiter mocks base method.

type MockLimiterFactoryMockRecorder

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

MockLimiterFactoryMockRecorder is the mock recorder for MockLimiterFactory.

func (*MockLimiterFactoryMockRecorder) GetLimiter

func (mr *MockLimiterFactoryMockRecorder) GetLimiter(arg0 interface{}) *gomock.Call

GetLimiter indicates an expected call of GetLimiter.

type MockLimiterMockRecorder

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

MockLimiterMockRecorder is the mock recorder for MockLimiter.

func (*MockLimiterMockRecorder) Allow

func (mr *MockLimiterMockRecorder) Allow() *gomock.Call

Allow indicates an expected call of Allow.

func (*MockLimiterMockRecorder) Limit

func (mr *MockLimiterMockRecorder) Limit() *gomock.Call

Limit indicates an expected call of Limit.

func (*MockLimiterMockRecorder) Reserve

func (mr *MockLimiterMockRecorder) Reserve() *gomock.Call

Reserve indicates an expected call of Reserve.

func (*MockLimiterMockRecorder) Wait

func (mr *MockLimiterMockRecorder) Wait(arg0 interface{}) *gomock.Call

Wait indicates an expected call of Wait.

type MultiStageRateLimiter

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

MultiStageRateLimiter indicates a domain specific rate limit policy

func NewMultiStageRateLimiter

func NewMultiStageRateLimiter(global Limiter, domainLimiters ICollection) *MultiStageRateLimiter

NewMultiStageRateLimiter returns a new domain quota rate limiter. This is about an order of magnitude slower than

func (*MultiStageRateLimiter) Allow

func (d *MultiStageRateLimiter) Allow(info Info) (allowed bool)

Allow attempts to allow a request to go through. The method returns immediately with a true or false indicating if the request can make progress

type Policy

type Policy interface {
	// Allow attempts to allow a request to go through. The method returns
	// immediately with a true or false indicating if the request can make
	// progress
	Allow(info Info) bool
}

Policy corresponds to a quota policy. A policy allows implementing layered and more complex rate limiting functionality.

type RPSFunc

type RPSFunc func() float64

RPSFunc returns a float64 as the RPS

type RPSKeyFunc

type RPSKeyFunc func(key string) float64

RPSKeyFunc returns a float64 as the RPS for the given key

type RateLimiter

type RateLimiter struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

RateLimiter is a wrapper around the golang rate limiter handling dynamic configuration updates of the max dispatch per second. This has comparable performance to the token bucket rate limiter. BenchmarkSimpleRateLimiter-4 10000000 114 ns/op (tokenbucket) BenchmarkRateLimiter-4 10000000 148 ns/op (this)

func NewRateLimiter

func NewRateLimiter(maxDispatchPerSecond *float64, ttl time.Duration, minBurst int) *RateLimiter

NewRateLimiter returns a new rate limiter that can handle dynamic configuration updates

func NewSimpleRateLimiter

func NewSimpleRateLimiter(t *testing.T, rps int) *RateLimiter

NewSimpleRateLimiter returns a new rate limiter backed by the golang rate limiter. This is currently only used in tests.

func (*RateLimiter) Allow

func (rl *RateLimiter) Allow() bool

Allow immediately returns with true or false indicating if a rate limit token is available or not

func (*RateLimiter) Limit

func (rl *RateLimiter) Limit() rate.Limit

Limit returns the current rate per second limit for this ratelimiter

func (*RateLimiter) Reserve

func (rl *RateLimiter) Reserve() clock.Reservation

Reserve reserves a rate limit token

func (*RateLimiter) UpdateMaxDispatch

func (rl *RateLimiter) UpdateMaxDispatch(maxDispatchPerSecond *float64)

UpdateMaxDispatch updates the max dispatch rate of the rate limiter

func (*RateLimiter) Wait

func (rl *RateLimiter) Wait(ctx context.Context) error

Wait waits up till deadline for a rate limit token