em-http-request 0.2.7 → 0.2.9

data/lib/em-http-request.rb

@@ -0,0 +1 @@
+require 'em-http'

data/lib/em-http.rb

@@ -3,14 +3,17 @@
 # You can redistribute this under the terms of the Ruby license
 # See file LICENSE for details
 #++
-                          
-require 'eventmachine'    
+
+require 'eventmachine'
 
 require File.dirname(__FILE__) + '/http11_client'
 require File.dirname(__FILE__) + '/em_buffer'
 
 require File.dirname(__FILE__) + '/em-http/core_ext/hash'
+require File.dirname(__FILE__) + '/em-http/core_ext/bytesize'
+
 require File.dirname(__FILE__) + '/em-http/client'
 require File.dirname(__FILE__) + '/em-http/multi'
 require File.dirname(__FILE__) + '/em-http/request'
-require File.dirname(__FILE__) + '/em-http/decoders'
+require File.dirname(__FILE__) + '/em-http/decoders'
+require File.dirname(__FILE__) + '/em-http/http_options'

data/lib/em-http/client.rb

@@ -20,12 +20,12 @@ module EventMachine
 
     # The status code (as a string!)
     attr_accessor :http_status
-    
+
     # E-Tag
     def etag
       self["ETag"]
     end
-    
+
     def last_modified
       time = self["Last-Modified"]
       Time.parse(time) if time
@@ -39,7 +39,7 @@ module EventMachine
     # 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
+                           (s =~ /^(\d+)$/)) ? $1.to_i : nil
     end
 
     # Cookie header from the server
@@ -104,7 +104,11 @@ module EventMachine
     # you include port 80 then further redirects will tack on the :80 which is
     # annoying.
     def encode_host
-      @uri.host + (@uri.port != 80 ? ":#{@uri.port}" : "")
+      if @uri.port == 80 || @uri.port == 443
+        return @uri.host
+      else
+        @uri.host + ":#{@uri.port}"
+      end
     end
 
     def encode_request(method, path, query, uri_query)
@@ -147,7 +151,7 @@ module EventMachine
         FIELD_ENCODING % [k, ["Basic", Base64.encode64(v.join(":")).chomp].join(" ")]
       else
         encode_field(k,v)
-      end      
+      end
     end
 
     def encode_headers(head)
@@ -155,10 +159,10 @@ module EventMachine
         # Munge keys from foo-bar-baz to Foo-Bar-Baz
         key = key.split('-').map { |k| k.to_s.capitalize }.join('-')
         result << case key
-        when 'Authorization', 'Proxy-authorization'          
-          encode_auth(key, value)
-        else
-          encode_field(key, value)
+          when 'Authorization', 'Proxy-authorization'
+            encode_auth(key, value)
+          else
+            encode_field(key, value)
         end
       end
     end
@@ -186,7 +190,7 @@ module EventMachine
     CRLF="\r\n"
 
     attr_accessor :method, :options, :uri
-    attr_reader   :response, :response_header, :errors
+    attr_reader   :response, :response_header, :error, :redirects, :last_effective_url
 
     def post_init
       @parser = HttpClientParser.new
@@ -194,34 +198,36 @@ module EventMachine
       @chunk_header = HttpChunkHeader.new
       @response_header = HttpResponseHeader.new
       @parser_nbytes = 0
+      @redirects = 0
       @response = ''
-      @errors = ''
+      @error = ''
+      @last_effective_url = nil
       @content_decoder = nil
       @stream = nil
+      @disconnect = nil
       @state = :response_header
     end
 
     # start HTTP request once we establish connection to host
-    def connection_completed              
+    def connection_completed
       # if connecting to proxy, then first negotiate the connection
-      # to intermediate server and wait for 200 response 
-      if @options[:proxy] and @state == :response_header 
+      # to intermediate server and wait for 200 response
+      if @options[:proxy] and @state == :response_header
         @state = :response_proxy
         send_request_header
-        
+
         # if connecting via proxy, then state will be :proxy_connected,
         # indicating successful tunnel. from here, initiate normal http
         # exchange
       else
         @state = :response_header
-                      
         ssl = @options[:tls] || @options[:ssl] || {}
         start_tls(ssl) if @uri.scheme == "https" or @uri.port == 443
         send_request_header
         send_request_body
       end
     end
-    
+
     # request is done, invoke the callback
     def on_request_complete
       begin
