quartz_torrent 0.1.1 → 0.2.0

data/README.md

@@ -16,6 +16,7 @@ Features:
   - Upload and download rate limiting
   - Upload ratio enforcement
   - Upload duration limit
+  - Torrent Queueing
 
 Requirements
 ------------
@@ -99,14 +100,10 @@ And a specific test case in a test using:
 
 To-Do
 -----
-  - Start a peerclient with the full torrent. Connect with another peerclient and start downloading, then pause.
+  - Bug: Start a peerclient with the full torrent. Connect with another peerclient and start downloading, then pause.
     Finally unpause. The "server" peerclient will refuse the connections to re-establish because it believes the
     peer is already connected.
-  - Improve CPU usage. 
-  - Implement endgame strategy and support Cancel messages.
-  - Refactor Metadata.Info into it's own independent class.
   - Improve Documentation
-  - In peerclient, prefix log messages with torrent infohash, or (truncated) torrent name
   - Implement uTP
     - <http://www.bittorrent.org/beps/bep_0029.html#packet-sizes>
     - <https://forum.utorrent.com/viewtopic.php?id=76640>

data/bin/quartztorrent_download_curses

@@ -128,19 +128,16 @@ class SummaryScreen < Screen
   end
 
   private
-  def summaryLine(state, paused, size, uploadRate, downloadRate, complete, total, progress)
+  def summaryLine(state, paused, queued, size, uploadRate, downloadRate, complete, total, progress)
     if state == :downloading_metainfo
       "     %12s  Rate: %6s | %6s  Bytes: %4d/%4d Progress: %5s\n" % [state, uploadRate, downloadRate, complete, total, progress]
     else
       primaryState = state.to_s
       secondaryState = ""
-      if state == :running && complete == total
-        secondaryState = "(completed)"
-      elsif (state == :running || state == :uploading) && paused
-        secondaryState = "(paused)"
-      end
+      secondaryState += "(paused)" if paused
+      secondaryState += "(queued)" if queued
       state = "#{primaryState} #{secondaryState}"
-      "     %12s  %9s  Rate: %6s | %6s  Pieces: %4d/%4d Progress: %5s\n" % [state, size, uploadRate, downloadRate, complete, total, progress]
+      "     %14s  %9s  Rate: %6s | %6s  Pieces: %4d/%4d Progress: %5s\n" % [state, size, uploadRate, downloadRate, complete, total, progress]
     end
   end
 
@@ -189,6 +186,7 @@ class SummaryScreen < Screen
       display.push summaryLine(
         state,
         torrent.paused,
+        torrent.queued,
         Formatter.formatSize(dataLength),
         Formatter.formatSpeed(torrent.uploadRate),
         Formatter.formatSpeed(torrent.downloadRate),
@@ -348,7 +346,7 @@ class DebugScreen < Screen
     @profiler.trackClass QuartzTorrent::PieceManager::Result
     @profiler.trackClass QuartzTorrent::Formatter
     @profiler.trackClass QuartzTorrent::TrackerClient
-    @profiler.trackClass QuartzTorrent::HttpTrackerClient
+    @profiler.trackClass QuartzTorrent::HttpTrackerDriver
     @profiler.trackClass QuartzTorrent::InterruptibleSleep
     @profiler.trackClass QuartzTorrent::LogManager
     @profiler.trackClass QuartzTorrent::Metainfo
@@ -392,7 +390,7 @@ class DebugScreen < Screen
     @profiler.trackClass QuartzTorrent::TrackerDynamicRequestParams
     @profiler.trackClass QuartzTorrent::TrackerResponse
     @profiler.trackClass QuartzTorrent::TrackerClient
-    @profiler.trackClass QuartzTorrent::UdpTrackerClient
+    @profiler.trackClass QuartzTorrent::UdpTrackerDriver
     @profiler.trackClass QuartzTorrent::UdpTrackerMessage
     @profiler.trackClass QuartzTorrent::UdpTrackerRequest
     @profiler.trackClass QuartzTorrent::UdpTrackerResponse
@@ -605,17 +603,6 @@ def initializeLogging(file)
     setLogfile file
     setDefaultLevel :info
   end
-  LogManager.setLevel "peer_manager", :debug
-  LogManager.setLevel "tracker_client", :debug
-  LogManager.setLevel "http_tracker_client", :debug
-  LogManager.setLevel "udp_tracker_client", :debug
-  LogManager.setLevel "peerclient", :debug
-  LogManager.setLevel "peerclient.reactor", :info
-  #LogManager.setLevel "peerclient.reactor", :debug
-  LogManager.setLevel "blockstate", :debug
-  LogManager.setLevel "piecemanager", :info
-  LogManager.setLevel "peerholder", :debug
-  #LogManager.setLevel "peermsg_serializer", :debug
 end
 
 def help
@@ -657,7 +644,9 @@ class Settings
     @uploadLimit = nil
     @downloadLimit = nil
     @uploadRatio = nil
-    @logfile = "/tmp/download_torrent_curses.log"
+    @logfile = "/tmp/download_torrent_curses.pid#{Process.pid}_.log"
+    @maxIncomplete = 5
+    @maxActive = 10
   end
 
   attr_accessor :baseDirectory
@@ -667,6 +656,20 @@ class Settings
   attr_accessor :uploadRatio
   attr_accessor :logfile
   attr_accessor :debugTTY
+  attr_accessor :maxIncomplete
+  attr_accessor :maxActive
+
+  def validate
+    if @maxIncomplete > @maxActive
+      puts "Max number of incomplete torrents must be <= Max number of active torrents"
+      return false
+    end
+    if @maxActive <= 0 || @maxIncomplete <= 0
+      puts "Max number of incomplete torrents and max number of active torrents must both be > 0"
+      return false
+    end
+    true
+  end
 end
 
 class PeerClient
@@ -702,6 +705,8 @@ begin
     [ '--help', '-h', GetoptLong::NO_ARGUMENT],
     [ '--ratio', '-r', GetoptLong::REQUIRED_ARGUMENT],
     [ '--debug-tty', '-t', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--queue-max-incomplete', '-i', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--queue-max-active', '-a', GetoptLong::REQUIRED_ARGUMENT],
   )
 
   opts.each do |opt, arg|
@@ -720,14 +725,18 @@ begin
       $settings.uploadRatio = arg.to_f
     elsif opt == '--debug-tty'
       $log = File.open arg, "w"
+    elsif opt == '--queue-max-incomplete'
+      $settings.maxIncomplete = arg.to_i
+    elsif opt == '--queue-max-active'
+      $settings.maxActive = arg.to_i
     end
   end
+  exit 1 if ! $settings.validate
 
   torrents = ARGV
 
   $log = File.open("/dev/null","w") if $log == $stdout
   
-
   initializeCurses
   cursesInitialized = true
   initializeLogging($settings.logfile)
@@ -743,7 +752,7 @@ begin
   scrManager.add :add, AddScreen.new(Ncurses::stdscr)
   scrManager.set :summary
 
-  peerclient = QuartzTorrent::PeerClient.new($settings.baseDirectory)
+  peerclient = QuartzTorrent::PeerClient.new($settings.baseDirectory, $settings.maxIncomplete, $settings.maxActive)
   peerclient.port = $settings.port
 
   torrents.each do |torrent|
@@ -769,7 +778,6 @@ begin
 
   RubyProf.start if $doProfiling
 
-  #puts "Starting peer client"
   peerclient.start
 
   while running

data/bin/quartztorrent_show_info

@@ -29,7 +29,7 @@ end
 info = nil
 begin
   metainfo = Metainfo.createFromFile(torrent)
-  puts "Info Hash: #{bytesToHex(metainfo.infoHash)}"
+  puts "Info Hash: #{QuartzTorrent.bytesToHex(metainfo.infoHash)}"
   puts "Announce: #{metainfo.announce}" if metainfo.announce
   if metainfo.announceList
     puts "Announce list: "
@@ -43,10 +43,7 @@ begin
   info = metainfo.info
 rescue
   # Doesn't seem to be a complete .torrent file. Maybe it is just the info part.
-  File.open(torrent, "r") do |file|
-    bencoded = file.read
-    info = Metainfo::Info.createFromBdecode(bencoded.bdecode)
-  end
+  info = info = Metainfo::Info.createFromBdecode(BEncode.load_file(torrent, {:ignore_trailing_junk => 1} ))
 end
 
 if info

