rat-hole 0.1.9

data/CHANGELOG.rdoc

@@ -0,0 +1,35 @@
+= 0.1.9
+
+* test tidy
+
+= 0.1.8
+
+* bug fixes
+* use jeweler instead of hoe
+* add test harness
+
+= 0.1.7
+
+* add support for tidy
+* update api to not require request/response to be returned
+* require rack 0.9.1 or greater
+
+= 0.1.6
+
+* properly calculate request_uri if query_string is empty
+
+= 0.1.5
+
+* calculate request_uri = path_info + query_string
+
+= 0.1.4
+
+* update process_server_response hook to include rack_request
+
+= 0.1.2
+
+* use patched-hoe from newgem
+
+= 0.1.0
+
+* First release.

data/Manifest.txt

@@ -0,0 +1,11 @@
+CHANGELOG.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/rat_hole.rb
+lib/rat_hole_test.rb
+lib/util.rb
+rat-hole.gemspec
+test/mock_request.rb
+test/test_rat_hole.rb
+VERSION.yml

data/README.rdoc

@@ -0,0 +1,107 @@
+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. 
+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
+    end
+
+    def process_server_response(rack_response, rack_request)
+      # 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
+    end
+  end
+
+  app = Rack::Builder.new do
+    use Rack::CommonLogger # display apache style common logs
+    use Rack::ShowExceptions # show exceptions
+    use Rack::Reloader # reload app when an included file changes
+    run PoliticalAgendaRatHole.new('www.google.com')
+  end
+
+  Rack::Handler::Mongrel.run(app, {:Host => 'localhost', :Port => 5001})
+
+=== Testing your RatHole into existance
+  class PoliticalAgendaRatHoleTest < RatHoleTest
+    def test_has_proper_response
+      through_the(PoliticalAgendaRatHole, 'terralien.com') do |raw_response, app_response|
+        assert_equal raw_response.status.to_i, app_response.status.to_i
+        assert !raw_response.headers.has_key?('Ron-Paul')
+        assert app_response.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
+    end
+  end
+
+== INSTALL:
+  * sudo gem install mikehale-rat-hole
+
+== How it Works
+  User Request  --->
+      ---  RatHoleProxy.process_user_request(rack_request) --->
+                                                                <==========> OLD SERVER
+      <---  RatHoleProxy.process_server_response(rack_response, rack_request) ---
+  User Response  <---
+
+== TODO
+* handle server down
+* handle gziped content (accept-encoding, transfer-encoding)
+* maybe use a pool of Net::HTTP connections to speed things up
+* write up some rathole's for common tasks (logging)
+* move to rspec?
+* support post, head, delete, etc?
+* add caching? can apache do this for us?
+
+== Credits
+* Michael Hale (http://halethegeek.com)
+* David Bogus
+
+== LICENSE
+The MIT License
+
+Copyright (c) 2008-2009 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/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 9

data/lib/rat_hole.rb

@@ -0,0 +1,91 @@
+require 'net/http'
+require 'rack'
+require 'delegate'
+require 'util'
+require 'open3'
+
+class RatHole
+
+  def initialize(host, tidy=false)
+    @host = host
+    @tidy = tidy
+  end
+
+  def process_user_request(rack_request)
+    rack_request
+  end
+
+  def process_server_response(rack_response, rack_request)
+    rack_response
+  end
+
+  def call(env)
+    Net::HTTP.start(@host) do |http|
+      http.instance_eval{@socket = MethodSpy.new(@socket){|method| method =~ /#{ENV['RH_METHOD_SPY_FILTER']}/}} if $DEBUG
+      env.delete('HTTP_ACCEPT_ENCODING')
+      source_request = Rack::Request.new(env)
+      process_user_request(source_request)
+      source_headers = request_headers(source_request.env)
+      
+      if source_request.query_string.nil? || source_request.query_string == ''
+        request_uri = source_request.path_info
+      else
+        request_uri = "#{source_request.path_info}?#{source_request.query_string}"
+      end
+
+      if source_request.get?
+        response = http.get(request_uri, source_headers)
+      elsif source_request.post?
+        post = Net::HTTP::Post.new(request_uri, source_headers)
+        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')
+
+      server_response = Rack::Response.new(body, code, headers)
+      whack_array(server_response)
+      tidy_html(body) if server_response["Content-Type"] =~ /text\/html/ && @tidy
+      
+      process_server_response(server_response, source_request)
+      server_response.finish
+    end
+  end
+
+  def whack_array(server_response)
+    server_response.headers.each do |k, v|
+      if v.is_a?(Array) && v.size == 1
+        server_response[k] = v.first
+      end
+    end
+  end
+
+  def tidy_html(body)
+    if `which tidy` == ''
+      $stderr.puts "tidy not found in path"
+      return
+    end
+    tidied, errors = Open3.popen3('tidy -ascii') do |stdin, stdout, stderr|
+      stdin.print body
+      stdin.close
+      [stdout.read, stderr.read]
+    end
+    $stderr.puts errors if $DEBUG
+    body.replace(tidied) if tidied != ""
+  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/rat_hole_test.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+
+class RatHoleTest < Test::Unit::TestCase
+  def through_the(rathole_klass, host, uri='/', headers={})
+    app = Rack::Builder.new do
+      use Rack::ShowExceptions
+      use Rack::ShowStatus
+      run rathole_klass.new(host)
+    end
+
+    app_response = Rack::MockRequest.new(app).get(uri, headers)
+    raw_response = Net::HTTP.start(host) do |http|
+      http.get(uri, headers)
+    end
+    # Wrap raw_response in Rack::Response to make things easier to work with.
+    raw_headers = raw_response.to_hash
+    raw_response = Rack::Response.new(raw_response.body, raw_response.code, raw_headers)
+    normalize_headers(raw_response.headers)
+    normalize_headers(app_response.headers)
+    yield(raw_response, app_response)
+  end
+
+  def normalize_headers(headers)
+    new_headers = headers.inject({}){|h,e|
+      k,v = e
+      # the value of these headers changes
+      v = nil if k =~ /cookie|date|runtime|last-modified/i
+      # skip headers that rat-hole removes
+      unless k =~ /transfer/i
+        v = v.first if v.is_a?(Array) && v.size == 1 #normalize things
+        h.merge!(k => v)
+      end
+      h
+    }
+    headers.replace(new_headers)
+  end
+
+  def test_nothing #make autotest happy
+  end
+end

data/lib/util.rb

@@ -0,0 +1,61 @@
+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)
+    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 Net::HTTPHeader
+  def to_hash
+    new_headers = @header.dup
+    @header.each do |k,v|
+      new_headers.delete(k)
+      new_headers[k.to_camel_case] = v
+    end
+    new_headers
+  end
+end
+
+class Net::HTTP::Post
+  # 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/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,233 @@
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rr'
+require 'delegate'
+require 'test/unit'
+require 'rat_hole'
+require 'rat_hole_test'
+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={}, uri='/someuri', tidy=false)
+    opts = {:lint=>true}.merge(rack_env)
+    rh = RatHole.new('127.0.0.1', tidy)
+    Rack::MockRequest.new(rh).get(uri, opts)
+  end
+
+  def send_post_request(body='', uri='/someuri')
+    rh = RatHole.new('127.0.0.1')
+    Rack::MockRequest.new(rh).post(uri, {: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_content_type
+    mock_server(:headers=>{'content-type' => ['image/gif']})
+    response = send_get_request
+    assert_equal 'image/gif', response.headers['Content-Type']
+
+    mock_server
+    response = send_get_request
+    assert_equal 'text/html', response.headers['Content-Type']
+  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_request_uri
+    mock_server
+    send_get_request({}, '/uri?with=param')
+    assert_equal('/uri?with=param', proxied_request.uri)
+
+    mock_server
+    send_get_request({}, '/uri')
+    assert_equal('/uri', proxied_request.uri)
+
+    mock_server
+    send_post_request('', '/uri?with=param')
+    assert_equal('/uri?with=param', proxied_request.uri)
+  end
+  
+  def test_tidy_fails
+    body = '<something tidy <will </barf on'
+    mock_server(:body => body)
+    response = send_get_request({}, '/', true)
+    assert_equal(response.body, body)
+  end
+
+  def test_tidy_tidies
+    mock_server(:body => 'tidy me')
+    response = send_get_request({:lint=>false}, '/', true)
+    assert response.body =~ /html/i
+  end
+end
+
+class TestEmptyRatHole < RatHoleTest
+  def test_has_proper_response
+    through_the(EmptyRatHole, 'halethegeek.com') do |raw_response, app_response|
+      assert_not_equal 0, raw_response.headers
+      assert_equal raw_response.status.to_i, app_response.status.to_i
+      assert_equal raw_response.headers, app_response.headers
+      assert_equal raw_response.body.to_s, app_response.body.to_s
+    end
+  end
+end
+
+class PoliticalAgendaRatHoleTest < RatHoleTest
+  def test_has_proper_response
+    through_the(PoliticalAgendaRatHole, 'terralien.com') do |raw_response, app_response|
+      assert_equal raw_response.status.to_i, app_response.status.to_i
+      assert !raw_response.headers.has_key?('Ron-Paul')
+      assert app_response.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
+  end
+end
+
+class PoliticalAgendaRatHole < RatHole
+  def process_server_response(rack_response, rack_request)
+    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
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: rat-hole
+version: !ruby/object:Gem::Version 
+  version: 0.1.9
+platform: ruby
+authors: 
+- Michael Hale
+- David Bogus
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-26 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.1
+    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: []
+
+files: 
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+- VERSION.yml
+- lib/rat_hole.rb
+- lib/rat_hole_test.rb
+- lib/util.rb
+- test/mock_request.rb
+- test/test_rat_hole.rb
+has_rdoc: true
+homepage: http://github.com/mikehale/rat-hole
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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.3.5
+signing_key: 
+specification_version: 2
+summary: Rack compliant http proxy
+test_files: []
+