quartz_torrent 0.1.1 → 0.2.0

data/lib/quartz_torrent/trackerclient.rb

@@ -1,8 +1,8 @@
 require "quartz_torrent/log"
 require "quartz_torrent/metainfo"
 require "quartz_torrent/udptrackermsg"
-require "quartz_torrent/httptrackerclient"
-require "quartz_torrent/udptrackerclient"
+require "quartz_torrent/httptrackerdriver"
+require "quartz_torrent/udptrackerdriver"
 require "quartz_torrent/interruptiblesleep"
 require "quartz_torrent/util"
 require "net/http"
@@ -67,6 +67,10 @@ module QuartzTorrent
       else
         @left = 0
       end
+      @port = 6881
+      @peerId = "-QR0001-" # Azureus style
+      @peerId << Process.pid.to_s
+      @peerId = @peerId + "x" * (20-@peerId.length)
     end
     # Number of bytes uploaded
     attr_accessor :uploaded
@@ -74,6 +78,8 @@ module QuartzTorrent
     attr_accessor :downloaded
     # Number of bytes left to download before torrent is completed
     attr_accessor :left
+    attr_accessor :port
+    attr_accessor :peerId
   end
 
   # Represents the response from a tracker request
@@ -100,6 +106,24 @@ module QuartzTorrent
     end
   end
 
+  # Low-level interface to trackers. TrackerClient uses an instance of a subclass of this to talk to 
+  # trackers using different protocols.
+  class TrackerDriver
+    def initialize(dataLength = 0)
+      @dynamicRequestParamsBuilder = Proc.new{ TrackerDynamicRequestParams.new(dataLength) }
+    end
+
+    # This should be set to a Proc that when called will return a TrackerDynamicRequestParams object
+    # with up-to-date information.
+    attr_accessor :dynamicRequestParamsBuilder
+    attr_accessor :port
+    attr_accessor :peerId
+
+    def request(event = nil)
+      raise "Implement me"
+    end
+  end
+
   # This class represents a connection to a tracker for a specific torrent. It can be used to get
   # peers for that torrent.
   class TrackerClient
@@ -124,10 +148,30 @@ module QuartzTorrent
       @event = :started
       @worker = nil
       @logger = LogManager.getLogger("tracker_client")
-      @announceUrl = announceUrl
+      @announceUrlList = announceUrl
       @infoHash = infoHash
       @peersChangedListeners = []
-      @dynamicRequestParamsBuilder = Proc.new{ TrackerDynamicRequestParams.new(dataLength) }
+      @dynamicRequestParamsBuilder = Proc.new do 
+        result = TrackerDynamicRequestParams.new(dataLength) 
+        result.port = @port
+        result.peerId = @peerId
+        result
+      end
+      @alarms = nil
+
+      # Convert announceUrl to an array
+      if @announceUrlList.nil?
+        @announceUrlList = []
+      elsif @announceUrlList.is_a? String
+        @announceUrlList = [@announceUrlList]
+        @announceUrlList.compact!
+      else
+        @announceUrlList = @announceUrlList.flatten.sort.uniq
+      end
+
+      raise "AnnounceURL contained no valid trackers" if @announceUrlList.size == 0
+  
+      @announceUrlIndex = 0
     end
     
     attr_reader :peerId
@@ -136,6 +180,10 @@ module QuartzTorrent
     # with up-to-date information.
     attr_accessor :dynamicRequestParamsBuilder
 
+    # This member can be set to an Alarms object. If it is, this tracker will raise alarms
+    # when it doesn't get a response, and clear them when it does.
+    attr_accessor :alarms
+
     # Return true if this TrackerClient is started, false otherwise.
     def started?
       @started
@@ -166,23 +214,35 @@ module QuartzTorrent
       @errors
     end
 
-    # Create a new TrackerClient using the passed information. This is a factory method that will return
-    # a tracker that talks the protocol specified in the URL.
+    # Create a new TrackerClient using the passed information. The announceUrl may be a string or a list.
     def self.create(announceUrl, infoHash, dataLength = 0, start = true)
