quartz_torrent 0.0.1

data/lib/quartz_torrent/formatter.rb

@@ -0,0 +1,92 @@
+module QuartzTorrent
+  # Class that can be used to format different quantities into 
+  # human readable strings.
+  class Formatter
+    Kb = 1024
+    Meg = 1024*Kb
+    Gig = 1024*Meg
+
+    # Format a size in bytes.
+    def self.formatSize(size)
+      s = size.to_f
+      if s >= Gig
+        s = "%.2fGB" % (s / Gig)
+      elsif s >= Meg
+        s = "%.2fMB" % (s / Meg)
+      elsif s >= Kb
+        s = "%.2fKB" % (s / Kb)
+      else
+        s = "%.2fB" % s
+      end
+      s
+    end
+
+    # Format a floating point number as a percentage with one decimal place.
+    def self.formatPercent(frac)
+      s = "%.1f" % (frac.to_f*100)
+      s + "%"
+    end
+    
+    # Format a speed in bytes per second.
+    def self.formatSpeed(s)
+      Formatter.formatSize(s) + "/s"
+    end
+
+    # Format a duration of time in seconds.
+    def self.formatTime(secs)
+      s = ""
+      time = secs.to_i
+      arr = []
+      conv = [60,60]
+      unit = ["s","m","h"]
+      conv.each{ |c|
+        v = time % c
+        time = time / c
+        arr.push v
+      }
+      arr.push time
+      i = unit.size-1
+      arr.reverse.each{ |v|
+        if v == 0
+          i -= 1
+        else
+          break
+        end
+      }
+      while i >= 0
+        s << arr[i].to_s + unit[i]
+        i -= 1
+      end
+      
+      s = "0s" if s.length == 0
+ 
+      s
+    end
+
+    # Parse a size in the format '50 KB'
+    def self.parseSize(size)
+      if size =~ /(\d+(?:\.\d+)?)\s*([^\d]+)*/
+        value = $1.to_f
+        suffix = ($2 ? $2.downcase : nil)
+
+        multiplicand = 1
+        if suffix.nil? || suffix[0] == 'b'
+          multiplicand = 1
+        elsif suffix[0,2] == 'kb'
+          multiplicand = Kb
+        elsif suffix[0,2] == 'mb'
+          multiplicand = Meg
+        elsif suffix[0,2] == 'gb'
+          multiplicand = Gig
+        else
+          raise "Unknown suffix '#{suffix}' for size '#{size}'"
+        end
+   
+        value*multiplicand
+      else  
+        raise "Malformed size '#{size}'"
+      end
+    end
+  end
+
+end

data/lib/quartz_torrent/httptrackerclient.rb

@@ -0,0 +1,121 @@
+module QuartzTorrent
+  class TrackerClient
+  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)
+      @startSent = false
+      @logger = LogManager.getLogger("http_tracker_client")
+    end
+ 
+    # Request a list of peers from the tracker and return it as a TrackerResponse.   
+    # Event, if specified, may be set to :started, :stopped, or :completed.
+    # This is used to notify the tracker that this is the first request,
+    # that we are shutting down, or that we have the full torrent respectively.
+    # Not specifying the event just means this is a regular poll.
+    #def getPeers(event = nil)
+    def request(event = nil)
+
+      uri = URI(@announceUrl)
+  
+      dynamicParams = @dynamicRequestParamsBuilder.call
+
+      params = {}
+      params['info_hash'] = CGI.escape(@infoHash)
+      params['peer_id'] = @peerId
+      params['port'] = @port
+      params['uploaded'] = dynamicParams.uploaded.to_s
+      params['downloaded'] = dynamicParams.downloaded.to_s
+      params['left'] = dynamicParams.left.to_s
+      params['compact'] = "1"
+      params['no_peer_id'] = "1"
+      if ! @startSent
+        event = :started  
+        @startSent = true
+      end
+      params['event'] = event.to_s if event
+      
+
+      @logger.debug "Request parameters: "
+      params.each do |k,v|
+        @logger.debug "  #{k}: #{v}"
+      end
+
+      query = ""
+      params.each do |k,v|
+        query  << "&" if query.length > 0
+        query  << "#{k}=#{v}"
+      end
+      uri.query = query
+  
+      res = Net::HTTP.get_response(uri)
+      @logger.debug "Tracker response code: #{res.code}"
+      @logger.debug "Tracker response body: #{res.body}"
+      result = buildTrackerResponse(res)
+      @logger.debug "TrackerResponse: #{result.inspect}"
+      result 
+    end
+
+    protected
+    def decodePeers(peersProp)
+      peers = []
+      if peersProp.is_a?(String)
+        # Compact format: 4byte IP followed by 2byte port, in network byte order 
+        index = 0
+        while index + 6 <= peersProp.length
+          ip = peersProp[index,4].unpack("CCCC").join('.')
+          port = peersProp[index+4,2].unpack("n").first
+          peers.push TrackerPeer.new(ip, port)
+          index += 6
+        end
+      else 
+        # Non-compact format
+        peersProp.each do |peer|
+          ip = peer['ip'] 
+          port = peer['port'] 
+          if ip && port
+            peers.push TrackerPeer.new(ip, port)
+          end
+        end
+        #raise "Non-compact peer format not implemented"
+      end
+      peers
+    end
+
+    private
+    def buildTrackerResponse(netHttpResponse)
+      error = nil
+      peers = []
+      interval = nil
+      success = netHttpResponse.code.to_i >= 200 && netHttpResponse.code.to_i < 300
+      if success
+        begin
+          decoded = netHttpResponse.body.bdecode
+        rescue
+          error = "Tracker netHttpResponse body was not a valid bencoded string"
+          success = false
+          return self
+        end
+
+        if decoded.has_key? 'peers'
+          peers = decodePeers(decoded['peers'])
+        else
+          error = "Tracker netHttpResponse didn't contain a peers property"
+          success = false
+        end
+
+        if decoded.has_key? 'interval'
+          interval = decoded['interval'].to_i
+        end
+      else
+        error = netHttpResponse.body
+      end
+      
+      result = TrackerResponse.new(success, error, peers)
+      result.interval = interval if interval
+      result
+    end
+  end
+end

