limiter

Documentation

Index

• func NewLimiterWrapper(conLimit ConcurrencyLimiter, qpsLimit RateLimiter) limit.Updater
• type ConcurrencyLimiter
  • func NewConcurrencyLimiter(lim int) ConcurrencyLimiter
• type DummyConcurrencyLimiter
  • func (dcl *DummyConcurrencyLimiter) Acquire(ctx context.Context) bool
  • func (dcl *DummyConcurrencyLimiter) Release(ctx context.Context)
  • func (dcl *DummyConcurrencyLimiter) Status(ctx context.Context) (limit, occupied int)
• type DummyRateLimiter
  • func (drl *DummyRateLimiter) Acquire(ctx context.Context) bool
  • func (drl *DummyRateLimiter) Status(ctx context.Context) (max, current int, interval time.Duration)
• type LimitReporter
• type RateLimiter
  • func NewQPSLimiter(interval time.Duration, limit int) RateLimiter
• type Updatable

Functions

func NewLimiterWrapper

func NewLimiterWrapper(conLimit ConcurrencyLimiter, qpsLimit RateLimiter) limit.Updater

NewLimiterWrapper wraps the given ConcurrencyLimiter and RateLimiter into a limit.Updater.

Types

type ConcurrencyLimiter

type ConcurrencyLimiter interface {
	// Acquire reports if next access to the protected resource is allowed.
	Acquire(ctx context.Context) bool

	// Release claims a previous taken access has released the resource.
	Release(ctx context.Context)

	// Status returns the total quota and occupied.
	Status(ctx context.Context) (limit, occupied int)
}

ConcurrencyLimiter limits the number of concurrent access towards the protected resource. The implementation of ConcurrencyLimiter should be concurrent safe.

func NewConcurrencyLimiter

func NewConcurrencyLimiter(lim int) ConcurrencyLimiter

NewConcurrencyLimiter returns a new ConcurrencyLimiter with the given limit.

type DummyConcurrencyLimiter

type DummyConcurrencyLimiter struct{}

DummyConcurrencyLimiter implements ConcurrencyLimiter but without actual limitation.

func (*DummyConcurrencyLimiter) Acquire

func (dcl *DummyConcurrencyLimiter) Acquire(ctx context.Context) bool

Acquire .

func (*DummyConcurrencyLimiter) Release

func (dcl *DummyConcurrencyLimiter) Release(ctx context.Context)

Release .

func (*DummyConcurrencyLimiter) Status

func (dcl *DummyConcurrencyLimiter) Status(ctx context.Context) (limit, occupied int)

Status .

type DummyRateLimiter

type DummyRateLimiter struct{}

DummyRateLimiter implements RateLimiter but without actual limitation.

func (*DummyRateLimiter) Acquire

func (drl *DummyRateLimiter) Acquire(ctx context.Context) bool

Acquire .

func (*DummyRateLimiter) Status

func (drl *DummyRateLimiter) Status(ctx context.Context) (max, current int, interval time.Duration)

Status .

type LimitReporter

type LimitReporter interface {
	ConnOverloadReport()
	QPSOverloadReport()
}

LimitReporter is the interface define to report(metric or print log) when limit happen

type RateLimiter

type RateLimiter interface {
	// Acquire reports if next access to the protected resource is allowed.
	Acquire(ctx context.Context) bool

	// Status returns the rate limit.
	Status(ctx context.Context) (max, current int, interval time.Duration)
}

RateLimiter limits the access rate towards the protected resource.

func NewQPSLimiter

func NewQPSLimiter(interval time.Duration, limit int) RateLimiter

NewQPSLimiter creates qpsLimiter.

type Updatable

type Updatable interface {
	UpdateLimit(limit int)
}

Updatable is a kind of limiters that support changing the limit dynamically. Note that `UpdateLimit` does not guarantee to be concurrent-safe.