webrick_httpreverseproxyserver-FlipPath 0.1.2

data/README.rdoc

@@ -0,0 +1,23 @@
+= HTTP Reverse proxy server
+
+This library is not meant for production use. It is based on a snippet on
+RubyForge and was packaged as gem to make it easily available.
+
+You may use this class, to programmatically set up a quick and simple reverse
+proxy. I found it useful to implement advanced inspection of an HTTP
+communication between an uncontrolled client and server.
+
+== Documentation
+
+See WEBrick::HTTPReverseProxyServer for more information.
+
+
+== License
+
+The code was originally released in 2006 by Richard Kernahan on Rubyforge.
+
+  http://rubyforge.org/snippet/detail.php?type=snippet&id=117
+
+It was packaged as RubyGem by Gregor Schmidt.
+
+The code is release under the terms of the Artistic License.

data/Rakefile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'rake'
+require 'rake/rdoctask'
+
+$: << File.expand_path('../lib', __FILE__)
+require 'webrick/httpreverseproxyserver/version'
+
+desc 'Generate documentation for the webrick_httpreverseproxyserver gem.'
+Rake::RDocTask.new(:doc) do |doc|
+  doc.rdoc_dir = 'doc'
+  doc.title = 'WEBRick::HTTPReverseProxyServer'
+  doc.options << '--line-numbers' << '--inline-source'
+  doc.rdoc_files.include('README.rdoc')
+  doc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Build gem'
+task :build do
+  sh 'gem build webrick_httpreverseproxyserver.gemspec'
+end
+
+desc "Install gem locally"
+task :install => :build do
+  sh "gem install webrick_httpreverseproxyserver-#{WEBrick::HTTPReverseProxyServer::VERSION}.gem"
+end
+
+desc 'Release gem'
+task :release => :build do
+  sh "gem push webrick_httpreverseproxyserver-#{WEBrick::HTTPReverseProxyServer::VERSION}.gem"
+end

