torrenter 0.0.5 → 0.0.6

data/lib/torrenter/peer.rb

@@ -2,34 +2,32 @@ module Torrenter
   class Peer
     include Torrenter
 
-    attr_reader :socket, :peer, :sha_list, :piece_len, :info_hash, :status, :index, :msg_length
-    attr_accessor :piece_index, :offset, :buffer, :block_map
-
-    def initialize(peer, file_list, peer_info={})
-      @peer            = peer
-      @info_hash       = peer_info[:info_hash]
-      @piece_len       = peer_info[:piece_length]
-      @sha_list        = peer_info[:sha_list]
-      @piece_index     = peer_info[:piece_index]
-      @buffer          = ''
-      @block_map       = []
-      @offset          = 0
-      @file_list       = file_list
-      @status          = false
+    attr_reader :status, :peer_state, :info_hash, :piece_length, :blocks, :buffer, :ip
+    attr_accessor :piece_index, :remaining, :index
+
+    def initialize(ip, port, info_hash, piece_length)
+      @ip           = ip
+      @port         = port
+      @info_hash    = info_hash
+      @piece_length = piece_length
+      @buffer       = ''
+      @blocks       = []
+      @dl_rate      = 0
+      @piece_index  = []
     end
 
-    def total_file_size
-      if @file_list.is_a?(Array)
-        @file_list.map { |f| f['length'] }.inject { |x, y| x + y }
-      else
-        @file_list['length']
-      end
+    def current_size
+      piece_data.bytesize + @buffer.bytesize
+    end
+
+    def piece_data
+      @blocks.join('')
     end
 
     def connect
-      puts "\nConnecting to IP: #{peer[:ip]} PORT: #{peer[:port]}"
+      puts "\nConnecting to IP: #{@ip} PORT: #{@port}"
       begin
-        Timeout::timeout(1) { @socket = TCPSocket.new(peer[:ip], peer[:port]) }
+        Timeout::timeout(1) { @socket = TCPSocket.new(@ip, @port) }
       rescue Timeout::Error
         puts "Timed out."
       rescue Errno::EADDRNOTAVAIL
@@ -43,9 +41,9 @@ module Torrenter
       if @socket
         puts "Connected!"
         @socket.write(handshake)
-        @status = true
+        @peer_state = true
       else
-        @status = false
+        @peer_state = false
       end
     end
 
@@ -53,8 +51,12 @@ module Torrenter
       "#{PROTOCOL}#{@info_hash}#{PEER_ID}"
     end
 
-    def msg_num
-      @buffer.slice!(0..3).unpack("N*").first
+    def connected?
+      @peer_state
+    end
+
+    def update_indices(master)
+      master.each_with_index { |p,i| @piece_index[i] = p }
     end
   end
 end

data/lib/torrenter/peer_state.rb

@@ -1,5 +1,4 @@
 module Torrenter
-
   # The buffer state should be responsible ONLY for the handling of non-metadata bytes.
   # the messaging behavior should and ought to remain with the peer class, though
   # in truth, it may be better if I didnt do that. 
@@ -9,9 +8,50 @@ module Torrenter
 
   # instead of initialiazing it with the buffer, 
 
-  class BufferState < Peer
-    def examine(buffer, msg_length)
-      binding.pry
+  class BufferState
+
+    def intialize(socket)
+      @socket = socket
+      @buffer = ''
+    end
+
+    # include Torrenter
+
+    def state(buffer, master_index)
+      buffer_id = buffer[4]
+      if buffer_id.nil?
+        buffer.slice!(0..3)
+      else
+        @length = buffer[0..3].unpack("N>")
+        case buffer_id
+        when BITFIELD   then process_bitfield
+        when HAVE       then process_have
+        when INTERESTED then process_interested
+        when PIECE      then process_piece
+        when CHOKE      then choke_message
+        when HANDSHAKE  then process_handshake
+        end
+      end
+    end
+
+    def process_bitfield
+      
+    end
+
+    def process_have
+      
+    end
+
+    def process_piece
+      
+    end
+
+    def process_handshake
+      
+    end
+
+    def recv_data
+      
     end
   end
 end

