// Package throttle begrenst de leessnelheid met een token bucket. package throttle import ( "context" "io" "sync" "time" ) // Limiter is een token bucket in bytes per seconde, gedeeld door alle // downloads van één server. type Limiter struct { mu sync.Mutex rate float64 // bytes/s; 0 = onbegrensd burst float64 tokens float64 last time.Time now func() time.Time sleep func(context.Context, time.Duration) error } // New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een // kwart seconde, minstens 16 KiB. func New(bytesPerSec int64) *Limiter { l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx} l.burst = l.rate / 4 if l.burst < 16<<10 { l.burst = 16 << 10 } l.tokens = l.burst l.last = l.now() return l } func sleepCtx(ctx context.Context, d time.Duration) error { t := time.NewTimer(d) defer t.Stop() select { case <-ctx.Done(): return ctx.Err() case <-t.C: return nil } } // Rate is de ingestelde snelheid in bytes/s. func (l *Limiter) Rate() int64 { if l == nil { return 0 } l.mu.Lock() defer l.mu.Unlock() return int64(l.rate) } // Wait blokkeert tot n bytes gelezen mogen worden. func (l *Limiter) Wait(ctx context.Context, n int) error { if l == nil || n <= 0 { return nil } l.mu.Lock() if l.rate <= 0 { l.mu.Unlock() return nil } now := l.now() l.tokens += now.Sub(l.last).Seconds() * l.rate if l.tokens > l.burst { l.tokens = l.burst } l.last = now l.tokens -= float64(n) var wait time.Duration if l.tokens < 0 { wait = time.Duration(-l.tokens / l.rate * float64(time.Second)) } l.mu.Unlock() if wait > 0 { return l.sleep(ctx, wait) } return nil } // Reader begrenst r met l. func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader { if l == nil { return r } return &reader{ctx: ctx, r: r, l: l} } type reader struct { ctx context.Context r io.Reader l *Limiter } func (t *reader) Read(p []byte) (int, error) { t.l.mu.Lock() max := int(t.l.burst) t.l.mu.Unlock() if len(p) > max { p = p[:max] } n, err := t.r.Read(p) if n > 0 { if werr := t.l.Wait(t.ctx, n); werr != nil { return n, werr } } return n, err } // SetRate past de snelheid aan zonder lopende downloads te onderbreken. func (l *Limiter) SetRate(bytesPerSec int64) { if l == nil { return } l.mu.Lock() defer l.mu.Unlock() l.rate = float64(bytesPerSec) l.burst = l.rate / 4 if l.burst < 16<<10 { l.burst = 16 << 10 } if l.tokens > l.burst { l.tokens = l.burst } }