whack-a-node 0.0.1 → 0.0.2

data/Gemfile

@@ -2,8 +2,11 @@ source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
-gem 'rack-proxy'
 gem 'rack'
+gem 'dnode'
+gem 'eventmachine'
+gem 'events'
+gem 'json'
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -4,14 +4,16 @@ GEM
     addressable (2.2.5)
     crack (0.1.8)
     diff-lcs (1.1.2)
+    dnode (0.0.1)
+    eventmachine (0.12.10)
+    events (0.9.5)
     git (1.2.5)
     jeweler (1.5.2)
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
+    json (1.5.1)
     rack (1.2.2)
-    rack-proxy (0.3.4)
-      rack
     rack-test (0.5.7)
       rack (>= 1.0)
     rake (0.8.7)
@@ -33,9 +35,12 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.0.0)
+  dnode
+  eventmachine
+  events
   jeweler (~> 1.5.2)
+  json
   rack
-  rack-proxy
   rack-test
   rcov
   rspec (~> 2.3.0)

data/README.rdoc

@@ -4,20 +4,58 @@ Node apps running in any rack server as a endpoint, and potentially a middleware
 
 Leverage authentication, authorization and more in front of your node apps, letting node be used for high concurrency portions of your app.
 
+Reach a node app as an RPC directly from your Rails models (coming soon)
+
+== Prerequisites
+
+* Ruby 1.8.7 or 1.9.2 work fine
+* Node.js  
+	brew install node (or equivalent for your environment)
+* Rack[http://rack.rubyforge.org/] (or Rails 3)
+
+== Installation
+
+	sudo gem install whack-a-node
+
 == Usage
 
-match "/proxy" => WhackANode.new("/")
+In Rails 3's routes.rb:
 
-This will attempt to reach a node server on localhost at port 8810.  The response will be proxied by Rack.
+	match "/proxy" => WhackANode::Proxy.new("/")
 
-match "/redirect" => WhackANode.new("/","www.example.com", 2306, true)
+This will attempt to reach a node server on localhost at port 8810.  The response will be proxied by Rack.
 
-This will redirect to a node server at www.example.com on port 2306.  
+	match "/redirect" => WhackANode::Redirect.new("/","www.example.com", 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.
+This will redirect to a node server at www.example.com on port 2306.  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.
 
+== Examples
+
+=== Node server code
+
+server.js:
+
+	var http = require('http');
+	http.createServer(function (req, res) {
+  		res.writeHead(200, {'Content-Type': 'text/plain'});
+  		res.end('Hello World\n');
+	}).listen(8810, "127.0.0.1");
+	console.log('Server running at http://127.0.0.1:8810/');
+
+Start the node server by running node server.js
+
+=== Rails server
+Create a new Rails app.  Add the following to routes.rb
+
+	match "/proxy" => WhackANode::Proxy.new("/")  -- WhackANode defaults to localhost port 8810, so this will work with above server
+	
+Add Whack-A-Node to your Gemfile:
+
+	gem 'whack-a-node'
+
+Start your Rails app.  Hit http://localhost:3000/proxy.  You should see 'Hello World' generated by Node.js
 
 == Contributing to whack-a-node
  

data/Rakefile

@@ -8,7 +8,6 @@ rescue Bundler::BundlerError => e
   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

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/whack-a-node.rb

@@ -1,105 +1 @@
-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
+require File.expand_path(File.dirname(__FILE__) + "/whack_a_node")

data/lib/whack_a_node.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/whack_a_node/proxy')
+require File.expand_path(File.dirname(__FILE__) + '/whack_a_node/redirect')
+require File.expand_path(File.dirname(__FILE__) + '/whack_a_node/whacky')
+require File.expand_path(File.dirname(__FILE__) + '/whack_a_node/rpc')

data/lib/whack_a_node/proxy.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+module WhackANode
+  class Proxy
+    
+    def initialize(path="/",host="localhost", port="8810")
+      @path = path
+      @host = host
+      @port = port
+    end
+    
+    def call(env)
+      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 uri
+      URI("http://#{@host}:#{@port}#{@path}")
+    end
+    
+    private
+    
+    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
+  end
+end

data/lib/whack_a_node/redirect.rb

@@ -0,0 +1,19 @@
+module WhackANode
+  class Redirect
+    
+    def initialize(path="/",host="localhost", port="8810")
+      @path = path
+      @host = host
+      @port = port
+    end
+    
+    def call(env)
+      [ 302, {'Location'=> uri.to_s }, [] ]
+    end
+    
+    def uri
+      URI("http://#{@host}:#{@port}#{@path}")
+    end
+    
+  end
+end

data/lib/whack_a_node/rpc.rb

@@ -0,0 +1,104 @@
+require 'dnode'
+require 'eventmachine'
+require 'events'
+module WhackANode
+  class Rpc
+    def initialize(path="/",host="localhost", port="8820", redirect=false)
+      @path = path
+      @host = host
+      @port = port
+      @redirect = redirect
+
+    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
+end

data/lib/whack_a_node/whacky.rb

@@ -0,0 +1,13 @@
+module WhackANode
+  module Whacky
+    def initialize(path="/",host="localhost", port="8810")
+      @path = path
+      @host = host
+      @port = port
+    end
+    
+    def uri
+      URI("http://#{@host}:#{@port}#{@path}")
+    end
+  end
+end

data/spec/rpc_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'rack/test'
+
+describe "Rpc" do
+  include Rack::Test::Methods
+  include WebMock::API
+  class DwhackyTest < WhackANode::Rpc
+    def rewrite_env(env)
+      env['PORT'] = 90220
+    end
+  end
+  
+  def app
+     WhackANode::Rpc.new
+  end 
+
+   it "should have a port of 90210" do
+     stub_request(:get, "http://localhost:8810/").
+       with(:headers => {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+       to_return(:status => 200, :body => "", :headers => {})
+     #@app.should_not be_nil
+   end
+end
+

data/spec/spec_helper.rb

@@ -3,10 +3,7 @@ $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}

data/spec/whack-a-node_spec.rb

@@ -1,9 +1,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'rack/test'
-include Rack::Test::Methods
 
 describe "WhackANode" do
-  class WhackyTest < WhackANode
+  include Rack::Test::Methods
+  include WebMock::API
+  class WhackyTest < WhackANode::Proxy
     def rewrite_env(env)
       env['PORT'] = 90210
     end
@@ -17,8 +18,13 @@ describe "WhackANode" do
     #@app = WhackyTest.new
   #end
    it "should have a port of 90210" do
-     get "/"
-     last_response.should_not be_nil
+      stub_request(:get, "http://localhost:8810/").
+       with(:headers => {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+       to_return(:status => 200, :body => "", :headers => {})
+     
+     #stub_request(:get, 'http://example.com/').to_return({:body => "Proxied App"})
+     #get '/'
+     #last_response.should_not be_nil
      #@app.should_not be_nil
    end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: whack-a-node
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Niels Meersschaert
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-17 00:00:00 -04:00
+date: 2011-05-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,7 +31,7 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  name: rack-proxy
+  name: rack
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   prerelease: false
@@ -45,12 +45,54 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  name: rack
+  name: dnode
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  type: :development
+  type: :runtime
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: eventmachine
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: events
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: json
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -62,11 +104,11 @@ dependencies:
         - 0
         version: 2.3.0
   name: rspec
-  version_requirements: *id003
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   prerelease: false
   type: :development
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -78,11 +120,11 @@ dependencies:
         - 0
         version: 1.0.0
   name: bundler
-  version_requirements: *id004
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   prerelease: false
   type: :development
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -94,11 +136,11 @@ dependencies:
         - 2
         version: 1.5.2
   name: jeweler
-  version_requirements: *id005
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   prerelease: false
   type: :development
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -108,11 +150,11 @@ dependencies:
         - 0
         version: "0"
   name: rack-test
-  version_requirements: *id006
+  version_requirements: *id009
 - !ruby/object:Gem::Dependency 
   prerelease: false
   type: :development
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -122,11 +164,11 @@ dependencies:
         - 0
         version: "0"
   name: webmock
-  version_requirements: *id007
+  version_requirements: *id010
 - !ruby/object:Gem::Dependency 
   prerelease: false
   type: :development
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -136,7 +178,7 @@ dependencies:
         - 0
         version: "0"
   name: rcov
-  version_requirements: *id008
+  version_requirements: *id011
 description: Extend your middleware to include Node.js
 email: nmeersschaert@mac.com
 executables: []
@@ -147,20 +189,19 @@ 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
+- lib/whack_a_node.rb
+- lib/whack_a_node/proxy.rb
+- lib/whack_a_node/redirect.rb
+- lib/whack_a_node/rpc.rb
+- lib/whack_a_node/whacky.rb
+- spec/rpc_spec.rb
 - spec/spec_helper.rb
 - spec/whack-a-node_spec.rb
 has_rdoc: true
@@ -198,7 +239,6 @@ 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/rpc_spec.rb
 - spec/spec_helper.rb
 - spec/whack-a-node_spec.rb

data/lib/net_http_hacked.rb

@@ -1,91 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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/spec/rack/reverse_proxy_spec.rb

@@ -1,180 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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