data/lib/quartz_torrent/alarm.rb

@@ -0,0 +1,36 @@
+module QuartzTorrent
+  class Alarm
+    def initialize(id, details)
+      @details = details
+      @time = Time.new
+    end
+
+    attr_accessor :id
+    attr_accessor :details
+    attr_accessor :time
+  end
+
+  class Alarms
+    def initialize
+      @alarms = {}
+    end
+
+    # Raise a new alarm, or overwrite the existing alarm with the same id if one exists.
+    def raise(alarm)
+      @alarms[alarm.id] = alarm
+    end
+
+    def clear(alarm)
+      if alarm.is_a?(Alarm)
+        @alarms.delete alarm.id
+      else
+        # Assume variable `alarm` is an id.
+        @alarms.delete alarm
+      end
+    end
+
+    def all
+      @alarms.values
+    end
+  end
+end

data/lib/quartz_torrent/blockstate.rb

@@ -222,6 +222,13 @@ module QuartzTorrent
       result
     end
 
+    # Get a bitfield representing the completed pieces.
+    def completeBlockBitfield
+      result = Bitfield.new(@numBlocks)
+      result.copyFrom(@completeBlocks)
+      result
+    end
+
     # Number of bytes we have downloaded and verified.
     def completedLength
       num = @completeBlocks.countSet

data/lib/quartz_torrent/formatter.rb

@@ -11,6 +11,7 @@ module QuartzTorrent
 
     # Format a size in bytes.
     def self.formatSize(size)
+      return nil if !size
       s = size.to_f
       if s >= Gig
         s = "%.2fGB" % (s / Gig)
@@ -26,17 +27,24 @@ module QuartzTorrent
 
     # Format a floating point number as a percentage with one decimal place.
     def self.formatPercent(frac)
+      return nil if ! frac
       s = "%.1f" % (frac.to_f*100)
       s + "%"
     end
     
     # Format a speed in bytes per second.
     def self.formatSpeed(s)
-      Formatter.formatSize(s) + "/s"
+      size = Formatter.formatSize(s)
+      if size
+        size + "/s"
+      else
+        nil
+      end
     end
 
     # Format a duration of time in seconds.
     def self.formatTime(secs)
+      return nil if ! secs
       s = ""
       time = secs.to_i
       arr = []
@@ -68,6 +76,7 @@ module QuartzTorrent
 
     # Parse a size in the format '50 KB'
     def self.parseSize(size)
+      return nil if ! size
       if size =~ /(\d+(?:\.\d+)?)\s*([^\d]+)*/
         value = $1.to_f
         suffix = ($2 ? $2.downcase : nil)

data/lib/quartz_torrent/{httptrackerclient.rb → httptrackerdriver.rb}

@@ -1,13 +1,17 @@
 module QuartzTorrent
   class TrackerClient
   end
+  class TrackerDriver
+  end
 
-  # A tracker client that uses the HTTP protocol. This is the classic BitTorrent tracker protocol.
-  class HttpTrackerClient < TrackerClient
-    def initialize(announceUrl, infoHash, dataLength)
-      super(announceUrl, infoHash, dataLength)
+  # A tracker driver that uses the HTTP protocol. This is the classic BitTorrent tracker protocol.
+  class HttpTrackerDriver < TrackerDriver
+    def initialize(announceUrl, infoHash)
+      super()
       @startSent = false
       @logger = LogManager.getLogger("http_tracker_client")
+      @announceUrl = announceUrl
+      @infoHash = infoHash
     end
  
     # Request a list of peers from the tracker and return it as a TrackerResponse.   
@@ -24,8 +28,8 @@ module QuartzTorrent
 
       params = {}
       params['info_hash'] = CGI.escape(@infoHash)
-      params['peer_id'] = @peerId
-      params['port'] = @port
+      params['peer_id'] = dynamicParams.peerId
+      params['port'] = dynamicParams.port
       params['uploaded'] = dynamicParams.uploaded.to_s
       params['downloaded'] = dynamicParams.downloaded.to_s
       params['left'] = dynamicParams.left.to_s
@@ -50,7 +54,11 @@ module QuartzTorrent
       end
       uri.query = query
   
-      res = Net::HTTP.get_response(uri)
+      begin
+        res = Net::HTTP.get_response(uri)
+      rescue Timeout::Error
+        return TrackerResponse.new(false, "Tracker request timed out", []) 
+      end
       @logger.debug "Tracker response code: #{res.code}"
       @logger.debug "Tracker response body: #{res.body}"
       result = buildTrackerResponse(res)

data/lib/quartz_torrent/magnet.rb

@@ -60,6 +60,16 @@ module QuartzTorrent
       end
     end
 
+    # Return an array of all tracker URLS in the magnet link. 
+    def trackers
+      tr = @params['tr']
+      if tr
+        tr
+      else
+        []
+      end
+    end
+
     # Return the first display name found in the magnet link. Returns nil if the magnet has no display name.
     def displayName
       dn = @params['dn']

data/lib/quartz_torrent/metainfo.rb

@@ -58,6 +58,7 @@ module QuartzTorrent
         # multi-file download. For a single-file download the 
         @files = []
         @logger = LogManager.getLogger("metainfo")
+        @source = nil
       end
 
       # Array of FileInfo objects
@@ -70,6 +71,8 @@ module QuartzTorrent
       attr_accessor :pieces
       # True if no external peer source is allowed.
       attr_accessor :private
+      # Optional source
+      attr_accessor :source
 
       # Total length of the torrent data in bytes.
       def dataLength
@@ -81,6 +84,7 @@ module QuartzTorrent
         result = Info.new
         result.pieceLen = infoDict['piece length']
         result.private = infoDict['private']
+        result.source = infoDict['source']
         result.pieces = parsePieces(Metainfo.valueOrException(infoDict['pieces'], "Torrent metainfo is missing the pieces property."))
         result.name = Metainfo.valueOrException(infoDict['name'], "Torrent metainfo is missing the name property.")
 
@@ -110,6 +114,7 @@ module QuartzTorrent
 
         hash['piece length'] = @pieceLen
         hash['private'] = @private if @private
+        hash['source'] = @source if @source
         hash['name'] = @name
         hash['pieces'] = @pieces.join
 
@@ -177,7 +182,7 @@ module QuartzTorrent
     def self.createFromString(data)
       logger = LogManager.getLogger("metainfo")
 
-      decoded = data.bdecode
+      decoded = BEncode.load(data, {:ignore_trailing_junk => 1})
       logger.debug "Decoded torrent metainfo: #{decoded.inspect}"
       result = Metainfo.new
       result.createdBy = decoded['created by']

data/lib/quartz_torrent/metainfopiecestate.rb

@@ -92,7 +92,7 @@ module QuartzTorrent
           # Sanity check
           testInfoHash = Digest::SHA1.digest( bencoded )
           if testInfoHash == infoHash
-            result = Metainfo::Info.createFromBdecode(bencoded.bdecode) 
+            result = Metainfo::Info.createFromBdecode(BEncode.load(bencoded, {:ignore_trailing_junk => 1})) 
           else
             logger.info "the computed SHA1 hash doesn't match the specified infoHash in #{path}"
           end
@@ -120,7 +120,11 @@ module QuartzTorrent
 
     # Return true if the specified piece is completed. The piece is specified by index.
     def pieceCompleted?(pieceIndex)
-      @completePieces.set? pieceIndex
+      if pieceIndex >= 0 && pieceIndex < @completePieces.length
+        @completePieces.set? pieceIndex
+      else
+        false
+      end
     end
 
     # Do we have all the pieces of the metadata?

data/lib/quartz_torrent/peerclient.rb

@@ -13,6 +13,8 @@ require "quartz_torrent/piecemanagerrequestmetadata.rb"
 require "quartz_torrent/metainfopiecestate.rb"
 require "quartz_torrent/extension.rb"
 require "quartz_torrent/magnet.rb"
+require "quartz_torrent/torrentqueue.rb"
+require "quartz_torrent/alarm.rb"
 
 
 module QuartzTorrent
@@ -52,11 +54,14 @@ module QuartzTorrent
       @checkPieceManagerTimer = nil
       @requestBlocksTimer = nil
       @paused = false
