torrenter 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a3773b22bb18ac1dc0b3ccd2994889a9f21bbc84
-  data.tar.gz: cd433369ba505739ad4672dae2b5e81a8b048971
+  metadata.gz: b84f8e49f69b5654aedf1edd2b894bf3d9d9a612
+  data.tar.gz: 6aa38459649cc8e4c8ce770799f46a161967d457
 SHA512:
-  metadata.gz: 0a25c88408740951f0400a2f723d5a02265a6d0a71e6af317b82913b3a58453f06bccd26af66349a8e276f25b56ca652b2ae7d1b392d98b7f4842cd9759ba233
-  data.tar.gz: 30b43deacc081ce8475a5e1ac83e058f10fdc7782a188d835e6da602438714f9e2a46b851f9d6fad83b8a84d498d84f39e62f5baa8e9c67f8e16ab5c2be77ea1
+  metadata.gz: 29dbc732d5bb03d5fb76362bb5825622c9ecbf14cc03cb352ddc3d780238154a1b60084fcbcb6b7f9ab9f00a75b401516e3bd243d6822d56ce129180ac225d68
+  data.tar.gz: 80d1d9d22e3186ebb45e555f70ae272c7beb472c39e3ea80796a83527ab50529e4b60a1bd7ed9b281b4fb243ce1cb2899af569a7d522e957c92d0b61046f5477

data/lib/torrenter.rb

@@ -6,18 +6,53 @@ require 'pry'
 require 'torrenter/message/messager'
 require 'torrenter/message/message_types'
 require 'torrenter/peer'
-require 'torrenter/reactor'
 require 'torrenter/torrent_reader'
+require 'torrenter/reactor'
 require 'torrenter/http_tracker'
 require 'torrenter/udp_tracker'
 
+# reader just reads the torrent file
+# trackers just get peer ips and ports
+# peers just hold peer data
+# reactor uses the peer data to connect to the peers
+# the buffer state should be a class on its own.
+
+
 module Torrenter
   class Torrent
     def start(file)
       IO.write($data_dump, '', 0) if !File.exists?($data_dump)
       stream  = BEncode.load_file(file)
-      peers   = Torrenter::TorrentReader.new(stream)
-      peers.determine_protocol
+      torrent_file = Torrenter::TorrentReader.new(stream)
+      trackers = torrent_file.access_trackers
+
+      # returns an array of initialized UDP and/or HTTP Tracker class objects
+
+      loop do
+        @tracker = trackers.shift
+        if @tracker
+          begin
+            Timeout::timeout(10) { @tracker.connect }
+          rescue Timeout::Error
+            puts 'Tracker not responding. Trying next.'
+          end
+        end
+        
+        if @tracker.connected?
+          break
+        elsif trackers.empty?
+          raise 'Trackers non-responsive'
+        end
+      end
+
+      peers = @tracker.bound_peers
+      reactor = Reactor.new(peers, stream)
+      reactor.check_for_existing_data
+      unless reactor.finished?
+        reactor.message_reactor
+      else
+        reactor.unpack_data
+      end
     end
   end
 end

data/lib/torrenter/http_tracker.rb

@@ -1,14 +1,14 @@
 module Torrenter
   class HTTPTracker < TorrentReader
-
-    def initialize(address, stream)
-      @address = URI(address)
+    attr_reader :response
+    def initialize(tracker, stream)
       super(stream)
+      @address   = URI(tracker)
     end
 
     def connect
       @address.query = URI.encode_www_form(tracker_params)
-      @response = 
+      @response =
         begin
           BEncode.load(Net::HTTP.get(@address))
         rescue
@@ -16,25 +16,29 @@ module Torrenter
         end
     end
 
-    def address_hashes
-      @response['peers']
+    def connect_interval
+      @response['min_interval']
     end
 
-    def address_list
-      parse_addresses(address_hashes, address_hashes.bytesize / 6)
+    def address_hashes
+      @response['peers']
     end
 
     def tracker_params
       {
-        :info_hash => @sha,
+        :info_hash => info_hash,
         :peer_id   => PEER_ID,
-        :left      => @piece_length,
-        :pieces    => @file_list
+        :left      => piece_length,
+        :pieces    => file_list
       }
     end
 
+    def bound_peers
+      peer_list(@response['peers'])
+    end
+
     def connected?
       @response
     end
   end
-end
+end

data/lib/torrenter/message/message_types.rb

@@ -9,5 +9,5 @@ module Torrenter
   PIECE      = "\a"
   CHOKE      = "\x00"
   PROTOCOL = "\x13BitTorrent protocol\x00\x00\x00\x00\x00\x00\x00\x00"
-  EXCEPTIONS = [Errno::EADDRNOTAVAIL, Errno::ECONNREFUSED, Errno::EPIPE, Errno::ECONNRESET]
+  EXCEPTIONS = [Errno::EADDRNOTAVAIL, Errno::ECONNREFUSED, Errno::EPIPE, Errno::ECONNRESET, IO::EAGAINWaitWritable]
 end

