rubytorrent 0.3

data/lib/rubytorrent/util.rb

@@ -0,0 +1,186 @@
+## util.rb -- miscellaneous RubyTorrent utility modules.
+## Copyright 2005 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+def rt_debug(*args)
+  if $DEBUG || RubyTorrent.log
+    stream = RubyTorrent.log || $stdout
+    stream << args.join << "\n" 
+    stream.flush
+  end
+end
+
+def rt_warning(*args)
+  if $DEBUG || RubyTorrent.log
+    stream = RubyTorrent.log || $stderr
+    stream << "warning: " << args.join << "\n" 
+    stream.flush
+  end
+end
+
+module RubyTorrent
+
+@log = nil
+def log_output_to(fn)
+  @log = File.open(fn, "w")
+end
+attr_reader :log
+module_function :log_output_to, :log
+
+
+## parse final hash of pseudo-keyword arguments
+def get_args(rest, *names)
+  hash = rest.find { |x| x.is_a? Hash }
+  if hash
+    rest.delete hash
+    hash.each { |k, v| raise ArgumentError, %{unknown argument "#{k}"} unless names.include?(k) }
+  end
+
+  [hash || {}, rest]
+end
+module_function :get_args
+
+## "events": very similar to Observable, but cleaner, IMO. events are
+## listened to and sent in instance space, but registered in class
+## space. example:
+##
+## class C
+##   include EventSource
+##   event :goat, :boat
+##
+##   def send_events
+##     send_event :goat
+##     send_event(:boat, 3)
+##   end
+## end
+##
+## c = C.new
+## c.on_event(:goat) { puts "got goat!" }
+## c.on_event(:boat) { |x| puts "got boat: #{x}" }
+##
+## Defining them in class space is not really necessary, except as an
+## error-checking mechanism.
+module EventSource
+  def on_event(who, *events, &b)
+    @event_handlers ||= Hash.new { [] }
+    events.each do |e|
+      raise ArgumentError, "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+      @event_handlers[e] <<= [who, b]
+    end
+    nil
+  end
+
+  def send_event(e, *args)
+    raise ArgumentError, "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+    @event_handlers ||= Hash.new { [] }
+    @event_handlers[e].each { |who, proc| proc[self, *args] }
+    nil
+  end
+
+  def unregister_events(who, *events)
+    @event_handlers.each do |event, handlers|
+      handlers.each do |ewho, proc|
+        if (ewho == who) && (events.empty? || events.member?(event))
+          @event_handlers[event].delete [who, proc]
+        end
+      end
+    end
+    nil
+  end
+
+  def relay_event(who, *events)
+    @event_handlers ||= Hash.new { [] }
+    events.each do |e|
+      raise "unknown event #{e} for #{self.class}" unless (self.class.class_eval "@@event_has")[e]
+      raise "unknown event #{e} for #{who.class}" unless (who.class.class_eval "@@event_has")[e]
+      @event_handlers[e] <<= [who, lambda { |s, *a| who.send_event e, *a }]
+    end
+    nil
+  end
+
+  def self.append_features(mod)
+    super(mod)
+    mod.class_eval %q{
+      @@event_has ||= Hash.new(false)
+      def self.event(*args)
+        args.each { |a| @@event_has[a] = true }
+      end
+    }
+  end
+end
+
+## ensure that a method doesn't execute more frequently than some
+## number of seconds. e.g.:
+##
+## def meth
+##   ...
+## end
+## min_iterval :meth, 10
+##
+## ensures that "meth" won't be executed more than once every 10
+## seconds.
+module MinIntervalMethods
+  def min_interval(meth, int)
+    class_eval %{
+      @@min_interval ||= {}
+      @@min_interval[:#{meth}] = [nil, #{int.to_i}]
+      alias :min_interval_#{meth} :#{meth}
+      def #{meth}(*a, &b)
+        last, int = @@min_interval[:#{meth}]
+        unless last && ((Time.now - last) < int)
+          min_interval_#{meth}(*a, &b) 
+          @@min_interval[:#{meth}][0] = Time.now
+        end
+      end
+    }
+  end
+end
+
+## boolean attributes now get question marks in their accessors
+## don't forget to 'extend' rather than 'include' this one
+module AttrReaderQ
+  def attr_reader_q(*args)
+    args.each { |v| class_eval "def #{v}?; @#{v}; end" }
+  end
+  
+  def attr_writer_q(*args)
+    args.each { |v| attr_writer v }
+  end
+  
+  def attr_accessor_q(*args)
+    attr_reader_q args
+    attr_writer_q args
+  end
+end
+
+module ArrayShuffle
+  def shuffle!
+    each_index do |i|
+      j = i + rand(self.size - i);
+      self[i], self[j] = self[j], self[i]
+    end
+  end
+
+  def shuffle
+    self.clone.shuffle! # dup doesn't preserve shuffle! method
+  end
+end
+
+module StringMapBytes
+  def map_bytes
+    ret = []
+    each_byte { |x| ret.push(yield(x)) }
+    ret
+  end
+end
+
+end

data/make-metainfo.rb

@@ -0,0 +1,211 @@
+## make-metainfo.rb -- interactive .torrent creater
+## Copyright 2005 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require 'digest/sha1'
+require "rubytorrent"
+
+def die(x); $stderr << "#{x}\n" && exit(-1); end
+def syntax
+  %{
+  Syntax: make-metainfo.rb [<file or directory>]+
+
+  make-metainfo is an interactive program for creating .torrent files from a set
+  of files or directories. any directories specified will be scanned recursively.
+  }
+end
+
+def find_files(f)
+  if FileTest.directory? f
+    Dir.new(f).entries.map { |x| find_files(File.join(f, x)) unless x =~ /^\.[\.\/]*$/}.compact
+  else
+    f
+  end
+end
+
+class Numeric
+  def to_size_s
+    if self < 1024
+      "#{self.round}b"
+    elsif self < 1024**2
+      "#{(self / 1024.0).round}kb"
+    elsif self < 1024**3
+      "#{(self / (1024.0**2)).round}mb"
+    else
+      "#{(self / (1024.0**3)).round}gb"
+    end
+  end
+end
+
+def read_pieces(files, length)
+  buf = ""
+  files.each do |f|
+    File.open(f) do |fh|
+      begin
+        read = fh.read(length - buf.length)
+        if (buf.length + read.length) == length
+          yield(buf + read)
+          buf = ""
+        else
+          buf += read
+        end
+      end until fh.eof?
+    end
+  end
+
+  yield buf
+end 
+
+die syntax if ARGV.length == 0
+
+puts "Scanning..."
+files = ARGV.map { |f| find_files f }.flatten
+single = files.length == 1
+
+puts "Building #{(single ? 'single' : 'multi')}-file .torrent for #{files.length} file#{(single ? '' : 's')}."
+
+mi = RubyTorrent::MetaInfo.new
+mii = RubyTorrent::MetaInfoInfo.new
+
+maybe_name = if single
+               ARGV[0]
+             else
+               (File.directory?(ARGV[0]) ? File.basename(ARGV[0]) : File.basename(File.dirname(ARGV[0])))
+             end
+puts
+print %{Default output file/directory name (enter for "#{maybe_name}"): }
+name = $stdin.gets.chomp
+mii.name = (name == "" ? maybe_name : name)
+puts %{We'll use "#{mii.name}".}
+
+puts
+puts "Measuring..."
+length = nil
+if single
+  length = mii.length = files.inject(0) { |s, f| s + File.size(f) }
+else
+  mii.files = []
+  length = files.inject(0) do |s, f|
+    miif = RubyTorrent::MetaInfoInfoFile.new
+    miif.length = File.size f
+    miif.path = f.split File::SEPARATOR
+    miif.path = miif.path[1, miif.path.length - 1] if miif.path[0] == mii.name
+    mii.files << miif
+    s + miif.length
+  end
+end
+
+puts <<EOS
+
+The file is #{length.to_size_s}. What piece size would you like? A smaller piece size
+will result in a larger .torrent file; a larger piece size may cause
+transfer inefficiency. Common sizes are 256, 512, and 1024kb.
+
+Hint: for this .torrent,
+EOS
+
+size = nil
+[64, 128, 256, 512, 1024, 2048, 4096].each do |size|
+  num_pieces = (length.to_f / size / 1024.0).ceil
+  tsize = num_pieces.to_f * 20.0 + 100
+  puts "  - piece size of #{size}kb => #{num_pieces} pieces and .torrent size of approx. #{tsize.to_size_s}."
+  break if tsize < 10240
+end
+
+maybe_plen = [size, 256].min
+begin
+  print "Piece size in kb (enter for #{maybe_plen}k): "
+  plen = $stdin.gets.chomp
+end while plen !~ /^\d*$/
+
+plen = (plen == "" ? maybe_plen : plen.to_i)
+
+mii.piece_length = plen * 1024
+num_pieces = (length.to_f / mii.piece_length.to_f).ceil
+puts "Using piece size of #{plen}kb => .torrent size of approx. #{(num_pieces * 20.0).to_size_s}."
+
+print "Calculating #{num_pieces} piece SHA1s... " ; $stdout.flush
+
+mii.pieces = ""
+i = 0
+read_pieces(files, mii.piece_length) do |piece|
+  mii.pieces += Digest::SHA1.digest(piece)
+  i += 1
+  if (i % 100) == 0
+    print "#{(i.to_f / num_pieces * 100.0).round}%... "; $stdout.flush
+  end
+end
+puts "done"
+
+mi.info = mii
+puts <<EOS
+
+Enter the tracker URL or URLs that will be hosting the .torrent
+file. These are typically of the form:
+
+  http://tracker.example.com:6969/announce
+
+Multiple trackers may be partitioned into tiers; clients will try all
+servers (in random order) from an earlier tier before trying those of
+a later tier. See http://home.elp.rr.com/tur/multitracker-spec.txt
+for details.
+
+Enter the tracker URL(s) now. Separate multiple tracker URLs on the
+same tier with spaces. Enter a blank line when you're done.
+
+(Note that if you have multiple trackers, some clients may only use
+the first one, so that should be the one capable of handling the most
+traffic.)
+EOS
+
+tier = 0
+trackers = []
+begin
+  print "Tier #{tier} tracker(s): "
+  these = $stdin.gets.chomp.split(/\s+/)
+  trackers.push these unless these.length == 0
+  tier += 1 unless these.length == 0
+end while (these.length != 0) || (tier == 0)
+
+mi.announce = URI.parse(trackers[0][0])
+mi.announce_list = trackers.map do |tier|
+  tier.map { |x| URI.parse(x) }
+end unless (trackers.length == 1) && (trackers[0].length == 1)
+
+puts <<EOS
+
+Enter any comments. No one will probably ever see these. End with a blank line.
+EOS
+comm = ""
+while true
+  s = $stdin.gets.chomp
+  break if s == ""
+  comm += s + "\n"
+end
+mi.comment = comm.chomp unless comm == ""
+
+mi.created_by = "RubyTorrent make-metainfo (http://rubytorrent.rubyforge.org)"
+mi.creation_date = Time.now
+
+maybe_name = "#{mii.name}.torrent"
+begin
+  print "Output filename (enter for #{maybe_name}): "
+  name = $stdin.gets.chomp
+end while name.length == ""
+
+name = (name == "" ? maybe_name : name)
+File.open(name, "w") do |f|
+  f.write mi.to_bencoding
+end
+
+puts "Succesfully created #{name}"
+

data/rtpeer-ncurses.rb

@@ -0,0 +1,340 @@
+## rtpeer-ncurses.rb -- RubyTorrent ncurses BitTorrent peer.
+## Copyright 2005 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require "rubygems"
+require "rubytorrent"
+require "ncurses"
+require "optparse"
+
+def die(x); $stderr << "#{x}\n" && exit(-1); end
+
+dlratelim = nil
+ulratelim = nil
+
+opts = OptionParser.new do |opts|
+  opts.banner = 
+%{Usage: rtpeer-ncurses [options] <torrent> [<target>]
+
+rtpeer-ncurses is a very simple ncurses-based BitTorrent peer. You can use it
+to download .torrents or to seed them.
+
+<torrent> is a .torrent filename or URL.
+<target> is a file or directory on disk. If not specified, the default value
+  from <torrent> will be used.
+[options] are:
+}
+
+  opts.on("-l", "--log FILENAME",
+          "Log events to FILENAME (for debugging)") do |fn|
+    RubyTorrent::log_output_to(fn)
+  end
+
+  opts.on("-d", "--downlimit LIMIT", Integer,
+          "Limit download rate to LIMIT kb/s") do |x|
+    dlratelim = x * 1024
+  end
+
+  opts.on("-u", "--uplimit LIMIT", Integer,
+          "Limit upload rate to LIMIT kb/s") do |x|
+    ulratelim = x * 1024
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+opts.parse!(ARGV)
+proxy = ENV["http_proxy"]
+torrent = ARGV.shift or (puts opts; exit)
+dest = ARGV.shift
+
+class Numeric
+  def to_sz
+    if self < 1024
+      "#{self.round}b"
+    elsif self < 1024 ** 2
+      "#{(self / 1024 ).round}k"
+    elsif self < 1024 ** 3
+      sprintf("%.1fm", self.to_f / (1024 ** 2))
+    else
+      sprintf("%.2fg", self.to_f / (1024 ** 3))
+    end
+  end
+
+  MIN = 60
+  HOUR = 60 * MIN
+  DAY = 24 * HOUR
+
+  def to_time
+    if self < MIN
+      sprintf("0:%02d", self)
+    elsif self < HOUR
+      sprintf("%d:%02d", self / MIN, self % MIN)
+    elsif self < DAY
+      sprintf("%d:%02d:%02d", self / HOUR, (self % HOUR) / MIN, (self % HOUR) % MIN)
+    else
+      sprintf("%dd %d:%02d:%02d", self / DAY, (self % DAY) / HOUR, ((self % DAY) % HOUR) / MIN, ((self % DAY) % HOUR) % MIN)
+    end
+  end
+end
+
+class NilClass
+  def to_time; "--:--"; end
+  def to_sz; "-"; end
+end
+
+class Display
+  STALL_SECS = 15
+
+  attr_accessor :fn, :dest, :status,:dlamt, :ulamt, :dlrate, :ulrate,
+                :conn_peers, :fail_peers, :untried_peers, :tracker,
+                :errcount, :completed, :total, :rate, :use_rate
+
+  def initialize(window)
+    @window = window
+    @need_update = true
+
+    @fn = ""
+    @dest = ""
+    @status = ""
+    @completed = 0
+    @total = 0
+    @dlamt = 0
+    @dlrate = 0
+    @ulamt = 0
+    @ulrate = 0
+    @rate = 0
+    @conn_peers = 0
+    @fail_peers = 0
+    @untried_peers = 0
+    @tracker = "not connected"
+    @errcount = 0
+    @dlblocks = 0
+    @ulblocks = 0
+
+    @got_blocks = 0
+    @sent_blocks = 0
+    @last_got_block = nil
+    @last_sent_block = nil
+    @start_time = nil
+
+    @use_rate = false
+  end
+
+  def got_block
+    @got_blocks += 1
+    @last_got_block = Time.now
+  end
+
+  def sent_block
+    @sent_blocks += 1
+    @last_sent_block = Time.now
+  end
+
+  def sigwinch_handler(sig = nil)
+    @need_update = true
+  end
+
+  def start_timer
+    @start_time = Time.now
+  end
+
+  def draw
+    if @need_update
+      update_size 
+      @window.erase
+    end
+
+    complete_width = [@cols - 23, 0].max
+    complete_ticks = ((@completed.to_f / @total) * complete_width)
+
+    elapsed = (@start_time ? Time.now - @start_time : nil)
+    rate = (use_rate ? @rate : @dlrate)
+    remaining = rate && (rate > 0 ? (@total - @completed).to_f / rate : nil)
+
+    dlstall = @last_got_block && ((Time.now - @last_got_block) > STALL_SECS)
+    ulstall = @last_sent_block && ((Time.now - @last_sent_block) > STALL_SECS)
+      
+    line = 1
+    [
+      "Contents: #@fn",
+      "    Dest: #@dest",
+      "",
+      "  Status: #@status",
+      "Progress: [" + ("#" * complete_ticks),
+      "    Time: elapsed #{elapsed.to_time}, remaining #{remaining.to_time}",
+      "Download: #{@dlamt.to_sz} at #{dlstall ? '(stalled)' : @dlrate.to_sz + '/s'}",
+      "  Upload: #{@ulamt.to_sz} at #{ulstall ? '(stalled)' : @ulrate.to_sz + '/s'}",
+      "   Peers: connected to #@conn_peers (#@fail_peers failed, #@untried_peers untried)",
+      " Tracker: #@tracker",
+      "  Errors: #@errcount",
+    ].each do |s|
+      break if line > @rows
+      @window.mvaddnstr(line, 2, s + (" " * @cols), @cols - 4)
+      line += 1
+    end
+
+    ## progress bar tail
+    @window.mvaddstr(5, @cols - 11, sprintf("] %.2f%%  ", (@completed.to_f / @total) * 100.0))
+    @window.mvaddnstr(7, 31, "|" + ("#" * (@dlrate / 1024)) + (" " * @cols), @cols - 31 - 2)
+    @window.mvaddnstr(8, 31, "|" + ('#' * (@ulrate / 1024)) + (" " * @cols), @cols - 31 - 2)
+
+    @window.box(0,0)
+
+#    @got_blocks -= 1 unless @got_blocks == 0
+#    @sent_blocks -= 1 unless @sent_blocks == 0
+  end
+
+  private
+
+  def update_size
+    rows = []
+    cols = []
+    ## jesus CHRIST this is a shitty interface.
+    @window.getmaxyx(rows, cols)
+    @rows = rows[0]
+    @cols = cols[0]
+    @need_update = false
+  end
+end
+
+begin
+  mi = RubyTorrent::MetaInfo.from_location(torrent, proxy)
+rescue RubyTorrent::MetaInfoFormatError, RubyTorrent::BEncodingError => e
+  die %{Error: can\'t parse metainfo file "#{torrent}"---maybe not a .torrent?}
+rescue RubyTorrent::TypedStructError => e
+  $stderr << <<EOS
+error parsing metainfo file, and it's likely something I should know about.
+please email the torrent file to wmorgan-rubytorrent-bug@masanjin.net,
+along with this backtrace: (this is RubyTorrent version #{RubyTorrent::VERSION})
+EOS
+
+  raise e
+rescue IOError, SystemCallError => e
+  $stderr.puts %{Error: can't read file "#{torrent}": #{e.message}}
+  exit
+end
+
+unless dest.nil?
+  if FileTest.directory?(dest) && mi.info.single?
+    dest = File.join(dest, mi.info.name)
+  elsif FileTest.file?(dest) && mi.info.multiple?
+    die %{Error: .torrent contains multiple files, but "#{dest}" is a single file (must be a directory)}
+  end
+end
+
+def handle_any_input(display)
+  case(Ncurses.getch())
+  when ?q, ?Q
+    Ncurses.curs_set(1)
+    Ncurses.endwin()
+    exit
+  when Ncurses::KEY_RESIZE
+    display.sigwinch_handler
+  end
+end
+
+Ncurses.initscr
+
+begin
+  Ncurses.nl()
+  Ncurses.noecho()
+  Ncurses.curs_set(0)
+  Ncurses.stdscr.nodelay(true)
+  Ncurses.timeout(0)
+
+  display = Display.new Ncurses.stdscr
+  display.status = "checking file on disk..."
+  display.dest = File.expand_path(dest || mi.info.name) + (mi.single? ? "" : "/")
+  if mi.single?
+    display.fn = "#{mi.info.name} (#{mi.info.length.to_sz} in one file)"
+  else
+    display.fn = "#{mi.info.name}/ (#{mi.info.total_length.to_sz} in #{mi.info.files.length} files)"
+  end
+  display.total = mi.info.num_pieces * mi.info.piece_length
+  display.completed = 0
+  display.draw; Ncurses.refresh
+
+  display.use_rate = true
+  display.start_timer
+  num_pieces = 0
+  start = Time.now
+  every = 10
+  package = RubyTorrent::Package.new(mi, dest) do |piece|
+    num_pieces += 1
+    if (num_pieces % every) == 0
+      display.completed = (num_pieces * mi.info.piece_length)
+      display.rate = display.completed.to_f / (Time.now - start)
+      handle_any_input display
+      display.draw; Ncurses.refresh
+    end
+  end
+
+  display.status = "starting peer..."
+  display.use_rate = false
+  display.draw; Ncurses.refresh
+  bt = RubyTorrent::BitTorrent.new(mi, package, :http_proxy => proxy, :dlratelim => dlratelim, :ulratelim => ulratelim)
+
+  connecting = true
+  bt.on_event(self, :received_block) do |s, b, peer|
+    display.got_block
+    connecting = false
+  end
+  bt.on_event(self, :sent_block) do |s, b, peer|
+    display.sent_block
+    connecting = false
+  end
+  bt.on_event(self, :discarded_piece) { |s, p| display.errcount += 1 }
+  bt.on_event(self, :tracker_connected) do |s, url|
+    display.tracker = url
+    display.untried_peers = bt.num_possible_peers
+  end
+  bt.on_event(self, :tracker_lost) { |s, url| display.tracker = "can't connect to #{url}" }
+  bt.on_event(self, :forgetting_peer) { |s, p| display.fail_peers += 1 }
+  bt.on_event(self, :removed_peer, :added_peer) do |s, p|
+    if (display.conn_peers = bt.num_active_peers) == 0
+      connecting = true
+    end
+  end
+  bt.on_event(self, :added_peer) { |s, p| display.conn_peers += 1 }
+  bt.on_event(self, :trying_peer) { |s, p| display.untried_peers -= 1 unless display.untried_peers == 0 }
+
+  display.total = bt.total_bytes
+  display.start_timer
+
+  while true
+    handle_any_input(display)
+
+    display.status = if bt.complete?
+                       "seeding (download complete)"
+                     elsif connecting
+                       "connecting to peers"
+                     else
+                       "downloading"
+                     end
+    display.draw; Ncurses.refresh
+
+    display.dlamt = bt.dlamt
+    display.dlrate = bt.dlrate
+    display.ulamt = bt.ulamt
+    display.ulrate = bt.ulrate
+    display.completed = bt.bytes_completed
+    display.draw; Ncurses.refresh
+    sleep(0.5)
+  end
+ensure
+  Ncurses.curs_set(1)
+  Ncurses.endwin()
+end