+      @queued = false
       @downRateLimit = nil
       @upRateLimit = nil
       @ratio = nil
       @uploadDuration = nil
       @downloadCompletedTime = nil
+      @isEndgame = false
+      @alarms = Alarms.new
     end
     # The torrents Metainfo.Info struct. This is nil if the torrent has no metadata and we need to download it
     # (i.e. a magnet link)
@@ -79,7 +84,15 @@ module QuartzTorrent
     attr_accessor :bytesUploadedDataOnly
     attr_accessor :bytesDownloaded
     attr_accessor :bytesUploaded
+    # State of the torrent. Is one of the following states:
+    #   :initializing           Datastructures have been created, but no work started.
+    #   :checking_pieces        Checking piece hashes on startup
+    #   :downloading_metainfo   Downloading the torrent metainfo
+    #   :uploading              The torrent is complete and we are only uploading
+    #   :running                The torrent is incomplete and we are downloading and uploading
+    #   :error                  There was an unrecoverable error with the torrent. 
     attr_accessor :state
+    attr_accessor :isEndgame
     attr_accessor :metainfoPieceState
     # The timer handle for the timer that requests metainfo pieces. This is used to cancel the 
     # timer when the metadata is completely downloaded.
@@ -92,8 +105,10 @@ module QuartzTorrent
     attr_accessor :checkPieceManagerTimer
     # Timer handle for timer that requests blocks
     attr_accessor :requestBlocksTimer
-
+    # Is the torrent paused
     attr_accessor :paused
+    # Is the torrent queued
+    attr_accessor :queued
     # The RateLimit for downloading this torrent.
     attr_accessor :downRateLimit
     # The RateLimit for uploading to peers for this torrent.
@@ -105,7 +120,8 @@ module QuartzTorrent
     attr_accessor :uploadDuration
     # Time at which we completely downloaded all bytes of the torrent.
     attr_accessor :downloadCompletedTime
-
+    # Alarms object for this torrent
+    attr_reader :alarms
   end
 
   # Data about torrents for use by the end user. 
@@ -150,6 +166,8 @@ module QuartzTorrent
     attr_reader :metainfoCompletedLength
     # Whether or not the torrent is paused.
     attr_reader :paused
+    # Whether or not the torrent is queued.
+    attr_reader :queued
     # After we have completed downloading a torrent, we will continue to upload until we have 
     # uploaded ratio * torrent_size bytes. If nil, no limit on upload.
     attr_accessor :ratio
@@ -158,6 +176,8 @@ module QuartzTorrent
     attr_accessor :bytesDownloadedDataOnly
     attr_accessor :bytesUploaded
     attr_accessor :bytesDownloaded
+    # Array of currently raised alarms
+    attr_accessor :alarms
   
     # Update the data in this TorrentDataDelegate from the torrentData
     # object that it was created from. TODO: What if that torrentData is now gone?
@@ -199,6 +219,7 @@ module QuartzTorrent
       @state = torrentData.state
       @metainfoLength = nil
       @paused = torrentData.paused
+      @queued = torrentData.queued
       @metainfoCompletedLength = nil
       if torrentData.metainfoPieceState && torrentData.state == :downloading_metainfo
         @metainfoLength = torrentData.metainfoPieceState.metainfoLength
@@ -219,6 +240,7 @@ module QuartzTorrent
       @uploadRateLimit = torrentData.upRateLimit.unitsPerSecond if torrentData.upRateLimit
       @ratio = torrentData.ratio
       @uploadDuration = torrentData.uploadDuration
+      @alarms = torrentData.alarms.all
     end
 
     def buildPeersList(torrentData)
@@ -233,9 +255,10 @@ module QuartzTorrent
   # This class implements a Reactor Handler object. This Handler implements the PeerClient.
   class PeerClientHandler < QuartzTorrent::Handler
   
-    def initialize(baseDirectory)
+    def initialize(baseDirectory, maxIncomplete = 5, maxActive = 10)
       # Hash of TorrentData objects, keyed by torrent infoHash
       @torrentData = {}
+      @torrentQueue = TorrentQueue.new(maxIncomplete, maxActive)
 
       @baseDirectory = baseDirectory
 
@@ -250,8 +273,11 @@ module QuartzTorrent
       @requestBlocksPeriod = 1
       @handshakeTimeout = 1
       @requestTimeout = 60
+      @endgameBlockThreshold = 20
     end
 
+    ################################################ PUBLIC API METHODS ################################################ 
+
     attr_reader :torrentData
 
     # Add a new tracker client. This effectively adds a new torrent to download. Returns the TorrentData object for the 
@@ -259,51 +285,28 @@ module QuartzTorrent
     def addTrackerClient(infoHash, info, trackerclient)
       raise "There is already a tracker registered for torrent #{QuartzTorrent.bytesToHex(infoHash)}" if @torrentData.has_key? infoHash
       torrentData = TorrentData.new(infoHash, info, trackerclient)
+      trackerclient.alarms = torrentData.alarms
       @torrentData[infoHash] = torrentData
+      torrentData.info = info
+      torrentData.state = :initializing
 
-      # If we already have the metainfo info for this torrent, we can begin checking the pieces. 
-      # If we don't have the metainfo info then we need to get the metainfo first.
-      if ! info
-        info = MetainfoPieceState.downloaded(@baseDirectory, torrentData.infoHash)
-        torrentData.info = info
-      end
-
-      if info
-        startCheckingPieces torrentData
-      else
-        # Request the metainfo from peers.
-        torrentData.state = :downloading_metainfo
-
-        @logger.info "Downloading metainfo"
-        #torrentData.metainfoPieceState = MetainfoPieceState.new(@baseDirectory, infoHash, )
-
-        # Schedule peer connection management. Recurring and immediate 
-        torrentData.managePeersTimer = 
-          @reactor.scheduleTimer(@managePeersPeriod, [:manage_peers, torrentData.infoHash], true, true)
+      queue(torrentData)
+      dequeue      
 
-        # Schedule a timer for requesting metadata pieces from peers.
-        torrentData.metainfoRequestTimer = 
-          @reactor.scheduleTimer(@requestBlocksPeriod, [:request_metadata_pieces, infoHash], true, false)
-
-        # Schedule checking for metainfo PieceManager results (including when piece reading completes)
-        torrentData.checkMetadataPieceManagerTimer =
-          @reactor.scheduleTimer(@requestBlocksPeriod, [:check_metadata_piece_manager, infoHash], true, false)
-      end
-      
       torrentData
     end
 
     # Remove a torrent.
     def removeTorrent(infoHash, deleteFiles = false)
       # Can't do this right now, since it could be in use by an event handler. Use an immediate, non-recurring timer instead.
-      @logger.info "Scheduling immediate timer to remove torrent #{QuartzTorrent.bytesToHex(infoHash)}. #{deleteFiles ? "Will" : "Wont"} delete downloaded files."
+      @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Scheduling immediate timer to remove torrent. #{deleteFiles ? "Will" : "Wont"} delete downloaded files."
       @reactor.scheduleTimer(0, [:removetorrent, infoHash, deleteFiles], false, true)
     end
 
     # Pause or unpause the specified torrent.
     def setPaused(infoHash, value)
       # Can't do this right now, since it could be in use by an event handler. Use an immediate, non-recurring timer instead.
-      @logger.info "Scheduling immediate timer to pause torrent #{QuartzTorrent.bytesToHex(infoHash)}."
+      @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Scheduling immediate timer to #{value ? "pause" : "unpause"} torrent."
       @reactor.scheduleTimer(0, [:pausetorrent, infoHash, value], false, true)
     end
 
@@ -381,6 +384,68 @@ module QuartzTorrent
       torrentData.uploadDuration = seconds
     end
 
