Merge pull request #4 from experteer/master

refactoring + some new features

Author: jaswope

README.rdoc

@@ -17,17 +17,25 @@ Below is an example for configuring the middleware:
 
   use Rack::ReverseProxy do 
     # Forward the path /test* to http://example.com/test*
+    reverse_proxy_options :preserve_host => true
+        
     reverse_proxy '/test', 'http://example.com/'
 
     # Forward the path /foo/* to http://example.com/bar/*
-    reverse_proxy /^\/foo(\/.*)$/, 'http://example.com/bar$1'
+    reverse_proxy /^\/foo(\/.*)$/, 'http://example.com/bar$1', :username => 'name', :password => 'basic_auth_secret'
   end
 
   app = proc do |env|
     [ 200, {'Content-Type' => 'text/plain'}, "b" ]
   end
   run app
 
+revers_proxy_options set global options for all reverse proxies. Available options are:
+  * :preserve_host
+  * :username username for basic auth
+  * :password password for basic auth
+  * :matching is a global only option, if set to :first the first matched url will be requested (no ambigous error). Default: :all.
+  * :timeout seconds to timout the requests
 == Note on Patches/Pull Requests
 
 * Fork the project.

lib/rack/reverse_proxy.rb

@@ -5,38 +5,40 @@ module Rack
   class ReverseProxy
     def initialize(app = nil, &b)
       @app = app || lambda { [404, [], []] }
-      @paths = {}
-      @opts = {:preserve_host => false}
+      @matchers = []
+      @global_options = {:preserve_host => false,:matching => :all}
       instance_eval &b if block_given?
     end
 
     def call(env)
       rackreq = Rack::Request.new(env)
-      matcher, url = get_matcher_and_url rackreq.fullpath
+      matcher = get_matcher rackreq.fullpath
       return @app.call(env) if matcher.nil?
 
-      uri = get_uri(url, matcher, rackreq.fullpath) 
+      uri = matcher.get_uri(rackreq.fullpath,env)
+      all_opts = @global_options.dup.merge(matcher.options)
       headers = Rack::Utils::HeaderHash.new
       env.each { |key, value|
         if key =~ /HTTP_(.*)/
           headers[$1] = value
         end
       }
