net-http-pipeline 0.1 → 1.0

data/.autotest

@@ -2,22 +2,7 @@
 
 require 'autotest/restart'
 
-# Autotest.add_hook :initialize do |at|
-#   at.extra_files << "../some/external/dependency.rb"
-#
-#   at.libs << ":../some/external"
-#
-#   at.add_exception 'vendor'
-#
-#   at.add_mapping(/dependency.rb/) do |f, _|
-#     at.files_matching(/test_.*rb$/)
-#   end
-#
-#   %w(TestA TestB).each do |klass|
-#     at.extra_class_map[klass] = "test/test_misc.rb"
-#   end
-# end
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'minitest/autorun'
+end
 
-# Autotest.add_hook :run_command do |at|
-#   system "rake build"
-# end

data/History.txt

@@ -1,3 +1,15 @@
+=== 1.0 / 2011-03-29
+
+* API change
+  * Net::HTTP::Pipeline#pipeline requires an Array of Net::HTTPRequests now.
+* Major enhancement
+  * If a sequence of requests contains a non-idempotent request #pipeline now
+    waits for a response to the previous request.
+* Minor enhancements
+  * Check for HTTP/1.1 and persistent connections before attempting
+    pipelining
+  * Added Net::HTTP#persistent= to avoid pipelining-capability check.
+
 === 0.1 / 2010-12-07
 
 * Minor enhancement

data/README.txt

@@ -5,8 +5,9 @@
 
 == DESCRIPTION:
 
-An HTTP/1.1 pipelining implementation atop Net::HTTP.  This is an experimental
-proof of concept.
+An HTTP/1.1 pipelining implementation atop Net::HTTP.  A pipelined connection
+sends multiple requests to the HTTP server without waiting for the responses.
+The server will respond in-order.
 
 == FEATURES/PROBLEMS:
 
@@ -21,8 +22,9 @@ proof of concept.
   Net::HTTP.start 'localhost' do |http|
     req1 = Net::HTTP::Get.new '/'
     req2 = Net::HTTP::Get.new '/'
+    req3 = Net::HTTP::Get.new '/'
 
-    http.pipeline req1, req2 do |res|
+    http.pipeline [req1, req2, req3] do |res|
       puts res.code
       puts res.body[0..60].inspect
       puts

data/Rakefile

@@ -9,6 +9,9 @@ Hoe.plugins.delete :rubyforge
 
 Hoe.spec 'net-http-pipeline' do
   developer 'Eric Hodel', 'drbrain@segment7.net'
+
+  rdoc_locations <<
+    'docs.seattlerb.org:/data/www/docs.seattlerb.org/net-http-pipeline/'
 end
 
 # vim: syntax=Ruby

data/lib/net/http/pipeline.rb

@@ -1,21 +1,28 @@
 require 'net/http'
 
 ##
-# An HTTP/1.1 pipelining implementation atop Net::HTTP.  Currently this is not
+# An HTTP/1.1 pipelining implementation atop Net::HTTP.  This library is
 # compliant with RFC 2616 8.1.2.2.
 #
-# Pipeline allows pou to create a bunch of requests then pipeline them to an
-# HTTP/1.1 server.
+# Pipeline allows you to create a bunch of requests then send them all to an
+# HTTP/1.1 server without waiting for responses.  The server will return HTTP
+# responses in-order.
+#
+# Net::HTTP::Pipeline does not assume the server supports pipelining.  If you
+# know the server supports pipelining you can set Net::HTTP#pipelining to
+# true.
 #
 # = Example
 #
 #   require 'net/http/pipeline'
 #
 #   Net::HTTP.start 'localhost' do |http|
-#     req1 = Net::HTTP::Get.new '/'
-#     req2 = Net::HTTP::Get.new '/'
+#     requests = []
+#     requests << Net::HTTP::Get.new('/')
+#     requests << Net::HTTP::Get.new('/')
+#     requests << Net::HTTP::Get.new('/')
 #