+    # Adjust the bytesUploaded property of the specified torrent by the passed amount.
+    # Adjustment should be an integer. It is added to the current bytesUploaded amount.
+    def adjustBytesUploaded(infoHash, adjustment)
+      torrentData = @torrentData[infoHash]
+      if ! torrentData
+        @logger.warn "Asked to adjust uploaded bytes for a non-existent torrent #{QuartzTorrent.bytesToHex(infoHash)}"
+        return
+      end
+      
+      runInReactorThread do
+        torrentData.bytesUploaded += adjustment
+        torrentData.bytesUploadedDataOnly += adjustment
+      end
+    end
+
+    # Adjust the bytesDownloaded property of the specified torrent by the passed amount.
+    # Adjustment should be an integer. It is added to the current bytesDownloaded amount.
+    def adjustBytesDownloaded(infoHash, adjustment)
+      torrentData = @torrentData[infoHash]
+      if ! torrentData
+        @logger.warn "Asked to adjust uploaded bytes for a non-existent torrent #{QuartzTorrent.bytesToHex(infoHash)}"
+        return
+      end
+      
+      runInReactorThread do
+        torrentData.bytesDownloaded += adjustment
+        torrentData.bytesDownloadedDataOnly += adjustment
+      end
+    end
+
+    # Get a hash of new TorrentDataDelegate objects keyed by torrent infohash.
+    # This method is meant to be called from a different thread than the one
+    # the reactor is running in. This method is not immediate but blocks until the
+    # data is prepared. 
+    # If infoHash is passed, only that torrent data is returned (still in a hashtable; just one entry)
+    def getDelegateTorrentData(infoHash = nil)
+      # Use an immediate, non-recurring timer.
+      result = {}
+      return result if stopped?
+      semaphore = Semaphore.new
+      timer = @reactor.scheduleTimer(0, [:get_torrent_data, result, semaphore, infoHash], false, true)
+      if semaphore.wait(3)
+        result
+      else
+        @logger.warn "getDelegateTorrentData: Waiting on semaphore timed out"
+        throw "Waiting on semaphore for timer #{timer.object_id} timed out"
+      end
+    end
+
+    # Update the data stored in a TorrentDataDelegate to the latest information.
+    def updateDelegateTorrentData(delegate)
+      return if stopped?
+      # Use an immediate, non-recurring timer.
+      semaphore = Semaphore.new
+      @reactor.scheduleTimer(0, [:update_torrent_data, delegate, semaphore], false, true)
+      semaphore.wait
+      result
+    end
+
+
+    ################################################ REACTOR METHODS ################################################ 
+
     # Reactor method called when a peer has connected to us.
     def serverInit(metadata, addr, port)
       # A peer connected to us
@@ -638,6 +703,8 @@ module QuartzTorrent
         requestMetadataPieces(metadata[1])
       elsif metadata.is_a?(Array) && metadata[0] == :check_metadata_piece_manager
         checkMetadataPieceManagerResults(metadata[1])
+      elsif metadata.is_a?(Array) && metadata[0] == :runproc
+        metadata[1].call
       else
         @logger.info "Unknown timer #{metadata} expired."
       end
@@ -657,30 +724,7 @@ module QuartzTorrent
       close
     end
     
-    # Get a hash of new TorrentDataDelegate objects keyed by torrent infohash.
-    # This method is meant to be called from a different thread than the one
-    # the reactor is running in. This method is not immediate but blocks until the
-    # data is prepared. 
-    # If infoHash is passed, only that torrent data is returned (still in a hashtable; just one entry)
-    def getDelegateTorrentData(infoHash = nil)
-      # Use an immediate, non-recurring timer.
-      result = {}
-      return result if stopped?
-      semaphore = Semaphore.new
-      @reactor.scheduleTimer(0, [:get_torrent_data, result, semaphore, infoHash], false, true)
-      semaphore.wait
-      result
-    end
-
-    def updateDelegateTorrentData(delegate)
-      return if stopped?
-      # Use an immediate, non-recurring timer.
-      semaphore = Semaphore.new
-      @reactor.scheduleTimer(0, [:update_torrent_data, delegate, semaphore], false, true)
-      semaphore.wait
-      result
-    end
-
+    ################################################ PRIVATE METHODS ################################################ 
     private
     def setPeerDisconnected(peer)
       peer.state = :disconnected
@@ -708,7 +752,7 @@ module QuartzTorrent
       return false if !torrentData
 
       if msg.peerId == torrentData.trackerClient.peerId
-        @logger.info "We connected to ourself. Closing connection."
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: We connected to ourself. Closing connection."
         peer.isUs = true
         close
         return
@@ -718,7 +762,7 @@ module QuartzTorrent
       if peers
         peers.each do |existingPeer|
           if existingPeer.state == :connected
-            @logger.warn "Peer with id #{msg.peerId} created a new connection when we already have a connection in state #{existingPeer.state}. Closing new connection."
+            @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Peer with id #{msg.peerId} created a new connection when we already have a connection in state #{existingPeer.state}. Closing new connection."
             torrentData.peers.delete existingPeer
             setPeerDisconnected(peer)
             close
@@ -734,12 +778,12 @@ module QuartzTorrent
         peer.bitfield = Bitfield.new(torrentData.info.pieces.length)
       else
         peer.bitfield = EmptyBitfield.new
-        @logger.info "We have no metainfo yet, so setting peer #{peer} to have an EmptyBitfield"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: We have no metainfo yet, so setting peer #{peer} to have an EmptyBitfield"
       end
 
       # Send extended handshake if the peer supports extensions
       if (msg.reserved.unpack("C8")[5] & 0x10) != 0
-        @logger.warn "Peer supports extensions. Sending extended handshake"
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Peer supports extensions. Sending extended handshake"
         extended = Extension.createExtendedHandshake torrentData.info
         extended.serializeTo currentIo
       end
@@ -764,7 +808,7 @@ module QuartzTorrent
     end
 
     def updatePeerWithHandshakeInfo(torrentData, msg, peer)
-      @logger.info "peer #{peer} sent valid handshake for torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)}"
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: peer #{peer} sent valid handshake for torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)}"
       peer.infoHash = msg.infoHash
       # If this was a peer we got from a tracker that had no id then we only learn the id on handshake.
       peer.trackerPeer.id = msg.peerId
@@ -788,7 +832,7 @@ module QuartzTorrent
         return
       end
 
-      return if torrentData.paused
+      return if torrentData.paused || torrentData.queued
 
       trackerclient = torrentData.trackerClient
 
@@ -799,19 +843,19 @@ module QuartzTorrent
 
       manager = torrentData.peerManager
       if ! manager
-        @logger.error "Manage peers: peer manager client for torrent #{QuartzTorrent.bytesToHex(infoHash)} not found."
+        @logger.error "#{QuartzTorrent.bytesToHex(infoHash)}: Manage peers: peer manager client for torrent #{QuartzTorrent.bytesToHex(infoHash)} not found."
         return
       end
 
       toConnect = manager.manageConnections(classifiedPeers)
       toConnect.each do |peer|
-        @logger.debug "Connecting to peer #{peer}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Connecting to peer #{peer}"
         connect peer.trackerPeer.ip, peer.trackerPeer.port, peer
       end
 
       manageResult = manager.managePeers(classifiedPeers)
       manageResult.unchoke.each do |peer|
-        @logger.debug "Unchoking peer #{peer}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Unchoking peer #{peer}"
         withPeersIo(peer, "unchoking peer") do |io|
           msg = Unchoke.new
           sendMessageToPeer msg, io, peer
@@ -820,7 +864,7 @@ module QuartzTorrent
       end
 
       manageResult.choke.each do |peer|
-        @logger.debug "Choking peer #{peer}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Choking peer #{peer}"
         withPeersIo(peer, "choking peer") do |io|
           msg = Choke.new
           sendMessageToPeer msg, io, peer
@@ -837,32 +881,44 @@ module QuartzTorrent
         return
       end
 
-      return if torrentData.paused
+      return if torrentData.paused || torrentData.queued
 
       classifiedPeers = ClassifiedPeers.new torrentData.peers.all
 
       if ! torrentData.blockState
-        @logger.error "Request blocks peers: no blockstate yet."
+        @logger.error "#{QuartzTorrent.bytesToHex(infoHash)}: Request blocks peers: no blockstate yet."
         return
       end
 
-      if torrentData.state == :uploading && (torrentData.state != :paused)
+      if torrentData.state == :uploading && !torrentData.paused
         if torrentData.ratio
           if torrentData.bytesUploadedDataOnly >= torrentData.ratio*torrentData.blockState.totalLength
-            @logger.info "Pausing torrent due to upload ratio limit." if torrentData.metainfoPieceState.complete?
+            @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Pausing torrent due to upload ratio limit." if torrentData.metainfoPieceState.complete?
             setPaused(infoHash, true)
             return
           end
         end
         if torrentData.uploadDuration && torrentData.downloadCompletedTime
           if Time.new > torrentData.downloadCompletedTime + torrentData.uploadDuration
