torrenter 0.0.6 → 0.0.7

data/lib/torrenter/torrent_reader.rb

@@ -1,10 +1,22 @@
 module Torrenter
   # torrent reader should only read the torrent file and return either
   # a UDP tracker object or an HTTP tracker object
+
+  # what is being used or accessed by the torrent reader, and what is being used by the trackers?
+
   class TorrentReader
-    attr_reader :stream
-    def initialize(stream)
-      @stream = stream
+    attr_reader :stream, :pieces
+
+    def initialize(file)
+      @stream = BEncode.load_file(file)
+    end
+
+    def folder
+      if multiple_files?
+        @stream['info']['name']
+      else
+        @stream['info']['name'].gsub(/\.\w+$/, '')
+      end
     end
 
     def info_hash
@@ -28,7 +40,11 @@ module Torrenter
     end
 
     def file_list
-      @stream['info']['files'] || @stream['info']
+      if @stream['info']['files'].nil?
+        [{ 'path' => [@stream['info']['name']], 'length' => @stream['info']['length'] }]
+      else
+        @stream['info']['files']
+      end
     end
 
     def announce_url
@@ -43,68 +59,46 @@ module Torrenter
       announce_list ? announce_list.flatten << announce_url : [announce_url]
     end
 
-    def access_trackers
-      url_list.map do |track|
-        if track.include?("http://")
-          HTTPTracker.new(track, @stream)
-        else
-          UDPTracker.new(track, @stream)
-        end
-      end
+    def multiple_files?
+      file_list.size > 1
     end
 
-    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
+    def write_paths
+      file_list.each { |file| write_path(file) }
     end
 
-    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) }
+    def write_path(file)
+      file = "#{folder}/#{file['path'].join('/')}"
+      if !Dir.exist?(File.dirname(file))
+        FileUtils.mkdir_p(File.dirname(file))
       end
-      File.delete($data_dump)
+      IO.write(file, '', 0)
     end
 
-    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
+    def piece_index
+      constructor = PieceConstructor.new(file_list, folder, sha_hashes, piece_length)
+      constructor.make_index
     end
 
-    def sub_folders
-      stream['info']['files'].select { |fold| fold['path'].length > 1 }
+    def tracker_params
+      {
+        :info_hash => info_hash,
+        :peer_id   => PEER_ID,
+        :left      => piece_length,
+        :pieces    => file_list
+      }
     end
 
-    def multiple_sub_folders?(file)
-      file['path'].length > 0
-    end
+    def connect_trackers
+      url_list.compact.map do |url|
+        tracker = if url.include?('http://')
+          Tracker::HTTPTracker.new(url, tracker_params)
+        else
+          Tracker::UDPTracker.new(url, tracker_params)
+        end
 
-    def multiple_files?
-      file_list.is_a?(Array)
+        tracker.connect
+      end
     end
   end
 end

data/lib/torrenter/torrent_reader/piece.rb

@@ -0,0 +1,125 @@
+module Torrenter
+  class TorrentReader
+    class Piece
+      attr_accessor :range, :path, :hash, :index, :status
+      attr_reader :peers, :data
+      def initialize(piece_length)
+        @range        = []
+        @path         = []
+        @piece_length = piece_length
+        @status       = :available
+        @data         = ''
+        @peers        = []
+      end
+
+      def tally
+        if @range.length > 0
+          @range.map { |r| r.end - r.begin }.inject { |x,y| x + y }
+        else
+          0
+        end
+      end
+
+      def left
+        @piece_length - tally
+      end
+
+      def full?
+        tally == @piece_length
+      end
+
+      def add(range, path)
+        @range << range
+        @path << path
+      end
+
+      def include?(socket)
+        @peers.include?(socket)
+      end
+
+      def verify
+        @data = if multiple_files?
+                  @path.map.with_index { |p, i| read_file(p, i) }.join
+                else
+                  File.file?(@path.join) ? (IO.read(@path.join, @piece_length, @range.first.begin) || '') : ''
+                end
+        @status = hash_match? ? :downloaded : :available
+        @data.clear
+      end
+
+      def offset(i)
+        @range[i].end - @range[i].begin
+      end
+
+      def multiple_files?
+        @path.length > 1
+      end
+
+      def write_to_file
+        if multiple_files?
+          @path.each_with_index { |p,i| write_file(p, i) }
+        else
+          IO.write(@path.first, @data, @range.first.begin)
+        end
+        @status = :downloaded
+        @data.clear
+      end
+
+      def complete?
+        @data.bytesize >= tally && hash_match?
+      end
+
+      def block
+        (tally - @data.size) < BLOCK ? tally - @data.size : BLOCK
+      end
+
+      def chunk
+        (@data.bytesize / BLOCK) * BLOCK
+      end
+
+      def <<(buffer)
+        @data << buffer
+      end
+
+      def peer_count(socket)
+        @peers.count(socket)
+      end
+
+      def peer_size
+        @peers.length
+      end
+
+      def add_peer(peer)
+        @peers << peer
+      end
+
+      def remove_peer
+        @peers.each { |p| @peers.delete(p) if p.closed? }
+      end
+
+      def hash_match?
+        Digest::SHA1.digest(@data) == @hash
+      end
+
+      def percent
+        if @status == :downloading
+          return (@data.size).fdiv(@piece_length)
+        elsif @status == :downloaded
+          return 1
+        else
+          return 0
+        end
+      end
+
+      private
+        def read_file(p, i)
+          binding.pry if offset(i) < 0
+          File.file?(p) ? IO.read(p, offset(i), @range[i].begin) : ''
+        end
+
+        def write_file(p, i)
+          IO.write(p, @data.slice!(0...offset(i)), @range[i].begin)
+        end
+    end
+  end
+end

