torrenter 0.0.5 → 0.0.6

data/lib/torrenter/test_reactor.rb

@@ -0,0 +1,219 @@
+module Torrenter
+  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
+      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
+      @peers.each { |peer| peer.connect if active_peers.length < 8 }
+      if !finished?
+        peer.state(@master_index) do |loc, buf|
+          
+        end
+      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
+      puts "#{peer.ip} picking a piece"
+      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)
+        p index
+        return index
+      else
+        binding.pry
+      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 with #{pieces_left} pieces left to download"
+        puts "and #{data_remaining} MB remaining ------ #{active_peers.size} connected."
+      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 pieces_left
+      @master_index.count(:free)
+    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
+
+    def index_percentages
+      active_peers.map do |peer|
+        size = peer.buffer.bytesize + peer.piece_size
+        [peer.index, (size.fdiv @piece_length) * 100]
+      end
+    end
+
+    def download_bar
+      ("\u2588" * pieces(:downloaded)) + ("\u2593" * pieces(:downloading)) + (" " * pieces(:free)) + " %#{pieces(:downloaded)} downloaded "
+    end
+
+    def pieces(type)
+      (@master_index.count(type).fdiv(@master_index.size) * 100).round
+    end
+
+    def seperate_data_dump_into_files
+      folder = $data_dump[/.+(?=\.torrent-data)/]
+
+      if multiple_files?
+        offset = 0
+
+        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
+        FileUtils.mkdir("#{folder}")
+        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/torrent_reader.rb

@@ -1,74 +1,110 @@
 module Torrenter
+  # torrent reader should only read the torrent file and return either
+  # a UDP tracker object or an HTTP tracker object
   class TorrentReader
     attr_reader :stream
     def initialize(stream)
-      @stream       = stream
-      @file_list    = stream['info']['files'] || stream['info']
-      @sha          = Digest::SHA1.digest(stream['info'].bencode)
-      @piece_length = stream['info']['piece length']
-      @sha_list     = stream['info']['pieces']
-      @sha_size     = stream['info']['pieces'].size / 20
-    end
-
-    def determine_protocol
-      trackers =  if @stream['announce-list']
-                    @stream['announce-list'].flatten << @stream['announce']
-                  else
-                    [@stream['announce']]
-                  end
-      
-      trackers.each do |track|
-        tracker = build_tracker(track)
-
-        tracker.connect
-        
-        if tracker.connected?
-          @peers = tracker.address_list
-        end
+      @stream = stream
+    end
 
-        break if @peers
-      end
+    def info_hash
+      Digest::SHA1.digest(@stream['info'].bencode)
+    end
+
+    def sha_hashes
+      @stream['info']['pieces']
+    end
+
+    def total_file_size
+      file_list.is_a?(Array) ? multiple_file_size : file_list['length']
+    end
+
+    def multiple_file_size
+      file_list.map { |file| file['length'] }.inject { |x,y| x + y }
+    end
+
+    def piece_length
+      @stream['info']['piece length']
+    end
+
+    def file_list
+      @stream['info']['files'] || @stream['info']
+    end
+
+    def announce_url
+      @stream['announce']
+    end
+
+    def announce_list
+      @stream['announce-list']
+    end
+
+    def url_list
+      announce_list ? announce_list.flatten << announce_url : [announce_url]
+    end
 
-      if @peers
-        establish_reactor
+    def access_trackers
+      url_list.map do |track|
+        if track.include?("http://")
+          HTTPTracker.new(track, @stream)
+        else
+          UDPTracker.new(track, @stream)
+        end
       end
     end
 
-    def peer_info
-      {
-        :info_hash    => @sha,
-        :piece_length => @piece_length,
-        :sha_list     => sha_pieces,
-        :piece_index  => Array.new(@sha_list.size) { false }
-      }
+    def peer_list(bytestring)
+      bytestring.chars.each_slice(6).map do |peer_data|
+        ip = peer_data[0..3].join('').bytes.join('.')
+        port = peer_data[4..5].join('').unpack("S>").first
+        Peer.new(ip, port, info_hash, piece_length)
+      end
     end
 
