em-http-request 1.0.0 → 1.0.1

data/lib/em-http/http_client_options.rb

@@ -28,6 +28,7 @@ class HttpClientOptions
   def follow_redirect?; @followed < @redirects; end
   def http_proxy?; @proxy && [nil, :http].include?(@proxy[:type]); end
   def ssl?; @uri.scheme == "https" || @uri.port == 443; end
+  def no_body?; @method == "HEAD"; end
 
   def set_uri(uri)
     uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)

data/lib/em-http/http_connection.rb

@@ -1,194 +1,199 @@
-module EventMachine
-
-  module HTTPMethods
-    def get    options = {}, &blk;  setup_request(:get,   options, &blk); end
-    def head   options = {}, &blk;  setup_request(:head,  options, &blk); end
-    def delete options = {}, &blk;  setup_request(:delete,options, &blk); end
-    def put    options = {}, &blk;  setup_request(:put,   options, &blk); end
-    def post   options = {}, &blk;  setup_request(:post,  options, &blk); end
-  end
-
-  class HttpStubConnection < Connection
-    include Deferrable
-    attr_reader :parent
-
-    def parent=(p)
-      @parent = p
-      @parent.conn = self
-    end
-
-    def receive_data(data)
-      @parent.receive_data data
-    end
-
-    def connection_completed
-      @parent.connection_completed
-    end
-
-    def unbind(reason=nil)
-      @parent.unbind(reason)
-    end
-  end
-
-  class HttpConnection
-    include HTTPMethods
-    include Socksify
-
-    attr_reader :deferred
-    attr_accessor :error, :connopts, :uri, :conn
-
-    def initialize
-      @deferred = true
-      @middleware = []
-    end
-
-    def conn=(c)
-      @conn = c
-      @deferred = false
-    end
-
-    def activate_connection(client)
-      begin
-        EventMachine.connect(@connopts.host, @connopts.port, HttpStubConnection) do |conn|
-          post_init
-
-          @deferred = false
-          @conn = conn
-
-          conn.parent = self
-          conn.pending_connect_timeout = @connopts.connect_timeout
-          conn.comm_inactivity_timeout = @connopts.inactivity_timeout
-        end
-
-        finalize_request(client)
-      rescue EventMachine::ConnectionError => e
-        #
-        # Currently, this can only fire on initial connection setup
-        # since #connect is a synchronous method. Hence, rescue the
-        # exception, and return a failed deferred which will immediately
-        # fail any client request.
-        #
-        # Once there is async-DNS, then we'll iterate over the outstanding
-        # client requests and fail them in order.
-        #
-        # Net outcome: failed connection will invoke the same ConnectionError
-        # message on the connection deferred, and on the client deferred.
-        #
-        client.close(e.message)
-      end
-    end
-
-    def setup_request(method, options = {}, c = nil)
-      c ||= HttpClient.new(self, HttpClientOptions.new(@uri, options, method))
-      @deferred ? activate_connection(c) : finalize_request(c)
-      c
-    end
-
-    def finalize_request(c)
-      @conn.callback { c.connection_completed }
-
-      middleware.each do |m|
-        c.callback &m.method(:response) if m.respond_to?(:response)
-      end
-
-      @clients.push c
-    end
-
-    def middleware
-      [HttpRequest.middleware, @middleware].flatten
-    end
-
-    def post_init
-      @clients = []
-      @pending = []
-
-      @p = Http::Parser.new
-      @p.header_value_type = :mixed
-      @p.on_headers_complete = proc do |h|
-        client.parse_response_header(h, @p.http_version, @p.status_code)
-      end
-
-      @p.on_body = proc do |b|
-        client.on_body_data(b)
-      end
-
-      @p.on_message_complete = proc do
-        if not client.continue?
-          c = @clients.shift
-          c.state = :finished
-          c.on_request_complete
-        end
-      end
-    end
-
-    def use(klass, *args, &block)
-      @middleware << klass.new(*args, &block)
-    end
-
-    def peer
-      Socket.unpack_sockaddr_in(@peer)[1] rescue nil
-    end
-
-    def receive_data(data)
-      begin
-        @p << data
-      rescue HTTP::Parser::Error => e
-        c = @clients.shift
-        c.nil? ? unbind : c.on_error(e.message)
-      end
-    end
-
-    def connection_completed
-      @peer = @conn.get_peername
-
-      if @connopts.proxy && @connopts.proxy[:type] == :socks5
-        socksify(client.req.uri.host, client.req.uri.port, *@connopts.proxy[:authorization]) { start }
-      else
-        start
-      end
-    end
-
-    def start
-      @conn.start_tls(@connopts.tls) if client && client.req.ssl?
-      @conn.succeed
-    end
-
-    def redirect(client)
-      @pending.push client
-    end
-
-    def unbind(reason)
-      @clients.map { |c| c.unbind(reason) }
-
-      if r = @pending.shift
-        @clients.push r
-
-        r.reset!
-        @p.reset!
-
-        begin
-          @conn.set_deferred_status :unknown
-          @conn.reconnect(r.req.host, r.req.port)
-          @conn.callback { r.connection_completed }
-        rescue EventMachine::ConnectionError => e
-          @clients.pop.close(e.message)
-        end
-      end
-    end
-    alias :close :unbind
-
-    def send_data(data)
-      @conn.send_data data
-    end
-
-    def stream_file_data(filename, args = {})
-      @conn.stream_file_data filename, args
-    end
-
-    private
-
-    def client
-      @clients.first
-    end
-  end
-end
+module EventMachine
+
+  module HTTPMethods
+    def get    options = {}, &blk;  setup_request(:get,   options, &blk); end
+    def head   options = {}, &blk;  setup_request(:head,  options, &blk); end
+    def delete options = {}, &blk;  setup_request(:delete,options, &blk); end
+    def put    options = {}, &blk;  setup_request(:put,   options, &blk); end
+    def post   options = {}, &blk;  setup_request(:post,  options, &blk); end
+  end
+
+  class HttpStubConnection < Connection
+    include Deferrable
+    attr_reader :parent
+
+    def parent=(p)
+      @parent = p
+      @parent.conn = self
+    end
+
+    def receive_data(data)
+      @parent.receive_data data
+    end
+
+    def connection_completed
+      @parent.connection_completed
+    end
+
+    def unbind(reason=nil)
+      @parent.unbind(reason)
+    end
+  end
+
+  class HttpConnection
+    include HTTPMethods
+    include Socksify
+
+    attr_reader :deferred
+    attr_accessor :error, :connopts, :uri, :conn
+
+    def initialize
+      @deferred = true
+      @middleware = []
+    end
+
+    def conn=(c)
+      @conn = c
+      @deferred = false
+    end
+
+    def activate_connection(client)
+      begin
+        EventMachine.bind_connect(@connopts.bind, @connopts.bind_port, @connopts.host, @connopts.port, HttpStubConnection) do |conn|
+          post_init
+
+          @deferred = false
+          @conn = conn
+
+          conn.parent = self
+          conn.pending_connect_timeout = @connopts.connect_timeout
+          conn.comm_inactivity_timeout = @connopts.inactivity_timeout
+        end
+
+        finalize_request(client)
+      rescue EventMachine::ConnectionError => e
+        #
+        # Currently, this can only fire on initial connection setup
+        # since #connect is a synchronous method. Hence, rescue the exception,
+        # and return a failed deferred which fail any client request at next
+        # tick.  We fail at next tick to keep a consistent API when the newly
+        # created HttpClient is failed. This approach has the advantage to
+        # remove a state check of @deferred_status after creating a new
+        # HttpRequest. The drawback is that users may setup a callback which we
+        # know won't be used.
+        #
+        # Once there is async-DNS, then we'll iterate over the outstanding
+        # client requests and fail them in order.
+        #
+        # Net outcome: failed connection will invoke the same ConnectionError
+        # message on the connection deferred, and on the client deferred.
+        #
+        EM.next_tick{client.close(e.message)}
+      end
+    end
+
+    def setup_request(method, options = {}, c = nil)
+      c ||= HttpClient.new(self, HttpClientOptions.new(@uri, options, method))
+      @deferred ? activate_connection(c) : finalize_request(c)
+      c
+    end
+
+    def finalize_request(c)
+      @conn.callback { c.connection_completed }
+
+      middleware.each do |m|
+        c.callback &m.method(:response) if m.respond_to?(:response)
+      end
+
+      @clients.push c
+    end
+
+    def middleware
+      [HttpRequest.middleware, @middleware].flatten
+    end
+
+    def post_init
+      @clients = []
+      @pending = []
+
+      @p = Http::Parser.new
+      @p.header_value_type = :mixed
+      @p.on_headers_complete = proc do |h|
+        client.parse_response_header(h, @p.http_version, @p.status_code)
+        :reset if client.req.no_body?
+      end
+
+      @p.on_body = proc do |b|
+        client.on_body_data(b)
+      end
+
+      @p.on_message_complete = proc do
+        if not client.continue?
+          c = @clients.shift
+          c.state = :finished
+          c.on_request_complete
+        end
+      end
+    end
+
+    def use(klass, *args, &block)
+      @middleware << klass.new(*args, &block)
+    end
+
+    def peer
+      Socket.unpack_sockaddr_in(@peer)[1] rescue nil
+    end
+
+    def receive_data(data)
+      begin
+        @p << data
+      rescue HTTP::Parser::Error => e
+        c = @clients.shift
+        c.nil? ? unbind(e.message) : c.on_error(e.message)
+      end
+    end
+
+    def connection_completed
+      @peer = @conn.get_peername
+
+      if @connopts.proxy && @connopts.proxy[:type] == :socks5
+        socksify(client.req.uri.host, client.req.uri.port, *@connopts.proxy[:authorization]) { start }
+      else
+        start
+      end
+    end
+
+    def start
+      @conn.start_tls(@connopts.tls) if client && client.req.ssl?
+      @conn.succeed
+    end
+
+    def redirect(client)
+      @pending.push client
+    end
+
+    def unbind(reason)
+      @clients.map { |c| c.unbind(reason) }
+
+      if r = @pending.shift
+        @clients.push r
+
+        r.reset!
+        @p.reset!
+
+        begin
+          @conn.set_deferred_status :unknown
+          @conn.reconnect(r.req.host, r.req.port)
+          @conn.callback { r.connection_completed }
+        rescue EventMachine::ConnectionError => e
+          @clients.pop.close(e.message)
+        end
+      end
+    end
+    alias :close :unbind
+
+    def send_data(data)
+      @conn.send_data data
+    end
+
+    def stream_file_data(filename, args = {})
+      @conn.stream_file_data filename, args
+    end
+
+    private
+
+      def client
+        @clients.first
+      end
+  end
+end

