rack-reproxy 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc6068d5884538676a120ab16acf3048fbce97b9
+  data.tar.gz: ba82d90ae5890d41e15f2444c959ac9a0012d26e
+SHA512:
+  metadata.gz: 9f230747d266b2407b772d593f22dbe8c0454a7b4cf6f204a62e98642d15c987d013d4d78c67ebf9f2408ef5a92d33cfdb33f950e65b7aa97f340c2cd405a586
+  data.tar.gz: 67ea7ea085e4d11de1c5a210a6c776d93870a5f517123020be16eccd8ee1ded654dc4a979593bc2046d5c656916846913188f877d9ee1d9cb1bc1b3792749c0d

data/lib/rack-reproxy.rb

@@ -0,0 +1 @@
+require 'rack/reproxy'

data/lib/rack/reproxy.rb

@@ -0,0 +1,172 @@
+module Rack
+  # = Reproxy
+  #
+  # Allow Rack responses to be proxied from a different URL. It's like
+  # Rack::Sendfile, but for any HTTP backend.
+  #
+  # Rack apps can return a URI as a response body (or an X-Reproxy-Url header)
+  # and we pass it upstream to Nginx/Apache/Lighttpd to serve.
+  #
+  # This is an approach pioneered by MogileFS using perlbal to reproxy file
+  # requests to an internal storage backend.
+  #
+  # === Proxing to an internal app: serving private files
+  #
+  # Rack::Sendfile can efficiently serve files from the local filesystem.
+  # But that means you have to have your files NFS-mounted on all your app
+  # servers, and you have to know their physical paths.
+  #
+  # Instead, you can expose your file server as a private HTTP service and
+  # reproxy requests to it. Get rid of fussy NFS mounts and just stream files
+  # back from your internal server.
+  #
+  # === Proxying to yourself
+  #
+  # You can reproxy requests back to your own app, too. This is useful when you
+  # you'd like to HTTP-cache private, authenticated content. You can't put a
+  # public HTTP cache in front of your app, but you can put it in the middle!
+  #
+  # Your app receives a request, authenticates, and proxies its own response
+  # via an internal HTTP cache that's backed by... your app.
+  #
+  # === Nginx
+  #
+  # # In config.ru
+  #   use Rack::Reproxy::Nginx, location: '/reproxy'
+  #
+  # # Nginx config
+  #   location /reproxy {
+  #     internal;
+  #     set $reproxy_url $upstream_http_x_reproxy_url;
+  #     proxy_pass $reproxy_url;
+  #   }
+  #
+  # === Apache with mod_reproxy
+  #
+  # # In config.ru
+  #   use Rack::Reproxy::Apache
+  #
+  # # Apache config
+  #   <Location />
+  #     AllowReproxy on
+  #     PreserveHeaders Content-Type Content-Disposition ETag Last-Modified
+  #   </Location>
+  #
+  # === Lighttpd
+  #
+  # # In config.ru
+  #   use Rack::Reproxy::Lighttpd
+  #
+  # # Lighttpd config
+  #   proxy-core.allow-x-rewrite = "enable"
+  #
+  # === Rack
+  #
+  # Wait, what? Yeah, you can reproxy without doing an HTTP roundtrip by
+  # immediately redispatching back to your own app. This only becomes useful
+  # when you do something like reproxy through Rack::Cache.
+  #
+  # # In config.ru
+  #   use Rack::Reproxy::Rack
+  #
+  # # To proxy to a different Rack app
+  #   use Rack::Reproxy::Rack, app: SomeInternalApp.new
+  #
+  module Reproxy
+    class Middleware
+      def initialize(app, options = {})
+        @app = app
+        @header = options.fetch(:header, 'X-Reproxy-Url')
+        @scrub_reproxy_header = "HTTP_#{@header.gsub('-', '_').upcase}"
+      end
+
+      def call(env)
+        # Don't let clients ask us to reproxy URLs.
+        env.delete(@scrub_reproxy_header)
+
+        # In case the Rack app would like to know which header to set.
+        env['rack.reproxy.header'] ||= @header
+
+        status, headers, body = @app.call(env)
+
+        # Reproxy URI response bodies.
+        if body.is_a?(URI)
+          reproxy env, status, headers.merge(@header => body.to_s), body
+
+        # Reproxy explicit requests to respond with a different URL.
+        elsif headers.include?(@header)
+          reproxy env, status, headers, body
+
+        # Pass through the response, otherwise.
+        else
+          [status, headers, body]
+        end
+      end
+
+      private
+      def reproxy(env, status, headers, body)
+        [status, headers.merge('X-Reproxied' => '1'), []]
+      end
+    end
+
+    # Nginx relies on an upstream /reproxy location that proxies to
+    # X-Reproxy-Url. So we just return an X-Accel-Redirect: /reproxy header.
+    class Nginx < Middleware
+      def initialize(app, options = {})
+        super
+        @location = options.fetch(:location, '/reproxy')
+      end
+
+      private
+      def reproxy(env, status, headers, body)
+        super.tap do |response|
+          response[1]['X-Accel-Redirect'] = @location
+        end
+      end
+    end
+
+    # Apache with mod_reproxy uses X-Reproxy-Url directly.
+    class Apache < Middleware
+    end
+
+    # Lighttpd uses X-Rewrite-URI and X-Rewrite-Host response headers.
+    # Be sure to set proxy-core.allow-x-rewrite in your lighty config.
+    class Lighttpd < Middleware
+      private
+      def reproxy(env, status, headers, body)
+        super.tap do |response|
+          uri = URI(headers[@header])
+          response[1]['X-Rewrite-Host'] = uri.hostname
+          response[1]['X-Rewrite-URI']  = uri.request_uri
+        end
+      end
+    end
+
+    # Rack dispatches the request again and returns the proxied response
+    # with its headers merged onto the original response's.
+    class Rack < Middleware
+      def initialize(app, options = {})
+        super
+        @proxy_to = options.fetch(:app, self)
+      end
+
+      private
+      def reproxy(env, status, headers, body)
+        uri = URI(headers.delete(@header))
+
+        path_info = uri.path
+        if script_name = env['SCRIPT_NAME']
+          path_info.sub! /\A#{Regexp.escape(script_name)}/, ''
+        end
+
+        proxy_env = env.merge 'HTTP_X_REPROXIED' => '1',
+          'HTTP_HOST'     => uri.host,
+          'PATH_INFO'     => path_info,
+          'QUERY_STRING'  => uri.query
+
+        proxied_status, proxied_headers, proxied_body = @proxy_to.call(proxy_env)
+        [proxied_status, headers.merge(proxied_headers), proxied_body]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: rack-reproxy
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Jeremy Kemper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.2'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+description: 
+email: jeremykemper@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/rack-reproxy.rb"
+- "./lib/rack/reproxy.rb"
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Redispatch your response via another URL. Like a transparent, internal HTTP
+  redirect.
+test_files: []