strobe 0.1.6 → 0.2.0.beta.1

data/lib/strobe/middleware/proxy.rb

@@ -1,155 +1,365 @@
-require 'thread'
-require 'net/http'
+require 'em-http'
 
 module Strobe
-  class Middleware::Proxy
-
-    # A wrapper around the Net/HTTP response body
-    # that allows rack to stream the result down
-    class Body
-      def initialize(queue, options = {})
-        @queue = queue
-        @options = options
+  module Middleware
+    class Proxy
+      PROXY_PATH = %r[/_strobe/proxy/([^/]+)(/.*)?$]
+
+      def self.proxy_response?(status, hdrs)
+        status == 302 && hdrs.any? { |k,v| k =~ /x-strobe-location/i }
       end
 
-      def each
-        while chunk = @queue.pop
-          if Exception === chunk
-            raise chunk
-          else
-            yield prepare_chunk(chunk)
-          end
+      def self.strobe_redirect(is_head, _hdrs, body, callback)
+        hdrs = {}
+        _hdrs.each { |k,v| hdrs[k.to_s.downcase] = v }
+
+        location = hdrs['x-strobe-location']
+        env      = redirect_env(is_head, hdrs, body, callback)
+        options  = redirect_opts(hdrs)
+
+        request  = ProxyRequest.new(env, location, options)
+
+        request.handle!
+      end
+
+      def self.redirect_env(is_head, hdrs, body, callback)
+        env = {}
+
+        parse_header_list(hdrs['x-strobe-forward-headers']).each do |from, to|
+          env[rackify(to)] = hdrs[from]
         end
 
-        yield "0\r\n\r\n" if chunked?
+        env['REQUEST_METHOD']    = hdrs['x-strobe-redirect-method']
+        env['REQUEST_METHOD']  ||= is_head ? 'HEAD' : 'GET'
+        env['async.callback']    = callback
+        env['rack.input']        = StringIO.new(body.join)
+        env
       end
 
-      def prepare_chunk(chunk)
-        if chunked?
-          size = chunk.respond_to?(:bytesize) ? chunk.bytesize : chunk.length
-          "#{size.to_s(16)}\r\n#{chunk}\r\n"
-        else
-          chunk
+      def self.redirect_opts(hdrs)
+        extra_headers = {}
+        block_headers = []
+
+        parse_header_list(hdrs['x-strobe-add-headers']).each do |from, to|
+          extra_headers[to] = hdrs[from]
+        end
+
+        parse_header_list(hdrs['x-strobe-block-headers']).each do |key, _|
+          block_headers << key
+        end
+
+        { :extra_headers => extra_headers,
+          :block_headers => block_headers,
+          :block_cookies => true }
+      end
+
+      def self.parse_header_list(str)
+        return {} unless str
+        parsed = {}
+
+        str.downcase.split(',').each do |item|
+          from, to, _ = item.split('=')
+          to ||= from
+          parsed[from.strip] = to.strip
         end
+
+        parsed
       end
 
-      def chunked?
-        @options[:chunked]
+      def self.rackify(key)
+        key = key.to_s.gsub('-', '_').upcase
+        key = "HTTP_#{key}" unless %w(REQUEST_METHOD
+                                      CONTENT_LENGTH
+                                      QUERY_STRING
+                                      SERVER_NAME
+                                      SERVER_PORT
+                                      PATH_INFO
+                                      SCRIPT_NAME).include?(key)
+        key
       end
-    end
 
-    def initialize(app)
-      @app = app
-    end
+      def initialize(app, opts = {})
+        @app, @opts = app, opts
+      end
 
-    def redirect?(status)
-      status >= 300 && status < 400
-    end
+      def call(env)
+        if env['PATH_INFO'] =~ PROXY_PATH
+          scheme     = scheme_from_env(env)
+          host, port = $1.split(':')
+          path       = $2 || '/'
+          port       = (port || 80).to_i
 
-    def call(env)
-      if env['PATH_INFO'] =~ proxy_path
-        host, port = $1.split(':')
-        path = $2 || '/'
+          url = "#{scheme}://#{host}"
 
-        running = true
-        while running
-          queue = run_request(env, host, ( port || 80 ).to_i, path)
+          if port
+            if (scheme == 'http' && port != 80) || (scheme == 'https' && port != 443)
+              url << ":#{port}"
+            end
+          end
 
-          msg = queue.pop
-          status = msg[0].to_i
+          url << path
 
-          if redirect?(status) && location = msg[1]['location']
-            uri = URI.parse(location)
-            host, port, path = uri.host, uri.port, uri.path
-          else
-            running = false
+          if !env['QUERY_STRING'].empty?
+            url << "?#{env['QUERY_STRING']}"
           end
