quartz_torrent 0.1.1 → 0.2.0

data/lib/quartz_torrent/peermsgserialization.rb

@@ -89,7 +89,7 @@ module QuartzTorrent
               @logger.debug "Peer supports extension #{extName} using id '#{extId}'."
               @extendedMessageIdToClass[extId] = clazz
             else
-              @logger.warn "Peer supports extension #{extName} using id '#{extId}', but I don't know what class to use for that extension."
+              @logger.debug "Peer supports extension #{extName} using id '#{extId}', but I don't know what class to use for that extension."
             end
           end
         else

data/lib/quartz_torrent/ratelimit.rb

@@ -37,6 +37,12 @@ module QuartzTorrent
       @pool -= n
     end
 
+    def to_s
+      s = ""
+      s << "units/sec: #{@unitsPerSecond}, avail: #{avail}, upperlim: #{@upperLimit}"
+      s
+    end
+
     private
     def updatePool
       now = Time.new

data/lib/quartz_torrent/reactor.rb

@@ -1,8 +1,8 @@
 require 'socket'
-require 'pqueue'
 require 'fiber'
 require 'thread'
 require 'quartz_torrent/ratelimit'
+require 'quartz_torrent/timermanager'
 include Socket::Constants
 
 module QuartzTorrent
@@ -311,7 +311,6 @@ module QuartzTorrent
       @ioInfo.writeRateLimit = rate
     end
 
-    attr_accessor :writeRateLimit
   end
 
   # An IoFacade that doesn't allow reading. This is not part of the public API.
@@ -346,6 +345,7 @@ module QuartzTorrent
       @useErrorhandler = true
       @readRateLimit = nil
       @writeRateLimit = nil
+      raise "IO passed to IOInfo initialize may not be nil" if io.nil?
     end
     attr_accessor :io
     attr_accessor :metainfo
@@ -366,84 +366,6 @@ module QuartzTorrent
     end
   end
 
-  # Class used to manage timers.
-  class TimerManager
-    class TimerInfo
-      def initialize(duration, recurring, metainfo)
-        @duration = duration
-        @recurring = recurring
-        @metainfo = metainfo
-        @cancelled = false
-        refresh
-      end
-      attr_accessor :recurring
-      attr_accessor :duration
-      attr_accessor :expiry
-      attr_accessor :metainfo
-      # Since pqueue doesn't allow removal of anything but the head
-      # we flag deleted items so they are deleted when they are pulled
-      attr_accessor :cancelled
-
-      def secondsUntilExpiry
-        @expiry - Time.new
-      end
-
-      def refresh
-        @expiry = Time.new + @duration
-      end
-    end
-
-    def initialize(logger = nil)
-      @queue = PQueue.new { |a,b| b.expiry <=> a.expiry }
-      @mutex = Mutex.new
-      @logger = logger
-    end
-
-    # Add a timer. Parameter 'duration' specifies the timer duration in seconds,
-    # 'metainfo' is caller information passed to the handler when the timer expires,
-    # 'recurring' should be true if the timer will repeat, or false if it will only
-    # expire once, and 'immed' when true specifies that the timer should expire immediately 
-    # (and again each duration if recurring) while false specifies that the timer will only
-    # expire the first time after it's duration elapses.
-    def add(duration, metainfo = nil, recurring = true, immed = false)
-      raise "TimerManager.add: Timer duration may not be nil" if duration.nil?
-      info = TimerInfo.new(duration, recurring, metainfo)
-      info.expiry = Time.new if immed
-      @mutex.synchronize{ @queue.push info }
-      info
-    end
-  
-    # Cancel a timer.
-    def cancel(timerInfo)
-      timerInfo.cancelled = true
-    end
-
-    # Return the next timer event from the queue, but don't remove it from the queue.
-    def peek
-      clearCancelled
-      @queue.top
-    end
-
-    # Remove the next timer event from the queue and return it as a TimerHandler::TimerInfo object.
-    def next
-      clearCancelled
-      result = nil
-      @mutex.synchronize{ result = @queue.pop }
-      if result && result.recurring
-        result.refresh
-        @mutex.synchronize{ @queue.push result }
-      end
-      result
-    end
-
-    private 
-    
-    def clearCancelled
-      while @queue.top && @queue.top.cancelled
-        info = @queue.pop 
-      end
-    end
-  end
 
   # This class implements the Reactor pattern. The Reactor listens for activity on IO objects and calls methods on 
   # an associated Handler object when activity is detected. Callers can use listen, connect or open to register IO