+      result = TrackerClient.new(announceUrl, infoHash, dataLength)
+      result.start if start
+      result
+    end
+
+    # Create a new TrackerClient using the passed Metainfo object.
+    def self.createFromMetainfo(metainfo, start = true)
+      announce = []
+      announce.push metainfo.announce if metainfo.announce
+      announce = announce.concat(metainfo.announceList) if metainfo.announceList
+      create(announce, metainfo.infoHash, metainfo.info.dataLength, start)
+    end
+
+    # Create a TrackerDriver for the specified URL. TrackerDriver is a lower-level interface to the tracker.
+    def self.createDriver(announceUrl, infoHash)
       result = nil
       if announceUrl =~ /udp:\/\//
-        result = UdpTrackerClient.new(announceUrl, infoHash, dataLength)
+        result = UdpTrackerDriver.new(announceUrl, infoHash)
       else
-        result = HttpTrackerClient.new(announceUrl, infoHash, dataLength)
+        result = HttpTrackerDriver.new(announceUrl, infoHash)
       end
-      result.start if start
-
       result
     end
 
-    # Create a new TrackerClient using the passed Metainfo object.
-    def self.createFromMetainfo(metainfo, start = true)
-      create(metainfo.announce, metainfo.infoHash, metainfo.info.dataLength, start)
+    # Create a TrackerDriver using the passed Metainfo object. TrackerDriver is a lower-level interface to the tracker.
+    def self.createDriverFromMetainfo(metainfo)
+      TrackerClient.createDriver(metainfo.announce, metainfo.infoHash)
     end
 
     # Start the worker thread
@@ -198,21 +258,36 @@ module QuartzTorrent
         while ! @stopped
           begin
             response = nil
-            begin 
-              @logger.debug "Sending request"
-              response = request(@event)
-              @event = nil
-              trackerInterval = response.interval
-            rescue
-              addError $!
-              @logger.debug "Request failed due to exception: #{$!}"
-              @logger.debug $!.backtrace.join("\n")
+
+            driver = currentDriver
+
+            if driver
+              begin 
+                @logger.debug "Sending request to tracker #{currentAnnounceUrl}"
+                response = driver.request(@event)
+                @event = nil
+                trackerInterval = response.interval
+              rescue
+                addError $!
+                @logger.info "Request failed due to exception: #{$!}"
+                @logger.debug $!.backtrace.join("\n")
+                changeToNextTracker
+                next
+
+                @alarms.raise Alarm.new(:tracker, "Tracker request failed: #{$!}") if @alarms
+              end
             end
 
             if response && response.successful?
+              @alarms.clear :tracker if @alarms
               # Replace the list of peers
               peersHash = {}
               @logger.info "Response contained #{response.peers.length} peers"
+
+              if response.peers.length == 0
+                @alarms.raise Alarm.new(:tracker, "Response from tracker contained no peers") if @alarms
+              end
+
               response.peers.each do |p|
                 peersHash[p] = 1
               end
@@ -223,8 +298,11 @@ module QuartzTorrent
                 @peersChangedListeners.each{ |l| l.call }
               end
             else
-              @logger.debug "Response was unsuccessful from tracker"
+              @logger.info "Response was unsuccessful from tracker: #{response.error}"
               addError response.error if response
+              @alarms.raise Alarm.new(:tracker, "Unsuccessful response from tracker: #{response.error}") if @alarms && response
+              changeToNextTracker
+              next
             end
 
             # If we have no interval from the tracker yet, and the last request didn't error out leaving us with no peers,
@@ -244,7 +322,8 @@ module QuartzTorrent
         @logger.info "Worker thread shutting down"
         @logger.info "Sending final update to tracker"
         begin
-          request(:stopped)
+          driver = currentDriver
+          driver.request(:stopped) if driver
         rescue
           addError $!
           @logger.debug "Request failed due to exception: #{$!}"
@@ -280,6 +359,31 @@ module QuartzTorrent
     def eventValid?(event)
       event == :started || event == :stopped || event == :completed
     end
+
+    def currentDriver
+      announceUrl = currentAnnounceUrl
+      return nil if ! announceUrl
+           
+      driver = TrackerClient.createDriver announceUrl, @infoHash
+      driver.dynamicRequestParamsBuilder = @dynamicRequestParamsBuilder if driver
+      driver.port = @port
+      driver.peerId = @peerId
+      driver
+    end
+
+    def currentAnnounceUrl
+      return nil if @announceUrlList.size == 0
+      @announceUrlIndex = 0 if @announceUrlIndex > @announceUrlList.size-1
+
+      @announceUrlList[@announceUrlIndex]
+    end
+
+    def changeToNextTracker
+      @announceUrlIndex += 1
+      @logger.info "Changed to next tracker #{currentAnnounceUrl}"
+      sleep 0.5
+    end
+
   end
 
 