-#     http.pipeline req1, req2 do |res|
+#     http.pipeline requests do |res|
 #       puts res.code
 #       puts res.body[0..60].inspect
 #       puts
@@ -24,49 +31,225 @@ require 'net/http'
 
 module Net::HTTP::Pipeline
 
-  VERSION = '0.1'
+  ##
+  # The version of net-http-pipeline you are using
+
+  VERSION = '1.0'
 
   ##
   # Pipeline error class
 
   class Error < RuntimeError
+
+    ##
+    # Remaining requests that have not been sent to the HTTP server
+
+    attr_reader :requests
+
+    ##
+    # Retrieved responses up to the error point
+
+    attr_reader :responses
+
+    ##
+    # Creates a new Error with +message+, a list of +requests+ that have not
+    # been sent to the server and a list of +responses+ that have been
+    # retrieved from the server.
+
+    def initialize message, requests, responses
+      super message
+
+      @requests = requests
+      @responses = responses
+    end
+
+  end
+
+  ##
+  # Raised when an invalid version is given
+
+  class VersionError < Error
+    ##
+    # Creates a new VersionError with a list of +requests+ that have not been
+    # sent to the server and a list of +responses+ that have been retrieved
+    # from the server.
+
+    def initialize requests, responses
+      super 'HTTP/1.1 or newer required', requests, responses
+    end
+  end
+
+  ##
+  # Raised when the server appears to not support persistent connections
+
+  class PersistenceError < Error
+    ##
+    # Creates a new PersistenceError with a list of +requests+ that have not
+    # been sent to the server and a list of +responses+ that have been
+    # retrieved from the server.
+
+    def initialize requests, responses
+      super 'persistent connections required', requests, responses
+    end
+  end
+
+  ##
+  # Raised when the server appears to not support pipelining connections
+
+  class PipelineError < Error
+    ##
+    # Creates a new PipelineError with a list of +requests+ that have not been
+    # sent to the server and a list of +responses+ that have been retrieved
+    # from the server.
+
+    def initialize requests, responses
+      super 'pipeline connections are not supported', requests, responses
+    end
+  end
+
+  ##
+  # Raised if an error occurs while reading responses.
+
+  class ResponseError < Error
+    ##
+    # The original exception
+
+    attr_accessor :original
+
+    ##
+    # Creates a new ResponseError with an original +exception+, a list of
+    # +requests+ that were in-flight and a list of +responses+ that have been
+    # retrieved from the server.
+
+    def initialize exception, requests, responses
+      @original = exception
+      message = "error handling responses: #{original} (#{original.class})"
+      super message, requests, responses
+    end
+  end
+
+  ##
+  # Pipelining capability accessor.
+  #
+  # Pipeline assumes servers do not support pipelining by default.  The first
+  # request is not pipelined while Pipeline ensures that the server is
+  # HTTP/1.1 or newer and defaults to persistent connections.
+  #
+  # If you know the server is HTTP/1.1 and defaults to persistent
+  # connections you can set this to true when you create the Net::HTTP object.
+
+  attr_accessor :pipelining
+
+  ##
+  # Is +req+ idempotent according to RFC 2616?
+
+  def idempotent? req
+    case req
+    when Net::HTTP::Delete, Net::HTTP::Get, Net::HTTP::Head,
+         Net::HTTP::Options, Net::HTTP::Put, Net::HTTP::Trace then
+      true
+    end
   end
 
   ##
   # Pipelines +requests+ to the HTTP server yielding responses if a block is
   # given.  Returns all responses recieved.
   #
-  # Raises an exception if the connection is not pipelining-capable or if the
+  # The Net::HTTP connection must be started before calling #pipeline.
+  #
+  # Raises an exception if the connection is not pipeline-capable or if the
   # HTTP session has not been started.
 
-  def pipeline *requests
-    raise Error, 'pipelining requires HTTP/1.1 or newer' unless
-      @curr_http_version >= '1.1'
-    raise Error, 'Net::HTTP not started' unless started?
+  def pipeline requests, &block # :yields: response
+    responses = []
 