-        end
 
-        if Exception === msg
-          raise msg
+          request = ProxyRequest.new(env, url, @opts)
+          request.handle!
+
+          throw :async
         else
-          [ msg[0], msg[1], Body.new(queue, :chunked => chunked?(msg[1])) ]
+          @app.call(env)
         end
-      else
-        @app.call(env)
       end
-    end
 
-  private
+      def scheme_from_env(env)
+        env['HTTP_X_STROBE_PROXY_PROTOCOL'] || env['rack.url_scheme']
+      end
 
-    def chunked?(headers)
-      headers["transfer-encoding"] == "chunked"
-    end
+      class ProxyRequest
+        KEEP = [ 'CONTENT_LENGTH', 'CONTENT_TYPE' ]
 
-    def proxy_path
-      %r[/_strobe/proxy/([^/]+)(/.*)?$]
-    end
+        def self.x_strobe_proxy(url, env, opts)
+          request = ProxyRequest.new(env, url, opts)
 
-    KEEP = [ 'CONTENT_LENGTH', 'CONTENT_TYPE', 'Connection' ]
+          request.handle!
 
-    def run_request(env, host, port, path)
-      queue = Queue.new
+          throw :async
+        end
 
-      if env['CONTENT_LENGTH'] || env['HTTP_TRANSFER_ENCODING']
-        body = env['rack.input']
-      end
+        class DeferrableBody
+          include EM::Deferrable
 
-      env["Connection"] = "keep-alive"
+          def initialize(request)
+            @request = request
+          end
 
-      unless env['QUERY_STRING'].blank?
-        path += "?#{env['QUERY_STRING']}"
-      end
+          def call(body)
+            Array(body).each do |chunk|
+              chunk = prepare_chunk(chunk)
+              @callback.call(chunk)
+            end
+          end
 
-      http = Net::HTTP.new(host, port)
-      http.read_timeout = 60
-      http.open_timeout = 60
+          def prepare_chunk(chunk)
+            if @request.chunked_response_body?
+              size = chunk.respond_to?(:bytesize) ? chunk.bytesize : chunk.length
+              "#{size.to_s(16)}\r\n#{chunk}\r\n"
+            else
+              # Thin doesn't like null bodies
+              chunk || ''
+            end
+          end
 
-      request = Net::HTTPGenericRequest.new(
-        env['REQUEST_METHOD'], !!body, true, path,
-        env_to_http_headers(env))
+          def each(&blk)
+            @callback = blk
+          end
+        end
+
+        attr_reader :url, :response_headers
+
+        def initialize(env, url, opts = {})
+          @env  = env
+          @url  = url
+          @opts = opts
 
-      request.body_stream = body if body
+          # STATE options
+          @http      = nil
+          @body      = nil
+          @redirect  = false
+          @responded = false
+        end
 
-      Thread.new do
-        begin
-          http.request(request) do |response|
-            hdrs = {}
-            response.each_header do |name, val|
-              hdrs[name] = val
+        def handle!
+          EM.next_tick do
+            begin
+              conn = EM::HttpRequest.new(url)
+
+              @http = case request_method
+              when 'GET'    then conn.get    request_options
+              when 'POST'   then conn.post   request_options
+              when 'PUT'    then conn.put    request_options
+              when 'DELETE' then conn.delete request_options
+              when 'HEAD'   then conn.head   request_options
+              else raise "Unknown HTTP method '#{request_method}'"
+              end
+
+              @http.headers  { |hdrs| handle_headers(hdrs) }
+              @http.stream   { |data| handle_chunk(data)   }
+              @http.callback { handle_done  }
+              @http.errback  { handle_error }
             end
+          end
+        end
 
-            queue << [ response.code.to_i, hdrs ]
+        def handle_headers(hdrs)
+          headers = {}
 
-            response.read_body do |chunk|
-              queue << chunk
+          hdrs.each do |key, value|
+            key = headerize(key)
+            if key == "Set-Cookie"
+              headers["Set-Cookie"] = handle_cookies(value)
+            else
+              headers[key] = value
             end
+          end
+
+          # Let's simplify things by always chunking the response
+          # Also, responses will never be compressed
+          headers.delete("Content-Length")
+          headers.delete("Content-Encoding")
+          headers['Transfer-Encoding'] = 'chunked'
+
+          @redirect = headers['Location'] && @http.req.follow_redirect?
 
-            queue << nil
+          unless @redirect
+            headers = headers.select { |k,v| !block_headers.include?(k.downcase) }
+            headers = headers.merge(extra_headers)
+            @response_headers = ::Rack::Utils::HeaderHash.new(headers)
+            @body = DeferrableBody.new(self) if has_response_body?
+            respond(@http.response_header.status, @response_headers)
           end
