rack-streaming-proxy 1.0.0 → 1.0.1

data/Rakefile

@@ -19,5 +19,9 @@ Bones {
   ignore_file  '.gitignore'
   depend_on "rack", :version => "~> 1.0.1"
   depend_on "servolux", :version => "~> 0.8.1"
+  depend_on "rack-test", :version => "~> 0.5.1", :development => true
+  spec {
+    opts ["--colour",  "--loadby mtime", "--reverse", "--diff unified"]
+  }
 }
 

data/lib/rack/streaming_proxy/proxy_request.rb

@@ -35,7 +35,8 @@ class Rack::StreamingProxy
             # has not yet been read. start reading it and putting it in the parent's pipe.
             response_headers = {}
             response.each_header {|k,v| response_headers[k] = v}
-            @piper.puts [response.code.to_i, response_headers]
+            @piper.puts response.code.to_i
+            @piper.puts response_headers
 
             response.read_body do |chunk|
               @piper.puts chunk
@@ -43,22 +44,26 @@ class Rack::StreamingProxy
             @piper.puts :done
           end
         end
-
-        exit!
       end
 
       @piper.parent do
         # wait for the status and headers to come back from the child
-        @status, @headers = @piper.gets
-        @headers = HeaderHash.new(@headers)
+        @status = read_from_child
+        @headers = HeaderHash.new(read_from_child)
       end
+    rescue => e
+      @piper.parent { raise }
+      @piper.child { @piper.puts e }
+    ensure
+      # child needs to exit, always.
+      @piper.child { exit!(0) }
     end
 
     def each
       chunked = @headers["Transfer-Encoding"] == "chunked"
       term = "\r\n"
 
-      while chunk = @piper.gets
+      while chunk = read_from_child
         break if chunk == :done
         if chunked
           size = bytesize(chunk)
@@ -72,5 +77,14 @@ class Rack::StreamingProxy
       yield ["0", term, "", term].join if chunked
     end
 
+
+    protected
+
+    def read_from_child
+      val = @piper.gets
+      raise val if val.kind_of?(Exception)
+      val
+    end
+
   end
 end

data/lib/rack/streaming_proxy.rb

@@ -4,9 +4,9 @@ module Rack
     class Error < StandardError; end
 
     # :stopdoc:
-    VERSION = '1.0.0'
+    VERSION = '1.0.1'
     LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-    PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    PATH = ::File.expand_path(::File.join(::File.dirname(__FILE__), "..", "..")) + ::File::SEPARATOR
     # :startdoc:
 
     # Returns the version string for the library.
@@ -68,14 +68,16 @@ module Rack
     def call(env)
       req = Rack::Request.new(env)
       return app.call(env) unless uri = request_uri.call(req)
-      proxy = ProxyRequest.new(req, uri)
-      [proxy.status, proxy.headers, proxy]
-    rescue => e
-      msg = "Proxy error when proxying to #{uri}: #{e.class}: #{e.message}"
-      env["rack.errors"].puts msg
-      env["rack.errors"].puts e.backtrace.map { |l| "\t" + l }
-      env["rack.errors"].flush
-      raise Error, msg
+      begin # only want to catch proxy errors, not app errors
+        proxy = ProxyRequest.new(req, uri)
+        [proxy.status, proxy.headers, proxy]
+      rescue => e
+        msg = "Proxy error when proxying to #{uri}: #{e.class}: #{e.message}"
+        env["rack.errors"].puts msg
+        env["rack.errors"].puts e.backtrace.map { |l| "\t" + l }
+        env["rack.errors"].flush
+        raise Error, msg
+      end
     end
 
     protected

data/spec/app.ru