@@ -229,13 +235,14 @@ module EventMachine
       rescue HttpDecoders::DecoderError
         on_error "Content-decoder error"
       end
-      unbind
+
+      close_connection
     end
-    
+
     # request failed, invoke errback
     def on_error(msg, dns_error = false)
-      @errors = msg
-      
+      @error = msg
+
       # no connection signature on DNS failures
       # fail the connection directly
       dns_error == true ? fail(self) : unbind
@@ -246,6 +253,11 @@ module EventMachine
       @stream = blk
     end
 
+    # assign disconnect callback for websocket
+    def disconnect(&blk)
+      @disconnect = blk
+    end
+
     # raw data push from the client (WebSocket) should
     # only be invoked after handshake, otherwise it will
     # inject data into the header exchange
@@ -269,23 +281,13 @@ module EventMachine
         end
       end
     end
-    
-    def normalize_uri
-      @normalized_uri ||= begin
-        uri = @uri.dup
-        encoded_query = encode_query(@uri.path, @options[:query], @uri.query)
-        path, query = encoded_query.split("?", 2)
-        uri.query = query unless encoded_query.empty?
-        uri.path  = path
-        uri
-      end
-    end
 
     def websocket?; @uri.scheme == 'ws'; end
-    
+
     def send_request_header
       query   = @options[:query]
       head    = @options[:head] ? munge_header_keys(@options[:head]) : {}
+      file    = @options[:file]
       body    = normalize_body
       request_header = nil
 
@@ -296,13 +298,16 @@ module EventMachine
         head = proxy[:head] ? munge_header_keys(proxy[:head]) : {}
         head['proxy-authorization'] = proxy[:authorization] if proxy[:authorization]
         request_header = HTTP_REQUEST_HEADER % ['CONNECT', "#{@uri.host}:#{@uri.port}"]
-        
+
       elsif websocket?
         head['upgrade'] = 'WebSocket'
         head['connection'] = 'Upgrade'
         head['origin'] = @options[:origin] || @uri.host
-        
+
       else
+        # Set the Content-Length if file is given
+        head['content-length'] = File.size(file) if file
+
         # Set the Content-Length if body is given
         head['content-length'] =  body.bytesize if body
 
@@ -323,6 +328,9 @@ module EventMachine
       # Set the User-Agent if it hasn't been specified
       head['user-agent'] ||= "EventMachine HttpClient"
 
+      # Record last seen URL
+      @last_effective_url = @uri
+
       # Build the request headers
       request_header ||= encode_request(@method, @uri.path, query, @uri.query)
       request_header << encode_headers(head)
@@ -331,9 +339,13 @@ module EventMachine
     end
 
     def send_request_body
-      return unless @options[:body]
-      body = normalize_body
-      send_data body
+      if @options[:body]
+        body = normalize_body
+        send_data body
+        return
+      elsif @options[:file]
+        stream_file_data @options[:file], :http_chunks => false
+      end
     end
 
     def receive_data(data)
@@ -363,12 +375,28 @@ module EventMachine
     end
 
     def unbind
-      if @state == :finished || (@state == :body && @bytes_remaining.nil?)
-        succeed(self)
+      if @last_effective_url != @uri and @redirects < @options[:redirects]
+        # update uri to redirect location if we're allowed to traverse deeper
+        @uri = @last_effective_url
+
+        # keep track of the depth of requests we made in this session
+        @redirects += 1
+
+        # swap current connection and reassign current handler
+        req = HttpOptions.new(@method, @uri, @options)
+        reconnect(req.host, req.port)
+
+        @response_header = HttpResponseHeader.new
+        @state = :response_header
+        @data.clear
       else
-        fail(self)
+        if @state == :finished || (@state == :body && @bytes_remaining.nil?)
+          succeed(self)
+        else
+          @disconnect.call(self) if @state == :websocket and @disconnect
+          fail(self)
+        end
       end
-      close_connection
     end
 
     #
@@ -377,25 +405,25 @@ module EventMachine
 
     def dispatch
       while case @state