-            @logger.info "Pausing torrent due to upload duration being reached." if torrentData.metainfoPieceState.complete?
+            @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Pausing torrent due to upload duration being reached." if torrentData.metainfoPieceState.complete?
             setPaused(infoHash, true)
             return
           end
         end
       end
 
+      # Should we switch to endgame mode?
+      if torrentData.state == :running && !torrentData.isEndgame
+        blocks = torrentData.blockState.completeBlockBitfield
+        set = blocks.countSet
+        if set >= blocks.length - @endgameBlockThreshold && set < blocks.length
+          @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Entering endgame mode: blocks #{set}/#{blocks.length} complete."
+          torrentData.isEndgame = true
+        end
+      elsif torrentData.isEndgame && torrentData.state != :running
+        torrentData.isEndgame = false
+      end
+
       # Delete any timed-out requests.
       classifiedPeers.establishedPeers.each do |peer|
         toDelete = []
@@ -870,7 +926,7 @@ module QuartzTorrent
           toDelete.push blockIndex if (Time.new - requestTime) > @requestTimeout
         end
         toDelete.each do |blockIndex|
-          @logger.debug "Block #{blockIndex} request timed out."
+          @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Block #{blockIndex} request timed out."
           blockInfo = torrentData.blockState.createBlockinfoByBlockIndex(blockIndex)
           torrentData.blockState.setBlockRequested blockInfo, false
           peer.requestedBlocks.delete blockIndex
@@ -895,32 +951,47 @@ module QuartzTorrent
       # Request blocks
       blockInfos = torrentData.blockState.findRequestableBlocks(classifiedPeers, 100)
       blockInfos.each do |blockInfo|
-        # Pick one of the peers that has the piece to download it from. Pick one of the
-        # peers with the top 3 upload rates.
-        elegiblePeers = blockInfo.peers.find_all{ |p| p.requestedBlocks.length < p.maxRequestedBlocks }.sort{ |a,b| b.uploadRate.value <=> a.uploadRate.value}
-        random = elegiblePeers[rand(blockInfo.peers.size)]
-        peer = elegiblePeers.first(3).push(random).shuffle.first
-        next if ! peer
-        withPeersIo(peer, "requesting block") do |io|
-          if ! peer.amInterested
-            # Let this peer know that I'm interested if I haven't yet.
-            msg = Interested.new
+
+        peersToRequest = []
+        if torrentData.isEndgame
+          # Since we are in endgame mode, request blocks from all elegible peers
+          elegiblePeers = blockInfo.peers.find_all{ |p| p.requestedBlocks.length < p.maxRequestedBlocks }
+
+          peersToRequest.concat elegiblePeers
+        else
+          # Pick one of the peers that has the piece to download it from. Pick one of the
+          # peers with the top 3 upload rates.
+          elegiblePeers = blockInfo.peers.find_all{ |p| p.requestedBlocks.length < p.maxRequestedBlocks }.sort{ |a,b| b.uploadRate.value <=> a.uploadRate.value}
+          random = elegiblePeers[rand(blockInfo.peers.size)]
+          peer = elegiblePeers.first(3).push(random).shuffle.first
+          next if ! peer
+          peersToRequest.push peer
+        end
+
+        peersToRequest.each do |peer|
+          withPeersIo(peer, "requesting block") do |io|
+            if ! peer.amInterested
+              # Let this peer know that I'm interested if I haven't yet.
+              msg = Interested.new
+              sendMessageToPeer msg, io, peer
+              peer.amInterested = true
+            end
+            @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Requesting block from #{peer}: piece #{blockInfo.pieceIndex} offset #{blockInfo.offset} length #{blockInfo.length}"
+            msg = blockInfo.getRequest
             sendMessageToPeer msg, io, peer
-            peer.amInterested = true
+            torrentData.blockState.setBlockRequested blockInfo, true
+            peer.requestedBlocks[blockInfo.blockIndex] = Time.new
           end
-          @logger.debug "Requesting block from #{peer}: piece #{blockInfo.pieceIndex} offset #{blockInfo.offset} length #{blockInfo.length}"
-          msg = blockInfo.getRequest
-          sendMessageToPeer msg, io, peer
-          torrentData.blockState.setBlockRequested blockInfo, true
-          peer.requestedBlocks[blockInfo.blockIndex] = Time.new
         end
       end
 
       if blockInfos.size == 0
         if torrentData.state != :uploading && torrentData.blockState.completePieceBitfield.allSet?
-          @logger.info "Download of #{QuartzTorrent.bytesToHex(infoHash)} complete."
+          @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Download complete."
           torrentData.state = :uploading
           torrentData.downloadCompletedTime = Time.new
+
+          dequeue
         end
       end
 
@@ -935,13 +1006,13 @@ module QuartzTorrent
         return
       end
       
-      return if torrentData.paused
+      return if torrentData.paused || torrentData.queued
 
       # We may not have completed the extended handshake with the peer which specifies the torrent size.
       # In this case torrentData.metainfoPieceState is not yet set.
       return if ! torrentData.metainfoPieceState
 
-      @logger.info "Obtained all pieces of metainfo." if torrentData.metainfoPieceState.complete?
+      @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Obtained all pieces of metainfo." if torrentData.metainfoPieceState.complete?
 
       pieces = torrentData.metainfoPieceState.findRequestablePieces
       classifiedPeers = ClassifiedPeers.new torrentData.peers.all
@@ -956,11 +1027,11 @@ module QuartzTorrent
           withPeersIo(peers.first, "requesting metadata piece") do |io|
             sendMessageToPeer msg, io, peers.first
             torrentData.metainfoPieceState.setPieceRequested(pieceIndex, true)
-            @logger.debug "Requesting metainfo piece from #{peers.first}: piece #{pieceIndex}"
+            @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Requesting metainfo piece from #{peers.first}: piece #{pieceIndex}"
           end
         end
       else
-        @logger.error "No peers found that have metadata."
+        @logger.error "#{QuartzTorrent.bytesToHex(infoHash)}: No peers found that have metadata."
       end
 
     end
@@ -971,7 +1042,7 @@ module QuartzTorrent
         @logger.error "Check metadata piece manager results: data for torrent #{QuartzTorrent.bytesToHex(infoHash)} not found."
         return
       end
- 
+
       # We may not have completed the extended handshake with the peer which specifies the torrent size.
       # In this case torrentData.metainfoPieceState is not yet set.
       return if ! torrentData.metainfoPieceState
@@ -980,7 +1051,7 @@ module QuartzTorrent
       results.each do |result|
         metaData = torrentData.pieceManagerMetainfoRequestMetadata.delete(result.requestId)
         if ! metaData
-          @logger.error "Can't find metadata for PieceManager request #{result.requestId}"
+          @logger.error "#{QuartzTorrent.bytesToHex(infoHash)}: Can't find metadata for PieceManager request #{result.requestId}"
           next
         end
 
@@ -991,7 +1062,7 @@ module QuartzTorrent
           msg.piece = metaData.data.requestMsg.piece
           msg.data = result.data
           withPeersIo(metaData.data.peer, "sending extended metainfo piece message") do |io|
-            @logger.debug "Sending metainfo piece to #{metaData.data.peer}: piece #{msg.piece} with data length #{msg.data.length}"
+            @logger.debug "#{QuartzTorrent.bytesToHex(infoHash)}: Sending metainfo piece to #{metaData.data.peer}: piece #{msg.piece} with data length #{msg.data.length}"
             sendMessageToPeer msg, io, metaData.data.peer
           end
           result.data
@@ -999,7 +1070,7 @@ module QuartzTorrent
       end
 
       if torrentData.metainfoPieceState.complete? && torrentData.state == :downloading_metainfo
-        @logger.info "Obtained all pieces of metainfo. Will begin checking existing pieces."
+        @logger.info "#{QuartzTorrent.bytesToHex(infoHash)}: Obtained all pieces of metainfo. Will begin checking existing pieces."
         torrentData.metainfoPieceState.flush
         # We don't need to download metainfo anymore.
         cancelTimer torrentData.metainfoRequestTimer if torrentData.metainfoRequestTimer
@@ -1008,7 +1079,7 @@ module QuartzTorrent
           torrentData.info = info
           startCheckingPieces torrentData
         else
