em-http-request 1.0.3 → 1.1.0

data/lib/em-http/http_connection_options.rb

@@ -18,7 +18,8 @@ class HttpConnectionOptions
     end
 
     uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
-    uri.port = (uri.scheme == "https" ? (uri.port || 443) : (uri.port || 80))
+    @https = uri.scheme == "https"
+    uri.port ||= (@https ? 443 : 80)
 
     if proxy = options[:proxy]
       @host = proxy[:host]
@@ -29,5 +30,15 @@ class HttpConnectionOptions
     end
   end
 
-  def http_proxy?; @proxy && [nil, :http].include?(@proxy[:type]); end
+  def http_proxy?
+    @proxy && (@proxy[:type] == :http || @proxy[:type].nil?) && !@https
+  end
+
+  def connect_proxy?
+    @proxy && (@proxy[:type] == :http || @proxy[:type].nil?) && @https
+  end
+
+  def socks_proxy?
+    @proxy && (@proxy[:type] == :socks5)
+  end
 end

data/lib/em-http/http_header.rb

@@ -25,7 +25,7 @@ module EventMachine
 
     # HTTP response status as an integer
     def status
-      Integer(http_status) rescue 0
+      @status ||= Integer(http_status) rescue 0
     end
 
     # Length of content as an integer, or nil if chunked/unspecified
@@ -59,5 +59,25 @@ module EventMachine
     def [](key)
       super(key) || super(key.upcase.gsub('-','_'))
     end
+
+    def informational?
+      100 <= status && 200 > status
+    end
+
+    def successful?
+      200 <= status && 300 > status
+    end
+
+    def redirection?
+      300 <= status && 400 > status
+    end
+
+    def client_error?
+      400 <= status && 500 > status
+    end
+
+    def server_error?
+      500 <= status && 600 > status
+    end
   end
 end

data/lib/em-http/middleware/digest_auth.rb

@@ -0,0 +1,112 @@
+module EventMachine
+  module Middleware
+    require 'digest'
+    require 'securerandom'
+
+    class DigestAuth
+      include EventMachine::HttpEncoding
+
+      attr_accessor :auth_digest, :is_digest_auth
+
+      def initialize(www_authenticate, opts = {})
+        @nonce_count = -1
+        @opts = opts
+        @digest_params = {
+            algorithm: 'MD5' # MD5 is the default hashing algorithm
+        }
+        if (@is_digest_auth = www_authenticate =~ /^Digest/)
+          get_params(www_authenticate)
+        end
+      end
+
+      def request(client, head, body)
+        # Allow HTTP basic auth fallback
+        if @is_digest_auth
+          head['Authorization'] = build_auth_digest(client.req.method, client.req.uri.path, @opts.merge(@digest_params))
+        else
+          head['Authorization'] = [@opts[:username], @opts[:password]]
+        end
+        [head, body]
+      end
+
+      def response(resp)
+        # If the server responds with the Authentication-Info header, set the nonce to the new value
+        if @is_digest_auth && (authentication_info = resp.response_header['Authentication-Info'])
+          authentication_info =~ /nextnonce="?(.*?)"?(,|\z)/
+          @digest_params[:nonce] = $1
+        end
+      end
+
+      def build_auth_digest(method, uri, params = nil)
+        params = @opts.merge(@digest_params) if !params
+        nonce_count = next_nonce
+
+        user = unescape params[:username]
+        password = unescape params[:password]
+
+        splitted_algorithm = params[:algorithm].split('-')
+        sess = "-sess" if splitted_algorithm[1]
+        raw_algorithm = splitted_algorithm[0]
+        if %w(MD5 SHA1 SHA2 SHA256 SHA384 SHA512 RMD160).include? raw_algorithm
+          algorithm = eval("Digest::#{raw_algorithm}")
+        else
+          raise "Unknown algorithm: #{raw_algorithm}"
+        end
+        qop = params[:qop]
+        cnonce = make_cnonce if qop or sess
+        a1 = if sess
+          [
+            algorithm.hexdigest("#{params[:username]}:#{params[:realm]}:#{params[:password]}"),
+            params[:nonce],
+            cnonce,
+            ].join ':'
+        else
+          "#{params[:username]}:#{params[:realm]}:#{params[:password]}"
+        end
+        ha1 = algorithm.hexdigest a1
+        ha2 = algorithm.hexdigest "#{method}:#{uri}"
+
+        request_digest = [ha1, params[:nonce]]
+        request_digest.push(('%08x' % @nonce_count), cnonce, qop) if qop
+        request_digest << ha2
+        request_digest = request_digest.join ':'
+        header = [
+          "Digest username=\"#{params[:username]}\"",
+          "realm=\"#{params[:realm]}\"",
+          "algorithm=#{raw_algorithm}#{sess}",
+          "uri=\"#{uri}\"",
+          "nonce=\"#{params[:nonce]}\"",
+          "response=\"#{algorithm.hexdigest(request_digest)[0, 32]}\"",
+        ]
+        if params[:qop]
+          header << "qop=#{qop}"
+          header << "nc=#{'%08x' % @nonce_count}"
+          header << "cnonce=\"#{cnonce}\""
+        end
+        header << "opaque=\"#{params[:opaque]}\"" if params.key? :opaque
+        header.join(', ')
+      end
+
+      # Process the WWW_AUTHENTICATE header to get the authentication parameters
+      def get_params(www_authenticate)
+        www_authenticate.scan(/(\w+)="?(.*?)"?(,|\z)/).each do |match|
+          @digest_params[match[0].to_sym] = match[1]
+        end
+      end
+
+      # Generate a client nonce
+      def make_cnonce
+        Digest::MD5.hexdigest [
+          Time.now.to_i,
+          $$,
+          SecureRandom.random_number(2**32),
+        ].join ':'
+      end
+
+      # Keep track of the nounce count
+      def next_nonce
+        @nonce_count += 1
+      end
+    end
+  end
+end

