torrenter 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b84f8e49f69b5654aedf1edd2b894bf3d9d9a612
-  data.tar.gz: 6aa38459649cc8e4c8ce770799f46a161967d457
+  metadata.gz: 3234eb20fcd3339fcecb2a52c4bfe3bdb0f84ee5
+  data.tar.gz: 88f9959f5111cb4c8bbc082a42a8bd7897b5c95a
 SHA512:
-  metadata.gz: 29dbc732d5bb03d5fb76362bb5825622c9ecbf14cc03cb352ddc3d780238154a1b60084fcbcb6b7f9ab9f00a75b401516e3bd243d6822d56ce129180ac225d68
-  data.tar.gz: 80d1d9d22e3186ebb45e555f70ae272c7beb472c39e3ea80796a83527ab50529e4b60a1bd7ed9b281b4fb243ce1cb2899af569a7d522e957c92d0b61046f5477
+  metadata.gz: ecb115dd277b70cd8769f2300d016b714042777be8665852fabe64f6c45a5bce5cab063b3ba97ad8625bc8eb3361401a63c30bae9e4e3508cc8f17c9a9f16546
+  data.tar.gz: e5a295b9a04b632801c3560fea6b2ce312830364fdfd06255bae7e3b649c040c160e5cb9ec06d4963ba33ded91e531e53ef71811d9f99da0fa344ffbfa0d459f

data/bin/torrenter

@@ -5,5 +5,8 @@ require 'net/http'
 require 'fileutils'
 require 'torrenter'
 file    = ARGV[0]
-$data_dump = "#{file}-data"
-Torrenter::Torrent.new.start(file)
+if File.file?(file)
+  Torrenter::Torrent.new.start(ARGV[0])
+else
+  puts "That's not a file, silly."
+end

data/lib/torrenter.rb

@@ -2,57 +2,32 @@ require 'socket'
 require 'digest/sha1'
 require 'bencode'
 require 'fileutils'
-require 'pry'
-require 'torrenter/message/messager'
-require 'torrenter/message/message_types'
+require 'torrenter/constants'
 require 'torrenter/peer'
-require 'torrenter/torrent_reader'
+require 'torrenter/peer/buffer_state'
 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.
-
+require 'torrenter/tracker'
+require 'torrenter/tracker/http_tracker'
+require 'torrenter/tracker/udp_tracker'
+require 'torrenter/torrent_reader'
+require 'torrenter/torrent_reader/piece'
+require 'torrenter/torrent_reader/piece_index'
+require 'torrenter/torrent_reader/piece_constructor'
+require 'torrenter/version'
 
 module Torrenter
   class Torrent
+
     def start(file)
-      IO.write($data_dump, '', 0) if !File.exists?($data_dump)
-      stream  = BEncode.load_file(file)
-      torrent_file = Torrenter::TorrentReader.new(stream)
-      trackers = torrent_file.access_trackers
+      @torrent = Torrenter::TorrentReader.new(file)
+      @torrent.write_paths
 
-      # returns an array of initialized UDP and/or HTTP Tracker class objects
+      trackers = @torrent.connect_trackers
 
-      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
+      reactor = Reactor.new(trackers, @torrent.piece_index)
+      reactor.extract_peers
+      reactor.message_reactor
     end
   end
 end

data/lib/torrenter/{message/message_types.rb → constants.rb}

@@ -6,6 +6,7 @@ module Torrenter
   HANDSHAKE  = "T"
   HAVE       = "\x04"
   BITFIELD   = "\x05"
+  CANCEL     = "\b"
   PIECE      = "\a"
   CHOKE      = "\x00"
   PROTOCOL = "\x13BitTorrent protocol\x00\x00\x00\x00\x00\x00\x00\x00"

data/lib/torrenter/peer.rb

@@ -1,27 +1,12 @@
 module Torrenter
   class Peer
-    include Torrenter
-
-    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 current_size
-      piece_data.bytesize + @buffer.bytesize
-    end
-
-    def piece_data
-      @blocks.join('')
+    attr_reader :buffer, :peer_state, :socket, :ip
+    def initialize(ip, port, params={})
+      @ip = ip
+      @port = port
+      @info_hash = params[:info_hash]
+      @piece_length = params[:left]
+      @peer_state   = false
     end
 
     def connect
@@ -40,13 +25,23 @@ module Torrenter
 
       if @socket
         puts "Connected!"
-        @socket.write(handshake)
         @peer_state = true
+        @buffer = BufferState.new(@socket, @info_hash)
+        @buffer.send(handshake)
       else
         @peer_state = false
       end
     end
 
+    def connection_state(index, blk)
+      if @socket.closed?
+        @peer_state = false
+        @buffer.current_piece = :available
+      else
+        @buffer.messager(index, blk)
+      end
+    end
+
     def handshake
       "#{PROTOCOL}#{@info_hash}#{PEER_ID}"
     end
@@ -54,9 +49,5 @@ module Torrenter
     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/buffer_state.rb

