rack-streaming-proxy 1.0.0

data/.gitignore

@@ -0,0 +1,18 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   Bones {
+#     ignore_file  '.gitignore'
+#   }
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
+announcement.txt
+coverage
+doc
+pkg

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2009-11-14
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,78 @@
+rack-streaming-proxy
+    by Nathan Witmer <nwitmer@gmail.com>
+    http://github.com/aniero/rack-streaming-proxy
+
+== DESCRIPTION:
+
+Streaming proxy for Rack, the rainbows to Rack::Proxy's unicorn.
+
+== FEATURES/PROBLEMS:
+
+Provides a transparent streaming proxy to be used as rack middleware.
+
+* Streams the response from the downstream server to minimize memory usage
+* Handles chunked encoding if used
+* Proxies GET/PUT/POST/DELETE, XHR, and cookies
+
+Use this when you need to have the response streamed back to the client,
+for example when handling large file requests that could be proxied
+directly but need to be authenticated against the rest of your middleware
+stack.
+
+Note that this will not work well with EventMachine. EM buffers the entire
+rack response before sending it to the client. When testing, try
+mongrel (via rackup) or passenger, rather than the EM-based thin. See
+http://groups.google.com/group/thin-ruby/browse_thread/thread/4762f8f851b965f6
+for more discussion.
+
+I've included a simple streamer app for testing and development.
+
+Thanks to:
+
+* Tom Lea (cwninja) for Rack::Proxy (http://gist.github.com/207938)
+* Tim Pease for bones, servolux, &c
+
+== SYNOPSIS:
+
+  require "rack/streaming_proxy"
+
+  use Rack::StreamingProxy do |request|
+    # inside the request block, return the full URI to redirect the request to,
+    # or nil/false if the request should continue on down the middleware stack.
+    if request.path.start_with?("/proxy")
+      "http://another_server#{request.path}"
+    end
+  end
+
+== REQUIREMENTS:
+
+* servolux (gem install servolux)
+
+== INSTALL:
+
+* sudo gem install rack-streaming-proxy --source http://gemcutter.org
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Nathan Witmer
+
+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/Rakefile

@@ -0,0 +1,23 @@
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+require 'rack/streaming_proxy'
+
+task :default => 'spec:specdoc'
+task 'gem:release' => 'spec:specdoc'
+
+Bones {
+  name  'rack-streaming-proxy'
+  authors  'Nathan Witmer'
+  email  'nwitmer@gmail.com'
+  url  'http://github.com/aniero/rack-streaming-proxy'
+  version  Rack::StreamingProxy::VERSION
+  ignore_file  '.gitignore'
+  depend_on "rack", :version => "~> 1.0.1"
+  depend_on "servolux", :version => "~> 0.8.1"
+}
+

data/coderack.rb

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

data/dev/proxy.ru

@@ -0,0 +1,13 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+
+use Rack::Reloader, 1
+# use Rack::CommonLogger # rackup already has commonlogger loaded
+use Rack::Lint
+use Rack::StreamingProxy do |req|
+  url = "http://localhost:4000#{req.path}"
+  url << "?#{req.query_string}" unless req.query_string.empty?
+  url
+end
+
+run lambda { |env| [200, {"Content-Type" => "text/plain"}, ""] }

data/dev/streamer.ru

@@ -0,0 +1,54 @@
+class Streamer
+  include Rack::Utils
+
+  def call(env)
+    req = Rack::Request.new(env)
+    headers = {"Content-Type" => "text/plain"}
+
+    @chunked = req.path.start_with?("/chunked")
+
+    if count = req.path.match(/(\d+)$/)
+      count = count[0].to_i
+    else
+      count = 100
+    end
+    @strings = count.times.collect {|n| "~~~~~ #{n} ~~~~~\n" }
+
+    if chunked?
+      headers["Transfer-Encoding"] = "chunked"
+    else
+      headers["Content-Length"] = @strings.inject(0) {|sum, s| sum += bytesize(s)}.to_s
+    end
+
+    [200, headers, self.dup]
+  end
+
+  def each
+    term = "\r\n"
+    @strings.each do |chunk|
+      if chunked?
+        size = bytesize(chunk)
+        yield [size.to_s(16), term, chunk, term].join
+      else
+        yield chunk
+      end
+      sleep 0.05
+    end
+    yield ["0", term, "", term].join if chunked?
+  end
+
+  protected
+
+  def chunked?
+    @chunked
+  end
+end
+
+# use Rack::CommonLogger # rackup already has commonlogger loaded
+use Rack::Lint
+
+# GET /
+# GET /10
+# GET /chunked
+# GET /chunked/10
+run Streamer.new

data/lib/rack/streaming_proxy/proxy_request.rb

@@ -0,0 +1,76 @@
+class Rack::StreamingProxy
+  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(", ")
+
+      @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
+end

data/lib/rack/streaming_proxy.rb

@@ -0,0 +1,95 @@
+module Rack
+  class StreamingProxy
+
+    class Error < StandardError; end
+
+    # :stopdoc:
+    VERSION = '1.0.0'
+    LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+    PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+    # :startdoc:
+
+    # Returns the version string for the library.
+    #
+    def self.version
+      VERSION
+    end
+
+    # Returns the library path for the module. If any arguments are given,
+    # they will be joined to the end of the libray path using
+    # <tt>File.join</tt>.
+    #
+    def self.libpath( *args )
+      args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    end
+
+    # Returns the lpath for the module. If any arguments are given,
+    # they will be joined to the end of the path using
+    # <tt>File.join</tt>.
+    #
+    def self.path( *args )
+      args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    end
+
+    # Utility method used to require all files ending in .rb that lie in the
+    # directory below this file that has the same name as the filename passed
+    # in. Optionally, a specific _directory_ name can be passed in such that
+    # the _filename_ does not have to be equivalent to the directory.
+    #
+    def self.require_all_libs_relative_to( fname, dir = nil )
+      dir ||= ::File.basename(fname, '.*')
+      search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+        Dir.glob(search_me).sort.each {|rb| require rb}
+    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
+
+  end
+
+end
+
+require "rack"
+require "servolux"
+require "net/http"
+require "uri"
+
+Rack::StreamingProxy.require_all_libs_relative_to(__FILE__)
+

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib rack streaming_proxy]))
+
+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

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Rack::StreamingProxy do
+  it "has specs"
+end
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: rack-streaming-proxy
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Nathan Witmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-15 00:00:00 -07: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: 1.0.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: servolux
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.8.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.1
+    version: 
+description: Streaming proxy for Rack, the rainbows to Rack::Proxy's unicorn.
+email: nwitmer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.txt
+files: 
+- .gitignore
+- 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/spec_helper.rb
+- spec/streaming_proxy_spec.rb
+has_rdoc: true
+homepage: http://github.com/aniero/rack-streaming-proxy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: rack-streaming-proxy
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Streaming proxy for Rack, the rainbows to Rack::Proxy's unicorn
+test_files: []
+