limiter

type BatchApi ¶

type BatchApi interface {
	// MaxPerBatch is the max number of ids to call per `Do` (zero implies no limit).
	MaxPerBatch() int

	// Do the batch call with the given map of IDs to Results.
	// The implementation must call Result.Set to provide the Value or Err (as applicable) for the every ID.
	// At the end of this call, if Result.Set was not called on the result of a particular ID,
	// the corresponding ID's `Do` call will get ErrNoResult.
	Do(map[ID]*Result)
}

BatchApi needs to be implemented in order to use BatchLimiter.

type BatchLimiter ¶

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

BatchLimiter provides the ability to batch calls and apply a rate limit (on the batches). Users have to provide an implementation of BatchApi and a rate.Limiter. Thereafter callers can concurrently Do calls for each individual ID and the BatchLimiter will batch calls (whenever appropriate) while respecting the rate limit. Individual requests are serviced in the order of submission.

func NewBatchLimiter(api BatchApi, limiter *rate.Limiter) *BatchLimiter

func (l *BatchLimiter) Do(ctx context.Context, id ID) (interface{}, error)

type ID ¶

type ID interface{}

ID is the identifier of each call.

type Limiter ¶

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

A Limiter enforces concurrency limits among a set of goroutines. It maintains a bucket of tokens; a number of tokens (e.g., representing the cost of an operation) must be acquired by a goroutine before proceeding. A limiter is not fair: tokens are not granted in FIFO order; rather, waiters are picked randomly to be granted new tokens.

A nil limiter issues an infinite number of tokens.

func New() *Limiter

func (l *Limiter) Acquire(ctx context.Context, need int) error

func (l *Limiter) Release(n int)

type LimiterIfc ¶

type LimiterIfc interface {
	Release(n int)
	Acquire(ctx context.Context, need int) error
}

type Result ¶

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

Result is the result of an API call for a given id.

func (r *Result) Set(v interface{}, err error)