quartz_torrent 0.0.1

data/lib/quartz_torrent/udptrackermsg.rb

@@ -0,0 +1,250 @@
+module QuartzTorrent
+  class UdpTrackerMessage
+    ActionConnect = 0
+    ActionAnnounce = 1
+    ActionScrape = 2
+    ActionError = 3
+
+    EventNone = 0
+    EventCompleted = 1
+    EventStarted = 2
+    EventStopped = 3
+
+    # Pack the number 'num' as a network byte order signed integer, 'len' bytes long. 
+    # Negative numbers are written in two's-compliment notation.
+    def self.packAsNetworkOrder(num, len)
+      result = ""
+      len.times do
+        result << (num & 0xff)
+        num >>= 8
+      end
+      result.reverse
+    end
+
+    # Unpack the number stored in 'str' assuming it is a network byte order signed integer. 
+    # Negative numbers are assumed to be in two's-compliment notation.
+    def self.unpackNetworkOrder(str, len = nil)
+      result = 0
+      first = true
+      negative = false
+      index = 0
+      str.each_byte do |b|
+        if first
+          negative = (b & 0x80) > 0
+          first = false
+        end
+        result <<= 8
+        result += b
+        index += 1
+        break if len && index == len
+      end
+      if negative
+        # Internally the value is being represented unsigned. To make it signed,
+        # we first take the ones compliment of the value, remove the sign bit, and add one.
+        # This takes the two's compliment of the two's compliment of the number, which results
+        # in the absolute value of the original number. Finally we use the unary - operator to
+        # make the value negative.
+        result = -(((~result) & 0x7fffffffffffffff) + 1)
+      end
+      result 
+    end
+  end
+
+  # Superclass for UDP tracker requests.
+  class UdpTrackerRequest
+    def initialize
+      @connectionId = 0x41727101980
+      @action = UdpTrackerMessage::ActionConnect
+      # Get a number that is a valid 32-bit signed integer.
+      @transactionId = rand(0x10000000)-8000000
+    end
+
+    # Get the connectionId as an integer
+    attr_reader :connectionId
+    # Get the action as an integer. Should be one of the UdpTrackerMessage::Action* constants
+    attr_reader :action
+    # Get the transactionId as an integer. 
+    attr_reader :transactionId
+
+    # Set the connectionId. Value must be an integer
+    def connectionId=(v)
+      raise "The 'connectionId' field must be an integer" if ! v.is_a?(Integer)
+      @connectionId = v
+    end
+    # Set the action. Value should be one of the UdpTrackerMessage::Action* constants
+    def action=(v)
+      raise "The 'action' field must be an integer" if ! v.is_a?(Integer)
+      @action = v
+    end
+    # Set the transactionId. Value must be an integer. If not set a random number is used as per the specification.
+    def transactionId=(v)
+      raise "The 'transactionId' field must be an integer" if ! v.is_a?(Integer)
+      @transactionId = v
+    end
+  end
+
+  # Superclass for UDP tracker responses
+  class UdpTrackerResponse
+    def initialize
+      @connectionId = nil
+      @action = nil
+      @transactionId = nil
+    end
+  
+    # ConnectionId as an integer
+    attr_accessor :connectionId
+    # Get the action as an integer. Should be one of the UdpTrackerMessage::Action* constants
+    attr_accessor :action
+    # Get the transactionId as an integer
+    attr_accessor :transactionId
+  end
+
+  class UdpTrackerConnectRequest < UdpTrackerRequest
+    def serialize
+      result = UdpTrackerMessage::packAsNetworkOrder(@connectionId, 8)
+      result << UdpTrackerMessage::packAsNetworkOrder(@action, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@transactionId, 4)
+      result
+    end
+  end
+
+  class UdpTrackerConnectResponse < UdpTrackerResponse
+    def initialize
+      super
+    end
+
+    def self.unserialize(msg)
+      raise "Invalid connect response: it is #{msg.length} when it must be at least 16" if msg.length < 16
+      result = UdpTrackerConnectResponse.new
+      result.action = UdpTrackerMessage::unpackNetworkOrder(msg,4)
+      result.transactionId = UdpTrackerMessage::unpackNetworkOrder(msg[4,4],4)
+      result.connectionId = UdpTrackerMessage::unpackNetworkOrder(msg[8,8],8)
+      raise "Invalid connect response: action is not connect" if result.action != UdpTrackerMessage::ActionConnect
+      result
+    end
+
+    def self.tohex(str)  
+      result = ""
+      str.each_byte do |b|
+        result << b.to_s(16)
+      end
+      result
+    end
+  end
+
+  class UdpTrackerAnnounceRequest < UdpTrackerRequest
+    def initialize(connectionId)
+      super()
+      @connectionId = connectionId
+      @action = UdpTrackerMessage::ActionAnnounce
+      @infoHash = nil
+      @peerId = nil
+      @downloaded = nil
+      @left = nil
+      @uploaded = nil
+      @event = nil
+      # 0 means allow tracker to assume the sender's IP address is the one it's looking for
+      # http://www.rasterbar.com/products/libtorrent/udp_tracker_protocol.html
+      @ipAddress = 0
+      @key = rand(0xffffffff)
+      # Number of peers requested: default.
+      @numWant = -1
+      @port = nil
+    end
+
+    attr_accessor :infoHash
+    attr_accessor :peerId
+    attr_reader   :downloaded
+    attr_reader   :left
+    attr_reader   :uploaded
+    attr_reader   :event
+    attr_accessor :ipAddress
+    attr_accessor :key
+    attr_accessor :numWant
+    attr_accessor :port
+
+    def downloaded=(v)
+      raise "The 'downloaded' field must be an integer" if ! v.is_a?(Integer)
+      @downloaded = v
+    end
+
+    def left=(v)
+      raise "The 'left' field must be an integer" if ! v.is_a?(Integer)
+      @left = v
+    end
+
+    def uploaded=(v)
+      raise "The 'uploaded' field must be an integer" if ! v.is_a?(Integer)
+      @uploaded = v
+    end
+
+    def event=(v)
+      raise "The 'event' field must be an integer" if ! v.is_a?(Integer)
+      @event = v
+    end
+
+    def numWant=(v)
+      raise "The 'numWant' field must be an integer" if ! v.is_a?(Integer)
+      @numWant = v
+    end
+
+    def port=(v)
+      raise "The 'port' field must be an integer" if ! v.is_a?(Integer)
+      @port = v
+    end
+
+    def serialize
+      result = UdpTrackerMessage::packAsNetworkOrder(@connectionId, 8)
+      result << UdpTrackerMessage::packAsNetworkOrder(@action, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@transactionId, 4)
+      result << infoHash
+      result << peerId
+      result << UdpTrackerMessage::packAsNetworkOrder(@downloaded, 8)
+      result << UdpTrackerMessage::packAsNetworkOrder(@left, 8)
+      result << UdpTrackerMessage::packAsNetworkOrder(@uploaded, 8)
+      result << UdpTrackerMessage::packAsNetworkOrder(@event, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@ipAddress, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@key, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@numWant, 4)
+      result << UdpTrackerMessage::packAsNetworkOrder(@port, 2)
+      result
+    end
+  end
+
+  class UdpTrackerAnnounceResponse < UdpTrackerResponse
+    def initialize
+      super
+      @interval = nil     
+      @leechers = nil     
+      @seeders = nil     
+      @ips = []
+      @ports = []
+    end
+
+    attr_accessor :interval
+    attr_accessor :leechers
+    attr_accessor :seeders
+    attr_accessor :ips
+    attr_accessor :ports
+
+    def self.unserialize(msg)
+      raise "Invalid connect response: it is #{msg.length} when it must be at least 20" if msg.length < 20
+      result = UdpTrackerAnnounceResponse.new
+      result.action = UdpTrackerMessage::unpackNetworkOrder(msg,4)
+      result.transactionId = UdpTrackerMessage::unpackNetworkOrder(msg[4,4],4)
+      result.interval = UdpTrackerMessage::unpackNetworkOrder(msg[8,4],4)
+      result.leechers = UdpTrackerMessage::unpackNetworkOrder(msg[12,4],4)
+      result.seeders = UdpTrackerMessage::unpackNetworkOrder(msg[16,4],4)
+      
+      index = 20
+      while index+6 < msg.length
+        result.ips.push msg[index,4]
+        result.ports.push msg[index+4,2]
+        index += 6
+      end
+      result
+    end
+  end
+  
+  
+end

