massive cleanup

Author: feross

README.md

@@ -111,7 +111,7 @@ var Server = require('bittorrent-tracker').Server
 var server = new Server({
   udp: true, // enable udp server? [default=true]
   http: true, // enable http server? [default=true]
-  ws: true, // enable websocket server? [default=false]
+  ws: true, // enable websocket server? [default=true]
   filter: function (infoHash, params, cb) {
     // Blacklist/whitelist function for allowing/disallowing torrents. If this option is
     // omitted, all torrents are allowed. It is possible to interface with a database or

client.js

@@ -1,10 +1,11 @@
 module.exports = Client
 
-var debug = require('debug')('bittorrent-tracker')
 var EventEmitter = require('events').EventEmitter
+var debug = require('debug')('bittorrent-tracker')
 var inherits = require('inherits')
 var once = require('once')
 var parallel = require('run-parallel')
+var uniq = require('uniq')
 var url = require('url')
 
 var common = require('./lib/common')
@@ -23,8 +24,6 @@ inherits(Client, EventEmitter)
  * @param {Number} port            torrent client listening port
  * @param {Object} torrent         parsed torrent
  * @param {Object} opts            options object
- * @param {Number} opts.numwant    number of peers to request
- * @param {Number} opts.interval   announce interval (in ms)
  * @param {Number} opts.rtcConfig  RTCPeerConnection configuration object
  * @param {Number} opts.wrtc       custom webrtc implementation
  */
@@ -55,13 +54,8 @@ function Client (peerId, port, torrent, opts) {
   self._rtcConfig = opts.rtcConfig
   self._wrtc = opts.wrtc
 
-  // optional
-  self._numwant = opts.numwant || common.DEFAULT_ANNOUNCE_PEERS
-  self._intervalMs = opts.interval || common.DEFAULT_ANNOUNCE_INTERVAL
-
   debug('new client %s', self._infoHashHex)
 
-  var trackerOpts = { interval: self._intervalMs }
   var webrtcSupport = !!self._wrtc || typeof window !== 'undefined'
 
   var announce = (typeof torrent.announce === 'string')
@@ -70,18 +64,27 @@ function Client (peerId, port, torrent, opts) {
       ? []
       : torrent.announce
 
+  announce = announce.map(function (announceUrl) {
+    announceUrl = announceUrl.toString()
+    if (announceUrl[announceUrl.length - 1] === '/') {
+      // remove trailing slash from trackers to catch duplicates
+      announceUrl = announceUrl.substring(0, announceUrl.length - 1)
+    }
+    return announceUrl
+  })
+
+  announce = uniq(announce)
+
   self._trackers = announce
     .map(function (announceUrl) {
-      announceUrl = announceUrl.toString()
       var protocol = url.parse(announceUrl).protocol
-
       if ((protocol === 'http:' || protocol === 'https:') &&
           typeof HTTPTracker === 'function') {
-        return new HTTPTracker(self, announceUrl, trackerOpts)
+        return new HTTPTracker(self, announceUrl)
       } else if (protocol === 'udp:' && typeof UDPTracker === 'function') {
-        return new UDPTracker(self, announceUrl, trackerOpts)
+        return new UDPTracker(self, announceUrl)
       } else if ((protocol === 'ws:' || protocol === 'wss:') && webrtcSupport) {
-        return new WebSocketTracker(self, announceUrl, trackerOpts)
+        return new WebSocketTracker(self, announceUrl)
       } else {
         process.nextTick(function () {
           var err = new Error('unsupported tracker protocol for ' + announceUrl)
@@ -151,7 +154,7 @@ Client.prototype.start = function (opts) {
 
   // start announcing on intervals
   self._trackers.forEach(function (tracker) {
-    tracker.setInterval(self._intervalMs)
+    tracker.setInterval()
   })
 }
 
@@ -231,9 +234,7 @@ Client.prototype.scrape = function (opts) {
 
 Client.prototype.setInterval = function (intervalMs) {
   var self = this
-  debug('setInterval')
-  self._intervalMs = intervalMs
-
+  debug('setInterval %d', intervalMs)
   self._trackers.forEach(function (tracker) {
     tracker.setInterval(intervalMs)
   })
@@ -248,7 +249,6 @@ Client.prototype.destroy = function (cb) {
   var tasks = self._trackers.map(function (tracker) {
     return function (cb) {
       tracker.destroy(cb)
-      tracker.setInterval(0) // stop announcing on intervals
     }
   })
 
@@ -260,7 +260,7 @@ Client.prototype._defaultAnnounceOpts = function (opts) {
   var self = this
   if (!opts) opts = {}
 
-  if (opts.numwant == null) opts.numwant = self._numwant
+  if (opts.numwant == null) opts.numwant = common.DEFAULT_ANNOUNCE_PEERS
 
   if (opts.uploaded == null) opts.uploaded = 0
   if (opts.downloaded == null) opts.downloaded = 0

examples/express-embed/server.js

@@ -12,6 +12,7 @@ var whitelist = {
 var server = new Server({
   http: false, // we do our own
   udp: false,  // not interested
+  ws: false,   // not interested
   filter: function (params) {
     // black/whitelist for disallowing/allowing specific clients [default=allow all]
     // this example only allows the uTorrent client

lib/client/http-tracker.js

@@ -3,15 +3,15 @@ module.exports = HTTPTracker
 var bencode = require('bencode')
 var compact2string = require('compact2string')
 var debug = require('debug')('bittorrent-tracker:http-tracker')
-var EventEmitter = require('events').EventEmitter
 var get = require('simple-get')
 var inherits = require('inherits')
 
 var common = require('../common')
+var Tracker = require('./tracker')
 
 var HTTP_SCRAPE_SUPPORT = /\/(announce)[^\/]*$/
 
-inherits(HTTPTracker, EventEmitter)
+inherits(HTTPTracker, Tracker)
 
 /**
  * HTTP torrent tracker client (for an individual tracker)
@@ -22,23 +22,15 @@ inherits(HTTPTracker, EventEmitter)
  */
 function HTTPTracker (client, announceUrl, opts) {
   var self = this
-  EventEmitter.call(self)
+  Tracker.call(self, client, announceUrl)
   debug('new http tracker %s', announceUrl)
 
-  self.client = client
-  self.destroyed = false
-
-  self._opts = opts
-  self._announceUrl = announceUrl
-  self._intervalMs = self.client._intervalMs // use client interval initially
-  self._interval = null
-
   // Determine scrape url (if http tracker supports it)
-  self._scrapeUrl = null
+  self.scrapeUrl = null
   var m
-  if ((m = self._announceUrl.match(HTTP_SCRAPE_SUPPORT))) {
-    self._scrapeUrl = self._announceUrl.slice(0, m.index) + '/scrape' +
-      self._announceUrl.slice(m.index + 9)
+  if ((m = self.announceUrl.match(HTTP_SCRAPE_SUPPORT))) {
+    self.scrapeUrl = self.announceUrl.slice(0, m.index) + '/scrape' +
+      self.announceUrl.slice(m.index + 9)
   }
 }
 
@@ -58,15 +50,15 @@ HTTPTracker.prototype.announce = function (opts) {
   }
   if (self._trackerId) params.trackerid = self._trackerId
 
-  self._request(self._announceUrl, params, self._onAnnounceResponse.bind(self))
+  self._request(self.announceUrl, params, self._onAnnounceResponse.bind(self))
 }
 
 HTTPTracker.prototype.scrape = function (opts) {
   var self = this
   if (self.destroyed) return
 
-  if (!self._scrapeUrl) {
-    self.client.emit('error', new Error('scrape not supported ' + self._announceUrl))
+  if (!self.scrapeUrl) {
+    self.client.emit('error', new Error('scrape not supported ' + self.announceUrl))
     return
   }
 
@@ -78,44 +70,33 @@ HTTPTracker.prototype.scrape = function (opts) {
   var params = {
     info_hash: infoHashes
   }
-  self._request(self._scrapeUrl, params, self._onScrapeResponse.bind(self))
-}
-
-// TODO: Improve this interface
-HTTPTracker.prototype.setInterval = function (intervalMs) {
-  var self = this
-  self._intervalMs = intervalMs
-  clearInterval(self._interval)
-
-  if (intervalMs) {
-    // HACK
-    var update = self.announce.bind(self, self.client._defaultAnnounceOpts())
-    self._interval = setInterval(update, self._intervalMs)
-  }
+  self._request(self.scrapeUrl, params, self._onScrapeResponse.bind(self))
 }
 
 HTTPTracker.prototype.destroy = function (cb) {
   var self = this
   if (self.destroyed) return
   self.destroyed = true
+  clearInterval(self.interval)
+
   cb(null)
 }
 
 HTTPTracker.prototype._request = function (requestUrl, params, cb) {
   var self = this
-
   var u = requestUrl + (requestUrl.indexOf('?') === -1 ? '?' : '&') +
     common.querystringStringify(params)
+
   get.concat(u, function (err, data, res) {
     if (self.destroyed) return
     if (err) return self.client.emit('warning', err)
     if (res.statusCode !== 200) {
       return self.client.emit('warning', new Error('Non-200 response code ' +
-        res.statusCode + ' from ' + self._announceUrl))
+        res.statusCode + ' from ' + self.announceUrl))
     }
     if (!data || data.length === 0) {
       return self.client.emit('warning', new Error('Invalid tracker response from' +
-        self._announceUrl))
+        self.announceUrl))
     }
 
     try {
@@ -145,11 +126,7 @@ HTTPTracker.prototype._onAnnounceResponse = function (data) {
   var self = this
 
   var interval = data.interval || data['min interval']
-  if (interval && !self._opts.interval && self._intervalMs !== 0) {
-    // use the interval the tracker recommends, UNLESS the user manually specifies an
-    // interval they want to use
-    self.setInterval(interval * 1000)
-  }
+  if (interval) self.setInterval(interval * 1000)
 
   var trackerId = data['tracker id']
   if (trackerId) {
@@ -158,7 +135,7 @@ HTTPTracker.prototype._onAnnounceResponse = function (data) {
   }
 
   self.client.emit('update', {
-    announce: self._announceUrl,
+    announce: self.announceUrl,
     complete: data.complete,
     incomplete: data.incomplete
   })
@@ -219,7 +196,7 @@ HTTPTracker.prototype._onScrapeResponse = function (data) {
     // TODO: optionally handle data.flags.min_request_interval
     // (separate from announce interval)
     self.client.emit('scrape', {
-      announce: self._announceUrl,
+      announce: self.announceUrl,
       infoHash: common.binaryToHex(infoHash),
       complete: response.complete,
       incomplete: response.incomplete,

lib/client/tracker.js

@@ -0,0 +1,31 @@
+module.exports = Tracker
+
+var EventEmitter = require('events').EventEmitter
+var inherits = require('inherits')
+
+var common = require('../common')
+
+inherits(Tracker, EventEmitter)
+
+function Tracker (client, announceUrl) {
+  var self = this
+  EventEmitter.call(self)
+
+  self.client = client
+  self.announceUrl = announceUrl
+  self.interval = null
+  self.destroyed = false
+}
+
+Tracker.prototype.setInterval = function (intervalMs) {
+  var self = this
+  if (self.interval) return
+  if (intervalMs == null) intervalMs = common.DEFAULT_ANNOUNCE_INTERVAL
+
+  clearInterval(self.interval)
+
+  if (intervalMs) {
+    var update = self.announce.bind(self, self.client._defaultAnnounceOpts())
+    self.interval = setInterval(update, intervalMs)
+  }
+}