tracker_scraper.go

   1 package torrent
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "fmt"
   7         "time"
   8
   9         "github.com/anacrolix/missinggo"
  10
  11         "github.com/anacrolix/torrent/tracker"
  12 )
  13
  14 // Announces a torrent to a tracker at regular intervals, when peers are
  15 // required.
  16 type trackerScraper struct {
  17         url string
  18         // Causes the trackerScraper to stop running.
  19         stop         missinggo.Event
  20         t            *Torrent
  21         lastAnnounce trackerAnnounceResult
  22 }
  23
  24 func (ts *trackerScraper) statusLine() string {
  25         var w bytes.Buffer
  26         fmt.Fprintf(&w, "%q\t%s\t%s",
  27                 ts.url,
  28                 func() string {
  29                         na := time.Until(ts.lastAnnounce.Completed.Add(ts.lastAnnounce.Interval))
  30                         if na > 0 {
  31                                 na /= time.Second
  32                                 na *= time.Second
  33                                 return na.String()
  34                         } else {
  35                                 return "anytime"
  36                         }
  37                 }(),
  38                 func() string {
  39                         if ts.lastAnnounce.Err != nil {
  40                                 return ts.lastAnnounce.Err.Error()
  41                         }
  42                         if ts.lastAnnounce.Completed.IsZero() {
  43                                 return "never"
  44                         }
  45                         return fmt.Sprintf("%d peers", ts.lastAnnounce.NumPeers)
  46                 }())
  47         return w.String()
  48 }
  49
  50 type trackerAnnounceResult struct {
  51         Err       error
  52         NumPeers  int
  53         Interval  time.Duration
  54         Completed time.Time
  55 }
  56
  57 func trackerToTorrentPeers(ps []tracker.Peer) (ret []Peer) {
  58         ret = make([]Peer, 0, len(ps))
  59         for _, p := range ps {
  60                 ret = append(ret, Peer{
  61                         IP:     p.IP,
  62                         Port:   p.Port,
  63                         Source: peerSourceTracker,
  64                 })
  65         }
  66         return
  67 }
  68
  69 // Return how long to wait before trying again. For most errors, we return 5
  70 // minutes, a relatively quick turn around for DNS changes.
  71 func (me *trackerScraper) announce() (ret trackerAnnounceResult) {
  72         defer func() {
  73                 ret.Completed = time.Now()
  74         }()
  75         ret.Interval = 5 * time.Minute
  76         blocked, urlToUse, host, err := me.t.cl.prepareTrackerAnnounceUnlocked(me.url)
  77         if err != nil {
  78                 ret.Err = err
  79                 return
  80         }
  81         if blocked {
  82                 ret.Err = errors.New("blocked by IP")
  83                 return
  84         }
  85         me.t.cl.mu.Lock()
  86         req := me.t.announceRequest()
  87         me.t.cl.mu.Unlock()
  88         res, err := tracker.AnnounceHost(me.t.cl.config.HTTP, urlToUse, &req, host)
  89         if err != nil {
  90                 ret.Err = err
  91                 return
  92         }
  93         me.t.AddPeers(trackerToTorrentPeers(res.Peers))
  94         ret.NumPeers = len(res.Peers)
  95         ret.Interval = time.Duration(res.Interval) * time.Second
  96         return
  97 }
  98
  99 func (me *trackerScraper) Run() {
 100         for {
 101                 select {
 102                 case <-me.t.closed.LockedChan(&me.t.cl.mu):
 103                         return
 104                 case <-me.stop.LockedChan(&me.t.cl.mu):
 105                         return
 106                 case <-me.t.wantPeersEvent.LockedChan(&me.t.cl.mu):
 107                 }
 108
 109                 ar := me.announce()
 110                 me.t.cl.mu.Lock()
 111                 me.lastAnnounce = ar
 112                 me.t.cl.mu.Unlock()
 113
 114                 intervalChan := time.After(time.Until(ar.Completed.Add(ar.Interval)))
 115
 116                 select {
 117                 case <-me.t.closed.LockedChan(&me.t.cl.mu):
 118                         return
 119                 case <-me.stop.LockedChan(&me.t.cl.mu):
 120                         return
 121                 case <-intervalChan:
 122                 }
 123         }
 124 }