data/lib/torrenter/reactor.rb

@@ -1,68 +1,175 @@
 module Torrenter
-  class Reactor
-    include Torrenter
-    def initialize(peers, sha_list, piece_length, file_list)
-      @peers        = peers
-      @master_index = Array.new(sha_list.size) { :free }
-      @blocks       = piece_length / BLOCK
-      @file_list    = file_list
-      @piece_length = piece_length
-      @sha_list     = sha_list
-      @data_size    = if file_list.is_a?(Array)
-                        file_list.map { |f| f['length'] }.inject { |x, y| x + y }
-                      else
-                        file_list['length']
-                      end
-    end
-
-    def modify_index
-      IO.write($data_dump, '', 0) unless File.exists?($data_dump)
-      file_size = File.size($data_dump)
-      0.upto(@sha_list.size - 1) do |n|
-        data = IO.read($data_dump, @piece_length, n * @piece_length) || ''
-        @master_index[n] = :downloaded if Digest::SHA1.digest(data) == @sha_list[n]
+  class Reactor < Torrenter::TorrentReader
+
+    attr_accessor :master_index
+    def initialize(peers, stream)
+      super(stream)
+      @peers         = peers
+      @master_index  = Array.new(sha_hashes.bytesize / 20) { :free }
+      @time_counter  = 0
+      @time          = Time.now.to_i
+      @byte_counter  = 0
+    end
+
+    def check_for_existing_data
+      # if the torrent data file is not present, one will be created
+      IO.write($data_dump, '', 0) unless File.file?($data_dump)
+
+      0.upto(@master_index.size - 1) do |n|
+        # this needs to get changed in order to account for 
+        # the last piece not being equal to the piece_length
+        data = IO.read($data_dump, piece_length, n * piece_length) || ''
+        # binding.pry
+        if verified?(n, data)
+          @master_index[n] = :downloaded
+          @byte_counter += data.bytesize
+        end
       end
-      $update = { index: indices }
-      puts "#{@master_index.count(:downloaded)} pieces are downloaded already."
+      puts "#{@master_index.count(:downloaded)} pieces downloaded"
+    end
+
+    def verified?(loc, piece)
+      Digest::SHA1.digest(piece) == sha_hashes[loc * 20..(loc * 20) + 19]
+    end
+
+    def finished?
+      @master_index.all? { |index| index == :downloaded }
+    end
+
+    def connect_peers
+      @peers.each { |peer| peer.connect if active_peers.size < 8 }
     end
 
     # sends the handshake messages.
 
     def message_reactor
-      modify_index
-      if !@master_index.all? { |index| index == :downloaded }
-        @peers.each { |peer| peer.connect if active_peers.size < 8 }
-        puts "You are now connected to #{active_peers.size} peers."
-        loop do
-          break if @master_index.all? { |piece| piece == :downloaded }
-          @peers.each do |peer|
-            $update = { index: indices, peer_count: peer_data }
-            piece_count = @master_index.count(:downloaded)
-
-            if peer.status
-              peer.state(@master_index, @blocks) # unless peer.piece_index.all? { |piece| piece == :downloaded }
-
-              if @master_index.count(:downloaded) > piece_count
-                system("clear")
-                puts download_bar + "Downloading from #{active_peers.size} active peers"
-              end
-            else
-              @peers.each { |peer| peer.connect if Time.now.to_i % 60 == 0 }
+      connect_peers
+
+      puts "You are now connected to #{active_peers.size} peers."
+      loop do
+        break if finished?
+
+        if Time.now.to_i - @time == 1
+          @time_counter = 0
+        end
+
+        @time = Time.now.to_i
+
+        active_peers.each_with_index do |peer, i|
+
+          datasize = peer.current_size
+
+          state = peer.state(@master_index, remaining) do |data, i|
+            if verified?(i, data)
+              @master_index[peer.index] = :downloaded
+              @byte_counter += peer.piece_data.bytesize
+              pack_piece(peer)
+              peer.mark_complete
+              piece_select(peer)
             end
           end