data/lib/webrick/httpreverseproxyserver.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+require 'webrick'
+require 'net/http'
+
+module WEBrick
+  # Proxy rule to configure WEBrick::HTTPReverseProxyServer
+  class ProxyRule < Struct.new(:pattern, :host, :port, :replacement)
+  end
+
+  # == Use case
+  #
+  # You have several services running as different users for security purposes
+  # (they might even be chrooted).  In production we use apache but for testing
+  # I prefer to use webrick because I find it more flexible for unit testing.
+  #
+  #
+  # == Configuration
+  #
+  # The proxy mapping is modelled on the ProxyPass directive of apache. For
+  # example:
+  #
+  #   original URL              proxies  private URL
+  #   ------------------------    ==>   --------------------------
+  #   /marmalade/index.html             localhost:8081/index.html
+  #   /apps/vegemite?id=123             localhost:8082/apps/someservlet?id=123
+  #
+  # Its not designed to be mod_rewrite (eg. query_string cannot be
+  # transformed), but you can specify proxy rules that match a fragment of the
+  # original URL and replace it with something else while also sending the new
+  # URL to the proxied host and port. So the rules in that example are
+  # specified thus:
+  #
+  #   serverConfig = {
+  #     :Port => 80,
+  #     :ProxyRules => [
+  #       WEBrick::ProxyRule.new('^/marmalade/', 'localhost', 8081, '/'),
+  #       WEBrick::ProxyRule.new('vegemite', 'localhost', 8082, 'someservlet')
+  #     ]
+  #   }
+  #   server = WEBrick::HTTPReverseProxyServer.new(serverConfig)
+  #
+  # ProxyRules is an array so the order is important - the first match is used!
+  # If no matches are found then the URL is handled by the local web server
+  # normally.
+  #
+  #
+  # == Running a server
+  #
+  # You may start a server, just like any WEBrick server.
+  #
+  # To get started using RubyGems, use the following example:
+  #
+  #   require 'rubygems'
+  #   require 'webrick/httpreverseproxyserver'
+  #
+  #   # create a configuration and a server instance
+  #   serverConfig = {
+  #     :Port => 8080,
+  #     :ProxyRules => [WEBrick::ProxyRule.new('/', 'www.example.com', 80, '/')]
+  #   }
+  #   server = WEBrick::HTTPReverseProxyServer.new(serverConfig)
+  #
+  #   # catch ^C to quit cleanly
+  #   trap("INT") { server.shutdown }
+  #
+  #   # start request-response-loop
+  #   server.start
+  #
+  #
+  # == Advanced inspection
+  #
+  # In order to better analyse an HTTP stream, you may easily subclass
+  # HTTPReverseProxyServer to add advanced request/response inspection.
+  #
+  # The following example implements basic Cookie logging:
+  #
+  #   class CookieLoggingProxy < WEBrick::HTTPReverseProxyServer
+  #     def service(request, response)
+  #       super.tap do
+  #         puts
+  #         puts request.request_line
+  #         print_cookie_headers request.header
+  #         puts response.status_line
+  #         print_cookie_headers response.header
+  #       end
+  #     end
+  #
+  #     def print_cookie_headers(headers)
+  #       headers.each do |key, val|
+  #         puts "#{key}: #{val}" if key =~ /cookie/i
+  #       end
+  #     end
+  #   end
+  class HTTPReverseProxyServer < HTTPServer
+    def service(request, response)
+      rule = first_matching_proxy_rule(request)
+      if rule.nil?
+        super(request, response)
+      else
+        service_proxy(request, response, rule)
+      end
+    end
+
+  protected
+    # find the *first* matching pattern in the proxy map
+    def first_matching_proxy_rule(request)
+      matching_rule = @config[:ProxyRules].detect { |rule|
+        re = Regexp.new(rule.pattern)
+        m = re.match(request.path)
+        not m.nil?
+      }
+      return(matching_rule)
+    end
+
+    def service_proxy(request, res, rule)
+      host, port, path  = map_to_proxyURI(request, rule)
+      # convert WEBrick header (values wrapped in an array) into Net::HTTP
+      # header (simple values)
+      header = {}
+      request.header.keys { |key| header[key] = request.header[key][0] }
+      header['x-forwarded-for'] = request.peeraddr[2] # the name of the requesting host
+      # send the new request to the private server (hacked from WEBrick::HTTPProxyServer)
+      response = nil
+      begin
+        http = Net::HTTP.new(host, port)
+        http.start {
+          case request.request_method
+          when "GET"  then response = http.get(path, header)
+          when "POST" then response = http.post(path, request.body || "", header)
+          when "HEAD" then response = http.head(path, header)
+          else
+            raise HTTPStatus::MethodNotAllowed,
+              "unsupported method `#{request.request_method}'."
+          end
+        }
+      rescue => err
+        logger.debug("#{err.class}: #{err.message}")
+        raise HTTPStatus::ServiceUnavailable, err.message
+      end
+      res['connection'] = "close"
+
+      # Convert Net::HTTP::HTTPResponse to WEBrick::HTTPResponse
+      res.status = response.code.to_i
+      res.each { |key, val| response[key] = val }
+      res.body = response.body
+
+      # Process contents
+      if handler = @config[:ProxyContentHandler]
+        handler.call(request, res)
+      end
+    end
+
+    def map_to_proxyURI(request, rule)
+      path = (request.path).sub(%r!#{rule.pattern}!, rule.replacement)
+      path += '?' + request.query_string if request.query_string
+      return([rule.host, rule.port, path])
+    end
+  end
+end
+
+require 'webrick/httpreverseproxyserver/version'

data/lib/webrick/httpreverseproxyserver/version.rb

@@ -0,0 +1,5 @@
+module WEBrick
+  class HTTPReverseProxyServer
+    VERSION = '0.1.2'
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: webrick_httpreverseproxyserver-FlipPath
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Richard Kernahan
+- Gregor Schmidt
+- Shayne Sweeney
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Implements a simple reverse HTTP proxy - useful for advanced configuration or inspection of reverse proxies in development.
+email: g.schmidt@finn.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/webrick/httpreverseproxyserver/version.rb
+- lib/webrick/httpreverseproxyserver.rb
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/FlipPath/webrick_httpreverseproxyserver
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: "[none]"
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Implements a simple reverse HTTP proxy server
+test_files: []
+