-    requests.each do |req|
-      begin_transport req
-      req.exec @socket, @curr_http_version, edit_path(req.path)
-    end
+    raise Error.new('Net::HTTP not started', requests, responses) unless
+      started?
 
-    responses = []
+    raise VersionError.new(requests, responses) if '1.1' > @curr_http_version
+
+    pipeline_check requests, responses, &block
+
+    retried = responses.length
 
-    requests.each do |req|
+    until requests.empty? do
       begin
-        res = Net::HTTPResponse.read_new @socket
-      end while res.kind_of? Net::HTTPContinue
+        in_flight = pipeline_send requests
 
-      res.reading_body @socket, req.response_body_permitted? do
-        responses << res
-        yield res if block_given?
-      end
+        pipeline_receive in_flight, responses, &block
+      rescue Net::HTTP::Pipeline::ResponseError => e
+        e.requests.reverse_each do |request|
+          requests.unshift request
+        end
+
+        raise if responses.length == retried or not idempotent? requests.first
+
+        retried = responses.length
+
+        pipeline_reset requests, responses
 
-      pipeline_end_transport res
+        retry
+      end
     end
 
     responses
   end
 
+  ##
+  # Ensures the connection supports pipelining.
+  #
+  # If the server has not been tested for pipelining support one of the
+  # +requests+ will be consumed and placed in +responses+.
+  #
+  # A VersionError will be raised if the server is not HTTP/1.1 or newer.
+  #
+  # A PersistenceError will be raised if the server does not support
+  # persistent connections.
+  #
+  # A PipelineError will be raised if the it was previously determined that
+  # the server does not support pipelining.
+
+  def pipeline_check requests, responses
+    if instance_variable_defined? :@pipelining then
+      return if @pipelining
+      raise PipelineError.new(requests, responses) unless @pipelining
+    else
+      @pipelining = false
+    end
+
+    req = requests.shift
+    retried = false
+
+    begin
+      res = request req
+    rescue Timeout::Error, EOFError, Errno::ECONNABORTED, Errno::ECONNRESET,
+           Errno::EPIPE, Net::HTTPBadResponse => e
+      if retried then
+        requests.unshift req
+        raise ResponseError.new(e, requests, responses)
+      end
+
+      retried = true
+
+      pipeline_reset requests, responses
+
+      retry
+    end
+
+    responses << res
+
+    yield res if block_given?
+
+    @pipelining = pipeline_keep_alive? res
+
+    if '1.1' > @curr_http_version then
+      @pipelining = false
+      raise VersionError.new(requests, responses)
+    elsif not @pipelining then
+      raise PersistenceError.new(requests, responses)
+    end
+  end
+
   ##
   # Updates the HTTP version and ensures the connection has keep-alive.
 
@@ -83,6 +266,14 @@ module Net::HTTP::Pipeline
     end
   end
 
+  ##
+  # Closes the connection and rescues any IOErrors this may cause
+
+  def pipeline_finish
+    finish
+  rescue IOError
+  end
+
   if Net::HTTPResponse.allocate.respond_to? :connection_close? then
     ##
     # Checks for an connection close header
@@ -92,10 +283,86 @@ module Net::HTTP::Pipeline
     end
   else
     def pipeline_keep_alive? res
-      not /close/i =~ res['connection'].to_s
+      not res['connection'].to_s =~ /close/i
     end
   end
 