data/lib/em-http/http_connection_options.rb

@@ -1,5 +1,5 @@
 class HttpConnectionOptions
-  attr_reader :host, :port, :tls, :proxy
+  attr_reader :host, :port, :tls, :proxy, :bind, :bind_port
   attr_reader :connect_timeout, :inactivity_timeout
 
   def initialize(uri, options)
@@ -9,6 +9,11 @@ class HttpConnectionOptions
     @tls   = options[:tls] || options[:ssl] || {}
     @proxy = options[:proxy]
 
+    if bind = options[:bind]
+      @bind = bind[:host] || '0.0.0.0'
+      @bind_port = bind[:port] || 0
+    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))
 

data/lib/em-http/http_encoding.rb

@@ -7,7 +7,7 @@ module EventMachine
       if defined?(EscapeUtils)
         EscapeUtils.escape_url(s.to_s)
       else
-        s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/n) {
+        s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/) {
           '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
         }
       end
@@ -17,7 +17,7 @@ module EventMachine
       if defined?(EscapeUtils)
         EscapeUtils.unescape_url(s.to_s)
       else
-        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) {
+        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/) {
           [$1.delete('%')].pack('H*')
         }
       end

data/lib/em-http/http_header.rb

@@ -52,5 +52,9 @@ module EventMachine
     def location
       self[HttpClient::LOCATION]
     end
+
+    def [](key)
+      super(key) || super(key.upcase.gsub('-','_'))
+    end
   end
 end

data/lib/em-http/http_status_codes.rb

@@ -1,43 +1,57 @@
 module EventMachine
   module HttpStatus
     CODE = {
-      100 => 'Continue',
-      101 => 'Switching Protocols',
-      200 => 'OK',
-      201 => 'Created',
-      202 => 'Accepted',
-      203 => 'Non-Authoritative Information',
-      204 => 'No Content',
-      205 => 'Reset Content',
-      206 => 'Partial Content',
-      300 => 'Multiple Choices',
-      301 => 'Moved Permanently',
-      302 => 'Moved Temporarily',
-      303 => 'See Other',
-      304 => 'Not Modified',
-      305 => 'Use Proxy',
-      400 => 'Bad Request',
-      401 => 'Unauthorized',
-      402 => 'Payment Required',
-      403 => 'Forbidden',
-      404 => 'Not Found',
-      405 => 'Method Not Allowed',
-      406 => 'Not Acceptable',
-      407 => 'Proxy Authentication Required',
-      408 => 'Request Time-out',
-      409 => 'Conflict',
-      410 => 'Gone',
-      411 => 'Length Required',
-      412 => 'Precondition Failed',
-      413 => 'Request Entity Too Large',
-      414 => 'Request-URI Too Large',
-      415 => 'Unsupported Media Type',
-      500 => 'Internal Server Error',
-      501 => 'Not Implemented',
-      502 => 'Bad Gateway',
-      503 => 'Service Unavailable',
-      504 => 'Gateway Time-out',
-      505 => 'HTTP Version not supported'
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      102  => 'Processing',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      207  => 'Multi-Status',
+      226  => 'IM Used',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      306  => 'Reserved',
+      307  => 'Temporary Redirect',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Long',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      422  => 'Unprocessable Entity',
+      423  => 'Locked',
+      424  => 'Failed Dependency',
+      426  => 'Upgrade Required',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported',
+      506  => 'Variant Also Negotiates',
+      507  => 'Insufficient Storage',
+      510  => 'Not Extended'
     }
   end
 end