@@ -0,0 +1,55 @@
+require "yaml"
+
+class Streamer
+  include Rack::Utils
+
+  def initialize(sleep=0.05)
+    @sleep = sleep
+    @strings = 5.times.collect {|n| "~~~~~ #{n} ~~~~~\n" }
+  end
+
+  def call(env)
+    req = Rack::Request.new(env)
+    headers = {"Content-Type" => "text/plain"}
+    headers["Transfer-Encoding"] = "chunked"
+    [200, headers, self.dup]
+  end
+
+  def each
+    term = "\r\n"
+    @strings.each do |chunk|
+      size = bytesize(chunk)
+      yield [size.to_s(16), term, chunk, term].join
+      sleep @sleep
+    end
+    yield ["0", term, "", term].join
+  end
+end
+
+# if no content-length is provided and the response isn't streamed,
+# make sure the headers get a content length.
+use Rack::ContentLength
+
+map "/" do
+  run lambda { |env| [200, {"Content-Type" => "text/plain"}, "ALL GOOD"] }
+end
+
+map "/stream" do
+  run Streamer.new
+end
+
+map "/slow_stream" do
+  run Streamer.new(0.5)
+end
+
+map "/env" do
+  run lambda { |env|
+    req = Rack::Request.new(env)
+    req.POST # modifies env inplace to include "rack.request.form_vars" key
+    [200, {"Content-Type" => "application/x-yaml"}, [env.to_yaml]] }
+end
+
+map "/boom" do
+  run lambda { |env| [500, {"Content-Type" => "text/plain"}, "kaboom!"] }
+end
+

data/spec/proxy.ru