data/lib/quartz_torrent/interruptiblesleep.rb

@@ -0,0 +1,27 @@
+require 'thread'
+
+module QuartzTorrent
+  # Class that implements a sleep for a specified number of seconds that can be interrupted.
+  # When a caller calls sleep, another thread can call wake to wake the sleeper.
+  class InterruptibleSleep
+    def initialize
+      @eventRead, @eventWrite = IO.pipe
+      @eventPending = false
+      @mutex = Mutex.new
+    end
+
+    # Sleep.
+    def sleep(seconds)
+      if IO.select([@eventRead], nil, nil, seconds)
+        @eventRead.read(1)
+      end
+    end
+
+    # Wake the sleeper.
+    def wake
+      @mutex.synchronize do
+        @eventWrite.print "X" if ! @eventPending
+      end
+    end
+  end
+end

data/lib/quartz_torrent/log.rb

@@ -0,0 +1,132 @@
+require 'log4r'
+
+# For some reason the Log4r log level constants (ERROR, etc) are not defined until we 
+# create at least one logger. Here I create one unused one so that the constants exist.
+Log4r::Logger.new '__init'
+
+module QuartzTorrent
+  # Class used to control logging.
+  class LogManager
+
+    @@outputter = nil
+    @@defaultLevel = Log4r::ERROR
+    @@maxOldLogs = 10
+    @@maxLogSize = 1048576
+    @@dest = nil
+
+    # Initialize logging based on environment variables. The QUARTZ_TORRENT_LOGFILE variable controls where logging is written,
+    # and should be either a file path, 'stdout' or 'stderr'.
+    def self.initializeFromEnv
+      @@dest = ENV['QUARTZ_TORRENT_LOGFILE']
+      @@defaultLevel = parseLogLevel(ENV['QUARTZ_TORRENT_LOGLEVEL'])
+  
+    end
+
+    # Initialize the log manager. This method expects a block, and the block may call the following methods:
+    #
+    #   setLogfile(path)
+    #   setDefaultLevel(level)
+    #   setMaxOldLogs(num)
+    #   setMaxLogSize(size)
+    #
+    # In the above methods, `path` defines where logging is written, and should be either a file path, 'stdout' or 'stderr';
+    # `level` is a logging level as per setLevel, `num` is an integer, and `size` is a value in bytes.
+    def self.setup(&block)
+      self.instance_eval &block
+
+      dest = @@dest
+      if dest
+        if dest.downcase == 'stdout'
+          dest = Log4r::Outputter.stdout
+        elsif dest.downcase == 'stderr' 
+          dest = Log4r::Outputter.stderr
+        else
+          dest = Log4r::RollingFileOutputter.new('outputter', {filename: dest, maxsize: @@maxLogSize, max_backups: @@maxOldLogs})
+        end
+      end
+      @@outputter = dest
+    end
+
+    # Set log level for the named logger. The level can be one of
+    # fatal, error, warn, info, or debug as a string or symbol.
+    def self.setLevel(name, level)
+      level = parseLogLevel(level)
+      logger = LogManager.getLogger(name)
+      logger.level = level
+    end
+
+    # Get the logger with the specified name. Currently this returns a log4r Logger.
+    def self.getLogger(name)
+      if ! @@outputter
+        Log4r::Logger.root
+      else
+        logger = Log4r::Logger[name]
+        if ! logger
+          logger = Log4r::Logger.new name
+          logger.level = @@defaultLevel
+          logger.outputters = @@outputter
+        end
+        logger
+      end
+    end
+
+    private
+    # DSL method used by setup.
+    # Set the logfile.
+    def self.setLogfile(dest)
+      @@dest = dest
+    end
+    # DSL method used by setup.
+    # Set the default log level.
+    def self.setDefaultLevel(level)
+      @@defaultLevel = parseLogLevel(level)
+    end
+
+    # Set number of old log files to keep when rotating.
+    def self.setMaxOldLogs(num)
+      @@maxOldLogs = num
+    end
+
+    # Max size of a single logfile in bytes
+    def self.setMaxLogSize(size)
+      @@maxLogSize = size
+    end
+
+    def self.parseLogLevel(level)
+      if level
+        if level.is_a? Symbol
+          if level == :fatal
+            level = Log4r::FATAL
+          elsif level == :error
+            level = Log4r::ERROR
+          elsif level == :warn
+            level = Log4r::WARN
+          elsif level == :info
+            level = Log4r::INFO
+          elsif level == :debug
+            level = Log4r::DEBUG
+          else
+            level = Log4r::ERROR
+          end
+        else
+          if level.downcase == 'fatal'
+            level = Log4r::FATAL
+          elsif level.downcase == 'error'
+            level = Log4r::ERROR
+          elsif level.downcase == 'warn'
+            level = Log4r::WARN
+          elsif level.downcase == 'info'
+            level = Log4r::INFO
+          elsif level.downcase == 'debug'
+            level = Log4r::DEBUG
+          else
+            level = Log4r::ERROR
+          end
+        end
+      else
+        level = Log4r::ERROR
+      end
+      level
+    end
+  end
+end