-        rescue Exception => e
-          queue << e
         end
-      end
 
-      queue
-    end
+        def handle_cookies(value)
+          cookies = []
+          uri = URI.parse(url)
+
+          case value
+          when Array then value.each { |c| cookies << c }
+          when Hash  then value.each { |_, c| cookies << c }
+          else            cookies << value
+          end
+
+          result = cookies.flatten.join(",").split(/,(?=[^;,]*=)|,$/).map do |cookie|
+            parts = cookie.split(/;+/).map!(&:strip)
 
-    def env_to_http_headers(env)
-      {}.tap do |hdrs|
-        env.each do |name, val|
-          next unless name.is_a?(String)
-          next if     name == 'HTTP_HOST'
-          next unless name =~ /^HTTP_/ || KEEP.include?(name)
+            # delete domain and extract path from the cookie
+            parts.delete_if { |p| p.start_with?("domain=") }
+            path_part = parts.find { |p| p.start_with?("path=") }.tap { |p| parts.delete(p) }
+
+            if (uri.scheme == "http" && uri.port != 80) || (uri.scheme == "https" && uri.port != 443)
+              domain = "#{uri.host}:#{uri.port}"
+            else
+              domain = uri.host
+            end
 
-          hdrs[ headerize(name) ] = val
+            path = path_part.to_s.split("=", 2)[1] || "/"
+
+            # add a new path
+            parts << "path=/_strobe/proxy/#{domain.sub(/^[.]/, "")}#{path.sub(/\/$/, "")}"
+
+            parts.join("; ")
+          end
+
+          result.join(", ")
+        end
+
+        def handle_chunk(chunk)
+          return if redirect?
+          @body.call(chunk) if @body
+        end
+
+        def handle_done
+          if has_response_body? && @body
+            @body.call ['']
+            @body.succeed
+          end
+        end
+
+        def handle_error
+          unless @responded
+            status  = @http.response_header.status
+            headers = { "Connection" => "close", "Content-Length" => "0" }
+            respond(status, headers, "")
+          end
+        end
+
+        def respond(status, hdrs, body = @body)
+          @responded = true
+          @env['async.callback'].call([status, hdrs, body || ['']])
+        end
+
+        def redirect?
+          @redirect
+        end
+
+        def has_response_body?
+          status = @http.response_header.status
+          status >= 200 && status != 204 && status != 304
+        end
+
+        def chunked_response_body?
+          has_response_body? && response_headers['Transfer-Encoding'] &&
+            response_headers['Transfer-Encoding'].downcase == 'chunked'
         end
-      end
-    end
 
-    def headerize(str)
-      parts = str.gsub(/^HTTP_/, '').split('_')
-      parts.map! { |p| p.capitalize }.join('-')
+        def request_method
+          @env['REQUEST_METHOD'].upcase
+        end
+
+        def request_headers
+          return @request_headers if @request_headers
+          @request_headers = {}
+          @env.each do |key, value|
+            next unless key.is_a?(String)
+            next if     key =~ /^HTTP_(HOST|VERSION|X_STROBE_PROXY_PROTOCOL)$/i
+            next unless key =~ /^HTTP_/ || KEEP.include?(key)
+
+            key = headerize(key)
+            @request_headers[key] = value
+          end
+
+          if requires_request_body? && !has_request_body?
+            @request_headers['Content-Length'] = '0'
+          end
+
+          @request_headers
+        end
+
+        def request_body
+          return unless has_request_body?
+          return @request_body if @request_body
+          @request_body = @env['rack.input'].read
+          @env['rack.input'].rewind
+          @request_body
+        end
+
+        def requires_request_body?
+          ['POST', 'PUT'].include?(@env['REQUEST_METHOD'])
+        end
+
+        def has_request_body?
+          @env['CONTENT_LENGTH'] || @env['HTTP_TRANSFER_ENCODING']
+        end
+
+        def request_options
+          return @request_options if @request_options
+          @request_options = {}
+          @request_options[:head]      = request_headers
+          @request_options[:body]      = request_body if has_request_body?
+          @request_options[:timeout]   = 60
+          @request_options[:redirects] = 10
+          @request_options
+        end
+
+        def headerize(str)
+          parts = str.gsub(/^HTTP_/, '').split('_')
+          parts.map! { |p| p.downcase.capitalize }.join('-')
+        end
+
+        def block_cookies?
+          @opts[:block_cookies]
+        end
+
+        def block_headers
+          @opts[:block_headers] || []
+        end
+
+        def extra_headers
+          @opts[:extra_headers] || {}
+        end
+      end
     end
   end
 end