mikehale-rat-hole 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 / 2008-12-17
+
+* First release.

data/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+Manifest.txt
+README.rdoc
+lib/rat_hole.rb
+lib/util.rb
+test/test_rat_hole.rb
+test/mock_request.rb

data/README.rdoc

@@ -0,0 +1,87 @@
+Rat Hole is a handy class for creating a rack compliant http proxy that allows you to modify the request from the user and the response from the server. 
+The name is inspired by why's mousehole[http://code.whytheluckystiff.net/mouseHole/]
+
+== Why
+Use Rat Hole to proxy site A into the namespace of site B.
+
+Along the way you can modify the request from the user (example: proxy to an ip and set the Host header to support virtual hosts without DNS).
+
+You can also modify the response from the server to cleanup html tweak headers etc.
+
+== Usage
+  require 'rat_hole'
+  require 'hpricot'
+
+  class PoliticalAgendaRatHole < RatHole
+    def process_user_request(rack_request)
+      # optionally munge the request before passing it to the old server
+      
+      # required to return the rack request
+      rack_request
+    end
+
+    def process_server_response(rack_response)
+      # For any html pages proxied replace all links with http://ronpaul.com and 
+      # add a Ron-Paul header.
+
+      if(rack_response.content_type == 'text/html')
+
+        # dump the body into hpricot so we can use hpricot's search/replace goodness
+        doc = Hpricot(rack_response.body.first)
+
+        # update all links to help spread our political views
+        (doc/"a").set('href', 'http://ronpaul.com')
+
+        # update the original string with our modified html
+        rack_response.body.first.replace(doc.to_html)
+
+        rack_response.headers['Ron-Paul'] = 'wish I could have voted for this guy'
+      end
+
+      # required to return the rack response
+      rack_response
+    end
+  end
+
+  app =  PoliticalAgendaRatHole.new('www.google.com')
+  Rack::Handler::Mongrel.run(app, {:Host => 'localhost', :Port => 5001})
+
+== How it Works
+  User Request  --->
+      ---  RatHoleProxy.process_user_request(rack_request) --->
+                                                                <==========> OLD SERVER
+      <---  RatHoleProxy.process_server_response(rack_response) ---
+  User Response  <---
+
+== TODO
+* add error handling
+* handle gziped content (accept-encoding, transfer-encoding)
+* maybe use a pool of Net::HTTP connections to speed things up
+* provide an easy way for testing rat holes
+
+== Credits
+* Michael Hale (http://halethegeek.com)
+* David Bogus
+
+== LICENSE
+The MIT License
+
+Copyright (c) 2008 Michael Hale & David Bogus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/rat_hole.rb

@@ -0,0 +1,59 @@
+require 'net/http'
+require 'rubygems'
+require 'rack'
+require 'delegate'
+require 'util'
+
+class RatHole
+  def initialize(host)
+    @host = host
+  end
+
+  def process_user_request(rack_request)
+    rack_request
+  end
+
+  def process_server_response(rack_response)
+    rack_response
+  end
+
+  def call(env)
+    Net::HTTP.start(@host) do |http|
+      http.instance_eval{@socket = MethodSpy.new(@socket){|method| method =~ /write/}} if $DEBUG
+
+      env.delete('HTTP_ACCEPT_ENCODING')
+      source_request = process_user_request(Rack::Request.new(env))
+      source_headers = request_headers(source_request.env)
+
+      if source_request.get?
+        response = http.get(source_request.path_info, source_headers)
+      elsif source_request.post?
+        post = Net::HTTP::Post.new(source_request.path_info, source_headers)
+        class << post
+          include HTTPHeaderPatch
+        end
+        post.form_data = source_request.POST
+        response = http.request(post)
+      end
+
+      code = response.code.to_i
+      headers = response.to_hash
+      body = response.body || ''
+      headers.delete('transfer-encoding')
+
+      process_server_response(Rack::Response.new(body, code, headers)).finish
+    end
+  end
+
+  def request_headers(env)
+    env.select{|k,v| k =~ /^HTTP/}.inject({}) do |h, e|
+      k,v = e
+      h.merge(k.split('_')[1..-1].join('-').to_camel_case => v)
+    end
+  end
+end
+
+# This class simply extends RatHole and does nothing.
+# It's only useful for making sure that you have everything hooked up correctly.
+class EmptyRatHole < RatHole
+end

data/lib/util.rb

@@ -0,0 +1,51 @@
+class SocketSpy < SimpleDelegator
+  def write(content)
+    p :writing => content
+    __getobj__.write content
+  end
+
+  [:readline, :readuntil, :read_all, :read].each{|symbol|
+    define_method(symbol) do |*args|
+      content = __getobj__.send(symbol, *args)
+      p :reading => content
+      content
+    end
+  }
+end
+
+class MethodSpy
+  def initialize(delegate, &block)
+    @delegate = delegate
+    @filter = block
+  end
+
+  def method_missing(symbol, *args, &block)
+    result = @delegate.send(symbol, *args, &block)
+    @block.call if @block
+    p [symbol, args, result, block] if @filter && @filter.call(symbol.to_s)
+    result
+  end
+end
+
+class String
+  def to_camel_case(split_on='-')
+    self.split(split_on).collect{|e| e.capitalize}.join(split_on)
+  end
+end
+
+module HTTPHeaderPatch
+  # handle multiple parameters with the same name
+  def form_data=(params, sep = '&')
+    self.body = params.map {|key,value|
+      if value.is_a?(Array)
+        value.map{|v| param_line(key, v) }
+      else
+        param_line(key, value)
+      end
+    }.join(sep)
+  end
+
+  def param_line(k, v)
+    "#{urlencode(k.to_s)}=#{urlencode(v.to_s)}"
+  end
+end

data/rat-hole.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name     = "rat-hole"
+  s.version  = "0.1.0"
+  s.date     = "2008-12-17"
+  s.summary  = "Rack compliant proxy"
+  s.email    = "mikehale@gmail.com"
+  s.homepage = "http://github.com/mikehale/rat-hole"
+  s.description = "Rat Hole is a handy library for creating a rack compliant http proxy that allows you to modify the request from the user and the response from the server."
+  s.has_rdoc = true
+  s.authors  = ["Michael Hale", "David Bogus"]
+  s.files    = ["History.txt", 
+    "README.rdoc", 
+    "rat-hole.gemspec", 
+    "lib/rat_hole.rb", 
+    "lib/util.rb"]
+  s.test_files = ["test/test_rat_hole.rb",
+    "test/mock_request.rb"]
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
+  s.add_dependency("rack", ["> 0.4.0"])
+  s.add_dependency("rr", ["> 0.6.0"])
+end

data/test/mock_request.rb

@@ -0,0 +1,35 @@
+class MockRequest
+
+  attr_reader :headers, :body, :uri
+
+  def initialize(request_string)
+    lines = request_string.split("\r\n")
+
+    # find blank line which seperates the headers from the body
+    index_of_blank = nil
+    lines.each_with_index{|e,i|
+      index_of_blank = i if e == ""
+    }
+
+    @type, @uri = lines.first.split(/\s+/)
+    if index_of_blank
+      @headers = lines[1..index_of_blank]
+      @body = lines[(index_of_blank + 1)..-1].first
+    else
+      @headers = lines[1..-1]
+    end
+
+    @headers = @headers.inject({}){|h,e|
+      k,v = e.split(/:\s+/)
+      h.merge k => v
+    }
+  end
+
+  def get?
+    @type == 'GET'
+  end
+
+  def post?
+    @type == 'POST'
+  end
+end

data/test/test_rat_hole.rb

@@ -0,0 +1,221 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'rr'
+require 'delegate'
+require 'test/unit'
+require 'ruby-debug'
+require 'rat_hole'
+require 'mock_request'
+require 'hpricot'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+
+class TestRatHole < Test::Unit::TestCase
+  def mock_server(opts={})
+    opts[:host] = opts[:host] || '127.0.0.1'
+    opts[:code] = opts[:code] || 200
+    opts[:headers] = opts[:headers] || {}
+
+    host = opts[:host]
+    code = opts[:code]
+    headers = opts[:headers]
+    body = opts[:body]
+
+    response = [%(HTTP/1.1 #{code} OK)]
+    headers.each{|k,vs|
+      if vs.is_a?(Array)
+        response << vs.map{|v| "#{k.to_s}: #{v.to_s}" }
+      else
+        response << "#{k.to_s}: #{vs.to_s}"
+      end
+    }
+    response << ''
+    response << %(#{body})
+    response = response.join("\r\n")
+
+    @io = StringIO.new(response)
+    class << @io
+      attr_reader :written
+
+      def write(content)
+        @written = '' unless @written
+        @written << content
+        0
+      end
+    end
+
+    mock(TCPSocket).open(host, 80) { @io }
+  end
+
+  def proxied_request
+    MockRequest.new(@io.written)
+  end
+
+  def send_get_request(rack_env={})
+    opts = {:lint=>true}.merge(rack_env)
+    rh = RatHole.new('127.0.0.1')
+    Rack::MockRequest.new(rh).get('/someuri', opts)
+  end
+
+  def send_post_request(body='')
+    rh = RatHole.new('127.0.0.1')
+    Rack::MockRequest.new(rh).post('/someuri', {:lint=>true, :input=> body})
+  end
+
+  def test_response_unchanged
+    expected_body = 'the body'
+    mock_server(:body => expected_body)
+    response = send_get_request
+
+    assert_equal 200, response.status
+    assert_equal expected_body, response.body
+  end
+
+  def test_headers_normalized
+    mock_server(:headers => {'server' => 'freedom-2.0', 'set-cookie' => 'ronpaul=true'})
+    response = send_get_request
+    assert_equal('ronpaul=true', response.headers['Set-Cookie'])
+    assert_equal('freedom-2.0', response.headers['Server'])
+  end
+
+  def test_default_body
+    mock_server(:body => nil)
+    response = send_get_request
+    assert_equal '', response.body
+  end
+
+  def test_get_request
+    mock_server
+    send_get_request
+    assert proxied_request.get?
+  end
+
+  def test_post_request
+    mock_server
+    send_post_request("field1=value1")
+    assert proxied_request.post?
+    assert proxied_request.body.include?("field1=value1")
+  end
+
+  def test_post_duplicate_keys
+    mock_server
+    send_post_request("field1=value1&field1=value2")
+    assert_equal("field1=value1&field1=value2", proxied_request.body)
+  end
+
+  def test_post_data_urlencoded
+    mock_server
+    send_post_request("field%201=value%201")
+    assert("field%201=value%201", proxied_request.body)
+  end
+
+  def test_convert_rack_env_to_http_headers
+    headers_added_by_rack = {"Accept"=>"*/*", "Host"=>"127.0.0.1"}
+    expected_headers = {"X-Forwarded-Host"=>"www.example.com"}.merge(headers_added_by_rack)
+
+    mock_server
+    send_get_request({"HTTP_X_FORWARDED_HOST"=>"www.example.com", "NON_HTTP_HEADER" => '42'})
+    assert_equal(expected_headers, proxied_request.headers)
+  end
+
+  def test_convert_rack_env_to_http_headers_more_data
+    expected_headers = {
+      "X-Forwarded-Host"=>"www.example.com",
+      "User-Agent"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.4) Gecko/2008102920 Firefox/3.0.4",
+      "Cache-Control"=>"max-age=0",
+      "If-None-Match"=>"\"58dc30c-216-3d878fe2\"-gzip",
+      "Accept-Language"=>"en-us,en;q=0.5",
+      "Host"=>"localhost:4001",
+      "Referer"=>"http://www.example.com/posts/",
+      "Cookie"=>"cookie1=YWJj; cookie2=ZGVm",
+      "Accept-Charset"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+      "X-Forwarded-Server"=>"www.example.com",
+      "If-Modified-Since"=>"Tue, 17 Sep 2002 20:26:10 GMT",
+      "X-Forwarded-For"=>"127.0.0.1",
+      "Accept"=>"image/png,image/*;q=0.8,*/*;q=0.5",
+      "Connection"=>"Keep-Alive"}
+
+    rack_env = {"SERVER_NAME"=>"localhost",
+      "HTTP_X_FORWARDED_HOST"=>"www.example.com",
+      "HTTP_ACCEPT_ENCODING"=>"gzip,deflate",
+      "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.0.4) Gecko/2008102920 Firefox/3.0.4",
+      "HTTP_CACHE_CONTROL"=>"max-age=0",
+      "HTTP_IF_NONE_MATCH"=>"\"58dc30c-216-3d878fe2\"-gzip",
+      "HTTP_ACCEPT_LANGUAGE"=>"en-us,en;q=0.5",
+      "HTTP_HOST"=>"localhost:4001",
+      "HTTP_REFERER"=>"http://www.example.com/posts/",
+      "HTTP_COOKIE"=>"cookie1=YWJj; cookie2=ZGVm",
+      "HTTP_ACCEPT_CHARSET"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+      "HTTP_X_FORWARDED_SERVER"=>"www.example.com",
+      "HTTP_IF_MODIFIED_SINCE"=>"Tue, 17 Sep 2002 20:26:10 GMT",
+      "HTTP_X_FORWARDED_FOR"=>"127.0.0.1",
+      "HTTP_ACCEPT"=>"image/png,image/*;q=0.8,*/*;q=0.5",
+      "HTTP_CONNECTION"=>"Keep-Alive",}
+
+    mock_server(:body => 'not testing this')
+    send_get_request(rack_env)
+    assert_equal(expected_headers, proxied_request.headers)
+  end
+
+  def test_systemic_empty_rathole
+    host = 'halethegeek.com'
+    app =  EmptyRatHole.new(host)
+    app_response = Rack::MockRequest.new(app).get('/', {})
+    raw_response = Net::HTTP.start(host) do |http|
+      http.get('/', {})
+    end
+    # Wrap raw_response in Rack::Response to make things easier to work with.
+    raw_response = Rack::Response.new(raw_response.body, raw_response.code, raw_response.to_hash)
+
+    assert_equal raw_response.status.to_i, app_response.status.to_i
+    assert_equal normalize_headers(raw_response.headers), normalize_headers(app_response.headers)
+    assert_equal raw_response.body.to_s, app_response.body.to_s
+  end
+
+  def test_systemic_political_agenda
+    host = 'terralien.com'
+    app =  PoliticalAgendaRatHole.new(host)
+    app_response = Rack::MockRequest.new(app).get('/', {})
+    raw_response = Net::HTTP.start(host) do |http|
+      http.get('/', {})
+    end
+    # Wrap raw_response in Rack::Response to make things easier to work with.
+    raw_response = Rack::Response.new(raw_response.body, raw_response.code, raw_response.to_hash)
+    raw_headers = normalize_headers(raw_response.headers)
+    app_headers = normalize_headers(app_response.headers)
+
+    assert_equal raw_response.status.to_i, app_response.status.to_i
+    assert !raw_headers.has_key?('Ron-Paul')
+    assert app_headers.has_key?('Ron-Paul')
+
+    assert !raw_response.body.to_s.include?('http://ronpaul.com')
+    assert app_response.body.to_s.include?('http://ronpaul.com')
+  end
+
+  def normalize_headers(headers)
+    headers.inject({}){|h,e|
+      k,v = e
+      # don't compare headers that change or that we remove
+      unless k =~ /cookie|transfer|date|runtime/i
+        v = [v] unless v.is_a? Array #normalize things
+        h.merge!(k => v)
+      end
+      h
+    }
+  end
+end
+
+class PoliticalAgendaRatHole < RatHole
+  def process_server_response(rack_response)
+    if(rack_response.content_type == 'text/html')
+      doc = Hpricot(rack_response.body.first)
+      (doc/"a").set('href', 'http://ronpaul.com')
+      rack_response.body.first.replace(doc.to_html)
+      rack_response.headers['Ron-Paul'] = 'wish I could have voted for this guy'
+    end
+    rack_response
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: mikehale-rat-hole
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Hale
+- David Bogus
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-17 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rr
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.6.0
+    version: 
+description: Rat Hole is a handy library for creating a rack compliant http proxy that allows you to modify the request from the user and the response from the server.
+email: mikehale@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- README.rdoc
+- rat-hole.gemspec
+- lib/rat_hole.rb
+- lib/util.rb
+- Manifest.txt
+has_rdoc: true
+homepage: http://github.com/mikehale/rat-hole
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Rack compliant proxy
+test_files: 
+- test/test_rat_hole.rb
+- test/mock_request.rb