@@ -0,0 +1,164 @@
+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. 
+
+  # So, if the state of the buffer reaches a certain step in its process involving the piece
+  # the buffer state should be fired off. 
+
+  # instead of initialiazing it with the buffer, 
+  class Peer
+    class BufferState
+      attr_reader :piece
+      def initialize(socket, info_hash)
+        @socket    = socket
+        @buffer    = ''
+        @info_hash = info_hash
+      end
+
+      def messager(index, blk)
+        if @buffer.empty?
+          recv
+        else
+          case @buffer[4]
+          when nil
+            @buffer.slice!(0..3) if @buffer[0..3] == KEEP_ALIVE
+          when HANDSHAKE
+            parse_handshake
+          when BITFIELD
+            bitfield.each_with_index do |bit, i|
+              blk.call(i, @socket) if bit == '1'
+            end
+
+            send_interested if @buffer.empty?
+          when HAVE
+            if @buffer.bytesize < 9
+              recv
+            else
+              have { |i| blk.call(i, @socket) }
+            end
+            send_interested if @buffer.empty?
+          when INTERESTED
+            parse_interested(index)
+          when PIECE
+            parse_piece(index)
+          when CANCEL
+            @socket.close
+          else
+            recv
+            send(KEEP_ALIVE)
+          end
+        end
+      end
+
+      def current_piece=(type)
+        @piece.status = type if @piece
+      end
+
+      def hash_matches?
+        @buffer[28..47] == @info_hash
+      end
+
+      def parse_handshake
+        if !hash_matches?
+          yield
+        else
+          @buffer.slice!(0..67)
+        end
+      end
+
+      def have
+        yield unpack('C').last
+      end
+
+      def bitfield
+        unpack('B').first.split('')
+      end
+
+      def pick_piece(index)
+        @piece = index.find_least(@socket)
+        if @piece
+          puts "#{@piece.index} selected by #{@socket}."
+        else
+          puts "No piece selected!"
+        end
+      end
+
+      def parse_interested(index)
+        if interested?
+          pick_piece(index)
+          request_piece if @piece
+        else
+          @socket.close
+        end
+      end
+
+      def parse_piece(index)
+        if packet_length?
+          @piece << @buffer.slice!(13..-1)
+          @buffer.clear
+          if @piece.complete?
+            @piece.write_to_file
+            @piece = nil
+            pick_piece(index) unless index.all?
+          end
+          request_piece
+        else
+          recv
+        end
+      end
+
+      def packet_length?
+        @buffer.size >= msg_length + 4
+      end
+
+      def request_piece
+        send pack(13, "\x06", @piece.index, @piece.chunk, @piece.block) if @piece
+      end
+
+      def send(msg)
+        @socket.sendmsg_nonblock(msg)
+      end
+
+      def recv(bytes=BLOCK)
+        begin
+          @buffer << @socket.recv_nonblock(bytes)
+        rescue *EXCEPTIONS
+          ''
+        rescue Errno::ETIMEDOUT
+          if piece_selected?
+            @piece.status = :available
+          end
+          @socket.close
+        end
+      end
+
+      def piece_selected?
+        @piece
+      end
+
+      private
+
+        def send_interested
+          send("\x00\x00\x00\x01\x02")
+        end
+
+        def pack(*msg)
+          msg.map { |m| m.is_a?(Integer) ? [m].pack("I>") : m }.join
+        end
+
+        def unpack(type)
+          @buffer.slice!(0...msg_length + 4)[5..-1].unpack("#{type}*")
+        end
+
+        def msg_length
+          @buffer[0..3].unpack("N*").last
+        end
+
+        def interested?
+          @buffer.slice!(0..4) == "\x00\x00\x00\x01\x01"
+        end
+
+    end
+  end
+end

data/lib/torrenter/reactor.rb

@@ -1,194 +1,45 @@
 module Torrenter
-  class Reactor < Torrenter::TorrentReader
+  class Reactor
 
-    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
+    def initialize(trackers, piece_index)
+      @trackers    = trackers
+      @piece_index = piece_index
     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
-      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 }
+    def extract_peers
+      @peers = @trackers.map { |tracker| tracker.peer_list if tracker.connected? }.flatten.compact
     end
 
-    def connect_peers
-      @peers.each { |peer| peer.connect if active_peers.size < 8 }
-    end
-
-    # sends the handshake messages.
-
     def message_reactor
-      connect_peers
-
+      @piece_index.verify_status
+      @peers.each { |peer| peer.connect }
       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
-        reattempt_disconnected_peer if Time.now.to_i % 30 == 0
-
-        show_status
-      end
-    end
-
-    def piece_indices
-      active_peers.select { |peer| peer.piece_index }
-        .map { |peer| peer.piece_index }
-    end
-
-    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
+        @peers.each do |peer|
+          if peer.peer_state
+            peer.connection_state(@piece_index, have)
           else
-            i += 1
+            peer.connect if Time.now.to_i % 60 == 0
           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"\
+        @piece_index.clean_peers
+        $status = @piece_index.to_json
       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
+    def have
+      ->(index, peer) { @piece_index[index].add_peer(peer) }
     end
 
-    def peer_indices
-      active_peers.map { |peer| peer.piece_index }
+    def finished?
+      @piece_index.all?
     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
-      @master_index.map do |piece|
-        if piece == :free
-          0
-        elsif piece == :downloaded
-          1
-        else
-          get_status @master_index.index(piece)
-        end
-      end
-    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.peer_state }
     end
@@ -205,7 +56,7 @@ module Torrenter
     end
 
     def pieces(type)
-      (@master_index.count(type).fdiv(@master_index.size) * 100).round
+      (@piece_index.count(type).fdiv(@piece_index.size) * 100).round
     end
   end
 end