+  ##
+  # Receives HTTP responses for +in_flight+ requests and adds them to
+  # +responses+
+
+  def pipeline_receive in_flight, responses
+    while req = in_flight.shift do
+      begin
+        begin
+          res = Net::HTTPResponse.read_new @socket
+        end while res.kind_of? Net::HTTPContinue
+
+        res.reading_body @socket, req.response_body_permitted? do
+          responses << res
+          yield res if block_given?
+        end
+
+        pipeline_end_transport res
+      rescue StandardError, Timeout::Error
+        in_flight.unshift req
+        raise
+      end
+    end
+
+    responses
+  rescue Timeout::Error, EOFError, Errno::ECONNABORTED, Errno::ECONNRESET,
+         Errno::EPIPE, Net::HTTPBadResponse => e
+    pipeline_finish
+
+    raise ResponseError.new(e, in_flight, responses)
+  end
+
+  ##
+  # Resets this connection
+
+  def pipeline_reset requests, responses
+    pipeline_finish
+
+    start
+  rescue Errno::ECONNREFUSED
+    raise Error.new("connection refused: #{address}:#{port}", requests,
+                    responses)
+  rescue Errno::EHOSTDOWN
+    raise Error.new("host down: #{address}:#{port}", requests, responses)
+  end
+
+  ##
+  # Sends +requests+ to the HTTP server and removes them from the +requests+
+  # list.  Returns the requests that have been pipelined and are in-flight.
+  #
+  # If a non-idempotent request is first in +requests+ it will be sent and no
+  # further requests will be pipelined.
+  #
+  # If a non-idempotent request is encountered after an idempotent request it
+  # will not be sent.
+
+  def pipeline_send requests
+    in_flight = []
+
+    while req = requests.shift do
+      idempotent = idempotent? req
+
+      unless idempotent or in_flight.empty? then
+        requests.unshift req
+        break
+      end
+
+      begin_transport req
+      req.exec @socket, @curr_http_version, edit_path(req.path)
+      in_flight << req
+
+      break unless idempotent
+    end
+
+    in_flight
+  end
+
 end
 
 class Net::HTTP

data/test/test_net_http_pipeline.rb

@@ -4,12 +4,27 @@ require 'stringio'
 
 class TestNetHttpPipeline < MiniTest::Unit::TestCase
 
+  include Net::HTTP::Pipeline
+
+  def setup
+    @curr_http_version = '1.1'
+    @started = true
+
+    @get1 = Net::HTTP::Get.new '/'
+    @get2 = Net::HTTP::Get.new '/'
+    @get3 = Net::HTTP::Get.new '/'
+    @post = Net::HTTP::Post.new '/'
+  end
+
   ##
   # Net::BufferedIO stub
 
   class Buffer
     attr_accessor :read_io, :write_io
-    def initialize
+    def initialize exception = nil, immediate = false
+      @readline = immediate
+      @exception = exception
+
       @read_io = StringIO.new
       @write_io = StringIO.new
       @closed = false
@@ -34,6 +49,8 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     end
 
     def readline
+      raise @exception if @exception and @readline
+      @readline = true
       @read_io.readline.chomp "\r\n"
     end
 
@@ -50,15 +67,8 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     end
   end
 
-  include Net::HTTP::Pipeline
-
   attr_writer :started
 
-  def setup
-    @curr_http_version = '1.1'
-    @started = true
-  end
-
   def D(*) end
 
   def begin_transport req
@@ -68,14 +78,28 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     path
   end
 
-  def http_request
-    http_request = []
-    http_request << 'GET / HTTP/1.1'
-    http_request << 'Accept: */*'
-    http_request << 'User-Agent: Ruby' if RUBY_VERSION > '1.9'
-    http_request.push nil, nil
+  def finish
+    @socket.close
+  end
+
+  def http_get
+    get = []
+    get << 'GET / HTTP/1.1'
+    get << 'Accept: */*'
+    get << 'User-Agent: Ruby' if RUBY_VERSION > '1.9'
+    get.push nil, nil
+
+    get.join "\r\n"
+  end
 
-    http_request.join "\r\n"
+  def http_post
+    get = []
+    get << 'POST / HTTP/1.1'
+    get << 'Accept: */*'
+    get << 'User-Agent: Ruby' if RUBY_VERSION > '1.9'
+    get.push nil, nil
+
+    get.join "\r\n"
   end
 
   def http_response body, *extra_header
@@ -88,6 +112,31 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     http_response.join("\r\n") << body
   end
 