+
+          current = peer.current_size - datasize
+          if state == :interested
+            peer.update_indices(@master_index)
+            piece_select(peer)
+          end
+
+          if current > 0
+            @time_counter += current
+          end
         end
-      else
-        # upload_data
+        reattempt_disconnected_peer if Time.now.to_i % 30 == 0
+
+        show_status
       end
-      seperate_data_dump_into_files
     end
 
-    def piece_done?(peer)
-      
+    def piece_indices
+      active_peers.select { |peer| peer.piece_index }
+        .map { |peer| peer.piece_index }
     end
 
-    def block_done?(peer)
-      
+    def tally
+      @master_index.map.with_index do |p,i| 
+        p == :free ? piece_indices.map { |x| x[i] } : []
+      end
+    end
+
+    def piece_select(peer, limit=1)
+      # binding.pry if @master_index.count(:free) == 1
+
+      piece_index = peer.piece_index
+      @tally = tally
+      index = nil
+
+      loop do
+        if limit == active_peers.size + 1
+          index = piece_index.index(:free)
+          break
+        elsif index.is_a?(Integer)
+          break
+        end
+        i = 0
+        loop do
+          break if i > piece_index.size - 1|| !index.nil?
+          if @tally[i].count(:free) == limit && piece_index[i] == :free
+            index = i
+          else
+            i += 1
+          end
+        end
+
+        limit += 1 if index.nil?
+      end
+
+      if index
+        @master_index[index] = :downloading
+        peer.request_piece(index)
+        return index
+      end
+    end
+
+    def show_status
+      if (Time.now.to_i - @time) == 1
+        system('clear')
+        puts "#{download_bar} \n Downloading #{$data_dump[/(.+)(?=torrent-data)/]}"\
+             "at #{real} KB/sec #{data_remaining} MB remaining"\
+      end
+    end
+
+    def remaining
+      total_file_size - @byte_counter
+    end
+
+    def select_index(index)
+      poo = @master_index.map.with_index do |peer,index|
+        active_peers.map { |x| x.piece_index[index] }
+      end
+    end
+
+    def peer_indices
+      active_peers.map { |peer| peer.piece_index }
+    end
+
+    def data_remaining
+      (total_file_size - @byte_counter).fdiv(1024).fdiv(1024).round(2)
+    end
+
+    def real
+      @time_counter.fdiv(1024).round(1)
+    end
+
+    def reattempt_disconnected_peer
+      disconnected_peers.sample.connect
+    end
+
+    def disconnected_peers
+      @peers.select { |peer| !peer.connected? }
+    end
+
+    def pack_piece(peer)
+      IO.write($data_dump, peer.piece_data, piece_length * peer.index)
     end
 
     def indices
@@ -77,17 +184,13 @@ module Torrenter
       end
     end
 
-    def peer_data
-      active_peers.map { |peer| "ip: #{peer.peer[:ip]} port:#{peer.peer[:port]}" }.join("\n")
-    end
-
     def get_status(i)
       peer = @peers.find { |peer| peer.piece_index[i] == :downloading }
       (peer.buffer.bytesize + peer.piece_size).fdiv(@piece_length)
     end
 
     def active_peers
-      @peers.select { |peer| peer.status }
+      @peers.select { |peer| peer.peer_state }
     end
 
     def index_percentages
@@ -104,42 +207,5 @@ module Torrenter
     def pieces(type)
       (@master_index.count(type).fdiv(@master_index.size) * 100).round
     end
-
-    def stop_downloading
-      @peers.each { |peer| peer.piece_index.map { |piece| piece = :downloaded} }
-    end
-
-    def seperate_data_dump_into_files
-      if multiple_files?
-        offset = 0
-        folder =  $data_dump[/.+(?=\.torrent-data)/] || FileUtils.mkdir($data_dump[/.+(?=\.torrent-data)/]).join
-        @file_list.each do |file|
-
-          length =  file['length']
-          filename = file['path'].pop
-
-          if multiple_sub_folders?(file)
-            subfolders = file['path'].join("/")
-            folder = folder + "/" + subfolders
-            FileUtils.mkdir_p("#{folder}", force: true)
-          end
-
-          File.open("#{folder}/#{filename}", 'a+') { |data| data << IO.read($data_dump, length, offset) }
-          
-          offset += length
-        end
-      else
-        File.open("#{folder}/#{@file_list['name']}", 'w') { |data| data << File.read($data_dump) }
-      end
-      File.delete($data_dump)
-    end
-
-    def multiple_sub_folders?(file)
-      file['path'].size > 1
-    end
-
-    def multiple_files?
-      @file_list.is_a?(Array)
-    end
   end
 end

