12 "github.com/anacrolix/dht/v2/krpc"
13 "github.com/anacrolix/log"
15 "github.com/anacrolix/torrent/tracker"
18 // Announces a torrent to a tracker at regular intervals, when peers are
20 type trackerScraper struct {
23 lastAnnounce trackerAnnounceResult
26 type torrentTrackerAnnouncer interface {
31 func (me trackerScraper) URL() *url.URL {
35 func (ts *trackerScraper) statusLine() string {
37 fmt.Fprintf(&w, "next ann: %v, last ann: %v",
39 na := time.Until(ts.lastAnnounce.Completed.Add(ts.lastAnnounce.Interval))
49 if ts.lastAnnounce.Err != nil {
50 return ts.lastAnnounce.Err.Error()
52 if ts.lastAnnounce.Completed.IsZero() {
55 return fmt.Sprintf("%d peers", ts.lastAnnounce.NumPeers)
61 type trackerAnnounceResult struct {
64 Interval time.Duration
68 func (me *trackerScraper) getIp() (ip net.IP, err error) {
69 ips, err := net.LookupIP(me.u.Hostname())
74 err = errors.New("no ips")
77 for _, ip = range ips {
78 if me.t.cl.ipIsBlocked(ip) {
93 err = errors.New("no acceptable ips")
97 func (me *trackerScraper) trackerUrl(ip net.IP) string {
100 u.Host = net.JoinHostPort(ip.String(), u.Port())
105 // Return how long to wait before trying again. For most errors, we return 5
106 // minutes, a relatively quick turn around for DNS changes.
107 func (me *trackerScraper) announce(ctx context.Context, event tracker.AnnounceEvent) (ret trackerAnnounceResult) {
110 ret.Completed = time.Now()
112 ret.Interval = time.Minute
114 // Limit concurrent use of the same tracker URL by the Client.
115 ref := me.t.cl.getAnnounceRef(me.u.String())
121 case ref.C() <- struct{}{}:
127 panic("should return immediately")
131 ip, err := me.getIp()
133 ret.Err = fmt.Errorf("error getting ip: %s", err)
137 req := me.t.announceRequest(event)
139 // The default timeout is currently 15s, and that works well as backpressure on concurrent
140 // access to the tracker.
141 //ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
143 me.t.logger.WithDefaultLevel(log.Debug).Printf("announcing to %q: %#v", me.u.String(), req)
144 res, err := tracker.Announce{
146 HTTPProxy: me.t.cl.config.HTTPProxy,
147 UserAgent: me.t.cl.config.HTTPUserAgent,
148 TrackerUrl: me.trackerUrl(ip),
150 HostHeader: me.u.Host,
151 ServerName: me.u.Hostname(),
152 UdpNetwork: me.u.Scheme,
153 ClientIp4: krpc.NodeAddr{IP: me.t.cl.config.PublicIp4},
154 ClientIp6: krpc.NodeAddr{IP: me.t.cl.config.PublicIp6},
156 me.t.logger.WithDefaultLevel(log.Debug).Printf("announce to %q returned %#v: %v", me.u.String(), res, err)
158 ret.Err = fmt.Errorf("announcing: %w", err)
161 me.t.AddPeers(peerInfos(nil).AppendFromTracker(res.Peers))
162 ret.NumPeers = len(res.Peers)
163 ret.Interval = time.Duration(res.Interval) * time.Second
167 // Returns whether we can shorten the interval, and sets notify to a channel that receives when we
168 // might change our mind, or leaves it if we won't.
169 func (me *trackerScraper) canIgnoreInterval(notify *<-chan struct{}) bool {
170 gotInfo := me.t.GotInfo()
173 // Private trackers really don't like us announcing more than they specify. They're also
174 // tracking us very carefully, so it's best to comply.
175 private := me.t.info.Private
176 return private == nil || !*private
183 func (me *trackerScraper) Run() {
185 defer me.announceStopped()
187 ctx, cancel := context.WithCancel(context.Background())
193 case <-me.t.Closed():
197 // make sure first announce is a "started"
201 ar := me.announce(ctx, e)
202 // after first announce, get back to regular "none"
209 // Make sure we don't announce for at least a minute since the last one.
210 interval := ar.Interval
211 if interval < time.Minute {
212 interval = time.Minute
216 wantPeers := me.t.wantPeersEvent.C()
217 closed := me.t.closed.C()
220 // If we want peers, reduce the interval to the minimum if it's appropriate.
222 // A channel that receives when we should reconsider our interval. Starts as nil since that
224 var reconsider <-chan struct{}
227 if interval > time.Minute && me.canIgnoreInterval(&reconsider) {
228 interval = time.Minute
231 reconsider = wantPeers
238 // Recalculate the interval.
240 case <-time.After(time.Until(ar.Completed.Add(interval))):
245 func (me *trackerScraper) announceStopped() {
246 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
248 me.announce(ctx, tracker.Stopped)