+  def http_bad_response
+    http_response = []
+    http_response << 'HTP/1.1 200 OK'
+    http_response << 'Content-Length: 0'
+    http_response.push nil, nil # Array chomps on #join
+
+    http_response.join("\r\n")
+  end
+
+  def request req
+    req.exec @socket, @curr_http_version, edit_path(req.path)
+
+    res = Net::HTTPResponse.read_new @socket
+
+    res.reading_body @socket, req.response_body_permitted? do
+      yield res if block_given?
+    end
+
+    @curr_http_version = res.http_version
+
+    @socket.close unless pipeline_keep_alive? res
+
+    res
+  end
+
   def response
     r = Net::HTTPResponse.allocate
     def r.http_version() Net::HTTP::HTTPVersion end
@@ -98,70 +147,370 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     r
   end
 
+  def start
+  end
+
   def started?() @started end
 
+  # tests start
+
+  def test_idempotent_eh
+    http = Net::HTTP.new 'localhost'
+
+    assert http.idempotent? Net::HTTP::Delete.new '/'
+    assert http.idempotent? Net::HTTP::Get.new '/'
+    assert http.idempotent? Net::HTTP::Head.new '/'
+    assert http.idempotent? Net::HTTP::Options.new '/'
+    assert http.idempotent? Net::HTTP::Put.new '/'
+    assert http.idempotent? Net::HTTP::Trace.new '/'
+
+    refute http.idempotent? Net::HTTP::Post.new '/'
+  end
+
   def test_pipeline
     @socket = Buffer.new
-
     @socket.read_io.write http_response('Worked 1!')
     @socket.read_io.write http_response('Worked 2!')
-
-    req1 = Net::HTTP::Get.new '/'
-    req2 = Net::HTTP::Get.new '/'
-
     @socket.start
 
-    responses = pipeline req1, req2
+    requests = [@get1, @get2]
+
+    responses = pipeline requests
 
     @socket.finish
 
-    expected = ''
-    expected << http_request
-    expected << http_request
+    expected = http_get * 2
 
     assert_equal expected, @socket.write_io.read
     refute @socket.closed?
 
     assert_equal 'Worked 1!', responses.first.body
     assert_equal 'Worked 2!', responses.last.body
+
+    assert_empty requests
   end
 
-  def test_pipeline_connection_close
+  def test_pipeline_block
     @socket = Buffer.new
-
-    @socket.read_io.write http_response('Worked 1!', 'Connection: close')
-
-    req1 = Net::HTTP::Get.new '/'
-
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.read_io.write http_response('Worked 2!')
     @socket.start
 
-    pipeline req1
+    requests = [@get1, @get2]
+    responses = []
+
+    pipeline requests do |response| responses << response end
 
     @socket.finish
 
-    assert @socket.closed?
+    assert_equal 'Worked 1!', responses.first.body
+    assert_equal 'Worked 2!', responses.last.body
   end
 
   def test_pipeline_http_1_0
     @curr_http_version = '1.0'
 
-    e = assert_raises Net::HTTP::Pipeline::Error do
-      pipeline
+    @socket = Buffer.new
+    @socket.read_io.write http_response('Worked 1!', 'Connection: close')
+    @socket.start
+
+    e = assert_raises Net::HTTP::Pipeline::VersionError do
+      pipeline [@get1, @get2]
     end
 
-    assert_equal 'pipelining requires HTTP/1.1 or newer', e.message
+    assert_equal [@get1, @get2], e.requests
+    assert_empty e.responses
+  end
+
+  def test_pipeline_non_idempotent
+    @socket = Buffer.new
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.read_io.write http_response('Worked 2!')
+    @socket.read_io.write http_response('Worked 3!')
+    @socket.read_io.write http_response('Worked 4!')
+    @socket.start
+
+    responses = pipeline [@get1, @get2, @post, @get3]
+
+    @socket.finish
+
+    expected = ''
+    expected << http_get * 2
+    expected << http_post
+    expected << http_get
+
+    assert_equal expected, @socket.write_io.read
+    refute @socket.closed?
+
+    assert_equal 'Worked 1!', responses.shift.body
+    assert_equal 'Worked 2!', responses.shift.body
+    assert_equal 'Worked 3!', responses.shift.body
+    assert_equal 'Worked 4!', responses.shift.body
+
+    assert responses.empty?
   end
 
   def test_pipeline_not_started
     @started = false
 
     e = assert_raises Net::HTTP::Pipeline::Error do