@@ -494,7 +416,9 @@ module QuartzTorrent
       @stopped
     end
 
-    # Create a TCP connection to the specified host
+    # Create a TCP connection to the specified host.
+    # Note that this method may raise exceptions. For example 'Too many open files' might be raised if 
+    # the process is using too many file descriptors
     def connect(addr, port, metainfo, timeout = nil)
       ioInfo = startConnection(port, addr, metainfo)
       @ioInfo[ioInfo.io] = ioInfo
@@ -704,14 +628,16 @@ module QuartzTorrent
         end
       end
 
-      if selectResult.nil?
-        # Process timer
-        @logger.debug "eventloop: processing timer" if @logger
+      if timer
         # Calling processTimer in withReadFiber here is not correct. What if at this point the fiber was already paused in a read, and we
         # want to process a timer? In that case we will resume the read and it will possibly finish, but we'll never 
         # call the timer handler. For this reason we must prevent read calls in timerHandlers.
-        processTimer(timer) if timer
-      else
+        # Process timer
+        @logger.debug "eventloop: processing timer" if @logger
+        processTimer(timer)
+      end
+
+      if ! selectResult.nil?
         readable, writeable = selectResult
   
         # If we are stopped, then ignore reads; we only care about completing our writes that were pending when we were stopped.
@@ -727,6 +653,10 @@ module QuartzTorrent
           end
 
           @currentIoInfo = @ioInfo[io]
+ 
+          # The IOInfo associated with this io could have been closed by the timer handler processed above.         
+          next if @currentIoInfo.nil?
+
           if @currentIoInfo.state == :listening
             @logger.debug "eventloop: calling handleAccept for IO metainfo=#{@currentIoInfo.metainfo}" if @logger
             # Replace the currentIoInfo with the accepted socket
@@ -773,9 +703,9 @@ module QuartzTorrent
       selectTimeout = nil
       timer = nil
       while true && ! @stopped
-        timer = @timerManager.peek
+        secondsUntilExpiry = nil
+        timer = @timerManager.next{ |s| secondsUntilExpiry = s }
         break if ! timer
-        secondsUntilExpiry = timer.secondsUntilExpiry
         if secondsUntilExpiry > 0
           selectTimeout = secondsUntilExpiry
           break
@@ -844,7 +774,6 @@ module QuartzTorrent
         @logger.error "Exception in timer event handler: #{$!}" if @logger
         @logger.error $!.backtrace.join "\n" if @logger
       end
-      @timerManager.next   
     end
 
     def disposeIo(io)

data/lib/quartz_torrent/semaphore.rb

@@ -9,19 +9,31 @@ class Semaphore
   end
 
   # Wait on the semaphore. If the count zero or below, the calling thread blocks.
-  def wait
+  # Optionally a timeout in seconds can be specified. This method returns true if the wait
+  # ended because of a signal, and false if it ended because of a timeout.
+  def wait(timeout = nil)
+    result = true
     c = nil
     @mutex.synchronize do
       @count -= 1
-      c = @count
+      if @count < 0
+        @sleeping.push Thread.current
+        @mutex.sleep(timeout)
+      end
     end
-
-    if c < 0
+    if timeout
+      # If we had a timeout we may have woken due to it expiring rather than
+      # due to signal being called. In that case we need to remove ourself from the sleepers.
       @mutex.synchronize do