data/lib/quartz_torrent/util.rb

@@ -0,0 +1,100 @@
+class Hash
+  # Treat the array as a hash of lists. This method will append 'value' to the list
+  # at key 'key' in the hash. If there is no list for 'key', one is created.
+  def pushToList(key, value)
+    list = self[key]
+    if ! list
+      list = [] 
+      self[key] = list
+    end
+    list.push value
+  end
+end
+
+module QuartzTorrent
+  # This is Linux specific: system call number for gettid
+  SYSCALL_GETTID = 224
+
+  # Return a hex string representing the bytes in the passed string.
+  def self.bytesToHex(v, addSpaces = nil)
+    s = ""
+    v.each_byte{ |b|
+      hex = b.to_s(16)
+      hex = "0" + hex if hex.length == 1
+      s << hex
+      s << " " if addSpaces == :add_spaces
+    }
+    s
+  end
+
+  # Given a hex string representing a sequence of bytes, convert it the the original bytes. Inverse of bytesToHex. 
+  def self.hexToBytes(v)
+    [v].pack "H*"
+  end
+
+  # Shuffle the subset of elements in the given array between start and start+length-1 inclusive.
+  def self.arrayShuffleRange!(array, start, length)
+    raise "Invalid range" if start + length > array.size
+
+    (start+length).downto(start+1) do |i|
+      r = start + rand(i-start)
+      array[r], array[i-1] = array[i-1], array[r]
+    end
+    true
+  end
+
+  # Store Linux Lightweight process ids (LWPID) on each thread.
+  # If this is called a while before logBacktraces the backtraces will
+  # include lwpids.
+  def self.setThreadLwpid(thread = nil)
+    # This function works by calling the GETTID system call in Linux. That
+    # system call must be called in the thread that we want to get the lwpid of,
+    # but the user may not have created those threads and so can't call the system call
+    # in those threads (think Sinatra). To get around this this function runs code in the
+    # thread by adding a trace function to the thread, and on the first traced operation
+    # stores the LWPID on the thread and unregisters itself.    
+
+    isLinux = RUBY_PLATFORM.downcase.include?("linux")
+    return if !isLinux
+
+    tracer = Proc.new do
+      Thread.current[:lwpid] = syscall(SYSCALL_GETTID) if ! Thread.current[:lwpid] && isLinux
+      Thread.current.set_trace_func(nil)
+    end
+    
+    if thread
+      thread.set_trace_func(tracer)
+    else
+      Thread.list.each { |thread| thread.set_trace_func(tracer) }
+    end
+  end
+
+  # Log backtraces of all threads currently running. The threads are logged to the 
+  # passed io, or if that's nil they are written to the logger named 'util' at error level.
+  def self.logBacktraces(io)
+    logger = nil
+    logger = LogManager.getLogger("util") if ! io
+    isLinux = RUBY_PLATFORM.downcase.include?("linux")
+
+    Thread.list.each do |thread|
+      lwpid = ""
+
+      setThreadLwpid thread if ! thread[:lwpid] && isLinux
+      lwpid = " [lwpid #{thread[:lwpid]}]" if thread[:lwpid]
+
+      msg = "Thread #{thread[:name]} #{thread.object_id}#{lwpid}: #{thread.status}\n  " + (thread.backtrace ? thread.backtrace.join("\n  ") : "no backtrace")
+      if io
+        io.puts msg
+      else
+        logger.error msg
+      end
+    end
+  end
+
+  # Method to set a few thread-local variables useful in debugging. Threads should call this when started.
+  def self.initThread(name)
+    Thread.current[:name] = name
+  end
+
+end
+

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: quartz_torrent
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bencode
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pqueue
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: base32
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A pure ruby bittorrent library
+email: 
+executables:
+- quartztorrent_download
+- quartztorrent_download_curses
+- quartztorrent_magnet_from_torrent
+- quartztorrent_show_info
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/quartz_torrent.rb
+- lib/quartz_torrent/blockstate.rb
+- lib/quartz_torrent/memprofiler.rb
+- lib/quartz_torrent/regionmap.rb
+- lib/quartz_torrent/httptrackerclient.rb
+- lib/quartz_torrent/interruptiblesleep.rb
+- lib/quartz_torrent/extension.rb
+- lib/quartz_torrent/util.rb
+- lib/quartz_torrent/log.rb
+- lib/quartz_torrent/metainfo.rb
+- lib/quartz_torrent/trackerclient.rb
+- lib/quartz_torrent/peermsgserialization.rb
+- lib/quartz_torrent/semaphore.rb
+- lib/quartz_torrent/reactor.rb
+- lib/quartz_torrent/metainfopiecestate.rb
+- lib/quartz_torrent/peer.rb
+- lib/quartz_torrent/peerclient.rb
+- lib/quartz_torrent/formatter.rb
+- lib/quartz_torrent/piecemanagerrequestmetadata.rb
+- lib/quartz_torrent/peerholder.rb
+- lib/quartz_torrent/rate.rb
+- lib/quartz_torrent/peermanager.rb
+- lib/quartz_torrent/bitfield.rb
+- lib/quartz_torrent/udptrackermsg.rb
+- lib/quartz_torrent/ratelimit.rb
+- lib/quartz_torrent/classifiedpeers.rb
+- lib/quartz_torrent/peermsg.rb
+- lib/quartz_torrent/filemanager.rb
+- lib/quartz_torrent/magnet.rb
+- lib/quartz_torrent/udptrackerclient.rb
+- bin/quartztorrent_download
+- bin/quartztorrent_download_curses
+- bin/quartztorrent_magnet_from_torrent
+- bin/quartztorrent_show_info
+homepage: https://github.com/jeffwilliams/quartz-torrent
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A bittorrent library
+test_files: []
+has_rdoc: