http_spew 0.1.0 → 0.2.0

data/lib/http_spew/hit_n_run.rb

@@ -12,6 +12,8 @@ class HTTP_Spew::HitNRun < HTTP_Spew::Request
     }.freeze,
     [].freeze ].freeze
 
+  # we close the connection once we're ready to read the response to
+  # save bandwidth
   def read_response
     close
     RESPONSE

data/lib/http_spew/input_spray.rb

@@ -3,33 +3,25 @@
 # Use this to wrap and replace your input object for spraying to multiple
 # servers.
 class HTTP_Spew::InputSpray
-  attr_reader :readers
-  class NoWritersError < HTTP_Spew::Error
-  end
-
-  class SizedPipe < HTTP_Spew::ChunkyPipe
-    attr_accessor :size
-  end
-
-  def initialize(env, nr)
-    @input = env["rack.input"]
-    size = @input.respond_to?(:size) ? @input.size : env["CONTENT_LENGTH"]
-    size = size ? size.to_i : nil
-    klass = size ? SizedPipe : HTTP_Spew::ChunkyPipe
-    @readers, @writers = [], []
+  def initialize(env, nr, input = env["rack.input"])
+    @input = input
+    @pipes = {}.compare_by_identity
     nr.times do
-      r, w = klass.new
-      r.size = size if size
-      @readers << r
-      @writers << w
+      r, w = HTTP_Spew::ChunkyPipe.new
+      @pipes[r] = w
     end
-    @wr = start_write_driver
+    start_write_driver
+  end
+
+  def readers
+    @pipes.keys
   end
 
-  def write_fail?(wr, buf)
-    wr.kgio_write(buf)
+  def write_fail?(rd, wr, buf)
+    wr.write(buf)
     false
-    rescue
+    rescue => e
+      rd.error = e
       wr.close
       true
   end
@@ -39,14 +31,14 @@ class HTTP_Spew::InputSpray
     Thread.new do
       begin
         buf = ""
-        while buf = @input.read(0x4000, buf)
-          @writers.delete_if { |wr| write_fail?(wr, buf) }.empty? and
-            raise NoWritersError, "all writers have died"
+        while @input.read(0x4000, buf)
+          @pipes.delete_if { |rd, wr| write_fail?(rd, wr, buf) }.empty? and
+            raise HTTP_Spew::NoWritersError, "all writers have died", []
         end
       rescue => e
-        @readers.each { |io| io.error = e }
+        @pipes.each { |rd, _| rd.error = e }
       ensure
-        @writers.each { |io| io.close unless io.closed? }
+        @pipes.each { |_, wr| wr.close unless wr.closed? }
       end
     end
   end

data/lib/http_spew/request.rb

@@ -1,20 +1,39 @@
 # -*- encoding: binary -*-
+require "io/wait"
+
+# This is the base class actually capable of making a normal HTTP request
 class HTTP_Spew::Request
+
+  # May be called by some Rack servers such as Rainbows! to bypass
+  # +to_path+ calls and avoid path lookups.
   attr_reader :to_io
+
+  # Stores any exception that was raised in another thread (e.g.
+  # ContentMD5 or InputSpray write drivers).
   attr_reader :error
+
+  # Stores the Rack response (a 3-element Array) on success
   attr_reader :response
-  class RequestError < HTTP_Spew::Error
-  end
 
   include HTTP_Spew::Headers
 
-  def initialize(env, input, sock)
+  # Creates a new Request based on a Rack +env+ and +input+ object and
+  # prepares it for writing to +sock+.  +input+ supercedes env["rack.input"]
+  # since it may be an alternate IO object (such as one filtered through
+  # HTTP_Spew::ContentMD5.
+  #
+  # +sock+ may be the String representing an address created with
+  # +Socket.pack_sockaddr_un+ or +Socket.pack_sockaddr_in+, or it
+  # may be an actual IO object with Kgio::SocketMethods mixed in
+  # (e.g. Kgio::Socket)
+  def initialize(env, input, sock, allow = nil)
     @to_io = Kgio::SocketMethods === sock ? sock : Kgio::Socket.start(sock)
     if Hash === env
       @buf, @input = env_to_headers(env, input)
     else
       @buf, @input = env, input
     end
+    @allow = allow
   end
 
   # returns a 3-element Rack response array on completion
@@ -35,43 +54,78 @@ class HTTP_Spew::Request
     end
   end
 
+  # returns a 3-element Rack response array on successful completion
+  # returns an Exception if one was raised
+  def run(timeout)
+    t0 = Time.now
+    buf, @buf = @buf, nil # make inspect nicer
+    @to_io.write(buf)
+    if @input
+      @to_io.write(buf) while @input.read(0x4000, buf)
+    end
+    timeout -= (Time.now - t0)
+    while :wait_readable == (rv = read_response) && timeout >= 0.0
+      t0 = Time.now
+      @to_io.wait(timeout) if timeout > 0.0
+      timeout -= (Time.now - t0)
+    end
+    rv
+    rescue => e
+      @input.respond_to?(:close) and @input.close rescue nil
+      self.error = e
+  end
+
+  # returns a 3-element Rack response array on completion
+  # returns :wait_readable or :wait_writable if busy
+  # Users do not need to call this directly, +resume+ will return the result
+  # of this.
   def read_response
-    buf = @to_io.kgio_trypeek(0x4000) or eof!
+    buf = @to_io.kgio_trypeek(0x4000) or
+      raise HttpSpew::EOF, "upstream server closed connection", []
     String === buf or return buf
 
     # Kcar::Parser#headers shortens +buf+ for us
     hdr_len = buf.size
     r = Kcar::Parser.new.headers({}, buf) or too_big!
+    if @allow && ! @allow.include?(r[0].to_i)
+      raise HTTP_Spew::UnexpectedResponse,
+            "#{r[0].to_i} not in #{@allow.inspect}", []
+    end
 
     # discard the header data from the socket buffer
     (hdr_len -= buf.size) > 0 and @to_io.kgio_read(hdr_len, buf)
-    r[2] = self
-    @response = r
+    @response = r << self
   end
 
+  # Used by some Rack-compatible servers to optimize transfers
+  # by using IO.copy_stream
   def to_path
     "/dev/fd/#{@to_io.fileno}"
   end
 
-  def too_big!
-    raise RequestError.new(self), "response headers too large", []
+  def too_big! # :nodoc:
+    raise HTTP_Spew::RequestError.new(self), "response headers too large", []
   end
 
+  # Called by Rack servers to write the response to a client
   def each
     buf = ""
-    while buf = @to_io.kgio_read(0x4000, buf)
+    while @to_io.kgio_read(0x4000, buf)
       yield buf
     end
   end
 
+  # Used internally by various HTTP_Spew elements to report errors
+  # across different Threads and Fibers
   def error=(exception)
+    @input.respond_to?(:error=) and @input.error = exception
     close
     @error = exception
   end
 
-  # this may be called by a Rack web server
+  # Called by Rack servers after writing a response to a client
   def close
     @to_io.close
-    IO === @input and @input.close
+    @input = nil
   end
 end

data/lib/http_spew/version.rb

@@ -0,0 +1,2 @@
+# -*- encoding: binary -*-
+HTTP_Spew.const_set :VERSION, "0.2.0"

data/lib/http_spew.rb

@@ -11,87 +11,17 @@ module HTTP_Spew
   class Error < RuntimeError; end
   class TimeoutError < Error; end
   class ConnectionReset < Error; end
-
-  def self.error_all(requests, error) # :nodoc:
-    requests.each { |req| req.error ||= error }
-  end
-
-  def self.done_early(ready, failed, requests) # :nodoc:
-    ready.concat(failed)
-    pending = requests - ready
-    unless pending.empty?
-      error = ConnectionReset.new("prematurely terminated")
-      ready.concat(error_all(pending, error))
-    end
-    ready.uniq!
-    ready
-  end
-
-  # Returns an array of requests that are complete, including those
-  # that have errored out.  Incomplete requests remain in +requests+
-  # If +need+ is fullfilled, it closes all incomplete requests and
-  # returns all requests.
-  def self.wait_nonblock!(need, requests)
-    ready, failed = [], []
-    requests.delete_if do |req|
-      begin
-        case req.resume
-        when Symbol # :wait_writable, :wait_readable
-          false
-        else
-          (ready << req).size == need and
-            return done_early(ready, failed, requests)
-          true
-        end
-      rescue => e
-        req.error = e
-        failed << req
-      end
-    end
-    ready.concat(failed).empty? ? nil : ready
-  end
-
-  # Returns an array of requests that are complete, including those
-  # that have errored out.
-  # If +need+ is fullfilled, it closes all incomplete requests.
-  def self.wait(need, requests, timeout)
-    ready, failed = [], []
-    pollset = {}
-    begin
-      requests.each do |req|
-        begin
-          case rv = req.resume
-          when Symbol # :wait_writable, :wait_readable
-            pollset[req] = rv
-          else
-            (ready << req).size == need and
-              return done_early(ready, failed, requests)
-            pollset.delete(req)
-          end
-        rescue => e
-          req.error = e
-          failed << req
-          pollset.delete(req)
-        end
-      end
-      break if pollset.empty?
-
-      t0 = Time.now
-      busy = pollset.keys
-      rv = Kgio.poll(pollset, timeout.to_i) or break
-      timeout -= (Time.now - t0) * 1000
-    rescue Errno::EINTR
-      timeout -= (Time.now - t0) * 1000
-      retry
-    end while timeout > 0.0 && requests = rv.keys.concat(busy).uniq!
-
-    ready.concat(failed)
-    unless requests.empty?
-      ready.concat(error_all(requests, TimeoutError.new("request timed out")))
-      ready.uniq!
-    end
-    ready
-  end
+  class RequestError < Error; end
+  class UnexpectedResponse < RequestError; end
+  class ChecksumError < HTTP_Spew::Error; end
+  class LengthError < HTTP_Spew::Error; end
+  class NoWritersError < HTTP_Spew::Error; end
+  class EOF < EOFError; end
+
+  require "http_spew/version"
+  require "http_spew/headers"
+  require "http_spew/request"
+  require "http_spew/class_methods"
+
+  extend HTTP_Spew::ClassMethods
 end
-require "http_spew/headers"
-require "http_spew/request"

data/pkg.mk

@@ -167,5 +167,9 @@ doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
 doc_gz:
 	for i in $(docs); do \
 	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+check-warnings:
+	@(for i in $$(git ls-files '*.rb'|grep -v '^setup\.rb$$'); \
+	  do $(RUBY) -d -W2 -c $$i; done) | grep -v '^Syntax OK$$' || :
 
 .PHONY: all .FORCE-GIT-VERSION-FILE doc test $(test_units) manifest
+.PHONY: check-warnings

data/test/content-md5.ru

@@ -2,7 +2,9 @@
 bs = ENV['bs'] ? ENV['bs'].to_i : 4096
 require 'digest/md5'
 use Rack::ContentLength
+use Rack::ContentType, "text/plain"
 app = lambda do |env|
+  return exit!(5) if env["HTTP_X_FAIL"] == "true"
   digest = Digest::MD5.new
   input = env['rack.input']
   if buf = input.read(bs)
@@ -16,6 +18,6 @@ app = lambda do |env|
   body = "expect=#{expect}\nreaded=#{readed}\n"
   status = expect == readed ? 200 : 500
 
-  [ status, {'Content-Type' => 'text/plain'}, [ body ] ]
+  [ status, {}, [ body ] ]
 end
 run app

data/test/helper.rb

@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 $stderr.sync = $stdout.sync = true
+Thread.abort_on_exception = true
 require "test/unit"
 require "digest/sha1"
 require "stringio"
@@ -10,7 +11,8 @@ require "tempfile"
 $-w = true
 require "http_spew"
 
-def start_server(config, worker_processes = 4)
+def start_server(config, worker_processes = 4, rewindable_input = false)
+  ENV["RACK_ENV"] = "deployment"
   addr = ENV["TEST_HOST"] || "127.0.0.1"
   sock = TCPServer.new(addr, 0)
   port = sock.addr[1]
@@ -21,6 +23,7 @@ def start_server(config, worker_processes = 4)
   cfg = Tempfile.new("unicorn.config")
   cfg.puts "worker_processes #{worker_processes}"
   cfg.puts "preload_app true"
+  cfg.puts "rewindable_input #{rewindable_input}"
   cfg.puts <<EOF
 after_fork do |s,w|
   w.nr == (s.worker_processes - 1) and File.open("#{fifo_path}", "w").close

data/test/response_code.ru

@@ -0,0 +1,20 @@
+# SHA1 checksum generator
+bs = ENV['bs'] ? ENV['bs'].to_i : 16384
+require 'digest/sha1'
+use Rack::ContentLength
+app = lambda do |env|
+  /\A100-continue\z/i =~ env['HTTP_EXPECT'] and
+    return [ 100, {}, [] ]
+  digest = Digest::SHA1.new
+  input = env['rack.input']
+  if buf = input.read(bs)
+    begin
+      digest.update(buf)
+    end while input.read(bs, buf)
+  end
+  code = env['HTTP_X_RESPONSE_CODE']
+  code = code.nil? ? 200 : code.to_i
+
+  [ code, {'Content-Type' => 'text/plain'}, [ digest.hexdigest << "\n" ] ]
+end
+run app

data/test/test_content_md5.rb

@@ -3,7 +3,6 @@ require "./test/helper"
 
 class TestContentMD5 < Test::Unit::TestCase
   def setup
-    ENV["RACK_ENV"] = "deployment" # quiet Rack 1.2.1 bug
     @addr, @port, @srv = start_server("./test/content-md5.ru", 1)
     @sockaddr = Socket.pack_sockaddr_in(@port, @addr)
     @env = {
@@ -22,19 +21,21 @@ class TestContentMD5 < Test::Unit::TestCase
 
   def test_upload_with_md5
     str = rand_data(123) * (8 * 1021 * 13)
-    expect = [Digest::MD5.digest(str)].pack("m").strip!
-    expect = "expect=#{expect}\nreaded=#{expect}\n"
+    expect_md5 = [Digest::MD5.digest(str)].pack("m0")
+    expect = "expect=#{expect_md5}\nreaded=#{expect_md5}\n"
     @env["CONTENT_LENGTH"] = str.size.to_s
     @env["rack.input"] = StringIO.new(str)
-    input = HTTP_Spew::ContentMD5.input(@env)
+    input = HTTP_Spew::ContentMD5.new(@env)
     assert_nil @env["CONTENT_LENGTH"]
     assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
     req = HTTP_Spew::Request.new(@env, input, @sockaddr)
-    rv = HTTP_Spew.wait 1, [req], 666000
+    rv = HTTP_Spew.wait 1, [req], 666
     assert_equal 200, rv[0].response[0].to_i
     body = ""
     req.each { |buf| body << buf }
     assert_equal body, expect
+    assert_equal expect_md5, input.content_md5
+    assert_equal 123 * 8 * 1021 * 13, input.bytes_digested
   end
 
   def test_upload_with_corrupt_md5
@@ -44,12 +45,12 @@ class TestContentMD5 < Test::Unit::TestCase
     str = rand_data(123) * (8 * 1021 * 13)
     @env["CONTENT_LENGTH"] = str.size.to_s
     @env["rack.input"] = StringIO.new(str)
-    input = HTTP_Spew::ContentMD5.input(@env)
+    input = HTTP_Spew::ContentMD5.new(@env)
     assert_nil @env["CONTENT_LENGTH"]
     assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
     req = HTTP_Spew::Request.new(@env, input, @sockaddr)
-    rv = HTTP_Spew.wait 1, [req], 3600_000
-    assert_kind_of HTTP_Spew::ContentMD5::MismatchError, rv[0].error
+    rv = HTTP_Spew.wait 1, [req], 3600
+    assert_kind_of HTTP_Spew::ChecksumError, rv[0].error
   end
 
   def test_upload_with_corrupt_length
@@ -59,12 +60,12 @@ class TestContentMD5 < Test::Unit::TestCase
     str = rand_data(123) * (8 * 1021 * 13)
     @env["CONTENT_LENGTH"] = (str.size + 1).to_s
     @env["rack.input"] = StringIO.new(str)
-    input = HTTP_Spew::ContentMD5.input(@env)
+    input = HTTP_Spew::ContentMD5.new(@env)
     assert_nil @env["CONTENT_LENGTH"]
     assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
     req = HTTP_Spew::Request.new(@env, input, @sockaddr)
-    rv = HTTP_Spew.wait 1, [req], 3600_000
-    assert_kind_of HTTP_Spew::ContentMD5::LengthError, rv[0].error
+    rv = HTTP_Spew.wait 1, [req], 3600
+    assert_kind_of HTTP_Spew::LengthError, rv[0].error
   end
 
   def test_upload_with_valid_md5
@@ -73,11 +74,11 @@ class TestContentMD5 < Test::Unit::TestCase
     @env["HTTP_CONTENT_MD5"] = expect
     @env["CONTENT_LENGTH"] = str.size.to_s
     @env["rack.input"] = StringIO.new(str)
-    input = HTTP_Spew::ContentMD5.input(@env)
+    input = HTTP_Spew::ContentMD5.new(@env)
     assert_nil @env["CONTENT_LENGTH"]
     assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
     req = HTTP_Spew::Request.new(@env, input, @sockaddr)
-    rv = HTTP_Spew.wait 1, [req], 3600_000
+    rv = HTTP_Spew.wait 1, [req], 3600
     assert_equal 200, rv[0].response[0].to_i
     body = ""
     req.each { |buf| body << buf }

data/test/test_input_spray.rb

@@ -25,12 +25,12 @@ class TestInputSpray < Test::Unit::TestCase
         sha1[rd].update buf
         false
       else
-        rd.close.nil?
+        true
       end
     end until readers.empty?
 
     sha1.each_value { |dig| assert_equal EXPECT, dig.hexdigest }
-    sprayer.instance_variable_get(:@writers).each { |x| assert x.closed? }
+    sprayer.instance_variable_get(:@pipes).each_value { |x| assert x.closed? }
   end
 
   def test_spray_one_reader_dies
@@ -50,22 +50,21 @@ class TestInputSpray < Test::Unit::TestCase
           false
         end
       else
-        rd.close.nil?
+        true
       end
     end until readers.empty?
 
     dead_sha1 = sha1.delete to_die
     assert EXPECT != dead_sha1.hexdigest
     sha1.each_value { |dig| assert_equal EXPECT, dig.hexdigest }
-    sprayer.instance_variable_get(:@writers).each { |x| assert x.closed? }
+    sprayer.instance_variable_get(:@pipes).each_value { |x| assert x.closed? }
   end
 
   def test_spray_stream
     rd, wr = IO.pipe
     assert @env.delete("CONTENT_LENGTH")
     io = @env.delete("rack.input")
-    buf = ""
-    thr = Thread.new do
+    thr = Thread.new("") do |buf|
       while buf = io.read(128, buf)
         wr.write buf
       end
@@ -77,20 +76,20 @@ class TestInputSpray < Test::Unit::TestCase
     readers = sprayer.readers
     assert_equal 2, readers.size
 
-    sha1 = Hash[readers.map { |rd| [ rd, Digest::SHA1.new ] } ]
+    sha1 = Hash[readers.map { |x| [ x, Digest::SHA1.new ] } ]
 
-    readers.delete_if do |rd|
-      assert ! rd.respond_to?(:size)
-      if buf = rd.read(0x10000)
-        sha1[rd].update buf
+    readers.delete_if do |x|
+      assert ! x.respond_to?(:size)
+      if buf = x.read(0x10000)
+        sha1[x].update buf
         false
       else
-        rd.close.nil?
+        true
       end
     end until readers.empty?
 
     sha1.each_value { |dig| assert_equal EXPECT, dig.hexdigest }
-    sprayer.instance_variable_get(:@writers).each { |x| assert x.closed? }
+    sprayer.instance_variable_get(:@pipes).each_value { |x| assert x.closed? }
     thr.join
     assert_equal :ok, thr.value
     assert ! rd.closed?

data/test/test_input_spray_with_md5.rb

@@ -0,0 +1,107 @@
+require "./test/helper"
+
+class TestInputSprayWithMD5 < Test::Unit::TestCase
+  def setup
+    @nr = 4
+    @addr, @port, @srv = start_server("./test/content-md5.ru", @nr)
+    @sockaddr = Socket.pack_sockaddr_in(@port, @addr)
+    @env = {
+      "REQUEST_METHOD" => "PUT",
+      "REQUEST_URI" => "/",
+      "HTTP_HOST" => "example.com",
+    }
+    @tmpfiles = []
+  end
+
+  def teardown
+    Process.kill(:QUIT, @srv)
+    Process.waitpid2(@srv)
+    @tmpfiles.each { |tmp| tmp.closed? or tmp.close! }
+  end
+
+  def test_upload_with_valid_md5_sprayed
+    str = rand_data(123) * (8 * 1021 * 13)
+    expect_md5 = [Digest::MD5.digest(str)].pack("m0")
+    @env["HTTP_CONTENT_MD5"] = expect_md5
+    expect = "expect=#{expect_md5}\nreaded=#{expect_md5}\n"
+    @env["CONTENT_LENGTH"] = str.size.to_s
+    @env["rack.input"] = StringIO.new(str)
+    input = HTTP_Spew::ContentMD5.new(@env)
+    sprayer = HTTP_Spew::InputSpray.new(@env, @nr, input)
+    assert_nil @env["CONTENT_LENGTH"]
+    assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
+    reqs = sprayer.readers.map do |md5_input|
+      HTTP_Spew::Request.new(@env, md5_input, @sockaddr)
+    end
+    assert_equal @nr, reqs.size
+    rv = HTTP_Spew.wait_mt reqs.size, reqs, 3600
+    assert_equal @nr, rv.size
+    rv.each do |resp|
+      assert_equal 200, resp.response[0].to_i
+      body = ""
+      resp.response[2].each { |buf| body << buf }
+      assert_equal expect, body
+    end
+    assert_equal expect_md5, input.content_md5
+    assert_equal 123 * 8 * 1021 * 13, input.bytes_digested
+  end
+
+  def test_upload_with_invalid_md5_sprayed
+    str = rand_data(123) * (8 * 1021 * 13)
+    expect = [Digest::MD5.digest(str + "HI")].pack("m0")
+    @env["HTTP_CONTENT_MD5"] = expect
+    @env["CONTENT_LENGTH"] = str.size.to_s
+    @env["rack.input"] = StringIO.new(str)
+    input = HTTP_Spew::ContentMD5.new(@env)
+    sprayer = HTTP_Spew::InputSpray.new(@env, @nr, input)
+    assert_nil @env["CONTENT_LENGTH"]
+    assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
+    reqs = sprayer.readers.map do |md5_input|
+      HTTP_Spew::Request.new(@env, md5_input, @sockaddr)
+    end
+    assert_equal @nr, reqs.size
+    t0 = Time.now
+    rv = HTTP_Spew.wait_mt reqs.size, reqs, 3600
+    elapsed = Time.now - t0
+    assert(elapsed <= 30, "took too long: #{elapsed}s")
+    assert_equal @nr, rv.size
+    rv.each { |r|
+      assert_kind_of HTTP_Spew::ChecksumError, r.error
+    }
+    assert_nil input.content_md5
+    assert_nil input.bytes_digested
+  end
+
+  def test_upload_with_valid_md5_sprayed_one_failure
+    str = rand_data(123) * (8 * 1021 * 13)
+    expect_md5 = [Digest::MD5.digest(str)].pack("m0")
+    @env["HTTP_CONTENT_MD5"] = expect_md5
+    expect = "expect=#{expect_md5}\nreaded=#{expect_md5}\n"
+    @env["CONTENT_LENGTH"] = str.size.to_s
+    @env["rack.input"] = StringIO.new(str)
+    input = HTTP_Spew::ContentMD5.new(@env)
+    sprayer = HTTP_Spew::InputSpray.new(@env, @nr, input)
+    assert_nil @env["CONTENT_LENGTH"]
+    assert_equal "chunked", @env["HTTP_TRANSFER_ENCODING"]
+    reqs = []
+    sprayer.readers.each_with_index do |md5_input,i|
+      env = @env.dup
+      env["HTTP_X_FAIL"] = "true" if i == 0
+      reqs << HTTP_Spew::Request.new(env, md5_input, @sockaddr)
+    end
+    assert_equal @nr, reqs.size
+    rv = HTTP_Spew.wait_mt reqs.size, reqs, 3600
+    assert_equal @nr, rv.size
+    rv.each { |resp| assert reqs.include?(resp) }
+    assert reqs[0].error
+    (1..3).each do |n|
+      resp = reqs[n]
+      assert_equal 200, resp.response[0].to_i
+      body = ""
+      resp.response[2].each { |buf| body << buf }
+      assert_equal expect, body
+    end
+    assert_equal expect_md5, input.content_md5
+    assert_equal 123 * 8 * 1021 * 13, input.bytes_digested
+  end
+end

data/test/test_mirror.rb

@@ -3,7 +3,7 @@ require "./test/helper"
 
 class TestMirror < Test::Unit::TestCase
   def setup
-    @addr, @port, @srv = start_server("./test/mirror.ru")
+    @addr, @port, @srv = start_server("./test/mirror.ru", 4 , true)
     @sockaddr = Socket.pack_sockaddr_in(@port, @addr)
     @env = {
       "REQUEST_METHOD" => "PUT",
@@ -25,9 +25,9 @@ class TestMirror < Test::Unit::TestCase
     req << HTTP_Spew::Request.new(@env, StringIO.new(str), @sockaddr)
     req << HTTP_Spew::Request.new(@env, StringIO.new(str), @sockaddr)
     rv = HTTP_Spew.wait(3, req, 666000)
-    rv.each do |req|
-      assert_nil req.error
-      response = req.response
+    rv.each do |r|
+      assert_nil r.error
+      response = r.response
       headers = Rack::Utils::HeaderHash.new(response[1])
       assert_equal 128, headers["Content-Length"].to_i
       assert_equal 200, response[0].to_i
@@ -46,9 +46,9 @@ class TestMirror < Test::Unit::TestCase
     req << HTTP_Spew::Request.new(@env, StringIO.new(str), @sockaddr)
     req << HTTP_Spew::Request.new(@env, StringIO.new(str), @sockaddr)
     rv = HTTP_Spew.wait(3, req, 6000)
-    rv.each do |req|
-      assert_nil req.error
-      response = req.response
+    rv.each do |r|
+      assert_nil r.error
+      response = r.response
       headers = Rack::Utils::HeaderHash.new(response[1])
       assert_equal str.size, headers["Content-Length"].to_i
       assert_equal 200, response[0].to_i