data/lib/torrenter/message/messager.rb

@@ -6,222 +6,159 @@ module Torrenter
   # and shrink the complexity of the Peer class.
   # the following methods are responsible solely for data retrieval and data transmission
 
-  def send_data(msg, opts={})
-    begin
-      Timeout::timeout(2) { @socket.sendmsg_nonblock(msg) }
-    rescue Timeout::Error
-      ''
-    rescue *EXCEPTIONS
-      @status = false
-      ''
-    end
-  end
+  def state(master_index, remaining, &block)
+    @remaining = remaining
 
-  def recv_data(bytes=BLOCK, opts={})
-    begin
-      Timeout::timeout(5) { buffer << @socket.recv_nonblock(bytes) }
-    rescue Timeout::Error
-      ''
-    rescue *EXCEPTIONS
-      @status = false
-      ''
-    rescue IO::EAGAINWaitReadable
-      ''
+    recv_data if @buffer.size <= 3
+    if @buffer[4].nil?
+      @buffer.slice!(0..3) if @buffer[0..3] == KEEP_ALIVE
+    else
+      @length    = @buffer[0..3].unpack("N*").last
+      @buffer_id = @buffer[4]
+      case @buffer_id
+      when BITFIELD
+        process_bitfield(master_index.size, clear_msg)
+      when HAVE
+        process_have(clear_msg)
+      when INTERESTED
+        @buffer = ''
+
+        return :interested
+      when PIECE
+        process_piece { block.call @blocks.join(''), @index }
+      when CHOKE      
+        choke_message
+      when HANDSHAKE
+        process_handshake
+      end
     end
   end
 
-  # the next few methods responsibility is for parsing the buffer. 
-  # They are responsible for the critical step of analyzing the buffer,
-  # checking for message consistency from the peer (and if it fails a test
-  # another message is sent out to attempt to fix the missing data)
-  
-
-  # parse message will be the gatekeeper. If the buffer is ever low in the READ part
-  # of the torrent program, then it knows more data may be required.
-  # It will also be responsble for EVERY new message that gets received, whether
-  # its in the download sequence of messaging or in the actual handshake, it will
-  # control it that way.
+  def completed?
+    piece_data.bytesize == @piece_length || piece_data.bytesize == @remaining
+  end
 
-  # for now, I'm assuming that at least the bitfield will be sent in full
+  def piece_data
+    @blocks.join('')
+  end
 
-  def parse_bitfield
-    len = msg_len
-    buffer.slice!(0)
-    @piece_index = buffer.slice!(0...len)
-      .unpack("B#{sha_list.size}")
-      .first
-      .split('')
-      .map { |bit| bit == '1' ? :available : :unavailable }
+  def choke_message
+    @peer_state = false
   end
 
-  def send_interested
-    send_data("\x00\x00\x00\x01\x02")
+  def clear_msg
+    @buffer.slice!(0..@length + 3)  
   end
 
-  def parse_have
-    if buffer[5..8].bytesize == 4
-      index = buffer[5..8].unpack("N*").first
-      @piece_index[index] = :available
-      buffer.slice!(0..8)
-    else
-      recv_data
-    end
-    send_interested if @buffer.empty?
+  def request_message(bytes=BLOCK)
+    @msg = "index: #{@index} offset: #{@blocks.size * BLOCK} bytes: #{bytes}"
+    send_data(pack(13) + "\x06" + pack(@index) + pack(@blocks.size * BLOCK) + pack(bytes))
   end
 
-  # because ruby.
+  def pack(msg)
+    [msg].pack("I>")
+  end
 
-  def parse_handshake
-    @buffer.slice!(0..67) if hash_match?
+  def process_bitfield(size, msg)
+    index = msg[5..-1].unpack("B#{size}").join.split('')
+    @piece_index = index.map { |bit| bit == '1' ? :free : :unavailable }
+    send_interested if @buffer.empty?
   end
 
-  def hash_match?
-    @buffer.unpack("A*").first[28..47] == info_hash
+  def process_have(msg)
+    @piece_index[msg[5..-1].unpack("C*").last] = :free
+    send_interested if @buffer.empty?
   end
 
-  # the negative 1 modifier is for factoring in the id
+  def request_piece(index)
+    @index = index
+    @piece_index[@index] = :downloading
 
-  def msg_len
-    @buffer.slice!(0..3).unpack("N*").first - 1
+    request_message
   end
 
-  # needs optimization. It evaluates the master index lazily with 
-  # no thought as to the 'rare pieces'
-
-  def evaluate_index(master)
-    if @piece_index.any? { |chunk| chunk == :available }
-      @index = @piece_index.index(:available)
-      if master[@index] == :free
-        @piece_index[@index] = :downloading
-        master[@index] = :downloading
-      else
-        @piece_index[@index] = :downloaded
-        evaluate_index(master)
-      end
-    end
+  def send_interested
+    send_data("\x00\x00\x00\x01\x02")
   end
 
