Client.announceTorrentDHT -> Torrent.announceDHT

diff --git a/client.go b/client.go
index fe86329966eca84454930fc004bc7ba09243e18c..fa63e446d494e92735254af68a7896aa94867b60 100644 (file)
--- a/client.go
+++ b/client.go
@@ -1533,7 +1533,7 @@ func (cl *Client) AddTorrentInfoHash(infoHash metainfo.Hash) (t *Torrent, new bo
        new = true
        t = cl.newTorrent(infoHash)
        if cl.dHT != nil {
-               go cl.announceTorrentDHT(t, true)
+               go t.announceDHT(true)
        }
        cl.torrents[infoHash] = t
        t.updateWantPeersEvent()
@@ -1579,62 +1579,6 @@ func (cl *Client) dropTorrent(infoHash metainfo.Hash) (err error) {
        return
 }
 
-func (cl *Client) announceTorrentDHT(t *Torrent, impliedPort bool) {
-       for {
-               select {
-               case <-t.wantPeersEvent.LockedChan(&cl.mu):
-               case <-t.closed.LockedChan(&cl.mu):
-                       return
-               }
-               // log.Printf("getting peers for %q from DHT", t)
-               ps, err := cl.dHT.Announce(string(t.infoHash[:]), cl.incomingPeerPort(), impliedPort)
-               if err != nil {
-                       log.Printf("error getting peers from dht: %s", err)
-                       return
-               }
-               // Count all the unique addresses we got during this announce.
-               allAddrs := make(map[string]struct{})
-       getPeers:
-               for {
-                       select {
-                       case v, ok := <-ps.Peers:
-                               if !ok {
-                                       break getPeers
-                               }
-                               addPeers := make([]Peer, 0, len(v.Peers))
-                               for _, cp := range v.Peers {
-                                       if cp.Port == 0 {
-                                               // Can't do anything with this.
-                                               continue
-                                       }
-                                       addPeers = append(addPeers, Peer{
-                                               IP:     cp.IP[:],
-                                               Port:   cp.Port,
-                                               Source: peerSourceDHT,
-                                       })
-                                       key := (&net.UDPAddr{
-                                               IP:   cp.IP[:],
-                                               Port: cp.Port,
-                                       }).String()
-                                       allAddrs[key] = struct{}{}
-                               }
-                               cl.mu.Lock()
-                               cl.addPeers(t, addPeers)
-                               numPeers := len(t.peers)
-                               cl.mu.Unlock()
-                               if numPeers >= torrentPeersHighWater {
-                                       break getPeers
-                               }
-                       case <-t.closed.LockedChan(&cl.mu):
-                               ps.Close()
-                               return
-                       }
-               }
-               ps.Close()
-               // log.Printf("finished DHT peer scrape for %s: %d peers", t, len(allAddrs))
-       }
-}
-
 func (cl *Client) prepareTrackerAnnounceUnlocked(announceURL string) (blocked bool, urlToUse string, host string, err error) {
        _url, err := url.Parse(announceURL)
        if err != nil {

diff --git a/torrent.go b/torrent.go
index 6848a6fddf6ffc87468f6b5cf20b60301f74f434..59dc38e72dfb7d7b0f04fadac618fc1ef1f42018 100644 (file)
--- a/torrent.go
+++ b/torrent.go
@@ -1191,3 +1191,60 @@ func (t *Torrent) announceRequest() tracker.AnnounceRequest {
                Left:     t.bytesLeftAnnounce(),
        }
 }
+
+func (t *Torrent) announceDHT(impliedPort bool) {
+       cl := t.cl
+       for {
+               select {
+               case <-t.wantPeersEvent.LockedChan(&cl.mu):
+               case <-t.closed.LockedChan(&cl.mu):
+                       return
+               }
+               // log.Printf("getting peers for %q from DHT", t)
+               ps, err := cl.dHT.Announce(string(t.infoHash[:]), cl.incomingPeerPort(), impliedPort)
+               if err != nil {
+                       log.Printf("error getting peers from dht: %s", err)
+                       return
+               }
+               // Count all the unique addresses we got during this announce.
+               allAddrs := make(map[string]struct{})
+       getPeers:
+               for {
+                       select {
+                       case v, ok := <-ps.Peers:
+                               if !ok {
+                                       break getPeers
+                               }
+                               addPeers := make([]Peer, 0, len(v.Peers))
+                               for _, cp := range v.Peers {
+                                       if cp.Port == 0 {
+                                               // Can't do anything with this.
+                                               continue
+                                       }
+                                       addPeers = append(addPeers, Peer{
+                                               IP:     cp.IP[:],
+                                               Port:   cp.Port,
+                                               Source: peerSourceDHT,
+                                       })
+                                       key := (&net.UDPAddr{
+                                               IP:   cp.IP[:],
+                                               Port: cp.Port,
+                                       }).String()
+                                       allAddrs[key] = struct{}{}
+                               }
+                               cl.mu.Lock()
+                               cl.addPeers(t, addPeers)
+                               numPeers := len(t.peers)
+                               cl.mu.Unlock()
+                               if numPeers >= torrentPeersHighWater {
+                                       break getPeers
+                               }
+                       case <-t.closed.LockedChan(&cl.mu):
+                               ps.Close()
+                               return
+                       }
+               }
+               ps.Close()
+               // log.Printf("finished DHT peer scrape for %s: %d peers", t, len(allAddrs))
+       }
+}