data/lib/em-http/middleware/oauth2.rb

@@ -0,0 +1,28 @@
+module EventMachine
+  module Middleware
+    class OAuth2
+      include EM::HttpEncoding
+      attr_accessor :access_token
+
+      def initialize(opts={})
+        self.access_token = opts[:access_token] or raise "No :access_token provided"
+      end
+
+      def request(client, head, body)
+        uri = client.req.uri.dup
+        update_uri! uri
+        client.req.set_uri uri
+
+        [head, body]
+      end
+
+      def update_uri!(uri)
+        if uri.query.nil?
+          uri.query = encode_param(:access_token, access_token)
+        else
+          uri.query += "&#{encode_param(:access_token, access_token)}"
+        end
+      end
+    end
+  end
+end

data/lib/em-http/request.rb

@@ -3,6 +3,7 @@ module EventMachine
     @middleware = []
 
     def self.new(uri, options={})
+      uri = uri.clone
       connopt = HttpConnectionOptions.new(uri, options)
 
       c = HttpConnection.new

data/lib/em-http/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   class HttpRequest
-    VERSION = "1.0.3"
+    VERSION = "1.1.0"
   end
 end

data/spec/client_spec.rb

@@ -453,6 +453,7 @@ describe EventMachine::HttpRequest do
       http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/timeout', :inactivity_timeout => 0.1).get
 
       http.errback {
+        http.error.should == Errno::ETIMEDOUT
         (Time.now.to_i - t).should <= 1
         EventMachine.stop
       }
@@ -682,9 +683,6 @@ describe EventMachine::HttpRequest do
   end
 
   it "should get the body without Content-Length" do
-    pending "blocked on new http_parser.rb release"
-    # https://github.com/igrigorik/em-http-request/issues/168
-
     EventMachine.run {
       @s = StubServer.new("HTTP/1.1 200 OK\r\n\r\nFoo")
 
@@ -763,15 +761,17 @@ describe EventMachine::HttpRequest do
 
   it "should reconnect if connection was closed between requests" do
     EventMachine.run {
-      conn = EM::HttpRequest.new('http://127.0.0.1:8090/', :inactivity_timeout => 0.5)
-      req = conn.get :keepalive => true
+      conn = EM::HttpRequest.new('http://127.0.0.1:8090/')
+      req = conn.get
 
       req.callback do
-        EM.add_timer(1) do
-          req = conn.get
+        conn.close('client closing connection')
 
+        EM.next_tick do
+          req = conn.get :path => "/gzip"
           req.callback do
             req.response_header.status.should == 200
+            req.response.should match('compressed')
             EventMachine.stop
           end
         end
@@ -779,6 +779,23 @@ describe EventMachine::HttpRequest do
     }
   end
 
+  it "should report error if connection was closed by server on client keepalive requests" do
+    EventMachine.run {
+      conn = EM::HttpRequest.new('http://127.0.0.1:8090/')
+      req = conn.get :keepalive => true
+
+      req.callback do
+        req = conn.get
+
+        req.callback { failed(http) }
+        req.errback do
+          req.error.should match('connection closed by server')
+          EventMachine.stop
+        end
+      end
+    }
+  end
+
   it 'should handle malformed Content-Type header repetitions' do
     EventMachine.run {
       response =<<-HTTP.gsub(/^ +/, '').strip
@@ -830,4 +847,42 @@ describe EventMachine::HttpRequest do
       }
     }
   end