data/lib/quartz_torrent/udptrackerdriver.rb

@@ -0,0 +1,95 @@
+module QuartzTorrent
+  # A tracker driver that uses the UDP protocol as defined by http://xbtt.sourceforge.net/udp_tracker_protocol.html
+  class UdpTrackerDriver < TrackerDriver
+    # Set UDP receive length to a value that allows up to 100 peers to be returned in an announce.
+    ReceiveLength = 620 
+    def initialize(announceUrl, infoHash, timeout = 2)
+      super()
+      @announceUrl = announceUrl
+      @infoHash = infoHash
+      @timeout = timeout
+      @logger = LogManager.getLogger("udp_tracker_client")
+      if @announceUrl =~ /udp:\/\/([^:]+):(\d+)/
+        @host = $1
+        @trackerPort = $2
+      else
+        throw "UDP Tracker announce URL is invalid: #{announceUrl}"
+      end
+    end
+
+    def request(event = nil)
+      if event == :started
+        event = UdpTrackerMessage::EventStarted
+      elsif event == :stopped
+        event = UdpTrackerMessage::EventStopped
+      elsif event == :completed
+        event = UdpTrackerMessage::EventCompleted
+      else
+        event = UdpTrackerMessage::EventNone
+      end
+
+      socket = UDPSocket.new
+      result = nil
+      begin
+        socket.connect @host, @trackerPort
+
+        @logger.debug "Sending UDP tracker request to #{@host}:#{@trackerPort}"
+
+        # Send connect request
+        req = UdpTrackerConnectRequest.new
+        socket.send req.serialize, 0
+        resp = UdpTrackerConnectResponse.unserialize(readWithTimeout(socket,ReceiveLength,@timeout))
+        @logger.debug "Connect response: #{resp.inspect}"
+        raise "Invalid connect response: response transaction id is different from the request transaction id" if resp.transactionId != req.transactionId
+        connectionId = resp.connectionId
+
+        dynamicParams = @dynamicRequestParamsBuilder.call
+
+        # Send announce request      
+        req = UdpTrackerAnnounceRequest.new(connectionId)
+        req.peerId = dynamicParams.peerId
+        req.infoHash = @infoHash
+        req.downloaded = dynamicParams.downloaded
+        req.left = dynamicParams.left
+        req.uploaded = dynamicParams.uploaded
+        req.event = event
+        #req.port = socket.addr[1]
+        req.port = dynamicParams.port
+        socket.send req.serialize, 0
+        resp = UdpTrackerAnnounceResponse.unserialize(readWithTimeout(socket,ReceiveLength,@timeout))
+        @logger.debug "Announce response: #{resp.inspect}"
+
+        peers = []
+        resp.ips.length.times do |i|
+          ip = resp.ips[i].unpack("CCCC").join('.')
+          port = resp.ports[i].unpack("n").first
+          peers.push TrackerPeer.new ip, port
+        end
+        peers
+
+        result = TrackerResponse.new(true, nil, peers)
+        result.interval = resp.interval if resp.interval
+      rescue
+        result = TrackerResponse.new(false, $!, [])
+      ensure
+        socket.close if ! socket.closed?
+      end
+      result
+    end
+
+    private
+    # Throws exception if timeout occurs
+    def readWithTimeout(socket, length, timeout)
+      rc = IO.select([socket], nil, nil, timeout)
+      if ! rc
+        raise "Waiting for response from UDP tracker #{@host}:#{@trackerPort} timed out after #{@timeout} seconds"
+      elsif rc[0].size > 0
+        socket.recvfrom(length)[0]
+      else
+        raise "Error receiving response from UDP tracker #{@host}:#{@trackerPort}"
+      end
+    end
+  end
+
+
+end

data/lib/quartz_torrent/util.rb

@@ -71,7 +71,7 @@ module QuartzTorrent
 
   # Log backtraces of all threads currently running. The threads are logged to the 
   # passed io, or if that's nil they are written to the logger named 'util' at error level.
