em-http-request 0.2.15 → 0.3.0

data/lib/em-http/http_header.rb

@@ -0,0 +1,71 @@
+module EventMachine
+  # A simple hash is returned for each request made by HttpClient with the
+  # headers that were given by the server for that request.
+  class HttpResponseHeader < Hash
+    # The reason returned in the http response ("OK","File not found",etc.)
+    attr_accessor :http_reason
+
+    # The HTTP version returned.
+    attr_accessor :http_version
+
+    # The status code (as a string!)
+    attr_accessor :http_status
+
+    # E-Tag
+    def etag
+      self[HttpClient::ETAG]
+    end
+
+    def last_modified
+      self[HttpClient::LAST_MODIFIED]
+    end
+
+    # HTTP response status as an integer
+    def status
+      Integer(http_status) rescue 0
+    end
+
+    # Length of content as an integer, or nil if chunked/unspecified
+    def content_length
+      @content_length ||= ((s = self[HttpClient::CONTENT_LENGTH]) &&
+                           (s =~ /^(\d+)$/)) ? $1.to_i : nil
+    end
+
+    # Cookie header from the server
+    def cookie
+      self[HttpClient::SET_COOKIE]
+    end
+
+    # Is the transfer encoding chunked?
+    def chunked_encoding?
+      /chunked/i === self[HttpClient::TRANSFER_ENCODING]
+    end
+
+    def keep_alive?
+      /keep-alive/i === self[HttpClient::KEEP_ALIVE]
+    end
+
+    def compressed?
+      /gzip|compressed|deflate/i === self[HttpClient::CONTENT_ENCODING]
+    end
+
+    def location
+      self[HttpClient::LOCATION]
+    end
+  end
+
+  class HttpChunkHeader < Hash
+    # When parsing chunked encodings this is set
+    attr_accessor :http_chunk_size
+
+    def initialize
+      super
+      @http_chunk_size = '0'
+    end
+
+    # Size of the chunk as an integer
+    def chunk_size
+      @http_chunk_size.to_i(base=16)
+    end
+  end
+end

data/lib/em-http/http_options.rb

@@ -2,7 +2,7 @@ class HttpOptions
   attr_reader :uri, :method, :host, :port, :options
 
   def initialize(method, uri, options)
-    uri.normalize!
+    uri.path = '/' if uri.path.empty?
 
     @options = options
     @method = method.to_s.upcase
@@ -18,8 +18,9 @@ class HttpOptions
       @port = uri.port
     end
 
-    @options[:timeout]    ||= 10  # default connect & inactivity timeouts
-    @options[:redirects]  ||= 0   # default number of redirects to follow
+    @options[:timeout]    ||= 10    # default connect & inactivity timeouts
+    @options[:redirects]  ||= 0     # default number of redirects to follow
+    @options[:keepalive]  ||= false # default to single request per connection
 
     # Make sure the ports are set as Addressable::URI doesn't
     # set the port if it isn't there

data/lib/em-http/request.rb

@@ -1,6 +1,3 @@
-require 'base64'
-require 'addressable/uri'
-
 module EventMachine
 
   # EventMachine based HTTP request class with support for streaming consumption

data/lib/em-http/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  class HttpRequest
+    VERSION = "0.3.0"
+  end
+end

data/spec/encoding_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/helper'
+require 'helper'
 
 describe EventMachine::HttpEncoding do
   include EventMachine::HttpEncoding
@@ -31,4 +31,10 @@ describe EventMachine::HttpEncoding do
     params.should == "bad%26str[key%26key][0]=bad%2B%26stuff&bad%26str[key%26key][1]=%5Btest%5D"
   end
 
+  it "should be fast on long string escapes" do
+    s = Time.now
+    5000.times { |n| form_encode_body({:a => "{a:'b', d:'f', g:['a','b']}"*50}) }
+    (Time.now - s).should satisfy { |t| t < 1.5 }
+  end
+
 end