+
+  context "User-Agent" do
+    it 'should default to "EventMachine HttpClient"' do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo-user-agent').get
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response.should == '"EventMachine HttpClient"'
+          EventMachine.stop
+        }
+      }
+    end
+
+    it 'should keep header if given empty string' do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo-user-agent').get(:head => { 'user-agent'=>'' })
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response.should == '""'
+          EventMachine.stop
+        }
+      }
+    end
+
+    it 'should ommit header if given nil' do
+      EventMachine.run {
+        http = EventMachine::HttpRequest.new('http://127.0.0.1:8090/echo-user-agent').get(:head => { 'user-agent'=>nil })
+
+        http.errback { failed(http) }
+        http.callback {
+          http.response.should == 'nil'
+          EventMachine.stop
+        }
+      }
+    end
+  end
 end

data/spec/digest_auth_spec.rb

@@ -0,0 +1,48 @@
+require 'helper'
+
+$: << 'lib' << '../lib'
+
+require 'em-http/middleware/digest_auth'
+
+describe 'Digest Auth Authentication header generation' do
+  before :each do
+    @reference_header = 'Digest username="digest_username", realm="DigestAuth_REALM", algorithm=MD5, uri="/", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", response="96829962ffc31fa2852f86dc7f9f609b", opaque="BzdNK3gsJ2ixTrBJ"'
+  end
+
+  it 'should generate the correct header'  do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should == @reference_header
+  end
+
+  it 'should not generate the same header for a different user' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg5", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+  it 'should not generate the same header if the nounce changes' do
+    www_authenticate = 'Digest realm="DigestAuth_REALM", nonce="MDAxMzQzNzQwNjA2OmRjZjAyZDY3YWMyMWVkZGQ4OWE2Nzg3ZTY3YTNlMjg6", opaque="BzdNK3gsJ2ixTrBJ", stale=false, algorithm=MD5'
+
+    params = {
+      username: 'digest_username_2',
+      password: 'digest_password'
+    }
+
+    middleware = EM::Middleware::DigestAuth.new(www_authenticate, params)
+    middleware.build_auth_digest('GET', '/').should_not == @reference_header
+  end
+
+end

data/spec/external_spec.rb

@@ -17,7 +17,7 @@ requires_connection do
 
     it "should follow redirect to https and initiate the handshake" do
       EventMachine.run {
-        http = EventMachine::HttpRequest.new('http://analytics.postrank.com/').get :redirects => 5
+        http = EventMachine::HttpRequest.new('http://github.com/').get :redirects => 5
 
         http.errback { failed(http) }
         http.callback {
@@ -31,7 +31,7 @@ requires_connection do
       EventMachine.run {
 
         # digg.com uses chunked encoding
-        http = EventMachine::HttpRequest.new('http://digg.com/news').get
+        http = EventMachine::HttpRequest.new('http://www.httpwatch.com/httpgallery/chunked/').get
 
         http.errback { failed(http) }
         http.callback {

data/spec/gzip_spec.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+describe EventMachine::HttpDecoders::GZip do
+
+  let(:compressed) {
+    compressed = ["1f8b08089668a6500003686900cbc8e402007a7a6fed03000000"].pack("H*")
+  }
+
+  it "should extract the stream of a vanilla gzip" do
+    header = EventMachine::HttpDecoders::GZipHeader.new
+    stream = header.extract_stream(compressed)
+
+    stream.unpack("H*")[0].should eq("cbc8e402007a7a6fed03000000")
+  end
+
+  it "should decompress a vanilla gzip" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << compressed
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a vanilla gzip file byte by byte" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    compressed.each_char do |byte|
+      gz << byte
+    end
+
+    gz.finalize!
+
+    decompressed.should eq("hi\n")
+  end
+
+  it "should decompress a large file" do
+    decompressed = ""
+
+    gz = EventMachine::HttpDecoders::GZip.new do |data|
+      decompressed << data
+    end
+
+    gz << File.read(File.dirname(__FILE__) + "/fixtures/gzip-sample.gz")
+
+    gz.finalize!
+
+    decompressed.size.should eq(32907)
+  end
+
+  it "should fail with a DecoderError if not a gzip file" do
+    not_a_gzip = ["1f8c08089668a650000"].pack("H*")
+    header = EventMachine::HttpDecoders::GZipHeader.new
+
+    lambda {
+      header.extract_stream(not_a_gzip)
+    }.should raise_exception(EventMachine::HttpDecoders::DecoderError)
+  end
+
+end