97 lines
2.2 KiB
Go
97 lines
2.2 KiB
Go
// Package ratelimit is a sliding-window limiter keyed by platform and user.
|
|
// Call EvictStale periodically.
|
|
package ratelimit
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Limiter enforces "at most max requests per window" per (platform,
|
|
// userID) pair using a sliding window log. It is safe for concurrent
|
|
// use.
|
|
type Limiter struct {
|
|
window time.Duration
|
|
max int
|
|
now func() time.Time
|
|
|
|
mu sync.Mutex
|
|
hits map[limiterKey][]time.Time
|
|
}
|
|
|
|
// limiterKey identifies one (platform, userID) budget. Using a struct
|
|
// rather than a concatenated string avoids any risk of two distinct
|
|
// pairs colliding on a chosen separator byte that turns up in
|
|
// externally-supplied platform or userID values.
|
|
type limiterKey struct {
|
|
platform string
|
|
userID string
|
|
}
|
|
|
|
// New returns a Limiter allowing at most maxRequests requests in any
|
|
// rolling window-length interval, per (platform, userID) pair. A
|
|
// maxRequests of 0 blocks every request.
|
|
func New(window time.Duration, maxRequests int) *Limiter {
|
|
return &Limiter{
|
|
window: window,
|
|
max: maxRequests,
|
|
now: time.Now,
|
|
hits: map[limiterKey][]time.Time{},
|
|
}
|
|
}
|
|
|
|
// Allow reports whether a request from userID on platform is within the
|
|
// limit, recording it if so.
|
|
func (l *Limiter) Allow(platform, userID string) bool {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
now := l.now()
|
|
key := limiterKey{platform: platform, userID: userID}
|
|
cutoff := now.Add(-l.window)
|
|
|
|
hits := l.hits[key]
|
|
live := hits[:0]
|
|
for _, h := range hits {
|
|
if h.After(cutoff) {
|
|
live = append(live, h)
|
|
}
|
|
}
|
|
|
|
if len(live) >= l.max {
|
|
l.hits[key] = live
|
|
return false
|
|
}
|
|
|
|
l.hits[key] = append(live, now)
|
|
return true
|
|
}
|
|
|
|
// EvictStale removes keys with no hits in the current window and returns
|
|
// how many it removed.
|
|
func (l *Limiter) EvictStale() int {
|
|
l.mu.Lock()
|
|
defer l.mu.Unlock()
|
|
|
|
cutoff := l.now().Add(-l.window)
|
|
evicted := 0
|
|
for key, hits := range l.hits {
|
|
if !hasHitAfter(hits, cutoff) {
|
|
delete(l.hits, key)
|
|
evicted++
|
|
}
|
|
}
|
|
return evicted
|
|
}
|
|
|
|
// hasHitAfter reports whether any recorded hit is strictly after cutoff,
|
|
// mirroring the pruning predicate Allow applies to each key's hit log.
|
|
func hasHitAfter(hits []time.Time, cutoff time.Time) bool {
|
|
for _, h := range hits {
|
|
if h.After(cutoff) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|