-			headers['HOST'] = uri.host if @opts[:preserve_host]
+			headers['HOST'] = uri.host if all_opts[:preserve_host]
 
 			session = Net::HTTP.new(uri.host, uri.port)
 			session.use_ssl = (uri.scheme == 'https')
 			session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+			session.read_timeout=all_opts[:timeout] if all_opts[:timeout]
 			session.start { |http|
         m = rackreq.request_method
         case m
         when "GET", "HEAD", "DELETE", "OPTIONS", "TRACE"
           req = Net::HTTP.const_get(m.capitalize).new(uri.request_uri, headers)
-          req.basic_auth @opts[:username], @opts[:password] if @opts[:username] and @opts[:password]
+          req.basic_auth all_opts[:username], all_opts[:password] if all_opts[:username] and all_opts[:password]
         when "PUT", "POST"
           req = Net::HTTP.const_get(m.capitalize).new(uri.request_uri, headers)
-          req.basic_auth @opts[:username], @opts[:password] if @opts[:username] and @opts[:password]
-          req.content_length = rackreq.body.length
+          req.basic_auth all_opts[:username], all_opts[:password] if all_opts[:username] and all_opts[:password]
+          req.content_length = rackreq.body.size
           req.body_stream = rackreq.body
         else
           raise "method not supported: #{m}"
@@ -55,17 +57,17 @@ def call(env)
 
     private
 
-    def get_matcher_and_url path
-      matches = @paths.select do |matcher, url|
-        match_path(path, matcher)
+    def get_matcher path
+      matches = @matchers.select do |matcher|
+        matcher.match?(path)
       end
 
       if matches.length < 1
         nil
-      elsif matches.length > 1
+      elsif matches.length > 1 && @global_options[:matching] != :first
         raise AmbiguousProxyMatch.new(path, matches)
       else
-        matches.first.map{|a| a.dup}
+        matches.first
       end
     end
 
@@ -79,27 +81,14 @@ def create_response_headers http_response
       response_headers
     end
 
-    def match_path(path, matcher)
-      if matcher.is_a?(Regexp)
-        path.match(matcher)
-      else
-        path.match(/^#{matcher.to_s}/)
-      end
-    end
 
-    def get_uri(url, matcher, path)
-      if url =~/\$\d/
-        match_path(path, matcher).to_a.each_with_index { |m, i| url.gsub!("$#{i.to_s}", m) }
-        URI(url)
-      else
-        URI.join(url, path)
-      end
+    def reverse_proxy_options(options)
+      @global_options=options
     end
 
     def reverse_proxy matcher, url, opts={}
-      raise GenericProxyURI.new(url) if matcher.is_a?(String) && URI(url).class == URI::Generic
-      @paths.merge!(matcher => url)
-      @opts.merge!(opts)
+      raise GenericProxyURI.new(url) if matcher.is_a?(String) && url.is_a?(String) && URI(url).class == URI::Generic
+      @matchers << ReverseProxyMatcher.new(matcher,url,opts)
     end
   end
 
@@ -129,8 +118,41 @@ def to_s
     private
 
     def formatted_matches
-      matches.map {|m| %Q("#{m[0].to_s}" => "#{m[1]}")}.join(', ')
+      matches.map {|matcher| matcher.to_s}.join(', ')
     end
   end
 
+  class ReverseProxyMatcher
+    def initialize(matching,url,options)
+      @matching=matching
+      @url=url
+      @options=options
+      @matching_regexp= matching.kind_of?(Regexp) ? matching : /^#{matching.to_s}/
+    end
+
+    attr_reader :matching,:matching_regexp,:url,:options
+
+    def match?(path)
+      match_path(path) ? true : false
+    end
+
+    def get_uri(path,env)
+      _url=(url.respond_to?(:call) ? url.call(env) : url)
+      if _url =~/\$\d/
+        match_path(path).to_a.each_with_index { |m, i| _url.gsub!("$#{i.to_s}", m) }
+        URI(_url)
+      else
+        URI.join(_url, path)
+      end
+    end
+    def to_s
+      %Q("#{matching.to_s}" => "#{url}")
+    end
+    private
+    def match_path(path)
+      path.match(matching_regexp)
+    end
+
+
+  end
 end

spec/rack/reverse_proxy_spec.rb

@@ -16,6 +16,8 @@ def dummy_app
     def app
       Rack::ReverseProxy.new(dummy_app) do
         reverse_proxy '/test', 'http://example.com/', {:preserve_host => true}
+        reverse_proxy '/2test', lambda{'http://example.com/'}
+
       end
     end
 
@@ -31,6 +33,12 @@ def app
       last_response.body.should == "Proxied App"
     end
 
+    it "should proxy requests to a lambda url when a pattern is matched" do
+      stub_request(:get, 'http://example.com/2test').to_return({:body => "Proxied App2"})
+      get '/2test'
+      last_response.body.should == "Proxied App2"
+    end
+
 		it "the response header should never contain Status" do
 			stub_request(:any, 'example.com/test/stuff').to_return(:headers => {'Status' => '200 OK'})
 			get '/test/stuff'
@@ -77,9 +85,10 @@ def app
       end
     end
 
-    describe "with ambiguous routes" do
+    describe "with ambiguous routes and all matching" do
       def app
         Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :all
           reverse_proxy '/test', 'http://example.com/'
           reverse_proxy /^\/test/, 'http://example.com/'
         end
@@ -90,6 +99,22 @@ def app
       end
     end
 
+    describe "with ambiguous routes and first matching" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy_options :matching => :first
+          reverse_proxy '/test', 'http://example1.com/'
+          reverse_proxy /^\/test/, 'http://example2.com/'
+        end
+      end
+
+      it "should throw an exception" do
+       stub_request(:get, 'http://example1.com/test').to_return({:body => "Proxied App"})
+       get '/test'
+       last_response.body.should == "Proxied App"
+      end
+    end
+
     describe "with a route as a regular expression" do
       def app
         Rack::ReverseProxy.new(dummy_app) do