whack-a-node 0.0.1

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+gem 'rack-proxy'
+gem 'rack'
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rack-test"
+  gem "webmock"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,42 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.5)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rack (1.2.2)
+    rack-proxy (0.3.4)
+      rack
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    webmock (1.6.2)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rack
+  rack-proxy
+  rack-test
+  rcov
+  rspec (~> 2.3.0)
+  webmock

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Niels Meersschaert
+
+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/README.rdoc

@@ -0,0 +1,36 @@
+= whack-a-node
+
+Node apps running in any rack server as a endpoint, and potentially a middleware layer.
+
+Leverage authentication, authorization and more in front of your node apps, letting node be used for high concurrency portions of your app.
+
+== Usage
+
+match "/proxy" => WhackANode.new("/")
+
+This will attempt to reach a node server on localhost at port 8810.  The response will be proxied by Rack.
+
+match "/redirect" => WhackANode.new("/","www.example.com", 2306, true)
+
+This will redirect to a node server at www.example.com on port 2306.  
+
+In this case, the last param causes the WhackANode to actually redirect instead of proxy the request.  In some cases, this can result in faster performance, as you don't have to have a Rack instance sitting around for the whole request.
+
+Generally speaking, using the proxy over a Rails controller ends up being about 8-10 times faster.  While still much slower than Node directly, this can still yield benefit.
+
+
+== Contributing to whack-a-node
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Niels Meersschaert & Matthew Jording. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "whack-a-node"
+  gem.homepage = "http://github.com/nielsm/whack-a-node"
+  gem.license = "MIT"
+  gem.summary = %Q{Run node apps as Rack apps}
+  gem.description = %Q{Extend your middleware to include Node.js}
+  gem.email = "nmeersschaert@mac.com"
+  gem.authors = ["Niels Meersschaert", "Matthew Jording"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "whack-a-node #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/net_http_hacked.rb

@@ -0,0 +1,91 @@
+# 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.
+#
+# Also, in Ruby 1.9.2 you could use Fibers to avoid hacking net/http.
+
+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,63 @@
+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.to_i
+    end
+    
+    def headers
+      h = Utils::HeaderHash.new
+      
+      response.each_header do |k, v|
+        h[k] = v
+      end
+      
+      h
+    end
+    
+    def body
+      self
+    end
+
+    # Can be called only once!
+    def each(&block)
+      response.read_body(&block)
+    ensure
+      session.end_request_hacked
+    end
+    
+    def to_s
+      @body ||= begin
+        lines = []
+
+        each do |line|
+          lines << line
+        end
+        
+        lines.join
+      end
+    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/reverse_proxy.rb

@@ -0,0 +1,142 @@
+require 'net/http'
+require 'net/https'
+
+module Rack
+  class ReverseProxy
+   
+
+    def initialize(app = nil, &b)
+      @app = app || lambda { [404, [], []] }
+      @paths = {}
+      @opts = {:preserve_host => false}
+      instance_eval &b if block_given?
+    end
+
+    def call(env)
+      rackreq = Rack::Request.new(env)
+      matcher, url = get_matcher_and_url rackreq.fullpath
+      return @app.call(env) if matcher.nil?
+      
+      
+
+      uri = get_uri(url, matcher, rackreq.fullpath) 
+      headers = Rack::Utils::HeaderHash.new
+      env.each { |key, value|
+        if key =~ /HTTP_(.*)/
+          headers[$1] = value
+        end
+      }
+			headers['HOST'] = uri.host if @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.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]
+        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.body_stream = rackreq.body
+        else
+          raise "method not supported: #{m}"
+        end
+
+        body = ''
+        res = http.request(req) do |res|
+          res.read_body do |segment|
+            body << segment
+          end
+        end
+
+        [res.code, create_response_headers(res), [body]]
+      }
+    end
+    
+    private
+
+
+    def get_matcher_and_url path
+      matches = @paths.select do |matcher, url|
+        match_path(path, matcher)
+      end
+
+      if matches.length < 1
+        nil
+      elsif matches.length > 1
+        raise AmbiguousProxyMatch.new(path, matches)
+      else
+        matches.first.map{|a| a.dup}
+      end
+    end
+
+    def create_response_headers http_response
+      response_headers = Rack::Utils::HeaderHash.new(http_response.to_hash)
+      # handled by Rack
+      response_headers.delete('status')
+      # TODO: figure out how to handle chunked responses
+      response_headers.delete('transfer-encoding')
+      # TODO: Verify Content Length, and required Rack headers
+      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
+    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)
+    end
+  end
+
+  class GenericProxyURI < Exception
+    attr_reader :url
+
+    def intialize(url)
+      @url = url
+    end
+
+    def to_s
+      %Q(Your URL "#{@url}" is too generic. Did you mean "http://#{@url}"?)
+    end
+  end
+
+  class AmbiguousProxyMatch < Exception
+    attr_reader :path, :matches
+    def initialize(path, matches)
+      @path = path
+      @matches = matches
+    end
+
+    def to_s
+      %Q(Path "#{path}" matched multiple endpoints: #{formatted_matches})
+    end
+
+    private
+
+    def formatted_matches
+      matches.map {|m| %Q("#{m[0].to_s}" => "#{m[1]}")}.join(', ')
+    end
+  end
+
+end
+

data/lib/rack/streaming_proxy.rb

@@ -0,0 +1,70 @@
+require "rack/http_streaming_response"
+
+module Rack
+
+  # Subclass and bring your own #rewrite_request and #rewrite_response
+  class StreamingProxy
+    VERSION = "0.3.4"
+    
+    def call(env)
+      rewrite_response(perform_request(rewrite_env(env)))
+    end
+
+    # Return modified env
+    def rewrite_env(env)
+      env
+    end
+    
+    # Return a rack triplet [status, headers, body]
+    def rewrite_response(triplet)
+      triplet
+    end
+
+    protected
+
+    def perform_request(env)
+      source_request = Rack::Request.new(env)
+      
+      # Initialize request
+      target_request = Net::HTTP.const_get(source_request.request_method.capitalize).new(source_request.fullpath)
+
+      # Setup headers
+      target_request.initialize_http_header(extract_http_request_headers(source_request.env))
+
+      # Setup body
+      if target_request.request_body_permitted? && source_request.body
+        target_request.body_stream    = source_request.body
+        target_request.content_length = source_request.content_length
+        target_request.content_type   = source_request.content_type if source_request.content_type
+      end
+      
+      # Create a streaming response (the actual network communication is deferred, a.k.a. streamed)
+      target_response = HttpStreamingResponse.new(target_request, source_request.host, source_request.port)
+      
+      [target_response.status, target_response.headers, target_response.body]
+    end
+    
+    def extract_http_request_headers(env)
+      headers = env.reject do |k, v|
+        !(/^HTTP_[A-Z_]+$/ === k)
+      end.map do |k, v|
+        [reconstruct_header_name(k), v]
+      end.inject(Utils::HeaderHash.new) do |hash, k_v|
+        k, v = k_v
+        hash[k] = v
+        hash
+      end
+
+      x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
+
+      headers.merge!("X-Forwarded-For" =>  x_forwarded_for)
+    end
+
+    def reconstruct_header_name(name)
+      name.sub(/^HTTP_/, "").gsub("_", "-")
+    end
+
+  end
+
+end
+

data/lib/whack-a-node.rb

@@ -0,0 +1,105 @@
+require 'rack/streaming_proxy'
+class WhackANode
+  
+  def initialize(path,host="localhost", port="8810",redirect=false)
+    @path = path
+    @host = host
+    @port = port
+    @redirect = redirect
+    @paths = {}
+  end
+  
+  def uri
+    URI("http://#{@host}:#{@port}#{@path}")
+  end
+  
+  def proxy_request
+    uri = self.uri
+    session = Net::HTTP.new(uri.host, uri.port)
+    session.start {|http|
+      req = Net::HTTP::Get.new(uri.request_uri)
+      body = ''
+      res = http.request(req) do |res|
+        res.read_body do |segment|
+          body << segment
+        end
+      end
+
+      [res.code, create_response_headers(res), [body]]
+      }
+  end
+  
+  def forward_request
+    [ 302, {'Location'=> uri.to_s }, [] ]
+  end
+  
+  def call(env)
+    return @redirect ? forward_request : proxy_request
+  end
+  
+    private
+
+
+    def get_matcher_and_url path
+      matches = @paths.select do |matcher, url|
+        match_path(path, matcher)
+      end
+
+      if matches.length < 1
+        nil
+      elsif matches.length > 1
+        raise AmbiguousProxyMatch.new(path, matches)
+      else
+        matches.first.map{|a| a.dup}
+      end
+    end
+
+    def create_response_headers http_response
+      response_headers = Rack::Utils::HeaderHash.new(http_response.to_hash)
+      # handled by Rack
+      response_headers.delete('status')
+      # TODO: figure out how to handle chunked responses
+      response_headers.delete('transfer-encoding')
+      # TODO: Verify Content Length, and required Rack headers
+      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
+    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)
+    end
+  
+
+  def rewrite_env(env)
+    env["PORT"] = "8000"
+
+    env
+  end
+
+  def rewrite_response(triplet)
+    status, headers, body = triplet
+
+    headers["X-Foo"] = "Bar"
+
+    triplet
+  end
+
+end

data/spec/rack/reverse_proxy_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rack::ReverseProxy do
+  include Rack::Test::Methods
+  include WebMock::API
+
+  def app
+    Rack::ReverseProxy.new
+  end
+
+  def dummy_app
+    lambda { [200, {}, ['Dummy App']] }
+  end
+
+  describe "as middleware" do
+    def app
+      Rack::ReverseProxy.new(dummy_app) do
+        reverse_proxy '/test', 'http://example.com/', {:preserve_host => true}
+      end
+    end
+
+    it "should forward requests to the calling app when the path is not matched" do
+      stub_request(:get, 'http://example.com/').to_return(:headers => {'Status' => '200 OK'})
+	    get '/'
+      last_response.body.should == "Dummy App"
+      last_response.should be_ok
+    end
+
+    it "should proxy requests when a pattern is matched" do
+      stub_request(:get, 'http://example.com/test').to_return({:body => "Proxied App"})
+      get '/test'
+      last_response.body.should == "Proxied App"
+    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'
+			last_response.headers['Status'].should == nil
+		end
+
+		it "the response header should never transfer-encoding" do
+			stub_request(:any, 'example.com/test/stuff').to_return(:headers => {'transfer-encoding' => 'Chunked'})
+			get '/test/stuff'
+			last_response.headers['transfer-encoding'].should == nil
+		end
+
+		it "should set the Host header" do
+			stub_request(:any, 'example.com/test/stuff')
+			get '/test/stuff'
+			a_request(:get, 'http://example.com/test/stuff').with(:headers => {"Host" => "example.com"}).should have_been_made
+		end
+
+    describe "with preserve host turned off" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/'
+        end
+      end
+
+      it "should not set the Host header" do
+        stub_request(:any, 'example.com/test/stuff')
+        get '/test/stuff'
+        a_request(:get, 'http://example.com/test/stuff').should have_been_made
+      end
+    end
+
+    describe "with basic auth turned on" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/', {:username => "joe", :password => "shmoe"}
+        end
+      end
+
+      it "should make request with basic auth" do
+        stub_request(:get, "http://joe:shmoe@example.com/test/stuff").to_return(:body => "secured content")
+        get '/test/stuff'
+        last_response.body.should == "secured content"
+      end
+    end
+
+    describe "with ambiguous routes" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/'
+          reverse_proxy /^\/test/, 'http://example.com/'
+        end
+      end
+
+      it "should throw an exception" do
+        lambda { get '/test' }.should raise_error(Rack::AmbiguousProxyMatch)
+      end
+    end
+
+    describe "with a route as a regular expression" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy %r|^/test(/.*)$|, 'http://example.com$1'
+        end
+      end
+
+      it "should support subcaptures" do
+        stub_request(:get, 'http://example.com/path').to_return({:body => "Proxied App"})
+        get '/test/path'
+        last_response.body.should == "Proxied App"
+      end
+    end
+
+		describe "with a https route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'https://example.com'
+        end
+      end
+
+			it "should make a secure request" do
+        stub_request(:get, 'https://example.com/test/stuff').to_return({:body => "Proxied Secure App"})
+        get '/test/stuff'
+        last_response.body.should == "Proxied Secure App"
+			end
+
+		end
+
+    describe "with a route as a string" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com'
+          reverse_proxy '/path', 'http://example.com/foo$0'
+        end
+      end
+
+      it "should append the full path to the uri" do
+        stub_request(:get, 'http://example.com/test/stuff').to_return({:body => "Proxied App"})
+        get '/test/stuff'
+        last_response.body.should == "Proxied App"
+      end
+
+    end
+
+    describe "with a generic url" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'example.com'
+        end
+      end
+
+      it "should throw an exception" do
+        lambda{ app }.should raise_error(Rack::GenericProxyURI)
+      end
+    end
+
+    describe "with a matching route" do
+      def app
+        Rack::ReverseProxy.new(dummy_app) do
+          reverse_proxy '/test', 'http://example.com/'
+        end
+      end
+
+      %w|get head delete put post|.each do |method|
+        describe "and using method #{method}" do
+          it "should forward the correct request" do
+            stub_request(method.to_sym, 'http://example.com/test').to_return({:body => "Proxied App for #{method}"})
+            eval "#{method} '/test'"
+            last_response.body.should == "Proxied App for #{method}"
+          end
+
+          if %w|put post|.include?(method)
+            it "should forward the request payload" do
+              stub_request(method.to_sym, 'http://example.com/test').to_return { |req| {:body => req.body} }
+              eval "#{method} '/test', {:test => 'test'}"
+              last_response.body.should == "test=test"
+            end
+          end
+        end
+      end
+    end
+  end
+
+
+end
+