-          @logger.error "Metadata download is complete but reading the metadata failed"
+          @logger.error "#{QuartzTorrent.bytesToHex(infoHash)}: Metadata download is complete but reading the metadata failed"
           torrentData.state = :error
         end
       end
@@ -1022,27 +1093,47 @@ module QuartzTorrent
       end
 
       if ! torrentData.blockState
-        @logger.error "Receive piece: no blockstate yet."
+        @logger.error "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Receive piece: no blockstate yet."
         return
       end
 
       blockInfo = torrentData.blockState.createBlockinfoByPieceResponse(msg.pieceIndex, msg.blockOffset, msg.data.length)
 
       if ! peer.requestedBlocks.has_key?(blockInfo.blockIndex) 
-        @logger.debug "Receive piece: we either didn't request this piece, or it was already received due to endgame strategy. Ignoring this message."
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Receive piece: we either didn't request this piece, or it was already received due to endgame strategy. Ignoring this message."
         return
       end
 
       if torrentData.blockState.blockCompleted?(blockInfo)
-        @logger.debug "Receive piece: we already have this block. Ignoring this message."
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Receive piece: we already have this block. Ignoring this message."
         return
       end
       peer.requestedBlocks.delete blockInfo.blockIndex
-      # Block is marked as not requested when hash is confirmed
 
+      # Block is marked as not requested when hash is confirmed
       torrentData.bytesDownloadedDataOnly += msg.data.length
       id = torrentData.pieceManager.writeBlock(msg.pieceIndex, msg.blockOffset, msg.data)
       torrentData.pieceManagerRequestMetadata[id] = PieceManagerRequestMetadata.new(:write, msg)
+
+      if torrentData.isEndgame
+        # Assume this block is correct. Send a Cancel message to all other peers from whom we requested
+        # this piece.
+        classifiedPeers = ClassifiedPeers.new torrentData.peers.all
+        classifiedPeers.requestablePeers.each do |otherPeer|
+          if otherPeer.requestedBlocks.has_key?(blockInfo.blockIndex) 
+            withPeersIo(otherPeer, "when sending Cancel message") do |io|
+
+              cancel = Cancel.new
+              cancel.pieceIndex = msg.pieceIndex
+              cancel.blockOffset = msg.blockOffset
+              cancel.blockLength = msg.data.length
+              sendMessageToPeer cancel, io, otherPeer
+              @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending Cancel message to peer #{peer}"
+            end
+          end
+        end
+      end
+
     end
 
     def handleRequest(msg, peer)
@@ -1057,7 +1148,7 @@ module QuartzTorrent
         return
       end
       if msg.blockLength <= 0
-        @logger.error "Request piece: peer requested block of length #{msg.blockLength} which is invalid."
+        @logger.error "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Request piece: peer requested block of length #{msg.blockLength} which is invalid."
         return
       end
 
@@ -1076,11 +1167,11 @@ module QuartzTorrent
       if torrentData.info
         peer.bitfield.length = torrentData.info.pieces.length
       else
-        @logger.warn "A peer connected and sent a bitfield but we don't know the length of the torrent yet. Assuming number of pieces is divisible by 8"
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: A peer connected and sent a bitfield but we don't know the length of the torrent yet. Assuming number of pieces is divisible by 8"
       end
 
       if ! torrentData.blockState
-        @logger.warn "Bitfield: no blockstate yet."
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Bitfield: no blockstate yet."
         return
       end
 
@@ -1089,7 +1180,7 @@ module QuartzTorrent
       needed.intersection!(peer.bitfield)
       if ! needed.allClear?
         if ! peer.amInterested
-          @logger.debug "Need some pieces from peer #{peer} so sending Interested message"
+          @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Need some pieces from peer #{peer} so sending Interested message"
           msg = Interested.new
           sendMessageToPeer msg, currentIo, peer
           peer.amInterested = true
@@ -1105,7 +1196,7 @@ module QuartzTorrent
       end
 
       if msg.pieceIndex >= peer.bitfield.length
-        @logger.warn "Peer #{peer} sent Have message with invalid piece index"
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Peer #{peer} sent Have message with invalid piece index"
         return
       end
 
@@ -1113,13 +1204,13 @@ module QuartzTorrent
       peer.bitfield.set msg.pieceIndex
 
       if ! torrentData.blockState
-        @logger.warn "Have: no blockstate yet."
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Have: no blockstate yet."
         return
       end
 
       # If we are interested in something from this peer, let them know.
       if ! torrentData.blockState.completePieceBitfield.set?(msg.pieceIndex)
-        @logger.debug "Peer #{peer} just got a piece we need so sending Interested message"
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Peer #{peer} just got a piece we need so sending Interested message"
         msg = Interested.new
         sendMessageToPeer msg, currentIo, peer
         peer.amInterested = true
@@ -1139,24 +1230,24 @@ module QuartzTorrent
 
         metaData = torrentData.pieceManagerRequestMetadata.delete(result.requestId)
         if ! metaData
-          @logger.error "Can't find metadata for PieceManager request #{result.requestId}"
+          @logger.error "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Can't find metadata for PieceManager request #{result.requestId}"
           next
         end
       
         if metaData.type == :write
           if result.successful?
-            @logger.debug "Block written to disk. "
+            @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Block written to disk. "
             # Block successfully written!
             torrentData.blockState.setBlockCompleted metaData.data.pieceIndex, metaData.data.blockOffset, true do |pieceIndex|
               # The peice is completed! Check hash.
-              @logger.debug "Piece #{pieceIndex} is complete. Checking hash. "
+              @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Piece #{pieceIndex} is complete. Checking hash. "
               id = torrentData.pieceManager.checkPieceHash(metaData.data.pieceIndex)
               torrentData.pieceManagerRequestMetadata[id] = PieceManagerRequestMetadata.new(:hash, metaData.data.pieceIndex)
             end
           else
             # Block failed! Clear completed and requested state.
             torrentData.blockState.setBlockCompleted metaData.data.pieceIndex, metaData.data.blockOffset, false
-            @logger.error "Writing block failed: #{result.error}"
+            @logger.error "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Writing block failed: #{result.error}"
           end
         elsif metaData.type == :read
           if result.successful?
@@ -1167,21 +1258,21 @@ module QuartzTorrent
               msg.pieceIndex = readRequestMetadata.requestMsg.pieceIndex
               msg.blockOffset = readRequestMetadata.requestMsg.blockOffset
               msg.data = result.data
-              @logger.debug "Sending block to #{peer}: piece #{msg.pieceIndex} offset #{msg.blockOffset} length #{msg.data.length}"
+              @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending block to #{peer}: piece #{msg.pieceIndex} offset #{msg.blockOffset} length #{msg.data.length}"
               sendMessageToPeer msg, io, peer
               torrentData.bytesUploadedDataOnly += msg.data.length
-              @logger.debug "Sending piece to peer"
+              @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending piece to peer"
             end
           else
-            @logger.error "Reading block failed: #{result.error}"
+            @logger.error "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Reading block failed: #{result.error}"
           end
         elsif metaData.type == :hash
           if result.successful?
-            @logger.debug "Hash of piece #{metaData.data} is correct"
+            @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Hash of piece #{metaData.data} is correct"
             sendHaves(torrentData, metaData.data)
             sendUninterested(torrentData)
           else
-            @logger.info "Hash of piece #{metaData.data} is incorrect. Marking piece as not complete."
+            @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Hash of piece #{metaData.data} is incorrect. Marking piece as not complete."
             torrentData.blockState.setPieceCompleted metaData.data, false
           end
         elsif metaData.type == :check_existing
@@ -1195,20 +1286,20 @@ module QuartzTorrent
     def handleCheckExistingResult(torrentData, pieceManagerResult)
       if pieceManagerResult.successful?
         existingBitfield = pieceManagerResult.data
-        @logger.info "We already have #{existingBitfield.countSet}/#{existingBitfield.length} pieces." 
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: We already have #{existingBitfield.countSet}/#{existingBitfield.length} pieces." 
 
         info = torrentData.info
        
         torrentData.blockState = BlockState.new(info, existingBitfield)
 
-        @logger.info "Starting torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)}. Information:"
-        @logger.info "  piece length:     #{info.pieceLen}"
-        @logger.info "  number of pieces: #{info.pieces.size}"
-        @logger.info "  total length      #{info.dataLength}"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Starting torrent. Information:"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}:   piece length:     #{info.pieceLen}"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}:   number of pieces: #{info.pieces.size}"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}:   total length      #{info.dataLength}"
 
         startDownload torrentData
       else