-      pipeline
+      pipeline []
     end
 
     assert_equal 'Net::HTTP not started', e.message
   end
 
+  def test_pipeline_retry
+    self.pipelining = true
+    @error_socket = Buffer.new Errno::ECONNRESET
+    @error_socket.read_io.write http_response('Worked 1!')
+    @error_socket.start
+
+    @good_socket = Buffer.new
+    @good_socket.read_io.write http_response('Worked 2!')
+    @good_socket.read_io.write http_response('Worked 3!')
+    @good_socket.start
+
+    @socket = @error_socket
+
+    def start
+      @socket = @good_socket
+    end
+
+    requests = [@get1, @get2, @get3]
+
+    responses = pipeline requests
+
+    @error_socket.finish
+    @good_socket.finish
+
+    assert_equal http_get * 3, @error_socket.write_io.read
+    assert @error_socket.closed?
+
+    assert_equal http_get * 2, @good_socket.write_io.read
+    refute @good_socket.closed?
+
+    assert_equal 'Worked 1!', responses.shift.body
+    assert_equal 'Worked 2!', responses.shift.body
+    assert_equal 'Worked 3!', responses.shift.body
+    assert_empty responses
+
+    assert_empty requests
+  end
+
+  def test_pipeline_retry_fail_post
+    self.pipelining = true
+
+    @socket = Buffer.new Errno::ECONNRESET, true
+    @socket.start
+
+    requests = [@post]
+
+    e = assert_raises Net::HTTP::Pipeline::ResponseError do
+      pipeline requests
+    end
+
+    @socket.finish
+
+    assert_equal http_post, @socket.write_io.read
+
+    assert_empty e.responses
+
+    assert_equal [@post], e.requests
+  end
+
+  def test_pipeline_retry_fail_different
+    self.pipelining = true
+    @error_socket = Buffer.new Errno::ECONNRESET
+    @error_socket.read_io.write http_response('Worked 1!')
+    @error_socket.start
+
+    @error_socket2 = Buffer.new Errno::ECONNRESET
+    @error_socket2.read_io.write http_response('Worked 2!')
+    @error_socket2.start
+
+    @good_socket = Buffer.new
+    @good_socket.read_io.write http_response('Worked 3!')
+    @good_socket.start
+
+    @socket = @error_socket
+
+    @sockets = [@error_socket2, @good_socket]
+
+    def start
+      @socket = @sockets.shift
+    end
+
+    requests = [@get1, @get2, @get3]
+
+    responses = pipeline requests
+
+    @error_socket.finish
+    @error_socket2.finish
+    @good_socket.finish
+
+    assert_equal http_get * 3, @error_socket.write_io.read
+    assert @error_socket.closed?
+
+    assert_equal http_get * 2, @error_socket2.write_io.read
+    assert @error_socket2.closed?
+
+    assert_equal http_get, @good_socket.write_io.read
+    refute @good_socket.closed?
+
+    assert_equal 'Worked 1!', responses.shift.body
+    assert_equal 'Worked 2!', responses.shift.body
+    assert_equal 'Worked 3!', responses.shift.body
+    assert_empty responses
+
+    assert_empty requests
+  end
+
+  def test_pipeline_retry_fail_same
+    self.pipelining = true
+
+    @error_socket = Buffer.new Errno::ECONNRESET
+    @error_socket.read_io.write http_response('Worked 1!')
+    @error_socket.start
+
+    @error_socket2 = Buffer.new Errno::ECONNRESET, true
+    @error_socket2.start
+
+    @socket = @error_socket
+
+    def start
+      @socket = @error_socket2
+    end
+
+    requests = [@get1, @get2, @get3]
+
+    e = assert_raises Net::HTTP::Pipeline::ResponseError do
+      pipeline requests
+    end
+
+    @error_socket.finish
+    @error_socket2.finish
+
+    assert_equal http_get * 3, @error_socket.write_io.read
+    assert @error_socket.closed?
+
+    assert_equal http_get * 2, @error_socket2.write_io.read
+    assert @error_socket2.closed?
+
+    responses = e.responses
+    assert_equal 'Worked 1!', responses.shift.body
+    assert_empty responses
+
+    assert_equal [@get2, @get3], e.requests
+  end
+
+  # end #pipeline tests
+
+  def test_pipeline_check
+    @socket = Buffer.new
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.start
+
+    requests = [@get1, @get2]
+    responses = []
+
+    pipeline_check requests, responses
+
+    assert_equal [@get2], requests
+    assert_equal 1, responses.length
+    assert_equal 'Worked 1!', responses.first.body
+    assert pipelining
+  end
+
+  def test_pipeline_check_again
+    self.pipelining = false
+
+    @socket = Buffer.new
+    @socket.start
+
+    e = assert_raises Net::HTTP::Pipeline::PipelineError do
+      pipeline_check [@get1, @get2], []
+    end
+
+    assert_equal [@get1, @get2], e.requests
+    assert_empty e.responses
+    refute pipelining
+  end
+
+  def test_pipeline_check_bad_response
+    @socket = Buffer.new
+    @socket.read_io.write http_bad_response
+    @socket.start
+
+    @socket2 = Buffer.new
+    @socket2.read_io.write http_response('Worked 1!')
+    @socket2.start
+
+    def start
+      @socket = @socket2
+    end
+
+    requests = [@get1, @get2]
+    responses = []
+
+    pipeline_check requests, responses
+
+    assert_equal [@get2], requests
+    assert_equal 1, responses.length
+    assert_equal 'Worked 1!', responses.first.body
+    assert pipelining
+  end
+
+  def test_pipeline_check_http_1_0
+    @socket = Buffer.new
+    @socket.read_io.write <<-HTTP_1_0
+HTTP/1.0 200 OK\r
+Content-Length: 9\r
+\r
+Worked 1!
+    HTTP_1_0
+    @socket.start
+
+    e = assert_raises Net::HTTP::Pipeline::VersionError do
+      pipeline_check [@get1, @get2], []
+    end
+
+    assert_equal [@get2], e.requests
+    assert_equal 1, e.responses.length
+    assert_equal 'Worked 1!', e.responses.first.body
+    refute pipelining
+  end
+
+  def test_pipeline_check_non_persistent
+    @socket = Buffer.new
+    @socket.read_io.write http_response('Worked 1!', 'Connection: close')
+    @socket.start
+
+    e = assert_raises Net::HTTP::Pipeline::PersistenceError do
+      pipeline_check [@get1, @get2], []
+    end
+
+    assert_equal [@get2], e.requests
+    assert_equal 1, e.responses.length
+    assert_equal 'Worked 1!', e.responses.first.body
+    refute pipelining
+  end
+
+  def test_pipeline_check_pipelining
+    self.pipelining = true
+    @socket = Buffer.new
+    @socket.start
+
+    requests = [@get1, @get2]
+    responses = []
+
+    pipeline_check requests, responses
+
+    assert_equal [@get1, @get2], requests
+    assert_empty responses
+    assert pipelining
+  end
+
   def test_pipeline_end_transport
     @curr_http_version = nil
 