-        when :response_proxy
-          parse_response_proxy
-        when :response_header
-          parse_response_header
-        when :chunk_header
-          parse_chunk_header
-        when :chunk_body
-          process_chunk_body
-        when :chunk_footer
-          process_chunk_footer
-        when :response_footer
-          process_response_footer
-        when :body
-          process_body
-        when :websocket
-          process_websocket
-        when :finished, :invalid
-          break
-        else raise RuntimeError, "invalid state: #{@state}"
+          when :response_proxy
+            parse_response_header
+          when :response_header
+            parse_response_header
+          when :chunk_header
+            parse_chunk_header
+          when :chunk_body
+            process_chunk_body
+          when :chunk_footer
+            process_chunk_footer
+          when :response_footer
+            process_response_footer
+          when :body
+            process_body
+          when :websocket
+            process_websocket
+          when :finished, :invalid
+            break
+          else raise RuntimeError, "invalid state: #{@state}"
         end
       end
     end
@@ -419,28 +447,6 @@ module EventMachine
 
       true
     end
-    
-    # TODO: refactor with parse_response_header
-    def parse_response_proxy
-      return false unless parse_header(@response_header)
-
-      unless @response_header.http_status and @response_header.http_reason
-        @state = :invalid
-        on_error "no HTTP response"
-        return false
-      end
-          
-      # when a successfull tunnel is established, the proxy responds with a
-      # 200 response code. from here, the tunnel is transparent.
-      if @response_header.http_status.to_i == 200
-        @response_header = HttpResponseHeader.new
-        connection_completed
-      else
-        @state = :invalid
-        on_error "proxy not accessible"
-        return false
-      end
-    end
 
     def parse_response_header
       return false unless parse_header(@response_header)
@@ -451,14 +457,32 @@ module EventMachine
         return false
       end
 
+      if @state == :response_proxy
+        # when a successfull tunnel is established, the proxy responds with a
+        # 200 response code. from here, the tunnel is transparent.
+        if @response_header.http_status.to_i == 200
+          @response_header = HttpResponseHeader.new
+          connection_completed
+          return true
+        else
+          @state = :invalid
+          on_error "proxy not accessible"
+          return false
+        end
+      end
+
       # correct location header - some servers will incorrectly give a relative URI
       if @response_header.location
         begin
-          location = Addressable::URI.parse @response_header.location
+          location = Addressable::URI.parse(@response_header.location)
           if location.relative?
-            location = (@uri.join location).to_s
-            @response_header[LOCATION] = location
+            location = @uri.join(location)
+            @response_header[LOCATION] = location.to_s
           end
+
+          # store last url on any sign of redirect
+          @last_effective_url = location
+
         rescue
           on_error "Location header format error"
           return false
@@ -468,7 +492,7 @@ module EventMachine
       # shortcircuit on HEAD requests
       if @method == "HEAD"
         @state = :finished
-        on_request_complete
+        unbind
       end
 
       if websocket?
@@ -478,7 +502,7 @@ module EventMachine
         else
           fail "websocket handshake failed"
         end
-       
+
       elsif @response_header.chunked_encoding?
         @state = :chunk_header
       elsif @response_header.content_length
@@ -496,7 +520,7 @@ module EventMachine
           on_error "Content-decoder error"
         end
       end
-      
+
       true
     end
 
@@ -610,7 +634,7 @@ module EventMachine
       end
 
       # store remainder if message boundary has not yet
-      # been recieved
+      # been received
       @data << buffer if not buffer.empty?
 
       false

data/lib/em-http/core_ext/bytesize.rb

@@ -0,0 +1,6 @@
+# bytesize was introduced in 1.8.7+
+if RUBY_VERSION <= "1.8.6"
+  class String
+    def bytesize; self.size; end
+  end
+end

data/lib/em-http/http_options.rb

@@ -0,0 +1,32 @@
+class HttpOptions
+  attr_reader :uri, :method, :host, :port, :options
+
+  def initialize(method, uri, options)
+    raise ArgumentError, "invalid request path" unless /^\// === uri.path
+
+    @options = options
+    @method = method.to_s.upcase
+    @uri = uri
+
+    if proxy = options[:proxy]
+      @host = proxy[:host]
+      @port = proxy[:port]
+    else
+      @host = uri.host
+      @port = uri.port
+    end
+
+    @options[:timeout]    ||= 10  # default connect & inactivity timeouts
+    @options[:redirects]  ||= 0   # default number of redirects to follow
+
+    # Make sure the ports are set as Addressable::URI doesn't
+    # set the port if it isn't there
+    if uri.scheme == "https"
+      @uri.port ||= 443
+      @port     ||= 443
+    else
+      @uri.port ||= 80
+      @port     ||= 80
+    end
+  end
+end