data/lib/torrenter/setup.rb

@@ -0,0 +1,10 @@
+require 'bencode'
+require 'pry'
+require 'digest/sha1'
+require './lib/torrenter/torrent_reader.rb'
+require './lib/torrenter/udp_tracker.rb'
+require './lib/torrenter/http_tracker.rb'
+
+stream = BEncode.load_file('thrones.torrent')
+reader = TorrentReader.new(stream)
+binding.pry

data/lib/torrenter/test_msg.rb

@@ -0,0 +1,166 @@
+module Torrenter
+  # KEEP_ALIVE = "\x00\x00\x00\x00"
+  # BLOCK = 2**14
+  # these methods get mixed in with the Peer class as a way to help 
+  # organize and parse the byte-encoded data. The intention is to shorten
+  # and shrink the complexity of the Peer class.
+  # the following methods are responsible solely for data retrieval and data transmission
+
+  def state(master_index)
+    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
+      when CHOKE      
+        choke_message
+      when HANDSHAKE
+        process_handshake
+      end
+    end
+  end
+
+  def choke_message
+    @peer_state = false
+  end
+
+  def clear_msg
+    @buffer.slice!(0..@length + 3)  
+  end
+
+  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
+
+  def pack(msg)
+    [msg].pack("I>")
+  end
+
+  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 process_have(msg)
+    @piece_index[msg[5..-1].unpack("C*").last] = :free
+    send_interested if @buffer.empty?
+  end
+
+  def request_piece(index)
+    @index = index
+    @piece_index[@index] = :downloading
+
+    request_message
+  end
+
+  def send_interested
+    send_data("\x00\x00\x00\x01\x02")
+  end
+
+  def buffer_length?
+    @buffer.bytesize >= @length + 4
+  end
+
+  def process_piece
+    if buffer_length?
+      if buffer_complete?
+        pack_buffer
+      end
+
+      diff = @remaining - @blocks.join('').bytesize
+      if diff < BLOCK
+        request_message(diff)
+      else
+        request_message
+      end
+    end
+    recv_data
+  end
+
+  def mark_complete
+    @blocks = []
+    @piece_index[@index] = :downloaded
+  end
+
+  def last_piece?
+    @remaining
+  end
+
+  def piece_complete?
+    piece_size == @piece_length
+  end
+
+  def buffer_size
+    @buffer[13..-1].bytesize
+  end
+
+  def pack_buffer
+    @blocks << @buffer.slice!(13..-1)
+    @buffer.clear
+  end
+
+  def buffer_complete?
+    (@buffer.length - 13) == BLOCK || (@buffer.length - 13) == @remaining
+  end
+
+  # will need a last piece sort of thing inserted in here
+
+  def piece_full?
+    @blocks.join('').size == @piece_len
+  end
+
+  def piece_size
+    @blocks.join('').bytesize + (@buffer.bytesize - 13)
+  end
+
+  def process_handshake
+    @buffer.slice!(0..67) if hash_check?
+  end
+
+  def hash_check?
+    @buffer[28..47] == @info_hash
+  end
+
+  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 recv_data(bytes=BLOCK)
+    begin
+      Timeout::timeout(5) { @buffer << @socket.recv_nonblock(bytes) }
+    rescue Timeout::Error
+      ''
+    rescue Errno::ETIMEDOUT
+      @peer_state = false
+    rescue *EXCEPTIONS
+      ''
+    rescue IO::EAGAINWaitReadable
+      ''
+    end
+  end
+end