@@ -199,5 +548,109 @@ class TestNetHttpPipeline < MiniTest::Unit::TestCase
     refute pipeline_keep_alive? res
   end
 
+  def test_pipeline_receive
+    @socket = Buffer.new
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.read_io.write http_response('Worked 2!')
+    @socket.start
+
+    in_flight = [@get1, @get2]
+    responses = []
+
+    r = pipeline_receive in_flight, responses
+
+    @socket.finish
+
+    refute @socket.closed?
+
+    assert_equal 'Worked 1!', responses.first.body
+    assert_equal 'Worked 2!', responses.last.body
+
+    assert_same r, responses
+  end
+
+  def test_pipeline_receive_bad_response
+    @socket = Buffer.new Errno::ECONNRESET
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.start
+
+    in_flight = [@get1, @get2]
+    responses = []
+
+    e = assert_raises Net::HTTP::Pipeline::ResponseError do
+      pipeline_receive in_flight, responses
+    end
+
+    @socket.finish
+
+    assert @socket.closed?
+
+    assert_equal [@get2], e.requests
+    assert_equal 1, e.responses.length
+    assert_equal 'Worked 1!', e.responses.first.body
+
+    assert_kind_of Errno::ECONNRESET, e.original
+  end
+
+  def test_pipeline_receive_timeout
+    @socket = Buffer.new Timeout::Error
+    @socket.read_io.write http_response('Worked 1!')
+    @socket.start
+
+    in_flight = [@get1, @get2]
+    responses = []
+
+    e = assert_raises Net::HTTP::Pipeline::ResponseError do
+      pipeline_receive in_flight, responses
+    end
+
+    @socket.finish
+
+    assert @socket.closed?
+
+    assert_equal [@get2], e.requests
+    assert_equal 1, e.responses.length
+    assert_equal 'Worked 1!', e.responses.first.body
+
+    assert_kind_of Timeout::Error, e.original
+  end
+
+  def test_pipeline_send
+    @socket = Buffer.new
+    @socket.start
+
+    requests = [@get1, @get2, @post, @get3]
+
+    in_flight = pipeline_send requests
+
+    @socket.finish
+
+    assert_equal [@get1, @get2], in_flight
+    assert_equal [@post, @get3], requests
+
+    expected = ''
+    expected << http_get * 2
+
+    assert_equal expected, @socket.write_io.read
+  end
+
+  def test_pipeline_send_non_idempotent
+    @socket = Buffer.new
+    @socket.start
+
+    requests = [@post, @get3]
+
+    in_flight = pipeline_send requests
+
+    @socket.finish
+
+    assert_equal [@post], in_flight
+    assert_equal [@get3], requests
+
+    expected = http_post
+
+    assert_equal expected, @socket.write_io.read
+  end
+
 end
 

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: net-http-pipeline
 version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: false
