BlueGit

timfa bluegit

Files

bluegit / internal / backupserver / throttle / throttle.go

throttle.go

throttle.go 2.1 KiB Download Raw
1// Package throttle begrenst de leessnelheid met een token bucket.
2package throttle
3
4import (
5 "context"
6 "io"
7 "sync"
8 "time"
9)
10
11// Limiter is een token bucket in bytes per seconde, gedeeld door alle
12// downloads van één server.
13type Limiter struct {
14 mu sync.Mutex
15 rate float64 // bytes/s; 0 = onbegrensd
16 burst float64
17 tokens float64
18 last time.Time
19 now func() time.Time
20 sleep func(context.Context, time.Duration) error
21}
22
23// New maakt een limiter. bytesPerSec 0 = geen limiet. De burst is een
24// kwart seconde, minstens 16 KiB.
25func New(bytesPerSec int64) *Limiter {
26 l := &Limiter{rate: float64(bytesPerSec), now: time.Now, sleep: sleepCtx}
27 l.burst = l.rate / 4
28 if l.burst < 16<<10 {
29 l.burst = 16 << 10
30 }
31 l.tokens = l.burst
32 l.last = l.now()
33 return l
34}
35
36func sleepCtx(ctx context.Context, d time.Duration) error {
37 t := time.NewTimer(d)
38 defer t.Stop()
39 select {
40 case <-ctx.Done():
41 return ctx.Err()
42 case <-t.C:
43 return nil
44 }
45}
46
47// Rate is de ingestelde snelheid in bytes/s.
48func (l *Limiter) Rate() int64 {
49 if l == nil {
50 return 0
51 }
52 return int64(l.rate)
53}
54
55// Wait blokkeert tot n bytes gelezen mogen worden.
56func (l *Limiter) Wait(ctx context.Context, n int) error {
57 if l == nil || l.rate <= 0 || n <= 0 {
58 return nil
59 }
60 l.mu.Lock()
61 now := l.now()
62 l.tokens += now.Sub(l.last).Seconds() * l.rate
63 if l.tokens > l.burst {
64 l.tokens = l.burst
65 }
66 l.last = now
67 l.tokens -= float64(n)
68 var wait time.Duration
69 if l.tokens < 0 {
70 wait = time.Duration(-l.tokens / l.rate * float64(time.Second))
71 }
72 l.mu.Unlock()
73 if wait > 0 {
74 return l.sleep(ctx, wait)
75 }
76 return nil
77}
78
79// Reader begrenst r met l.
80func (l *Limiter) Reader(ctx context.Context, r io.Reader) io.Reader {
81 if l == nil || l.rate <= 0 {
82 return r
83 }
84 return &reader{ctx: ctx, r: r, l: l}
85}
86
87type reader struct {
88 ctx context.Context
89 r io.Reader
90 l *Limiter
91}
92
93func (t *reader) Read(p []byte) (int, error) {
94 if max := int(t.l.burst); len(p) > max {
95 p = p[:max]
96 }
97 n, err := t.r.Read(p)
98 if n > 0 {
99 if werr := t.l.Wait(t.ctx, n); werr != nil {
100 return n, werr
101 }
102 }
103 return n, err
104}