package downloader
import (
"context"
"sync"
"github.com/gotd/td/tgerr"
)
type SchedulerOptions struct {
Min int
Start int
Max int
}
func (o *SchedulerOptions ) setDefaults () {
if o .Min <= 0 {
o .Min = 1
}
if o .Max <= 0 {
o .Max = 16
}
if o .Max < o .Min {
o .Max = o .Min
}
if o .Start <= 0 {
o .Start = 4
}
if o .Start < o .Min {
o .Start = o .Min
}
if o .Start > o .Max {
o .Start = o .Max
}
}
type SchedulerSnapshot struct {
Window int
InFlight int
Waiting int
Decreases int64
}
type Scheduler struct {
mux sync .Mutex
opts SchedulerOptions
window int
inFlight int
waiting int
successes int
decreases int64
epoch uint64
wake chan struct {}
}
func NewScheduler (opts SchedulerOptions ) *Scheduler {
opts .setDefaults ()
return &Scheduler {
opts : opts ,
window : opts .Start ,
wake : make (chan struct {}),
}
}
func (s *Scheduler ) Snapshot () SchedulerSnapshot {
s .mux .Lock ()
defer s .mux .Unlock ()
return SchedulerSnapshot {
Window : s .window ,
InFlight : s .inFlight ,
Waiting : s .waiting ,
Decreases : s .decreases ,
}
}
func (s *Scheduler ) notify () {
close (s .wake )
s .wake = make (chan struct {})
}
func (s *Scheduler ) acquire (ctx context .Context ) (uint64 , error ) {
s .mux .Lock ()
for s .inFlight >= s .window {
wake := s .wake
s .waiting ++
s .mux .Unlock ()
select {
case <- wake :
case <- ctx .Done ():
s .mux .Lock ()
s .waiting --
s .mux .Unlock ()
return 0 , ctx .Err ()
}
s .mux .Lock ()
s .waiting --
}
s .inFlight ++
epoch := s .epoch
s .mux .Unlock ()
return epoch , nil
}
func (s *Scheduler ) release (ctx context .Context , epoch uint64 , err error ) {
s .mux .Lock ()
defer s .mux .Unlock ()
s .inFlight --
switch {
case err == nil :
s .successes ++
if s .successes >= s .window && s .window < s .opts .Max {
s .window ++
s .successes = 0
}
case isSchedulerBackoff (ctx , err ):
s .decrease (epoch )
}
s .notify ()
}
func (s *Scheduler ) backoff (ctx context .Context , epoch uint64 , err error ) uint64 {
if !isSchedulerBackoff (ctx , err ) {
return epoch
}
s .mux .Lock ()
defer s .mux .Unlock ()
s .decrease (epoch )
if _ , ok := tgerr .AsFloodWait (err ); !ok {
return epoch
}
return s .epoch
}
func (s *Scheduler ) decrease (epoch uint64 ) {
s .successes = 0
if epoch != s .epoch {
return
}
s .epoch ++
s .decreases ++
s .window /= 2
if s .window < s .opts .Min {
s .window = s .opts .Min
}
}
type backoffReporter struct {
mux sync .Mutex
sch *Scheduler
epoch uint64
}
func (r *backoffReporter ) report (ctx context .Context , err error ) {
if isSchedulerBackoff (ctx , err ) {
observerFrom (ctx ).backoff (ctx , err )
}
r .mux .Lock ()
defer r .mux .Unlock ()
r .epoch = r .sch .backoff (ctx , r .epoch , err )
}
func (r *backoffReporter ) release (ctx context .Context , err error ) {
r .mux .Lock ()
epoch := r .epoch
r .mux .Unlock ()
r .sch .release (ctx , epoch , err )
}
type backoffReporterKey struct {}
func withBackoffReporter (ctx context .Context , r *backoffReporter ) context .Context {
return context .WithValue (ctx , backoffReporterKey {}, r )
}
func reportBackoff (ctx context .Context , err error ) {
if r , ok := ctx .Value (backoffReporterKey {}).(*backoffReporter ); ok {
r .report (ctx , err )
}
}
func isSchedulerBackoff (ctx context .Context , err error ) bool {
if _ , ok := tgerr .AsFloodWait (err ); ok {
return true
}
return isRetryableTimeout (ctx , err )
}
func (d *Downloader ) WithScheduler (s *Scheduler ) *Downloader {
d .scheduler = s
return d
}
func (b *Builder ) WithScheduler (s *Scheduler ) *Builder {
b .scheduler = s
return b
}
The pages are generated with Golds v0.8.7 . (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu .
PR and bug reports are welcome and can be submitted to the issue list .
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds .