rack-proxy 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/Rakefile

@@ -0,0 +1,28 @@
+require "rake/testtask"
+
+task :test do
+  Rake::TestTask.new do |t|
+    t.libs << "test"
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose = true
+  end
+end
+
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rack-proxy"
+    gem.summary = "A request/response rewriting HTTP proxy. A Rack app."
+    gem.description = "A Rack app that provides request/response rewriting proxy capabilities with streaming."
+    gem.email = "jacek.becela@gmail.com"
+    gem.homepage = "http://github.com/ncr/rack-proxy"
+    gem.authors = ["Jacek Becela"]
+    gem.add_dependency "rack"
+    gem.add_development_dependency "rack-test"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/Readme

@@ -0,0 +1 @@
+A request/response rewriting HTTP proxy. A Rack app.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/net_http_hacked.rb

@@ -0,0 +1,88 @@
+# We are hacking net/http to change semantics of streaming handling
+# from "block" semantics to regular "return" semnatics.
+# We need it to construct a streamable rack triplet:
+#
+# [status, headers, streamable_body]
+#
+# See http://github.com/aniero/rack-streaming-proxy 
+# for alternative that uses additional process.
+#
+# BTW I don't like monkey patching either
+# but this is not real monkey patching. 
+# I just added some methods and named them very uniquely
+# to avoid eventual conflicts. You're safe. Trust me.
+
+require 'net/http'
+
+class Net::HTTP
+  # Original #request with block semantics.
+  #
+  # def request(req, body = nil, &block)
+  #   unless started?
+  #     start {
+  #       req['connection'] ||= 'close'
+  #       return request(req, body, &block)
+  #     }
+  #   end
+  #   if proxy_user()
+  #     unless use_ssl?
+  #       req.proxy_basic_auth proxy_user(), proxy_pass()
+  #     end
+  #   end
+  #
+  #   req.set_body_internal body
+  #   begin_transport req
+  #     req.exec @socket, @curr_http_version, edit_path(req.path)
+  #     begin
+  #       res = HTTPResponse.read_new(@socket)
+  #     end while res.kind_of?(HTTPContinue)
+  #     res.reading_body(@socket, req.response_body_permitted?) {
+  #       yield res if block_given?
+  #     }
+  #   end_transport req, res
+  #
+  #   res
+  # end
+  
+  def begin_request_hacked(req)
+    begin_transport req
+    req.exec @socket, @curr_http_version, edit_path(req.path)
+    begin
+      res = Net::HTTPResponse.read_new(@socket)
+    end while res.kind_of?(Net::HTTPContinue)
+    res.begin_reading_body_hacked(@socket, req.response_body_permitted?)
+    @req_hacked, @res_hacked = req, res
+    @res_hacked
+  end
+  
+  def end_request_hacked
+    @res_hacked.end_reading_body_hacked
+    end_transport @req_hacked, @res_hacked
+    @res_hacked
+  end
+end
+
+class Net::HTTPResponse
+  # Original #reading_body with block semantics
+  #
+  # def reading_body(sock, reqmethodallowbody)  #:nodoc: internal use only
+  #   @socket = sock
+  #   @body_exist = reqmethodallowbody && self.class.body_permitted?
+  #   begin
+  #     yield
+  #     self.body   # ensure to read body
+  #   ensure
+  #     @socket = nil
+  #   end
+  # end
+  
+  def begin_reading_body_hacked(sock, reqmethodallowbody)
+    @socket = sock
+    @body_exist = reqmethodallowbody && self.class.body_permitted?
+  end
+  
+  def end_reading_body_hacked
+    self.body
+    @socket = nil
+  end
+end

data/lib/rack/http_streaming_response.rb

@@ -0,0 +1,49 @@
+require "net_http_hacked"
+
+module Rack
+
+  # Wraps the hacked net/http in a Rack way.
+  class HttpStreamingResponse
+    def initialize(request, host, port = nil)
+      @request, @host, @port = request, host, port
+    end
+    
+    def status
+      response.code
+    end
+    
+    def headers
+      h = Utils::HeaderHash.new
+      
+      response.each_header do |k, v|
+        h[k] = v
+      end
+      
+      h
+    end
+    
+    def body
+      self
+    end
+
+    def each(&block)
+      response.read_body(&block)
+    ensure
+      session.end_request_hacked
+    end
+        
+    protected
+    
+    # Net::HTTPResponse
+    def response
+      @response ||= session.begin_request_hacked(@request)
+    end
+    
+    # Net::HTTP
+    def session
+      @session ||= Net::HTTP.start(@host, @port)
+    end
+    
+  end
+
+end

data/lib/rack/proxy.rb

@@ -0,0 +1,54 @@
+require "net_http_hacked"
+require "rack/http_streaming_response"
+
+module Rack
+
+  # Subclass and bring your own #rewrite_request and #rewrite_response
+  class Proxy
+    def call(env)
+      rewrite_response(perform_request(rewrite_request(Rack::Request.new(env))))
+    end
+
+    def rewrite_request(req)
+      req
+    end
+    
+    def rewrite_response(res)
+      res
+    end
+
+    protected
+
+    def perform_request(req)
+      # Initialize request
+      http_request = Net::HTTP.const_get(req.request_method.capitalize).new(req.fullpath)
+
+      # Setup headers
+      http_request.initialize_http_header(http_request_headers(req))
+
+      # Setup body
+      if http_request.request_body_permitted? && req.body
+        http_request.body_stream = req.body
+      end
+      
+      # Create a streaming response (the actual network communication is deferred, a.k.a. streamed)
+      http_response = HttpStreamingResponse.new(http_request, req.host, req.port)
+      
+      [http_response.status, http_response.headers, http_response.body]
+    end
+    
+    def http_request_headers(req)
+      req.env.reject do |k, v| 
+        !(/^HTTP_[A-Z_]+$/ === k)
+      end.map do |k, v|
+        [k.sub(/^HTTP_/, ""), v]
+      end.inject({}) do |hash, k_v|
+        k, v = k_v
+        hash[k] = v
+        hash
+      end
+    end
+
+  end
+
+end

data/rack-proxy.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rack-proxy}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jacek Becela"]
+  s.date = %q{2010-01-08}
+  s.description = %q{A Rack app that provides request/response rewriting proxy capabilities with streaming.}
+  s.email = %q{jacek.becela@gmail.com}
+  s.files = [
+    ".gitignore",
+     "Rakefile",
+     "Readme",
+     "VERSION",
+     "lib/net_http_hacked.rb",
+     "lib/rack/http_streaming_response.rb",
+     "lib/rack/proxy.rb",
+     "rack-proxy.gemspec",
+     "test/http_streaming_response_test.rb",
+     "test/net_http_hacked_test.rb",
+     "test/rack_proxy_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ncr/rack-proxy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A request/response rewriting HTTP proxy. A Rack app.}
+  s.test_files = [
+    "test/http_streaming_response_test.rb",
+     "test/net_http_hacked_test.rb",
+     "test/rack_proxy_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_development_dependency(%q<rack-test>, [">= 0"])
+    else
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+  end
+end
+

data/test/http_streaming_response_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+require "rack/http_streaming_response"
+
+class HttpStreamingResponseTest < Test::Unit::TestCase
+  
+  def test_streaming
+    host, req = "trix.pl", Net::HTTP::Get.new("/")
+    
+    response = Rack::HttpStreamingResponse.new(req, host)
+    
+    # Response status
+    assert response.status == "200"
+    
+    # Headers
+    headers = response.headers
+    
+    assert headers.size > 0
+    assert headers["content-type"] == "text/html"
+    assert headers["CoNtEnT-TyPe"] == "text/html"
+    assert headers["content-length"].to_i > 0
+    
+    # Body
+    chunks = []
+    response.body.each do |chunk|
+      chunks << chunk
+    end
+    
+    assert chunks.size > 0
+    chunks.each do |chunk|
+      assert chunk.is_a?(String)
+    end
+  end
+  
+end
+

data/test/net_http_hacked_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+require "net_http_hacked"
+
+class NetHttpHackedTest < Test::Unit::TestCase
+  
+  def test_net_http_hacked
+    req = Net::HTTP::Get.new("/")
+    http = Net::HTTP.start("trix.pl", "80")
+    
+    # Response code
+    res = http.begin_request_hacked(req)
+    assert res.code == "200"
+    
+    # Headers
+    headers = {}
+    res.each_header { |k, v| headers[k] = v }
+
+    assert headers.size > 0
+    assert headers["content-type"] == "text/html"
+    assert headers["content-length"].to_i > 0
+    
+    # Body
+    chunks = []
+    res.read_body do |chunk|
+      chunks << chunk
+    end
+    
+    assert chunks.size > 0
+    chunks.each do |chunk|
+      assert chunk.is_a?(String)
+    end
+    
+    http.end_request_hacked
+  end
+  
+end

data/test/rack_proxy_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+require "rack/proxy"
+
+class RackProxyTest < Test::Unit::TestCase
+  class TrixProxy < Rack::Proxy
+    def rewrite_request(req)
+      req.env["HTTP_HOST"] = "trix.pl"
+      
+      req
+    end
+  end
+  
+  def app
+    TrixProxy.new
+  end
+  
+  def test_trix
+    get "/"
+    assert last_response.ok?
+    assert /Jacek Becela/ === last_response.body
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "test/unit"
+
+require "rack"
+require "rack/test"
+
+Test::Unit::TestCase.class_eval do
+  include Rack::Test::Methods
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: rack-proxy
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jacek Becela
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-08 00:00:00 +01: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"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A Rack app that provides request/response rewriting proxy capabilities with streaming.
+email: jacek.becela@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- Readme
+- VERSION
+- lib/net_http_hacked.rb
+- lib/rack/http_streaming_response.rb
+- lib/rack/proxy.rb
+- rack-proxy.gemspec
+- test/http_streaming_response_test.rb
+- test/net_http_hacked_test.rb
+- test/rack_proxy_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/ncr/rack-proxy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --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: 3
+summary: A request/response rewriting HTTP proxy. A Rack app.
+test_files: 
+- test/http_streaming_response_test.rb
+- test/net_http_hacked_test.rb
+- test/rack_proxy_test.rb
+- test/test_helper.rb