-        @sleeping.push Thread.current
+        i = @sleeping.index(Thread.current)
+        if i
+          @count += 1
+          @sleeping.delete_at(i)
+          result = false
+        end
       end
-      Thread.stop
     end
+    result
   end
 
   # Signal the semaphore. If the count is below zero the waiting threads are woken.
@@ -30,14 +42,16 @@ class Semaphore
     @mutex.synchronize do
       c = @count
       @count += 1
-    end
-    if c < 0 
-      t = nil
-      @mutex.synchronize do
+      if c < 0 
         t = @sleeping.shift
+        t.wakeup if t
       end
-      t.wakeup if t
     end
   end
+
+  # Testing method.
+  def count
+    @count
+  end
 end
 

data/lib/quartz_torrent/timermanager.rb

@@ -0,0 +1,120 @@
+require 'pqueue'
+
+module QuartzTorrent
+  # Class used to manage timers.
+  class TimerManager
+    class TimerInfo
+      def initialize(duration, recurring, metainfo)
+        @duration = duration
+        @recurring = recurring
+        @metainfo = metainfo
+        @cancelled = false
+        refresh
+      end
+      attr_accessor :recurring
+      attr_accessor :duration
+      attr_accessor :expiry
+      attr_accessor :metainfo
+      # Since pqueue doesn't allow removal of anything but the head
+      # we flag deleted items so they are deleted when they are pulled
+      attr_accessor :cancelled
+
+      def secondsUntilExpiry
+        @expiry - Time.new
+      end
+
+      def refresh
+        @expiry = Time.new + @duration
+      end
+    end
+
+    def initialize(logger = nil)
+      @queue = PQueue.new { |a,b| b.expiry <=> a.expiry }
+      @mutex = Mutex.new
+      @logger = logger
+    end
+
+    # Add a timer. Parameter 'duration' specifies the timer duration in seconds,
+    # 'metainfo' is caller information passed to the handler when the timer expires,
+    # 'recurring' should be true if the timer will repeat, or false if it will only
+    # expire once, and 'immed' when true specifies that the timer should expire immediately 
+    # (and again each duration if recurring) while false specifies that the timer will only
+    # expire the first time after it's duration elapses.
+    def add(duration, metainfo = nil, recurring = true, immed = false)
+      raise "TimerManager.add: Timer duration may not be nil" if duration.nil?
+      info = TimerInfo.new(duration, recurring, metainfo)
+      info.expiry = Time.new if immed
+      @mutex.synchronize{ @queue.push info }
+      info
+    end
+  
+    # For testing. Add a cancelled timer.
+    def add_cancelled(duration, metainfo = nil, recurring = true, immed = false)
+      raise "TimerManager.add: Timer duration may not be nil" if duration.nil?
+      info = TimerInfo.new(duration, recurring, metainfo)
+      info.expiry = Time.new if immed
+      info.cancelled = true
+      @mutex.synchronize{ @queue.push info }
+      info
+    end
+
+    # Cancel a timer.
+    def cancel(timerInfo)
+      timerInfo.cancelled = true
+    end
+
+    # Return the next timer event from the queue, but don't remove it from the queue.
+    def peek
+      result = nil
+      @mutex.synchronize do 
+        clearCancelled
+        result = @queue.top 
+      end
+      result
+    end
+
+    # Remove the next timer event from the queue and return it as a TimerHandler::TimerInfo object.
+    # Warning: if the timer is a recurring timer, the secondsUntilExpiry will be set to the NEXT time
+    # the timer would expire, instead of this time. If the original secondsUntilExpiry is needed, 
+    # pass a block to this method, and the block will be called with the original secondsUntilExpiry.
+    def next
+      result = nil
+      @mutex.synchronize do 
+        clearCancelled
+        result = @queue.pop 
+      end
+      if result
+        yield result.secondsUntilExpiry if block_given?
+        if result.recurring
+          result.refresh
+          @mutex.synchronize{ @queue.push result }
+        end
+      end
+      result
+    end
+
+    def to_s
+      arr = nil
+      @mutex.synchronize do
+        arr = @queue.to_a
+      end
+      s = "now = #{Time.new}. Queue = ["
+      arr.each do |e|
+        s << "(#{e.object_id};#{e.expiry};#{e.metainfo[0]};#{e.secondsUntilExpiry}),"
+      end
+      s << "]"
+    end
+
+    def empty?
+      @queue.empty?
+    end
+
+    private 
+    
+    def clearCancelled
+      while @queue.top && @queue.top.cancelled
+        @queue.pop 
+      end
+    end
+  end
+end