data/spec/mock_spec.rb

@@ -1,4 +1,4 @@
-require 'spec/helper'
+require 'helper'
 
 describe 'em-http mock' do
 

data/spec/multi_spec.rb

@@ -1,68 +1,68 @@
-require 'spec/helper'
-require 'spec/stallion'
-
-describe EventMachine::MultiRequest do
-
-  it "should submit multiple requests in parallel and return once all of them are complete" do
-    EventMachine.run {
-
-      # create an instance of multi-request handler, and the requests themselves
-      multi = EventMachine::MultiRequest.new
-
-      # add multiple requests to the multi-handler
-      multi.add(EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'}))
-      multi.add(EventMachine::HttpRequest.new('http://0.0.0.0:8083/').get(:timeout => 1))
-
-      multi.callback  {
-        # verify successful request
-        multi.responses[:succeeded].size.should == 1
-        multi.responses[:succeeded].first.response.should match(/test/)
-
-        # verify invalid requests
-        multi.responses[:failed].size.should == 1
-        multi.responses[:failed].first.response_header.status.should == 0
-
-        EventMachine.stop
-      }
-    }
-  end
-
-  it "should accept multiple open connections and return once all of them are complete" do
-    EventMachine.run {
-      http1 = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'})
-      http2 = EventMachine::HttpRequest.new('http://0.0.0.0:8083/').get(:timeout => 1)
-
-      multi = EventMachine::MultiRequest.new([http1, http2]) do
-        multi.responses[:succeeded].size.should == 1
-        multi.responses[:succeeded].first.response.should match(/test/)
-
-        multi.responses[:failed].size.should == 1
-        multi.responses[:failed].first.response_header.status.should == 0
-
-        EventMachine.stop
-      end
-    }
-  end
-
-  it "should handle multiple mock requests" do
-    EventMachine::MockHttpRequest.register_file('http://127.0.0.1:8080/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
-    EventMachine::MockHttpRequest.register_file('http://0.0.0.0:8083/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
-
-    EventMachine.run {
-
-      # create an instance of multi-request handler, and the requests themselves
-      multi = EventMachine::MultiRequest.new
-
-      # add multiple requests to the multi-handler
-      multi.add(EventMachine::MockHttpRequest.new('http://127.0.0.1:8080/').get)
-      multi.add(EventMachine::MockHttpRequest.new('http://0.0.0.0:8083/').get)
-
-      multi.callback  {
-        # verify successful request
-        multi.responses[:succeeded].size.should == 2
-
-        EventMachine.stop
-      }
-    }
-  end
-end
+require 'helper'
+require 'stallion'
+
+describe EventMachine::MultiRequest do
+
+  it "should submit multiple requests in parallel and return once all of them are complete" do
+    EventMachine.run {
+
+      # create an instance of multi-request handler, and the requests themselves
+      multi = EventMachine::MultiRequest.new
+
+      # add multiple requests to the multi-handler
+      multi.add(EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'}))
+      multi.add(EventMachine::HttpRequest.new('http://0.0.0.0:8083/').get(:timeout => 1))
+
+      multi.callback  {
+        # verify successful request
+        multi.responses[:succeeded].size.should == 1
+        multi.responses[:succeeded].first.response.should match(/test/)
+
+        # verify invalid requests
+        multi.responses[:failed].size.should == 1
+        multi.responses[:failed].first.response_header.status.should == 0
+
+        EventMachine.stop
+      }
+    }
+  end
+
+  it "should accept multiple open connections and return once all of them are complete" do
+    EventMachine.run {
+      http1 = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get(:query => {:q => 'test'})
+      http2 = EventMachine::HttpRequest.new('http://0.0.0.0:8083/').get(:timeout => 1)
+
+      multi = EventMachine::MultiRequest.new([http1, http2]) do
+        multi.responses[:succeeded].size.should == 1
+        multi.responses[:succeeded].first.response.should match(/test/)
+
+        multi.responses[:failed].size.should == 1
+        multi.responses[:failed].first.response_header.status.should == 0
+
+        EventMachine.stop
+      end
+    }
+  end
+
+  it "should handle multiple mock requests" do
+    EventMachine::MockHttpRequest.register_file('http://127.0.0.1:8080/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+    EventMachine::MockHttpRequest.register_file('http://0.0.0.0:8083/', :get, {}, File.join(File.dirname(__FILE__), 'fixtures', 'google.ca'))
+
+    EventMachine.run {
+
+      # create an instance of multi-request handler, and the requests themselves
+      multi = EventMachine::MultiRequest.new
+
+      # add multiple requests to the multi-handler
+      multi.add(EventMachine::MockHttpRequest.new('http://127.0.0.1:8080/').get)
+      multi.add(EventMachine::MockHttpRequest.new('http://0.0.0.0:8083/').get)
+
+      multi.callback  {
+        # verify successful request
+        multi.responses[:succeeded].size.should == 2
+
+        EventMachine.stop
+      }
+    }
+  end
+end

data/spec/request_spec.rb

@@ -1,19 +1,19 @@
-require 'spec/helper'
-require 'spec/stallion'
-require 'spec/stub_server'
+require 'helper'
+require 'stallion'
+require 'stub_server'
 
 describe EventMachine::HttpRequest do
 
-  def failed
+  def failed(http=nil)
     EventMachine.stop
-    fail
+    http ? fail(http.error) : fail
   end
 
   it "should fail GET on DNS timeout" do
     EventMachine.run {
       EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://127.1.1.1/').get :timeout => 1
-      http.callback { failed }
+      http.callback { failed(http) }
       http.errback {
         http.response_header.status.should == 0
         EventMachine.stop
@@ -25,7 +25,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       EventMachine.heartbeat_interval = 0.1
       http = EventMachine::HttpRequest.new('http://somethinglocal/').get :timeout => 1
-      http.callback { failed }
+      http.callback { failed(http) }
       http.errback {
         http.response_header.status.should == 0
         http.error.should match(/unable to resolve server address/)
@@ -59,7 +59,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/Hello/)
@@ -74,7 +74,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://google.com:8080/').get :host => '127.0.0.1'
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response.should match(/Hello/)
@@ -87,7 +87,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get :redirects => 1, :host => '127.0.0.1'
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response_header["CONTENT_ENCODING"].should == "gzip"
@@ -105,7 +105,7 @@ describe EventMachine::HttpRequest do
         @s = StubServer.new("HTTP/1.0 301 MOVED PERMANENTLY\r\nlocation: http://127.0.0.1:8080/redirect\r\n\r\n")
 
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :redirects => 2
-        http.errback { failed }
+        http.errback { failed(http) }
 
         http.callback {
           http.response_header.status.should == 200
@@ -123,7 +123,7 @@ describe EventMachine::HttpRequest do
     it "should follow redirects on HEAD method" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/head').head :redirects => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/'
@@ -136,7 +136,7 @@ describe EventMachine::HttpRequest do
 
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://www.google.com/').head :redirects => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           EM.stop
@@ -151,7 +151,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/Hello/)
@@ -165,7 +165,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).head
 
-      http.errback { p http; failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == ""
@@ -180,7 +180,7 @@ describe EventMachine::HttpRequest do
       uri = URI.parse('http://127.0.0.1:8080/')
       http = EventMachine::HttpRequest.new(uri).delete
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == ""
@@ -193,7 +193,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/fail').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 404
         EventMachine.stop
@@ -205,7 +205,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => {:q => 'test'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/test/)
@@ -218,7 +218,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :query => "q=test"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/test/)
@@ -231,7 +231,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_query').get :query => {:hash => ['value1', 'value2']}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/hash\[\]=value1&hash\[\]=value2/)
@@ -245,7 +245,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').put :body => "data"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/data/)
@@ -258,7 +258,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => "data"
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should match(/data/)
@@ -271,7 +271,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => {:stuff => 'string&string'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == "stuff=string%26string"
@@ -284,7 +284,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :body => {"key1" => 1, "key2" => [2,3]}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
 
@@ -298,7 +298,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_length').post :body => {"key1" => "data1"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
 
@@ -312,7 +312,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'if-none-match' => 'evar!'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 304
         EventMachine.stop
@@ -326,7 +326,7 @@ describe EventMachine::HttpRequest do
       # digg.com uses chunked encoding
       http = EventMachine::HttpRequest.new('http://digg.com/news').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         EventMachine.stop
@@ -339,7 +339,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get :head => {'authorization' => ['user', 'pass']}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         EventMachine.stop
@@ -352,7 +352,7 @@ describe EventMachine::HttpRequest do
       oauth_header = 'OAuth oauth_nonce="oqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU", b=c, d=e'
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/oauth_auth').get :head => {'authorization' => oauth_header}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response.should == oauth_header
@@ -361,24 +361,39 @@ describe EventMachine::HttpRequest do
     }
   end
 
-  it "should work with keep-alive servers" do
-    EventMachine.run {
+  context "keepalive" do
+    it "should default to non-keepalive" do
+      EventMachine.run {
+        headers = {'If-Modified-Since' => 'Thu, 05 Aug 2010 22:54:44 GMT'}
+        http = EventMachine::HttpRequest.new('http://www.google.com/images/logos/ps_logo2.png').get :head => headers
 
-      http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get
+        http.errback { fail }
+        start = Time.now.to_i
+        http.callback {
+          (start - Time.now.to_i).should be_within(1).of(0)
+          EventMachine.stop
+        }
+      }
+    end
 
-      http.errback { failed }
-      http.callback {
-        http.response_header.status.should == 200
-        EventMachine.stop
+    it "should work with keep-alive servers" do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://mexicodiario.com/touch.public.json.php').get :keepalive => true
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          EventMachine.stop
+        }
       }
-    }
+    end
   end
 
   it "should return ETag and Last-Modified headers" do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_query').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header.etag.should match('abcdefg')
@@ -393,7 +408,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header["CONTENT_ENCODING"].should == "deflate"
@@ -409,7 +424,7 @@ describe EventMachine::HttpRequest do
 
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/gzip').get :head => {"accept-encoding" => "gzip, compressed"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header["CONTENT_ENCODING"].should == "gzip"
@@ -430,7 +445,7 @@ describe EventMachine::HttpRequest do
         (Time.now.to_i - t).should <= 5
         EventMachine.stop
       }
-      http.callback { failed }
+      http.callback { failed(http) }
     }
   end
 
@@ -438,7 +453,7 @@ describe EventMachine::HttpRequest do
     it "should report last_effective_url" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/'
@@ -451,7 +466,7 @@ describe EventMachine::HttpRequest do
     it "should follow location redirects" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get :redirects => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response_header["CONTENT_ENCODING"].should == "gzip"
@@ -467,7 +482,7 @@ describe EventMachine::HttpRequest do
     it "should default to 0 redirects" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect').get
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 301
           http.last_effective_url.to_s.should == 'http://127.0.0.1:8080/gzip'
@@ -478,10 +493,10 @@ describe EventMachine::HttpRequest do
       }
     end
 
-    it "should not invoke redirect logic on failed connections" do
+    it "should not invoke redirect logic on failed(http) connections" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get :timeout => 0.1, :redirects => 5
-        http.callback { failed }
+        http.callback { failed(http) }
         http.errback {
           http.redirects.should == 0
           EM.stop
@@ -492,7 +507,7 @@ describe EventMachine::HttpRequest do
     it "should normalize redirect urls" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/bad').get :redirects => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.last_effective_url.to_s.should match('http://127.0.0.1:8080/')
           http.response.should match('Hello, World!')
@@ -504,7 +519,7 @@ describe EventMachine::HttpRequest do
     it "should fail gracefully on a missing host in absolute Location header" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/nohost').get :redirects => 1
-        http.callback { failed }
+        http.callback { failed(http) }
         http.errback {
           http.error.should == 'Location header format error'
           EM.stop
@@ -515,7 +530,7 @@ describe EventMachine::HttpRequest do
     it "should fail gracefully on an invalid host in Location header" do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/redirect/badhost').get :redirects => 1
-        http.callback { failed }
+        http.callback { failed(http) }
         http.errback {
           http.error.should == 'unable to resolve server address'
           EM.stop
@@ -529,7 +544,7 @@ describe EventMachine::HttpRequest do
       body = ''
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.stream { |chunk| body += chunk }
 
       http.callback {
@@ -546,7 +561,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.headers { |hash|
           hash.should be_an_kind_of Hash
           hash.should include 'CONNECTION'
@@ -565,7 +580,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').get
 
-        http.callback { failed }
+        http.callback { failed(http) }
         http.headers { |hash|
           hash.should be_an_kind_of Hash
           hash.should include 'CONNECTION'
@@ -589,7 +604,7 @@ describe EventMachine::HttpRequest do
       body = ''
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/deflate').get :head => {"accept-encoding" => "deflate, compressed"}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.stream { |chunk| body += chunk }
 
       http.callback {
@@ -606,7 +621,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('https://mail.google.com:443/mail/').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 302
         EventMachine.stop
@@ -618,7 +633,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/set_cookie').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header.status.should == 200
         http.response_header.cookie.should == "id=1; expires=Tue, 09-Aug-2011 17:53:39 GMT; path=/;"
@@ -631,7 +646,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => 'id=2;'}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should == "id=2;"
         EventMachine.stop
@@ -643,7 +658,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_cookie').get :head => {'cookie' => {'id' => 2}}
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should == "id=2;"
         EventMachine.stop
@@ -657,7 +672,7 @@ describe EventMachine::HttpRequest do
         @s = StubServer.new("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nFoo")
 
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response.should match(/Foo/)
           http.response_header['CONTENT_LENGTH'].should_not == 0
@@ -673,7 +688,7 @@ describe EventMachine::HttpRequest do
         @s = StubServer.new("HTTP/1.0 200 OK\nContent-Type: text/plain\nContent-Length: 3\nConnection: close\n\nFoo")
 
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8081/').get
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response_header['CONTENT_TYPE'].should == 'text/plain'
@@ -691,7 +706,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post :body => "data"
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response.should be_empty
@@ -704,7 +719,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post :body => {:a => :b}
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
           http.response.should match("application/x-www-form-urlencoded")
@@ -715,24 +730,59 @@ describe EventMachine::HttpRequest do
 
     it "should not override content-type when passing in ruby hash/array for body" do
       EventMachine.run {
+        ct = 'text; charset=utf-8'
         http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post({
-        :body => {:a => :b}, :head => {'content-type' => 'text'}})
+        :body => {:a => :b}, :head => {'content-type' => ct}})
 
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 200
-          http.response.should match("text")
+          http.content_charset.should == Encoding.find('utf-8')
+          http.response_header["CONTENT_TYPE"].should == ct
           EventMachine.stop
         }
       }
     end
+
+    it "should default to external encoding on invalid encoding" do
+      EventMachine.run {
+        ct = 'text/html; charset=utf-8lias'
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post({
+        :body => {:a => :b}, :head => {'content-type' => ct}})
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.content_charset.should == Encoding.find('utf-8')
+          http.response_header["CONTENT_TYPE"].should == ct
+          EventMachine.stop
+        }
+      }
+    end
+
+    it "should processed escaped content-type" do
+      EventMachine.run {
+        ct = "text/html; charset=\"ISO-8859-4\""
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/echo_content_type').post({
+        :body => {:a => :b}, :head => {'content-type' => ct}})
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response_header.status.should == 200
+          http.content_charset.should == Encoding.find('ISO-8859-4')
+          http.response_header["CONTENT_TYPE"].should == ct
+          EventMachine.stop
+        }
+      }
+    end
+
   end
 
   it "should complete a Location: with a relative path" do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/relative-location').get
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response_header['LOCATION'].should == 'http://127.0.0.1:8080/forwarded'
         EventMachine.stop
@@ -744,7 +794,7 @@ describe EventMachine::HttpRequest do
     EventMachine.run {
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8080/').post :file => 'spec/fixtures/google.ca'
 
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         http.response.should match('google')
         EventMachine.stop
@@ -760,7 +810,7 @@ describe EventMachine::HttpRequest do
         c.options[:body] = {:callback_run => 'yes'}
         client = c
       }
-      http.errback { failed }
+      http.errback { failed(http) }
       http.callback {
         client.should be_kind_of(EventMachine::HttpClient)
         http.response_header.status.should == 200
@@ -797,7 +847,7 @@ describe EventMachine::HttpRequest do
             :host => '127.0.0.1', :port => 8083
           }
 
-          http.errback { p http.inspect; failed }
+          http.errback { failed(http) }
           http.callback {
             http.response_header.status.should == 200
             http.response.should match('test')
@@ -813,7 +863,7 @@ describe EventMachine::HttpRequest do
             :host => '127.0.0.1', :port => 8083
           }
 
-          http.errback { p http.inspect; failed }
+          http.errback { failed(http) }
           http.callback {
             http.response_header.status.should == 200
             # The test proxy server gives the requested uri back in this header
@@ -833,7 +883,7 @@ describe EventMachine::HttpRequest do
             :query => { 'q' => 'test' }
           )
 
-          http.errback { p http.inspect; failed }
+          http.errback { failed(http) }
           http.callback {
             http.response_header.status.should == 200
             http.response.should match('test')
@@ -851,7 +901,7 @@ describe EventMachine::HttpRequest do
                                                                                :proxy => {:host => '127.0.0.1', :port => 8082, :use_connect => true}
           })
 