-        @logger.info "Checking existing pieces of torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)} failed: #{pieceManagerResult.error}"
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Checking existing pieces of torrent failed: #{pieceManagerResult.error}"
         torrentData.state = :error
       end
     end
@@ -1221,7 +1312,7 @@ module QuartzTorrent
       torrentData.pieceManager = QuartzTorrent::PieceManager.new(@baseDirectory, torrentData.info)
 
       torrentData.state = :checking_pieces
-      @logger.info "Checking pieces of torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)} asynchronously."
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Checking pieces of torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)} asynchronously."
       id = torrentData.pieceManager.findExistingPieces
       torrentData.pieceManagerRequestMetadata[id] = PieceManagerRequestMetadata.new(:check_existing, nil)
 
@@ -1240,13 +1331,43 @@ module QuartzTorrent
       end
     end
  
+    # Take a torrent that is in the :initializing state and make it go.
+    def initTorrent(torrentData)
+      # If we already have the metainfo info for this torrent, we can begin checking the pieces. 
+      # If we don't have the metainfo info then we need to get the metainfo first.
+      if ! torrentData.info
+        torrentData.info = MetainfoPieceState.downloaded(@baseDirectory, torrentData.infoHash)
+      end
+
+      if torrentData.info
+        startCheckingPieces torrentData
+      else
+        # Request the metainfo from peers.
+        torrentData.state = :downloading_metainfo
+
+        @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Downloading metainfo"
+
+        # Schedule peer connection management. Recurring and immediate 
+        torrentData.managePeersTimer = 
+          @reactor.scheduleTimer(@managePeersPeriod, [:manage_peers, torrentData.infoHash], true, true)
+
+        # Schedule a timer for requesting metadata pieces from peers.
+        torrentData.metainfoRequestTimer = 
+          @reactor.scheduleTimer(@requestBlocksPeriod, [:request_metadata_pieces, torrentData.infoHash], true, false)
+
+        # Schedule checking for metainfo PieceManager results (including when piece reading completes)
+        torrentData.checkMetadataPieceManagerTimer =
+          @reactor.scheduleTimer(@requestBlocksPeriod, [:check_metadata_piece_manager, torrentData.infoHash], true, false)
+      end
+    end
+
     # Start the actual torrent download. This method schedules the necessary timers and registers the necessary listeners
     # and changes the state to :running. It is meant to be called after checking for existing pieces or downloading the 
     # torrent metadata (if this is a magnet link torrent)
     def startDownload(torrentData)
       # Add a listener for when the tracker's peers change.
       torrentData.peerChangeListener = Proc.new do
-        @logger.debug "Managing peers for torrent #{QuartzTorrent.bytesToHex(torrentData.infoHash)} on peer change event"
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Managing peers on peer change event"
   
         # Non-recurring and immediate timer
         torrentData.managePeersTimer =
@@ -1277,7 +1398,7 @@ module QuartzTorrent
       if metadataSize
         # This peer knows the size of the metadata. If we haven't created our MetainfoPieceState yet, create it now.
         if ! torrentData.metainfoPieceState
-          @logger.info "Extended Handshake: Learned that metadata size is #{metadataSize}. Creating MetainfoPieceState"
+          @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Extended Handshake: Learned that metadata size is #{metadataSize}. Creating MetainfoPieceState"
           torrentData.metainfoPieceState = MetainfoPieceState.new(@baseDirectory, torrentData.infoHash, metadataSize)
         end
       end
@@ -1292,10 +1413,10 @@ module QuartzTorrent
       end
 
       if msg.msgType == :request
-        @logger.debug "Got extended metainfo request for piece #{msg.piece}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Got extended metainfo request for piece #{msg.piece}"
         # Build a response for this piece.
         if torrentData.metainfoPieceState.pieceCompleted? msg.piece
-          @logger.debug "Requesting extended metainfo piece #{msg.piece} from metainfoPieceState."
+          @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Requesting extended metainfo piece #{msg.piece} from metainfoPieceState."
           id = torrentData.metainfoPieceState.readPiece msg.piece
           torrentData.pieceManagerMetainfoRequestMetadata[id] = 
             PieceManagerRequestMetadata.new(:read, ReadRequestMetadata.new(peer,msg))
@@ -1304,19 +1425,19 @@ module QuartzTorrent
           reject.msgType = :reject
           reject.piece = msg.piece
           withPeersIo(peer, "sending extended metainfo reject message") do |io|
-            @logger.debug "Sending metainfo reject to #{peer}: piece #{msg.piece}"
+            @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending metainfo reject to #{peer}: piece #{msg.piece}"
             sendMessageToPeer reject, io, peer
           end
         end
       elsif msg.msgType == :piece
-        @logger.debug "Got extended metainfo piece response for piece #{msg.piece} with data length #{msg.data.length}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Got extended metainfo piece response for piece #{msg.piece} with data length #{msg.data.length}"
         if ! torrentData.metainfoPieceState.pieceCompleted? msg.piece
           id = torrentData.metainfoPieceState.savePiece msg.piece, msg.data
           torrentData.pieceManagerMetainfoRequestMetadata[id] = 
             PieceManagerRequestMetadata.new(:write, msg)
         end
       elsif msg.msgType == :reject
-        @logger.debug "Got extended metainfo reject response for piece #{msg.piece}"
+        @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Got extended metainfo reject response for piece #{msg.piece}"
         # Mark this peer as bad.
         torrentData.metainfoPieceState.markPeerBad peer
         torrentData.metainfoPieceState.setPieceRequested(msg.piece, false)
@@ -1347,7 +1468,7 @@ module QuartzTorrent
     end
 
     def sendHaves(torrentData, pieceIndex)
-      @logger.debug "Sending Have messages to all connected peers for piece #{pieceIndex}"
+      @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending Have messages to all connected peers for piece #{pieceIndex}"
       torrentData.peers.all.each do |peer|
         next if peer.state != :established || peer.isUs
         withPeersIo(peer, "when sending Have message") do |io|
@@ -1373,7 +1494,7 @@ module QuartzTorrent
             msg = Uninterested.new
             sendMessageToPeer msg, io, peer
             peer.amInterested = false
-            @logger.debug "Sending Uninterested message to peer #{peer}"
+            @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending Uninterested message to peer #{peer}"
           end
         end
       end
@@ -1387,7 +1508,7 @@ module QuartzTorrent
       begin
         peer.peerMsgSerializer.serializeTo(msg, io)
       rescue
-        @logger.warn "Sending message to peer #{peer} failed: #{$!.message}"
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Sending message to peer #{peer} failed: #{$!.message}"
       end
     end
 
@@ -1427,7 +1548,7 @@ module QuartzTorrent
         next if p.id && p.id == trackerclient.peerId
             
         if ! torrentData.peers.findByAddr(p.ip, p.port)
-          @logger.debug "Adding tracker peer #{p} to peers list"
+          @logger.debug "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Adding tracker peer #{p} to peers list"
           break if ! addProc.call(p)
         end
       end
@@ -1440,13 +1561,13 @@ module QuartzTorrent
         @logger.warn "Asked to remove a non-existent torrent #{QuartzTorrent.bytesToHex(infoHash)}"
         return
       end
-      @logger.info "Removing torrent #{QuartzTorrent.bytesToHex(infoHash)} and #{deleteFiles ? "will" : "wont"} delete downloaded files."
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent.  #{deleteFiles ? "Will" : "Wont"} delete downloaded files."
 
-      @logger.info "Removing torrent: no torrentData.metainfoRequestTimer" if ! torrentData.metainfoRequestTimer
-      @logger.info "Removing torrent: no torrentData.managePeersTimer" if ! torrentData.managePeersTimer 
-      @logger.info "Removing torrent: no torrentData.checkMetadataPieceManagerTimer" if ! torrentData.checkMetadataPieceManagerTimer 
-      @logger.info "Removing torrent: no torrentData.checkPieceManagerTimer" if ! torrentData.checkPieceManagerTimer 
-      @logger.info "Removing torrent: no torrentData.requestBlocksTimer" if ! torrentData.requestBlocksTimer 
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent: no torrentData.metainfoRequestTimer" if ! torrentData.metainfoRequestTimer
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent: no torrentData.managePeersTimer" if ! torrentData.managePeersTimer 
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent: no torrentData.checkMetadataPieceManagerTimer" if ! torrentData.checkMetadataPieceManagerTimer 
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent: no torrentData.checkPieceManagerTimer" if ! torrentData.checkPieceManagerTimer 
+      @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Removing torrent: no torrentData.requestBlocksTimer" if ! torrentData.requestBlocksTimer 
 
 
       # Stop all timers