data/lib/quartz_torrent/torrentqueue.rb

@@ -0,0 +1,91 @@
+require "quartz_torrent/log.rb"
+
+module QuartzTorrent
+  class TorrentQueue
+    # The maxIncomplete and maxActive parameters specify how many torrents may be unpaused and unqueued at once.
+    # Parameter maxActive is the total maximum number of active torrents (unpaused, unqueued), and maxIncomplete is a subset of 
+    # maxActive that are incomplete and thus downloading (as opposed to only uploading). An exception is thrown if
+    # maxIncomplete > maxActive.
+    # 
+    def initialize(maxIncomplete, maxActive)
+      raise "The maximum number of running torrents may not be larger than the maximum number of unqueued torrents" if maxIncomplete > maxActive
+      @maxIncomplete = maxIncomplete
+      @maxActive = maxActive
+      @queue = []
+      @logger = LogManager.getLogger("queue")
+    end
+
+    # Compute which torrents can now be unqueued based on the state of running torrents.
+    # Parameter torrentDatas should be an array of TorrentData that the decision will be based off. At a minimum
+    # these items should respond to 'paused', 'queued', 'state', 'queued=' 
+    def dequeue(torrentDatas)
+      numActive = 0
+      numIncomplete = 0
+      torrentDatas.each do |torrentData|
+        next if torrentData.paused || torrentData.queued
+        numIncomplete += 1 if incomplete?(torrentData)
+        numActive += 1
+      end
+      @logger.debug "incomplete: #{numIncomplete}/#{@maxIncomplete} active: #{numActive}/#{@maxActive}"
+      @logger.debug "Queue contains #{size} torrents"
+
+      torrents = []
+
+      while numActive < @maxActive
+        torrentData = nil
+        if numIncomplete < @maxIncomplete
+          # Unqueue first incomplete torrent from queue
+          torrentData = dequeueFirstMatching{ |torrentData| incomplete?(torrentData)}
+          @logger.debug "#{torrentData ? "dequeued" : "failed to dequeue"} an incomplete torrent"
+          numIncomplete += 1 if torrentData
+        end
+        if ! torrentData
+          # Unqueue first complete (uploading) torrent from queue
+          torrentData = dequeueFirstMatching{ |torrentData| !incomplete?(torrentData)}
+          @logger.debug "#{torrentData ? "dequeued" : "failed to dequeue"} a complete torrent"
+        end
+        numActive += 1 if torrentData
+        
+        if torrentData
+          torrentData.queued = false
+          torrents.push torrentData
+        else
+          break
+        end
+      end
+
+      @logger.debug "Will dequeue #{torrents.size}"
+
+      torrents
+    end
+
+    def push(torrentData)
+      torrentData.queued = true
+      @queue.push torrentData
+    end
+
+    def unshift(torrentData)
+      torrentData.queued = true
+      @queue.unshift torrentData
+    end
+
+    def size
+      @queue.size
+    end
+
+    private
+
+    def incomplete?(torrentData)
+      torrentData.state != :uploading
+    end
+
+    def dequeueFirstMatching
+      index = @queue.index{ |torrentData| yield(torrentData) }
+      if index
+        @queue.delete_at index
+      else
+        nil
+      end
+    end
+  end
+end