-    def parse_addresses(addr, size)
-      Array.new(size) do
-        peer = { :ip   => addr.slice!(0..3).bytes.join('.'), 
-                 :port => port(addr.slice!(0..1)) }
-        Peer.new(peer, @file_list, peer_info)
+    def unpack_data
+      puts "ALL FINISHED! Transferring data into file(s)."
+      @main_folder = $data_dump[/.+(?=\.torrent-data)/]
+      create_folders
+
+      if multiple_files?
+        offset = 0
+        file_list.each do |file|
+
+          length = file['length']
+          filename = file['path'].join("/")
+
+          File.open("#{@main_folder}/#{filename}", 'a+') do |data| 
+            data << IO.read($data_dump, length, offset)
+          end
+
+          offset += length
+        end
+      else
+        FileUtils.mkdir(@main_folder)
+        File.open("#{@main_folder}/#{file_list['name']}", 'w') { |data| data << File.read($data_dump) }
       end
+      File.delete($data_dump)
     end
 
-    def port(addr)
-      addr.unpack("S>").first
+    def create_folders
+      if multiple_files?
+        folders = sub_folders.map { |fold| fold['path'][0..-2].join("/") }.uniq
+        folders.each { |folder| FileUtils.mkdir_p(@main_folder + "/#{folder}") }
+      else
+        FileUtils.mkdir(@main_folder)
+      end
     end
 
-    def build_tracker(track)
-      track.include?('http://') ? HTTPTracker.new(track, stream) : UDPTracker.new(track, stream)
+    def sub_folders
+      stream['info']['files'].select { |fold| fold['path'].length > 1 }
     end
 
-    def sha_pieces
-      start, term = -20, 0
-      Array.new(@sha_size) { start += 20; term += 20; @sha_list[start...term]}
+    def multiple_sub_folders?(file)
+      file['path'].length > 0
     end
 
-    def establish_reactor
-      react = Reactor.new(@peers, sha_pieces, @piece_length, @file_list)
-      react.message_reactor
+    def multiple_files?
+      file_list.is_a?(Array)
     end
   end
 end
-
-

data/lib/torrenter/tracker.rb

@@ -0,0 +1,13 @@
+module Torrenter
+  class Tracker < TorrentReader
+    def initialize(tracker_url)
+      @tracker_url = tracker_url
+    end
+
+    def tracker_connect
+      if @tracker_url.include?("http://")
+        @tracker_url = URI(@tracker_url)
+        @tracker_url.query = URI.encode_www_form(peer_hash)
+    end
+  end
+end

data/lib/torrenter/udp_tracker.rb

@@ -1,19 +1,20 @@
 module Torrenter
   class UDPTracker < TorrentReader
+
     attr_reader :socket, :response
 
     def initialize(tracker, stream)
+      super(stream)
       @url           = tracker[/(?<=udp\:\/\/).+(?=\:\d+)/]
       @port          = tracker[/\d+$/].to_i
       @socket        = UDPSocket.new
       @connection_id = [0x41727101980].pack("Q>")
-      super(stream)
     end
 
     def connect
+      @transaction_id = [rand(1000)].pack("I>")
+      @socket.connect(ip_addr, @port)
       begin
-        @transaction_id = [rand(1000)].pack("I>")
-        @socket.connect(ip_addr, @port)
         send_msg(connect_msg)
         read_response
       rescue
@@ -37,15 +38,16 @@ module Torrenter
       Socket.getaddrinfo(@url, @port)[0][3]
     end
 
-    def address_list
+    def bound_peers
       @connection_id = @response[-8..-1]
       @transaction_id = [rand(10000)].pack("I>")
       send_msg(announce_msg)
 
       read_response
-    
+
       parse_announce if @response[0..3] == action(1)
-      parse_addresses(@response, @response.size / 6)
+
+      peer_list(@response)
     end
 
     def parse_announce
@@ -76,7 +78,7 @@ module Torrenter
     end
 
     def announce_input
-      @connection_id + action(1) + @transaction_id + @sha + PEER_ID
+      @connection_id + action(1) + @transaction_id + info_hash + PEER_ID
     end
 
     def connect_msg
@@ -86,9 +88,9 @@ module Torrenter
     def action(n)
       [n].pack("I>")
     end
-    
+
     def announce_msg
-      @connection_id + action(1) + @transaction_id + @sha + PEER_ID + [0].pack("Q>") + [0].pack("Q>") + [0].pack("Q>") + action(0) + action(0) + action(0) + action(-1) + [@socket.addr[1]].pack(">S")
+      @connection_id + action(1) + @transaction_id + info_hash + PEER_ID + [0].pack("Q>") + [0].pack("Q>") + [0].pack("Q>") + action(0) + action(0) + action(0) + action(-1) + [@socket.addr[1]].pack(">S")
     end
   end
-end
+end