-  def modify_index(master)
-    master.each_with_index do |v,i|
-      if v == :downloaded
-        @piece_index[i] = :downloaded
-      end
-    end
+  def buffer_length?
+    @buffer.bytesize >= @length + 4
   end
 
-  def state(master, blocks)
-    @buffer_state = @buffer[4]
-    if buffer.bytesize <= 3 
-      recv_data
-    elsif buffer.bytesize == 4 && buffer[0..3] == KEEP_ALIVE
-      buffer.slice!(0..3)
-    else
+  def process_piece(&block)
+    binding.pry if @length < BLOCK
+    if buffer_length?
+      if buffer_complete?
+        pack_buffer
+      end
 
-      # p @buffer[0..3].unp@buack("C*")
-      case @buffer[4]
-      when INTERESTED
-        buffer.slice!(0..4)
-        modify_index(master)
-        evaluate_index(master)
-        request_message
-      when HAVE
-        parse_have
-      when BITFIELD
-        parse_bitfield
-        send_interested if buffer.empty?
-      when PIECE
-        @msg_length = buffer[0..3].unpack("N*").first + 4
-
-        if block_finished?
-          buffer.slice!(0..12)
-
-          # the metadata is sliced off.
-
-          @offset += (@msg_length - 13)
-
-          # buffer is reduced
-
-          pack_buffer
-          # that means the bytes for that block have been collected entirely.
-          # the buffer becomes empty
-          if pieces_remaining(master) > 1
-
-            if piece_size == @piece_len
-              pack_file(master)
-              evaluate_index(master)
-              request_message
-            else
-              request_message
-            end
-          elsif (File.size($data_dump) + piece_size) == total_file_size
-            pack_file(master)
-          else
-            if bytes_remaining >= BLOCK
-              request_message
-            else
-              request_message(bytes_remaining)
-            end
-          end
+      if @blocks.join('').bytesize < @piece_length
+        diff = @remaining - @blocks.join('').bytesize
+        if diff < BLOCK
+          request_message(diff)
         else
-          recv_data(@msg_length - buffer.bytesize)
+          request_message
         end
-        # piece
-      when CHOKE
-        buffer.slice!(0..3)
-        send_interested
-      when HANDSHAKE
-        parse_handshake
       end
+
+      block.call if completed?
     end
+    recv_data
   end
 
-  def pieces_remaining(master)
-    master.count(:downloading) + master.count(:free)
+  def mark_complete
+    @blocks = []
+    @piece_index[@index] = :downloaded
   end
 
-  def bytes_remaining
-    (total_file_size - File.size($data_dump)) - piece_size
+  def pack_buffer
+    @blocks << @buffer.slice!(13..-1)
+    @buffer.clear
   end
 
-  def piece_size
-    @block_map.join.bytesize
+  def buffer_complete?
+    (@buffer.bytesize - 13) == BLOCK || (@buffer.bytesize - 13) == @length - 9
   end
 
-  def pack_buffer
-    @block_map << @buffer.slice!(0...(@msg_length - 13))
-  end
+  # will need a last piece sort of thing inserted in here
 
-  def pack_file(master)
-    data = @block_map.join
-    if piece_verified?(data)
-      IO.write($data_dump, data, @index * @offset)
-      master[@index] = :downloaded
-      @piece_index[@index] = :downloaded
+  def process_handshake
+    if hash_check?
+      @buffer.slice!(0..67) 
     else
-      master[@index] = :free
-      @piece_index[@index] = :downloaded
+      @peer_state = false
     end
-    @block_map = []
-    @offset = 0
   end
 
-  def piece_verified?(data)
-    Digest::SHA1.digest(data) == sha_list[@index]
+  def hash_check?
+    @buffer[28..47] == @info_hash
   end
 
-  def request_message(bytes=BLOCK)
-    send_data(pack(13) + "\x06" + pack(@index) + pack(@offset) + pack(bytes))
-  end
-
-  def pack(i)
-    [i].pack("I>")
-  end
-
-  def block_finished?
-    buffer.bytesize >= @msg_length
+  def send_data(msg)
+    begin
+      Timeout::timeout(2) { @socket.sendmsg_nonblock(msg) }
+    rescue Timeout::Error
+      ''
+    rescue IO::EAGAINWaitReadable
+      ''
+    rescue *EXCEPTIONS
+      ''
+    rescue Errno::ETIMEDOUT
+      @peer_state = false
+    end
   end
 
-  def piece_finished?
-    
+  def recv_data(bytes=BLOCK)
+    begin
+      Timeout::timeout(5) { @buffer << @socket.recv_nonblock(bytes) }
+    rescue Timeout::Error
+      ''
+    rescue IO::EAGAINWaitReadable
+      ''
+    rescue *EXCEPTIONS
+      ''
+    rescue Errno::ETIMEDOUT
+      @peer_state = false
+    end
   end
 end