-  def self.logBacktraces(io)
+  def self.logBacktraces(io = nil)
     logger = nil
     logger = LogManager.getLogger("util") if ! io
     isLinux = RUBY_PLATFORM.downcase.include?("linux")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quartz_torrent
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bencode
@@ -135,15 +135,19 @@ extra_rdoc_files: []
 files:
 - lib/quartz_torrent.rb
 - lib/quartz_torrent/blockstate.rb
+- lib/quartz_torrent/httptrackerdriver.rb
 - lib/quartz_torrent/memprofiler.rb
+- lib/quartz_torrent/alarm.rb
 - lib/quartz_torrent/regionmap.rb
-- lib/quartz_torrent/httptrackerclient.rb
+- lib/quartz_torrent/udptrackerdriver.rb
+- lib/quartz_torrent/torrentqueue.rb
 - lib/quartz_torrent/interruptiblesleep.rb
 - lib/quartz_torrent/extension.rb
 - lib/quartz_torrent/util.rb
 - lib/quartz_torrent/log.rb
 - lib/quartz_torrent/metainfo.rb
 - lib/quartz_torrent/trackerclient.rb
+- lib/quartz_torrent/timermanager.rb
 - lib/quartz_torrent/peermsgserialization.rb
 - lib/quartz_torrent/semaphore.rb
 - lib/quartz_torrent/reactor.rb
@@ -162,7 +166,6 @@ files:
 - lib/quartz_torrent/peermsg.rb
 - lib/quartz_torrent/filemanager.rb
 - lib/quartz_torrent/magnet.rb
-- lib/quartz_torrent/udptrackerclient.rb
 - README.md
 - LICENSE
 - .yardopts

data/lib/quartz_torrent/udptrackerclient.rb

@@ -1,70 +0,0 @@
-module QuartzTorrent
-  # A tracker client that uses the UDP protocol as defined by http://xbtt.sourceforge.net/udp_tracker_protocol.html
-  class UdpTrackerClient < TrackerClient
-    # Set UDP receive length to a value that allows up to 100 peers to be returned in an announce.
-    ReceiveLength = 620 
-    def initialize(announceUrl, infoHash, dataLength)
-      super(announceUrl, infoHash, dataLength)
-      @logger = LogManager.getLogger("udp_tracker_client")
-      if @announceUrl =~ /udp:\/\/([^:]+):(\d+)/
-        @host = $1
-        @trackerPort = $2
-      else
-        throw "UDP Tracker announce URL is invalid: #{announceUrl}"
-      end
-    end
-
-    def request(event = nil)
-      if event == :started
-        event = UdpTrackerMessage::EventStarted
-      elsif event == :stopped
-        event = UdpTrackerMessage::EventStopped
-      elsif event == :completed
-        event = UdpTrackerMessage::EventCompleted
-      else
-        event = UdpTrackerMessage::EventNone
-      end
-
-      socket = UDPSocket.new
-      socket.connect @host, @trackerPort
-
-      @logger.debug "Sending UDP tracker request to #{@host}:#{@trackerPort}"
-
-      # Send connect request
-      req = UdpTrackerConnectRequest.new
-      socket.send req.serialize, 0
-      resp = UdpTrackerConnectResponse.unserialize(socket.recvfrom(ReceiveLength)[0])
-      raise "Invalid connect response: response transaction id is different from the request transaction id" if resp.transactionId != req.transactionId
-      connectionId = resp.connectionId
-
-      dynamicParams = @dynamicRequestParamsBuilder.call
-
-      # Send announce request      
-      req = UdpTrackerAnnounceRequest.new(connectionId)
-      req.peerId = @peerId
-      req.infoHash = @infoHash
-      req.downloaded = dynamicParams.downloaded
-      req.left = dynamicParams.left
-      req.uploaded = dynamicParams.uploaded
-      req.event = event
-      #req.port = socket.addr[1]
-      req.port = @port
-      socket.send req.serialize, 0
-      resp = UdpTrackerAnnounceResponse.unserialize(socket.recvfrom(ReceiveLength)[0])
-      socket.close
-
-      peers = []
-      resp.ips.length.times do |i|
-        ip = resp.ips[i].unpack("CCCC").join('.')
-        port = resp.ports[i].unpack("n").first
-        peers.push TrackerPeer.new ip, port
-      end
-      peers
-
-      result = TrackerResponse.new(true, nil, peers)
-      result.interval = resp.interval if resp.interval
-      result
-    end
-  end
-
-end