data/lib/torrenter/torrent_reader/piece_constructor.rb

@@ -0,0 +1,81 @@
+module Torrenter
+  class TorrentReader
+    class PieceConstructor
+
+      attr_reader :index
+      def initialize(files, folder, sha_hashes, piece_length)
+        @files        = files
+        @folder       = folder
+        @sha_hashes   = sha_hashes
+        @piece_length = piece_length
+        @index        = PieceIndex.new(piece_length)
+        @excess_bytes = 0
+      end
+
+      def index_length
+        @sha_hashes.size / 20
+      end
+
+      def correct?
+        total_left == @arr.map { |x| x.tally }.inject { |x,y| x + y }
+      end
+
+      def total_left
+        @files.map { |f| f['length']}.inject { |x,y| x + y }
+      end
+
+      def final_piece?
+        index_length == @index.size + 1
+      end
+
+      def make_index
+        @piece = Piece.new(@piece_length)
+        @files.each do |file|
+          path = "#{@folder}/#{file['path'].join('/')}"
+          offset = 0
+          if @piece.tally != 0
+            if @piece.left > file['length']
+              @piece.add(0...file['length'], path)
+            else
+              offset = @piece.left
+              @piece.add(0...@piece.left, path)
+            end
+
+            @index << @piece if @piece.full?
+          else
+            offset = 0
+          end
+
+          while offset < ((file['length']) - @piece_length)
+            @piece = Piece.new(@piece_length)
+            @piece.add(offset...(offset += @piece_length), path)
+            @index << @piece if @piece.full?
+          end
+
+          if @piece.full? && offset > 0
+            @piece = Piece.new(@piece_length)
+            @piece.add(offset...file['length'], path)
+          end
+
+          if final_piece?
+            @index << @piece
+          end
+        end
+        set_hash
+      end
+
+      def set_hash
+        0.upto(@index.size - 1) do |i|
+          @index[i].hash = piece_hash(i)
+          @index[i].index = i
+        end
+
+        return @index
+      end
+
+      def piece_hash(n)
+        @sha_hashes[(n * 20)...(n * 20) + 20]
+      end
+    end
+  end
+end

data/lib/torrenter/torrent_reader/piece_index.rb

@@ -0,0 +1,87 @@
+module Torrenter
+  class TorrentReader
+    class PieceIndex
+      attr_reader :piece_index, :piece_length
+      def initialize(piece_length)
+        @piece_length = piece_length
+        @piece_index  = []
+      end
+
+      def find_least(socket, i=1)
+        return nil if none_remain? || i > peer_count.sort.last
+        index = peer_count.find_index(i)
+        if index && available_pieces[index].include?(socket)
+          piece = available_pieces[index]
+          piece.status = :downloading
+          return piece
+        else
+          find_least(socket, i+1)
+        end
+      end
+
+      def clean_peers
+        @piece_index.each { |piece| piece.remove_peer }
+      end
+
+      def <<(piece)
+        @piece_index << piece
+      end
+
+      def none_remain?
+        count(:available) == 0
+      end
+
+      def peer_count
+        available_pieces.map { |piece| piece.peers.length }
+      end
+
+      def available_pieces
+        @piece_index.select { |piece| piece.status == :available }
+      end
+
+      def count(type)
+        @piece_index.select { |piece| piece.status == type }.length
+      end
+
+      def verify_status
+        @piece_index.each { |piece| piece.verify }
+      end
+
+      def all?
+        @piece_index.all? { |piece| piece.status == :downloaded }
+      end
+
+      def add_peer(index, peer)
+        @piece_index[index].peers << peer if @piece_index[index]
+      end
+
+      def size
+        @piece_index.size
+      end
+
+      def length
+        @piece_index.length
+      end
+
+      def [](index)
+        @piece_index[index]
+      end
+
+      def []=(i, val)
+        @piece_index[i] = Piece.new(i, piece_length, val)
+      end
+
+      def push(val)
+        @piece_index[size] = val
+      end
+
+      def last
+        @piece_index.last
+      end
+
+      def to_json
+        JSON.generate({ :master_index => @piece_index.map { |p| p.percent } })
+      end
+    end
+  end
+end

data/lib/torrenter/tracker.rb

@@ -1,13 +1,17 @@
-module Torrenter
-  class Tracker < TorrentReader
-    def initialize(tracker_url)
-      @tracker_url = tracker_url
-    end
+  module Torrenter
+  class Tracker
+    def format_peers(peers)
+      pool = []
+      peers.chars.each_slice(6) do |peer_data|
+        ip = peer_data[0..3].join('').bytes.join('.')
+        port = peer_data[4..5].join('').unpack("S>").first
+
+        if !pool.find { |peer| peer.ip == ip }
+          pool << Peer.new(ip, port, @params)
+        end
+      end
 
-    def tracker_connect
-      if @tracker_url.include?("http://")
-        @tracker_url = URI(@tracker_url)
-        @tracker_url.query = URI.encode_www_form(peer_hash)
+      return pool
     end
   end
 end