quartz_torrent 0.0.1

data/lib/quartz_torrent/regionmap.rb

@@ -0,0 +1,124 @@
+class Array
+  def binsearch(low = nil, high = nil) 
+    return nil if length == 0
+    result = binsearch_index(low, high){ |x| yield x if !x.nil?}
+    result = at(result) if result
+    result
+  end
+
+  def binsearch_index(low = nil, high = nil) 
+    return nil if length == 0
+    low = 0 if !low
+    high = length if !high
+
+    if low == high
+      if yield at(low)
+        return low
+      else
+        return nil
+      end
+    end
+
+    mid = (high-low)/2 + low
+    if yield at(mid)
+      # this value >= target.
+      result = binsearch_index(low, mid == low ? mid : mid-1){ |x| yield x if !x.nil?}
+      if result
+        return result
+      else
+        return mid
+      end
+    else
+      # this value < target
+      binsearch_index(mid == high ? mid : mid+1, high){ |x| yield x if !x.nil?}
+    end
+  end
+end
+
+module QuartzTorrent
+  # This class is used to map consecutive integer regions to objects. The lowest end of the 
+  # lowest region is assumed to be 0.
+  class RegionMap
+    def initialize
+      @map = []
+      @sorted = false
+    end
+
+    # Add a region that ends at the specified 'regionEnd' with the associated 'obj'
+    def add(regionEnd, obj)
+      @map.push [regionEnd, obj]
+      @sorted = false
+    end
+
+    # Given an integer value, find which region it falls in and return the object associated with that region.
+    def findValue(value)
+      if ! @sorted
+        @map.sort{ |a,b| a[0] <=> b[0] }
+        @sorted = true
+      end
+      
+      @map.binsearch{|x| x[0] >= value}[1]
+    end
+
+    def findIndex(value)
+      if ! @sorted
+        @map.sort{ |a,b| a[0] <=> b[0] }
+        @sorted = true
+      end
+      
+      @map.binsearch_index{|x| x[0] >= value}
+    end
+
+    # Given a value, return a list of the form [index, value, left, right, offset] where
+    # index is the zero-based index in this map of the region, value is the associated object, 
+    # left is the lowest value in the region, right is the highest, and offset is the
+    # offset within the region of the value.
+    def find(value)
+      
+      index = findIndex(value)
+      return nil if ! index
+      result = at(index)
+
+      if index == 0
+        offset = value
+      else
+        offset = value - result[1]
+      end
+      
+      [index, result[0], result[1], result[2], offset]
+    end
+
+    # For the region with index i, return an array of the form [value, left, right]
+    def at(i)
+      return nil if @map.length == 0
+      if i == 0
+        left = 0
+      else
+        left = @map[i-1][0]+1
+      end
+
+      [@map[i][1],left,@map[i][0]]
+    end
+
+    def [](i)
+      at(i)
+    end
+ 
+    # Return the rightmost index of the final region, or -1 if no regions have been added.
+    def maxIndex
+      @map.size-1
+    end
+
+    # For the final region, return an array of the form [index, value, left, right]
+    def last
+      return nil if ! @map.last
+      if @map.length == 1
+        left = 0
+      else
+        left = @map[@map.length-2][0]+1
+      end
+      [@map.length-1,@map.last[1],left,@map.last[0]]
+    end
+
+  end
+end

data/lib/quartz_torrent/semaphore.rb

@@ -0,0 +1,43 @@
+
+# Implements a counting semaphore.
+class Semaphore
+  # Create a new semaphore initialized to the specified count.
+  def initialize(count = 0)
+    @mutex = Mutex.new
+    @count = count
+    @sleeping = []
+  end
+
+  # Wait on the semaphore. If the count zero or below, the calling thread blocks.
+  def wait
+    c = nil
+    @mutex.synchronize do
+      @count -= 1
+      c = @count
+    end
+
+    if c < 0
+      @mutex.synchronize do
+        @sleeping.push Thread.current
+      end
+      Thread.stop
+    end
+  end
+
+  # Signal the semaphore. If the count is below zero the waiting threads are woken.
+  def signal
+    c = nil
+    @mutex.synchronize do
+      c = @count
+      @count += 1
+    end
+    if c < 0 
+      t = nil
+      @mutex.synchronize do
+        t = @sleeping.shift
+      end
+      t.wakeup if t
+    end
+  end
+end
+