data/lib/quartz_torrent/magnet.rb

@@ -0,0 +1,92 @@
+require 'quartz_torrent/util'
+require 'uri'
+require 'base32'
+
+module QuartzTorrent
+  class MagnetURI
+    @@regex = /magnet:\?(.*)/
+  
+    # Create a new MagnetURI object given a magnet URI string.
+    def initialize(str)
+      @params = {}
+      @raw = str
+
+      if str =~ @@regex
+        parseQuery $1
+      else
+        raise "Not a magnet URI"
+      end
+    end
+
+    attr_reader :raw
+
+    def self.magnetURI?(str)
+      str =~ @@regex
+    end
+
+    # Return the value of the specified key from the magnet URI.
+    def [](key)
+      @params[key]
+    end
+
+    # Return the first Bittorrent info hash found in the magnet URI. The returned
+    # info hash is in binary format.
+    def btInfoHash
+      result = nil
+      @params['xt'].each do |topic|
+        if topic =~ /urn:btih:(.*)/
+          hash = $1
+          if hash.length == 40
+            # Hex-encoded info hash. Convert to binary.
+            result = [hash].pack "H*" 
+          else
+            # Base32 encoded
+            result = Base32.decode hash
+          end
+          break
+        end
+      end
+      result
+    end
+
+    # Return the first tracker URL found in the magnet link. Returns nil if the magnet has no tracker info.
+    def tracker
+      tr = @params['tr']
+      if tr
+        tr.first
+      else
+        nil
+      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']
+      if dn
+        dn.first
+      else
+        nil
+      end
+    end
+
+    # Create a magnet URI string given the metainfo from a torrent file.
+    def self.encodeFromMetainfo(metainfo)
+      s = "magnet:?xt=urn:btih:"
+      s << metainfo.infoHash.unpack("H*").first
+      s << "&tr="
+      s << metainfo.announce
+    end
+
+    private
+    def parseQuery(query)
+      query.split('&').each do |part|
+        if part =~ /(.*)=(.*)/
+          name = $1
+          val = $2
+          name = $1 if name =~ /(.*).\d+$/
+          @params.pushToList name, URI.unescape(val).tr('+',' ')
+        end
+      end
+    end
+  end
+end