data/spec/rack/streaming_proxy_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Rack::StreamingProxy do
+  include Rack::Test::Methods
+  include WebMock::API
+
+  def app 
+    Rack::StreamingProxy.new
+  end
+
+  it "should have a port of 90210" do
+     get "/"
+     last_response.should_not be_nil
+     #@app.should_not be_nil
+   end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rack/test'
+require 'whack-a-node'
+require 'rack/reverse_proxy'
+require 'rack/streaming_proxy'
+require 'webmock/rspec'
+    
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/whack-a-node_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rack/test'
+include Rack::Test::Methods
+
+describe "WhackANode" do
+  class WhackyTest < WhackANode
+    def rewrite_env(env)
+      env['PORT'] = 90210
+    end
+  end
+  
+  def app
+     WhackANode.new
+  end
+
+  #before(:each) do
+    #@app = WhackyTest.new
+  #end
+   it "should have a port of 90210" do
+     get "/"
+     last_response.should_not be_nil
+     #@app.should_not be_nil
+   end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification 
+name: whack-a-node
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Niels Meersschaert
+- Matthew Jording
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rack-proxy
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rack
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  name: rspec
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  name: jeweler
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rack-test
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: webmock
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id008
+description: Extend your middleware to include Node.js
+email: nmeersschaert@mac.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .DS_Store
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/net_http_hacked.rb
+- lib/rack/http_streaming_response.rb
+- lib/rack/reverse_proxy.rb
+- lib/rack/streaming_proxy.rb
+- lib/whack-a-node.rb
+- spec/rack/reverse_proxy_spec.rb
+- spec/rack/streaming_proxy_spec.rb
+- spec/spec_helper.rb
+- spec/whack-a-node_spec.rb
+has_rdoc: true
+homepage: http://github.com/nielsm/whack-a-node
+licenses: 
+- MIT
+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: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Run node apps as Rack apps
+test_files: 
+- spec/rack/reverse_proxy_spec.rb
+- spec/rack/streaming_proxy_spec.rb
+- spec/spec_helper.rb
+- spec/whack-a-node_spec.rb