@@ -1482,7 +1603,7 @@ module QuartzTorrent
       begin
         torrentData.metainfoPieceState.remove if torrentData.metainfoPieceState
       rescue
-        @logger.warn "Deleting metainfo file for torrent #{QuartzTorrent.bytesToHex(infoHash)} failed: #{$!}"  
+        @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Deleting metainfo file for torrent #{QuartzTorrent.bytesToHex(infoHash)} failed: #{$!}"  
       end
 
       if deleteFiles
@@ -1491,15 +1612,17 @@ module QuartzTorrent
             path = @baseDirectory + File::SEPARATOR + torrentData.info.name
             if File.exists? path
               FileUtils.rm_r path
-              @logger.info "Deleted #{path}"
+              @logger.info "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Deleted #{path}"
             else
-              @logger.warn "Deleting '#{path}' for torrent #{QuartzTorrent.bytesToHex(infoHash)} failed: #{$!}"  
+              @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: Deleting '#{path}' for torrent #{QuartzTorrent.bytesToHex(infoHash)} failed: #{$!}"  
             end
           rescue
-            @logger.warn "When removing torrent #{QuartzTorrent.bytesToHex(infoHash)} deleting '#{path}' failed because it doesn't exist"  
+            @logger.warn "#{QuartzTorrent.bytesToHex(torrentData.infoHash)}: When removing torrent, deleting '#{path}' failed because it doesn't exist"  
           end
         end
       end
+
+      dequeue
     end
 
     # Pause or unpause a torrent that we are downloading.
@@ -1512,9 +1635,59 @@ module QuartzTorrent
 
       return if torrentData.paused == value
 
-      if value
-        torrentData.paused = true
+      torrentData.paused = value
+
+      if !value
+        # On unpause, queue the torrent since there might not be room for it to run.
+        # Make sure it goes to the head of the queue.
+        queue(torrentData, :unshift)
+      end
+
+      setFrozen infoHash, value if ! torrentData.queued
+
+      dequeue
+    end
+
+    # Queue a torrent
+    def queue(torrentData, mode = :queue)
+      return if torrentData.queued
+      
+      # Queue the torrent
+      if mode == :unshift
+        @torrentQueue.unshift torrentData
+      else
+        @torrentQueue.push torrentData
+      end
+
+      setFrozen torrentData, true if ! torrentData.paused
+    end
+    
+    # Dequeue any torrents that can now run based on available space
+    def dequeue
+      torrents = @torrentQueue.dequeue(@torrentData.values)
+      torrents.each do |torrentData|
+        if torrentData.state == :initializing
+          initTorrent torrentData
+        else
+          setFrozen torrentData, false if ! torrentData.paused
+        end
+      end
+    end
 
+    # Freeze or unfreeze a torrent. If value is true, then we disconnect from all peers for this torrent and forget 
+    # the peers. If value is false, we start reconnecting to peers.
+    # Parameter torrent can be an infoHash or TorrentData
+    def setFrozen(torrent, value)
+      torrentData = torrent
+      if ! torrent.is_a?(TorrentData)
+        torrentData = @torrentData[torrent]
+        if ! torrentData
+          @logger.warn "Asked to freeze a non-existent torrent #{QuartzTorrent.bytesToHex(torrent)}"
+          return
+        end
+      end
+
+      if value
         # Disconnect from all peers so we won't reply to any messages.
         torrentData.peers.all.each do |peer|
           if peer.state != :disconnected
@@ -1525,16 +1698,21 @@ module QuartzTorrent
             end
           end
           torrentData.peers.delete peer
-        end 
+        end
       else
-        torrentData.paused = false
-
         # Get our list of peers and start connecting right away
         # Non-recurring and immediate timer
-        torrentData.managePeersTimer = 
+        torrentData.managePeersTimer =
           @reactor.scheduleTimer(@managePeersPeriod, [:manage_peers, torrentData.infoHash], false, true)
       end
     end
+    
+    # Run the passed block in the Reactor's thread. This allows manipulation of torrent data without race
+    # conditions. This method works by scheduling a non-recurring, immediate timer in the reactor that
+    # on expiry runs the passed block.
+    def runInReactorThread(&block)
+      @reactor.scheduleTimer(0, [:runproc, block], false, true)
+    end
 
   end
 
@@ -1543,14 +1721,14 @@ module QuartzTorrent
   class PeerClient 
 
     # Create a new PeerClient that will save and load torrent data under the specified baseDirectory.
-    def initialize(baseDirectory)
+    def initialize(baseDirectory, maxIncomplete = 5, maxActive = 10)
       @port = 9998
       @handler = nil
       @stopped = true
       @reactor = nil
       @logger = LogManager.getLogger("peerclient")
       @worker = nil
-      @handler = PeerClientHandler.new baseDirectory
+      @handler = PeerClientHandler.new baseDirectory, maxIncomplete, maxActive
       @reactor = QuartzTorrent::Reactor.new(@handler, LogManager.getLogger("peerclient.reactor"))
       @toStart = []
     end
@@ -1559,8 +1737,10 @@ module QuartzTorrent
     attr_accessor :port
 
     # Start the PeerClient: open the listening port, and start a new thread to begin downloading/uploading pieces.
+    # If listening fails, an exception of class Errno::EADDRINUSE is thrown.
     def start 
       return if ! @stopped
+      @logger.info "Starting"
 
       @reactor.listen("0.0.0.0",@port,:listener_socket)
 
@@ -1602,7 +1782,7 @@ module QuartzTorrent
       addTorrent(trackerclient, metainfo.infoHash, metainfo.info)
     end
 
-    # Add a new torrent to manage given an announceUrl and an infoHash. 
+    # Add a new torrent to manage given an announceUrl and an infoHash. The announceUrl may be a list. 
     # Returns the infoHash of the newly added torrent.
     def addTorrentWithoutMetainfo(announceUrl, infoHash, magnet = nil)
       raise "addTorrentWithoutMetainfo should be called with a Magnet object, not a #{magnet.class}" if magnet && ! magnet.is_a?(MagnetURI)
@@ -1616,7 +1796,7 @@ module QuartzTorrent
     def addTorrentByMagnetURI(magnet)
       raise "addTorrentByMagnetURI should be called with a MagnetURI object, not a #{magnet.class}" if ! magnet.is_a?(MagnetURI)
 
-      trackerUrl = magnet.tracker
+      trackerUrl = magnet.trackers
       raise "addTorrentByMagnetURI can't handle magnet links that don't have a tracker URL." if !trackerUrl
 
       addTorrentWithoutMetainfo(trackerUrl, magnet.btInfoHash, magnet)
@@ -1660,6 +1840,22 @@ module QuartzTorrent
       @handler.setUploadDuration(infoHash, seconds)
     end
 
+    # Adjust the bytesUploaded property of the specified torrent by the passed amount.
+    # Adjustment should be an integer. It is added to the current bytesUploaded amount.
+    def adjustBytesUploaded(infoHash, adjustment)
+      return if ! adjustment
+      raise "Bytes uploaded adjustment must be an Integer, not a #{adjustment.class}" if !adjustment.is_a?(Integer)
+      @handler.adjustBytesUploaded(infoHash, adjustment)
+    end
+
+    # Adjust the bytesDownloaded property of the specified torrent by the passed amount.
+    # Adjustment should be an integer. It is added to the current bytesUploaded amount.
+    def adjustBytesDownloaded(infoHash, adjustment)
+      return if ! adjustment
+      raise "Bytes downloaded adjustment must be an Integer, not a #{adjustment.class}" if !adjustment.is_a?(Integer)
+      @handler.adjustBytesDownloaded(infoHash, adjustment)
+    end
+
     # Remove a currently running torrent
     def removeTorrent(infoHash, deleteFiles = false)
       @handler.removeTorrent(infoHash, deleteFiles)