Files
kandev/apps/backend/internal/system/frontenderrors/limiter.go
T
2026-08-02 20:14:53 +01:00

144 lines
3.7 KiB
Go

package frontenderrors
import (
"math"
"sync"
"time"
)
const (
identityRatePerMinute = 60
identityBurst = 20
globalRatePerMinute = 300
globalBurst = 100
identityBytesPerMinute = 64 * 1024
identityBytesBurst = 64 * 1024
globalBytesPerMinute = 256 * 1024
globalBytesBurst = 256 * 1024
identityBucketTTL = 10 * time.Minute
limiterCleanupEvery = time.Minute
)
type tokenBucket struct {
tokens float64
last time.Time
lastSeen time.Time
}
type identityBuckets struct {
requests tokenBucket
bytes tokenBucket
lastSeen time.Time
}
type limiter struct {
mu sync.Mutex
now func() time.Time
globalRequests tokenBucket
globalBytes tokenBucket
identities map[string]*identityBuckets
lastCleanup time.Time
}
func newLimiter(now func() time.Time) *limiter {
if now == nil {
now = time.Now
}
current := now()
return &limiter{
now: now,
globalRequests: newTokenBucket(globalBurst, current),
globalBytes: newTokenBucket(globalBytesBurst, current),
identities: make(map[string]*identityBuckets),
lastCleanup: current,
}
}
func (l *limiter) Allow(identity string) (bool, time.Duration) {
return l.allow(identity, 1, false)
}
func (l *limiter) AllowBytes(identity string, size int) (bool, time.Duration) {
return l.allow(identity, max(1, size), true)
}
func (l *limiter) allow(identity string, cost int, bytes bool) (bool, time.Duration) {
l.mu.Lock()
defer l.mu.Unlock()
now := l.now()
l.cleanup(now)
buckets := l.identities[identity]
if buckets == nil {
buckets = &identityBuckets{
requests: newTokenBucket(identityBurst, now),
bytes: newTokenBucket(identityBytesBurst, now),
lastSeen: now,
}
l.identities[identity] = buckets
}
buckets.lastSeen = now
if bytes {
return consumeBuckets(&buckets.bytes, &l.globalBytes, cost,
identityBytesPerMinute, identityBytesBurst,
globalBytesPerMinute, globalBytesBurst, now)
}
return consumeBuckets(&buckets.requests, &l.globalRequests, cost,
identityRatePerMinute, identityBurst, globalRatePerMinute, globalBurst, now)
}
func consumeBuckets(identity, global *tokenBucket, cost, identityRate, identityBurst,
globalRate, globalBurst int, now time.Time) (bool, time.Duration) {
refill(identity, identityRate, identityBurst, now)
refill(global, globalRate, globalBurst, now)
identityRetry := retryAfter(identity, identityRate, cost)
globalRetry := retryAfter(global, globalRate, cost)
if identityRetry > 0 || globalRetry > 0 {
return false, maxDuration(identityRetry, globalRetry)
}
identity.tokens -= float64(cost)
global.tokens -= float64(cost)
return true, 0
}
func (l *limiter) cleanup(now time.Time) {
if now.Sub(l.lastCleanup) < limiterCleanupEvery {
return
}
for identity, bucket := range l.identities {
if now.Sub(bucket.lastSeen) > identityBucketTTL {
delete(l.identities, identity)
}
}
l.lastCleanup = now
}
func newTokenBucket(burst int, now time.Time) tokenBucket {
return tokenBucket{tokens: float64(burst), last: now, lastSeen: now}
}
func refill(bucket *tokenBucket, ratePerMinute, burst int, now time.Time) {
elapsed := now.Sub(bucket.last).Minutes()
if elapsed > 0 {
bucket.tokens = math.Min(float64(burst), bucket.tokens+elapsed*float64(ratePerMinute))
bucket.last = now
}
}
func retryAfter(bucket *tokenBucket, ratePerMinute, cost int) time.Duration {
if bucket.tokens >= float64(cost) {
return 0
}
seconds := math.Ceil((float64(cost) - bucket.tokens) / (float64(ratePerMinute) / 60))
if seconds < 1 {
seconds = 1
}
return time.Duration(seconds) * time.Second
}
func maxDuration(left, right time.Duration) time.Duration {
if left > right {
return left
}
return right
}