+  hash: 15
+  prerelease: 
   segments: 
-  - 0
   - 1
-  version: "0.1"
+  - 0
+  version: "1.0"
 platform: ruby
 authors: 
 - Eric Hodel
@@ -35,7 +35,7 @@ cert_chain:
   x52qPcexcYZR7w==
   -----END CERTIFICATE-----
 
-date: 2010-12-07 00:00:00 -08:00
+date: 2011-03-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,12 +46,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 11
         segments: 
-        - 1
-        - 5
+        - 2
         - 0
-        version: 1.5.0
+        - 2
+        version: 2.0.2
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -62,17 +62,18 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 41
         segments: 
         - 2
-        - 7
-        - 0
-        version: 2.7.0
+        - 9
+        - 1
+        version: 2.9.1
   type: :development
   version_requirements: *id002
 description: |-
-  An HTTP/1.1 pipelining implementation atop Net::HTTP.  This is an experimental
-  proof of concept.
+  An HTTP/1.1 pipelining implementation atop Net::HTTP.  A pipelined connection
+  sends multiple requests to the HTTP server without waiting for the responses.
+  The server will respond in-order.
 email: 
 - drbrain@segment7.net
 executables: []
@@ -92,6 +93,7 @@ files:
 - lib/net/http/pipeline.rb
 - sample/two_get.rb
 - test/test_net_http_pipeline.rb
+- .gemtest
 has_rdoc: true
 homepage: http://seattlerb.rubyforge.org/net-http-pipeline
 licenses: []
@@ -123,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: net-http-pipeline
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: An HTTP/1.1 pipelining implementation atop Net::HTTP