-          http.errback { p http.inspect; failed }
+          http.errback { failed(http) }
           http.callback {
             http.response_header.status.should == 200
             http.response.should == 'Hello, World!'
@@ -867,7 +917,7 @@ describe EventMachine::HttpRequest do
                                                                                 :body => "data", :proxy => {:host => '127.0.0.1', :port => 8082, :use_connect => true}
           })
 
-          http.errback { failed }
+          http.errback { failed(http) }
           http.callback {
             http.response_header.status.should == 200
             http.response.should match(/data/)
@@ -890,7 +940,7 @@ describe EventMachine::HttpRequest do
       EventMachine.run {
         http = EventMachine::HttpRequest.new('ws://127.0.0.1:8080/').get :timeout => 0
 
-        http.callback { failed }
+        http.callback { failed(http) }
         http.errback {
           http.response_header.status.should == 200
           EventMachine.stop
@@ -907,7 +957,7 @@ describe EventMachine::HttpRequest do
         end
 
         http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 1
-        http.errback { failed }
+        http.errback { failed(http) }
         http.callback {
           http.response_header.status.should == 101
           http.response_header['CONNECTION'].should match(/Upgrade/)
@@ -938,7 +988,7 @@ describe EventMachine::HttpRequest do
 
         EventMachine.add_timer(0.1) do
           http = EventMachine::HttpRequest.new('ws://127.0.0.1:8085/').get :timeout => 0
-          http.errback { failed }
+          http.errback { failed(http) }
           http.callback { http.response_header.status.should == 101 }
           http.stream {|msg|
             msg.should == messages[recieved.size]