Files
archie/internal/ratelimit/limiter.go
T

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
}