redis_rate

type ConcurrencyLimit struct {
	Max int64
	// RequestMaxDuration is the time period in seconds over which the a request must complete.  If unset it defaults to 30 seconds.
	RequestMaxDuration time.Duration
}

type ConcurrencyResult struct {
	// Name of the key used for this result.
	Key string

	// Request ID used for this result.
	RequestID string

	// Limit is the limit that was used to obtain this result.
	Limit ConcurrencyLimit

	// Allowed is the number of events that may happen at time now.
	Allowed bool

	// Used is the number of events that have already happened at time now.
	Used int64

	// Remaining is the maximum number of requests that could be
	// permitted instantaneously for this key given the current
	// state. For example, if a rate limiter allows 10 requests per
	// second and has already received 6 requests for this key this
	// second, Remaining would be 4.
	Remaining int64
}

type Limit struct {
	Rate   int
	Burst  int
	Period time.Duration
}

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

type Pipeline interface {
	Allow(ctx context.Context,
		key string,
		limit Limit,
	) *Result

	Take(ctx context.Context, key string, requestID string, limit ConcurrencyLimit) *ConcurrencyResult

	Release(ctx context.Context, key string, requestID string)

	Exec(ctx context.Context) error
}

type RedisClientConn interface {
	Pipeline() redis.Pipeliner
	Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error)

	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd
	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd
	ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd
	ScriptLoad(ctx context.Context, script string) *redis.StringCmd
	Del(ctx context.Context, keys ...string) *redis.IntCmd

	EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd
	EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd
}

type Result struct {
	// Name of the key used for this result.
	Key string

	// Limit is the limit that was used to obtain this result.
	Limit Limit

	// Allowed is the number of events that may happen at time now.
	Allowed int64

	// Used is the number of events that have already happened at time now.
	Used int64

	// Remaining is the maximum number of requests that could be
	// permitted instantaneously for this key given the current
	// state. For example, if a rate limiter allows 10 requests per
	// second and has already received 6 requests for this key this
	// second, Remaining would be 4.
	Remaining int64

	// RetryAfter is the time until the next request will be permitted.
	// It should be -1 unless the rate limit has been exceeded.
	RetryAfter time.Duration

	// ResetAfter is the time until the RateLimiter returns to its
	// initial state for a given key. For example, if a rate limiter
	// manages requests per second and received one request 200ms ago,
	// Reset would return 800ms. You can also think of this as the time
	// until Limit and Remaining will be equal.
	ResetAfter time.Duration
}