data/lib/quartz_torrent/trackerclient.rb

@@ -0,0 +1,271 @@
+require "quartz_torrent/log"
+require "quartz_torrent/metainfo"
+require "quartz_torrent/udptrackermsg"
+require "quartz_torrent/httptrackerclient"
+require "quartz_torrent/udptrackerclient"
+require "quartz_torrent/interruptiblesleep"
+require "quartz_torrent/util"
+require "net/http"
+require "cgi"
+require "thread"
+# http://xbtt.sourceforge.net/udp_tracker_protocol.html
+# https://wiki.theory.org/BitTorrentSpecification
+# http://stackoverflow.com/questions/9669152/get-https-response
+
+module QuartzTorrent
+ 
+  # Represents a peer returned by the tracker
+  class TrackerPeer
+    def initialize(ip, port, id = nil)
+      if ip =~ /(\d+).(\d+).(\d+).(\d+)/
+        @ip = ip
+        @port = port
+        @id = id
+      
+        @hash = $1.to_i << 24 + 
+          $2.to_i << 16 + 
+          $3.to_i << 8 +
+          $4.to_i +
+          port << 32
+
+        @displayId = nil
+        @displayId = id.gsub(/[\x80-\xff]/,'?') if id
+      else
+        raise "Invalid IP address #{ip}"
+      end
+    end
+
+    def hash
+      @hash
+    end
+
+    def eql?(o)
+      o.ip == @ip && o.port == @port
+    end
+
+    # Ip address, a string in dotted-quad notation
+    attr_accessor :ip
+    attr_accessor :port
+    attr_accessor :id
+
+    def to_s
+      "#{@displayId ? "["+@displayId+"] " : ""}#{ip}:#{port}"
+    end
+  end
+
+  # Dynamic parameters needed when making a request to the tracker.
+  class TrackerDynamicRequestParams
+    def initialize(dataLength = nil)
+      @uploaded = 0
+      @downloaded = 0
+      if dataLength
+        @left = dataLength.to_i
+      else
+        @left = 0
+      end
+    end
+    attr_accessor :uploaded
+    attr_accessor :downloaded
+    attr_accessor :left
+  end
+
+  # Represents the response from a tracker request
+  class TrackerResponse
+    def initialize(success, error, peers)
+      @success = success
+      @error = error
+      @peers = peers
+      @interval = nil
+    end
+
+    # The error message if this was not successful
+    attr_reader :error
+
+    # The list of peers from the response if the request was a success.
+    attr_reader :peers
+
+    # Refresh interval in seconds
+    attr_accessor :interval
+
+    # Returns true if the Tracker response was a success
+    def successful?
+      @success
+    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
+    include QuartzTorrent
+
+    def initialize(announceUrl, infoHash, dataLength = 0, maxErrors = 20)
+      @peerId = "-QR0001-" # Azureus style
+      @peerId << Process.pid.to_s
+      @peerId = @peerId + "x" * (20-@peerId.length)
+      @stopped = false
+      @started = false
+      @peers = {}
+      @port = 6881
+      @peersMutex = Mutex.new
+      @errors = []
+      @maxErrors = @errors
+      @sleeper = InterruptibleSleep.new
+      # Event to send on the next update
+      @event = :started
+      @worker = nil
+      @logger = LogManager.getLogger("tracker_client")
+      @announceUrl = announceUrl
+      @infoHash = infoHash
+      @peersChangedListeners = []
+      @dynamicRequestParamsBuilder = Proc.new{ TrackerDynamicRequestParams.new(dataLength) }
+    end
+    
+    attr_reader :peerId
+    attr_accessor :port
+    # This should be set to a Proc that when called will return a TrackerDynamicRequestParams object
+    # with up-to-date information.
+    attr_accessor :dynamicRequestParamsBuilder
+
+    def started?
+      @started
+    end
+
+    def peers
+      result = nil
+      @peersMutex.synchronize do
+        result = @peers.keys
+      end
+      result
+    end
+
+    # Add a listener that gets notified when the peers list has changed.
+    # This listener is called from another thread so be sure to synchronize
+    # if necessary. The passed listener should be a proc that takes no arguments.
+    def addPeersChangedListener(listener)
+      @peersChangedListeners.push listener
+    end
+    def removePeersChangedListener(listener)
+      @peersChangedListeners.delete listener
+    end
+
+    # Get the last N errors reported 
+    def errors
+      @errors
+    end
+
+    # Create a new TrackerClient using the passed information.
+    def self.create(announceUrl, infoHash, dataLength = 0, start = true)
+      result = nil
+      if announceUrl =~ /udp:\/\//
+        result = UdpTrackerClient.new(announceUrl, infoHash, dataLength)
+      else
+        result = HttpTrackerClient.new(announceUrl, infoHash, dataLength)
+      end
+      result.start if start
+
+      result
+    end
+
+    def self.createFromMetainfo(metainfo, start = true)
+      create(metainfo.announce, metainfo.infoHash, metainfo.info.dataLength, start)
+    end
+
+    # Start the worker thread
+    def start
+      @stopped = false
+      return if @started
+      @started = true
+      @worker = Thread.new do
+        QuartzTorrent.initThread("trackerclient")
+        @logger.info "Worker thread starting"
+        @event = :started
+        trackerInterval = nil
+        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")
+            end
+
+            if response && response.successful?
+              # Replace the list of peers
+              peersHash = {}
+              @logger.info "Response contained #{response.peers.length} peers"
+              response.peers.each do |p|
+                peersHash[p] = 1
+              end
+              @peersMutex.synchronize do
+                @peers = peersHash
+              end
+              if @peersChangedListeners.size > 0
+                @peersChangedListeners.each{ |l| l.call }
+              end
+            else
+              @logger.debug "Response was unsuccessful from tracker"
+              addError response.error if response
+            end
+
+            # If we have no interval from the tracker yet, and the last request didn't error out leaving us with no peers,
+            # then set the interval to 20 seconds.
+            interval = trackerInterval
+            interval = 20 if ! interval
+            interval = 2 if response && !response.successful? && @peers.length == 0
+
+            @logger.debug "Sleeping for #{interval} seconds"
+            @sleeper.sleep interval 
+
+          rescue
+            @logger.warn "Unhandled exception in worker thread: #{$!}"
+            @logger.warn $!.backtrace.join("\n")
+          end
+        end
+        @logger.info "Worker thread shutting down"
+        @logger.info "Sending final update to tracker"
+        begin
+          request(:stopped)
+        rescue
+          addError $!
+          @logger.debug "Request failed due to exception: #{$!}"
+          @logger.debug $!.backtrace.join("\n")
+        end
+        @started = false
+      end
+    end
+
+    # Stop the worker thread
+    def stop
+      @stopped = true
+      @sleeper.wake
+      if @worker
+        @logger.info "Stop called. Waiting for worker"
+        @logger.info "Worker wait timed out after 2 seconds. Shutting down anyway" if ! @worker.join(2)
+      end
+    end
+
+    # Notify the tracker that we have finished downloading all pieces.
+    def completed
+      @event = :completed
+      @sleeper.wake
+    end
+
+    # Add an error to the error list
+    def addError(e)
+      @errors.pop if @errors.length == @maxErrors
+      @errors.push e
+    end
+  
+    private
+    def eventValid?(event)
+      event == :started || event == :stopped || event == :completed
+    end
+  end
+
+
+end

data/lib/quartz_torrent/udptrackerclient.rb

@@ -0,0 +1,70 @@
+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