@@ -0,0 +1,9 @@
+require File.expand_path(
+  File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+
+use Rack::Lint
+# use Rack::CommonLogger
+use Rack::StreamingProxy do |req|
+  "http://localhost:4321#{req.path}"
+end
+run lambda { |env| [200, {}, "should never get here..."]}

data/spec/spec_helper.rb

@@ -1,14 +1,8 @@
 require File.expand_path(
-    File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+  File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+
+require "rack/test"
 
 Spec::Runner.configure do |config|
-  # == Mock Framework
-  #
-  # RSpec uses it's own mocking framework by default. If you prefer to
-  # use mocha, flexmock or RR, uncomment the appropriate line:
-  #
-  # config.mock_with :mocha
-  # config.mock_with :flexmock
-  # config.mock_with :rr
 end
 

data/spec/streaming_proxy_spec.rb

@@ -1,7 +1,147 @@
-
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe Rack::StreamingProxy do
-  it "has specs"
+  include Rack::Test::Methods
+
+  APP_PORT = 4321 # hardcoded in proxy.ru as well!
+  PROXY_PORT = 4322
+
+  def app
+    @app ||= Rack::Builder.new do
+      use Rack::Lint
+      use Rack::StreamingProxy do |req|
+        unless req.path.start_with?("/not_proxied")
+          url = "http://localhost:#{APP_PORT}#{req.path}"
+          url << "?#{req.query_string}" unless req.query_string.empty?
+          # STDERR.puts "PROXYING to #{url}"
+          url
+        end
+      end
+      run lambda { |env|
+        raise "app error" if env["PATH_INFO"] =~ /boom/
+        [200, {"Content-Type" => "text/plain"}, "not proxied"]
+      }
+    end
+  end
+
+  before(:all) do
+    app_path = Rack::StreamingProxy.path("spec", "app.ru")
+    @app_server = Servolux::Child.new(
+      # :command => "thin -R #{app_path} -p #{APP_PORT} start", # buffers!
+      :command => "rackup #{app_path} -p #{APP_PORT}",
+      :timeout => 30, # all specs should take <30 sec to run
+      :suspend => 0.25
+    )
+    puts "----- starting app server -----"
+    @app_server.start
+    sleep 2 # give it a sec
+    puts "----- started app server -----"
+  end
+
+  after(:all) do
+    puts "----- shutting down app server -----"
+    @app_server.stop
+    @app_server.wait
+    puts "----- app server is stopped -----"
+  end
+
+  def with_proxy_server
+    proxy_path = Rack::StreamingProxy.path("spec", "proxy.ru")
+    @proxy_server = Servolux::Child.new(
+      :command => "rackup #{proxy_path} -p #{PROXY_PORT}",
+      :timeout => 10,
+      :suspend => 0.25
+    )
+    puts "----- starting proxy server -----"
+    @proxy_server.start
+    sleep 2
+    puts "----- started proxy server -----"
+    yield
+  ensure
+    puts "----- shutting down proxy server -----"
+    @proxy_server.stop
+    @proxy_server.wait
+    puts "----- proxy server is stopped -----"
+  end
+
+  it "passes through to the rest of the stack if block returns false" do
+    get "/not_proxied"
+    last_response.should be_ok
+    last_response.body.should == "not proxied"
+  end
+
+  it "proxies a request back to the app server" do
+    get "/"
+    last_response.should be_ok
+    last_response.body.should == "ALL GOOD"
+  end
+
+  it "uses chunked encoding when the app server send data that way" do
+    get "/stream"
+    last_response.should be_ok
+    last_response.headers["Transfer-Encoding"].should == "chunked"
+    last_response.body.should =~ /^e\r\n~~~~~ 0 ~~~~~\n\r\n/
+  end
+
+  # this is the most critical spec: it makes sure things are actually streamed, not buffered
+  it "streams data from the app server to the client" do
+    @app = Rack::Builder.new do
+      use Rack::Lint
+      run lambda { |env|
+        body = []
+        Net::HTTP.start("localhost", PROXY_PORT) do |http|
+          http.request_get("/slow_stream") do |response|
+            response.read_body do |chunk|
+              body << "#{Time.now.to_i}\n"
+            end
+          end
+        end
+        [200, {"Content-Type" => "text/plain"}, body]
+      }
+    end
+
+    with_proxy_server do
+      get "/"
+      last_response.should be_ok
+      times = last_response.body.split("\n").map {|l| l.to_i}
+      unless (times.last - times.first) >= 2
+        violated "expected receive time of first chunk to be at least " +
+          "two seconds before the last chunk"
+      end
+    end
+
+  end
+
+  it "handles POST, PUT, and DELETE methods" do
+    post "/env"
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: POST/
+    put "/env"
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: PUT/
+    delete "/env"
+    last_response.should be_ok
+    last_response.body.should =~ /REQUEST_METHOD: DELETE/
+  end
+
+  it "sets a X-Forwarded-For header" do
+    post "/env"
+    last_response.should =~ /HTTP_X_FORWARDED_FOR: 127.0.0.1/
+  end
+
+  it "preserves the post body" do
+    post "/env", "foo" => "bar"
+    last_response.body.should =~ /rack.request.form_vars: foo=bar/
+  end
+
+  it "raises a Rack::Proxy::StreamingProxy error when something goes wrong" do
+    Rack::StreamingProxy::ProxyRequest.should_receive(:new).and_raise(RuntimeError.new("kaboom"))
+    lambda { get "/" }.should raise_error(Rack::StreamingProxy::Error, /proxy error.*kaboom/i)
+  end
+
+  it "does not raise a Rack::Proxy error if the app itself raises something" do
+    lambda { get "/not_proxied/boom" }.should raise_error(RuntimeError, /app error/)
+  end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-streaming-proxy
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Nathan Witmer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-15 00:00:00 -07:00
+date: 2009-11-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.8.1
     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.5.1
+    version: 
 - !ruby/object:Gem::Dependency 
   name: bones
   type: :development
@@ -56,11 +66,12 @@ files:
 - History.txt
 - README.txt
 - Rakefile
-- coderack.rb
 - dev/proxy.ru
 - dev/streamer.ru
 - lib/rack/streaming_proxy.rb
 - lib/rack/streaming_proxy/proxy_request.rb
+- spec/app.ru
+- spec/proxy.ru
 - spec/spec_helper.rb
 - spec/streaming_proxy_spec.rb
 has_rdoc: true

data/coderack.rb

@@ -1,133 +0,0 @@
-require "servolux"
-require "net/http"
-require "uri"
-
-# see: http://github.com/aniero/rack-streaming-proxy for the latest code
-# or: sudo gem install rack-streaming-proxy --source http://gemcutter.org
-
-module Rack
-  class StreamingProxy
-
-    class Error < StandardError; end
-
-    # The block provided to the initializer is given a Rack::Request
-    # and should return:
-    #
-    #   * nil/false to skip the proxy and continue down the stack
-    #   * a complete uri (with query string if applicable) to proxy to
-    #
-    # E.g.
-    #
-    #   use Rack::StreamingProxy do |req|
-    #     if req.path.start_with?("/search")
-    #       "http://some_other_service/search?#{req.query}"
-    #     end
-    #   end
-    #
-    # Most headers, request body, and HTTP method are preserved.
-    #
-    def initialize(app, &block)
-      @request_uri = block
-      @app = app
-    end
-
-    def call(env)
-      req = Rack::Request.new(env)
-      return app.call(env) unless uri = request_uri.call(req)
-      proxy = ProxyRequest.new(req, uri)
-      [proxy.status, proxy.headers, proxy]
-    rescue => e
-      msg = "Proxy error when proxying to #{uri}: #{e.class}: #{e.message}"
-      env["rack.errors"].puts msg
-      env["rack.errors"].puts e.backtrace.map { |l| "\t" + l }
-      env["rack.errors"].flush
-      raise Error, msg
-    end
-
-    protected
-
-    attr_reader :request_uri, :app
-
-    public
-
-
-    class ProxyRequest
-      include Rack::Utils
-
-      attr_reader :status, :headers
-
-      def initialize(request, uri)
-        uri = URI.parse(uri)
-
-        method = request.request_method.downcase
-        method[0..0] = method[0..0].upcase
-
-        proxy_request = Net::HTTP.const_get(method).new("#{uri.path}#{"?" if uri.query}#{uri.query}")
-
-        if proxy_request.request_body_permitted? and request.body
-          proxy_request.body_stream = request.body
-          proxy_request.content_length = request.content_length
-          proxy_request.content_type = request.content_type
-        end
-
-      %w(Accept Accept-Encoding Accept-Charset
-        X-Requested-With Referer User-Agent Cookie).each do |header|
-        key = "HTTP_#{header.upcase.gsub('-', '_')}"
-        proxy_request[header] = request.env[key] if request.env[key]
-        end
-      proxy_request["X-Forwarded-For"] =
-        (request.env["X-Forwarded-For"].to_s.split(/, +/) + [request.env["REMOTE_ADDR"]]).join(", ")
-      proxy_request.basic_auth(*uri.userinfo.split(':')) if (uri.userinfo && uri.userinfo.index(':'))
-
-      @piper = Servolux::Piper.new 'r', :timeout => 30
-
-      @piper.child do
-        Net::HTTP.start(uri.host, uri.port) do |http|
-          http.request(proxy_request) do |response|
-            # at this point the headers and status are available, but the body
-            # has not yet been read. start reading it and putting it in the parent's pipe.
-            response_headers = {}
-            response.each_header {|k,v| response_headers[k] = v}
-            @piper.puts [response.code.to_i, response_headers]
-
-            response.read_body do |chunk|
-              @piper.puts chunk
-            end
-            @piper.puts :done
-          end
-        end
-
-        exit!
-      end
-
-      @piper.parent do
-        # wait for the status and headers to come back from the child
-        @status, @headers = @piper.gets
-        @headers = HeaderHash.new(@headers)
-      end
-      end
-
-      def each
-        chunked = @headers["Transfer-Encoding"] == "chunked"
-        term = "\r\n"
-
-        while chunk = @piper.gets
-          break if chunk == :done
-          if chunked
-            size = bytesize(chunk)
-            next if size == 0
-            yield [size.to_s(16), term, chunk, term].join
-          else
-            yield chunk
-          end
-        end
-
-        yield ["0", term, "", term].join if chunked
-      end
-
-    end # ProxyRequest
-
-  end
-
-end
-