ae_reverse_proxy 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3c66d26c7edb28c270618fa3e210d7d96cc46f8d81d85c0247daf31839d4f9eb
+  data.tar.gz: e7d859b126d02a8e2c726774b8c634a9f11fbd161ead8eb82ecc589006e20f66
+SHA512:
+  metadata.gz: de053974f52bf99341f8d5457661aa42ff8f107fa2e31bc2b0b2155a185c6a8531d16132d71de45f17cbfab36461e6d6c85c112e3ebc3cf60d779ebea459e54d
+  data.tar.gz: 11b8b5b987d1441dc4cf91fbca5a1746e29f66fd3e20ff5adda84d48fa4bd7d1110b757bc3ee61346fd7f55deca3cae5af5b3c671de08f527059bcff783e4aee

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org' do
+  group :test, :development do
+    gem 'bundler', '>= 1.10.4', '< 3'
+    gem 'minitest', '>= 5.8', '< 6'
+    gem 'mocha', '>= 1.11', '< 2'
+    gem 'pry'
+    gem 'rake', '>= 13', '< 14'
+    gem 'rubocop', '~> 1.8', require: false
+    gem 'webmock', '~> 3.11.1'
+  end
+end
+
+gemspec

data/README.md

@@ -0,0 +1,41 @@
+# AeReverseProxy
+
+A reverse proxy accepts a request from a client, forwards it to a server that can fulfill it, and returns the server's response to the client
+
+This is forked from https://github.com/axsuul/rails-reverse-proxy. Thanks to https://github.com/axsuul and contributors.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ae_reverse_proxy'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ae_reverse_proxy
+
+Use it in a console with:
+
+    $ ./console
+
+## Usage
+
+```ruby
+class ImageController < ActionController::Base
+  include AeReverseProxy::ControllerCallbackMethod
+
+  before_action do
+    reverse_proxy('https://www.another_server.com')
+  end
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: %i[test]

data/ae_reverse_proxy.gemspec

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ae_reverse_proxy'
+
+Gem::Specification.new do |spec|
+  spec.name                          = 'ae_reverse_proxy'
+  spec.version                       = AeReverseProxy::VERSION
+  spec.platform                      = Gem::Platform::RUBY
+  spec.authors                       = ['Appfolio']
+  spec.email                         = ['opensource@appfolio.com']
+  spec.summary                       = 'Gem for reverse proxying requests.'
+  spec.description                   = spec.summary
+  spec.license                       = 'MIT'
+  spec.required_ruby_version         = Gem::Requirement.new('>= 2.4.0')
+  spec.files                         = Dir['**/*'].select { |f| f[%r{^(lib/|Gemfile$|Rakefile|README.md|.*gemspec)}] }
+  spec.require_paths                 = ['lib']
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.add_runtime_dependency('addressable', '>= 2.3.6')
+  spec.add_runtime_dependency('rack', '~> 2.2.3')
+end

data/lib/ae_reverse_proxy.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AeReverseProxy
+  VERSION = '1.0.0'
+  autoload :Client, 'ae_reverse_proxy/client'
+  autoload :ControllerCallbackMethod, 'ae_reverse_proxy/controller_callback_method'
+end

data/lib/ae_reverse_proxy/client.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'addressable/uri'
+
+module AeReverseProxy
+  class Client
+    attr_accessor :uri, :callbacks
+
+    CALLBACK_METHODS = %i[
+      on_response
+      on_set_cookies
+      on_connect
+      on_success
+      on_redirect
+      on_missing
+      on_error
+      on_complete
+    ].freeze
+
+    # Define callback setters
+    CALLBACK_METHODS.each do |method|
+      define_method(method) do |&block|
+        callbacks[method] = block
+      end
+    end
+
+    def initialize(uri)
+      self.uri = uri
+      self.callbacks = CALLBACK_METHODS.to_h { |method| [method, proc {}] }
+
+      yield(self) if block_given?
+    end
+
+    def forward_request(env, options = {})
+      # Initialize requests
+      source_request = Rack::Request.new(env)
+      target_request = Net::HTTP.const_get(source_request.request_method.capitalize).new(source_request.path)
+
+      # Setup headers for forwarding.
+      target_request_headers = extract_http_request_headers(source_request.env).merge({
+        'ORIGIN' => uri.origin,
+        'HOST' => uri.authority,
+      })
+      target_request.initialize_http_header(target_request_headers)
+
+      # Setup basic auth.
+      target_request.basic_auth(options[:username], options[:password]) if options[:username] && options[:password]
+
+      # Setup body.
+      if target_request.request_body_permitted? && source_request.body
+        source_request.body.rewind
+        target_request.body_stream = source_request.body
+      end
+
+      # Setup content encoding and type.
+      target_request.content_length = source_request.content_length || 0
+      target_request.content_type   = source_request.content_type if source_request.content_type
+
+      # Don't encode response/support compression which was
+      # causing content length not match the actual content
+      # length of the response which ended up causing issues
+      # within Varnish (503)
+      target_request['Accept-Encoding'] = nil
+
+      # Setup HTTP SSL options.
+      http_options = {}
+      http_options[:use_ssl] = (uri.scheme == 'https')
+
+      # Make the request.
+      target_response = nil
+      Net::HTTP.start(uri.hostname, uri.port, http_options) do |http|
+        callbacks[:on_connect].call(http)
+        target_response = http.request(target_request)
+      end
+
+      # Initiate callbacks.
+      status_code = target_response.code.to_i
+      payload = [status_code, target_response]
+
+      callbacks[:on_response].call(payload)
+
+      if target_response.to_hash['set-cookie']
+        set_cookies_hash = {}
+        set_cookie_headers = target_response.to_hash['set-cookie']
+
+        set_cookie_headers.each do |set_cookie_header|
+          set_cookie_hash = parse_cookie(set_cookie_header)
+          name = set_cookie_hash[:name]
+          set_cookies_hash[name] = set_cookie_hash
+        end
+
+        callbacks[:on_set_cookies].call(payload | [set_cookies_hash])
+      end
+
+      case status_code
+      when 200..299
+        callbacks[:on_success].call(payload)
+      when 300..399
+        callbacks[:on_redirect].call(payload | [target_response['Location']]) if target_response['Location']
+      when 400..499
+        callbacks[:on_missing].call(payload)
+      when 500..599
+        callbacks[:on_error].call(payload)
+      end
+
+      callbacks[:on_complete].call(payload)
+
+      payload
+    end
+
+    private
+
+    COOKIE_PARAM_PATTERN = %r{\A([^(),/<>@;:\\"\[\]?={}\s]+)(?:=([^;]*))?\Z}.freeze
+    COOKIE_SPLIT_PATTERN = /;\s*/.freeze
+
+    def extract_http_request_headers(env)
+      env
+        .reject { |k, v| !(/^HTTP_[A-Z_]+$/ === k) || k == 'HTTP_VERSION' || v.nil? }
+        .map { |k, v| [reconstruct_header_name(k), v] }
+        .each_with_object(Rack::Utils::HeaderHash.new) do |k_v, hash|
+          k, v = k_v
+          hash[k] = v
+        end
+    end
+
+    def reconstruct_header_name(name)
+      name.sub(/^HTTP_/, '').gsub('_', '-')
+    end
+
+    def parse_cookie(cookie_str)
+      params = cookie_str.split(COOKIE_SPLIT_PATTERN)
+      info = params.shift.match(COOKIE_PARAM_PATTERN)
+      return {} unless info
+
+      cookie = {
+        name: info[1],
+        value: CGI.unescape(info[2]),
+      }
+
+      params.each do |param|
+        result = param.match(COOKIE_PARAM_PATTERN)
+        next unless result
+
+        key = result[1].downcase.to_sym
+        value = result[2]
+        case key
+        when :expires
+          begin
+            cookie[:expires] = Time.parse(value)
+          rescue ArgumentError
+          end
+        when :httponly, :secure
+          cookie[key] = true
+        else
+          cookie[key] = value
+        end
+      end
+
+      cookie
+    end
+  end
+end

data/lib/ae_reverse_proxy/controller_callback_method.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+
+module AeReverseProxy
+  module ControllerCallbackMethod
+    def reverse_proxy(uri)
+      proxy_uri = Addressable::URI.parse(uri)
+
+      client = AeReverseProxy::Client.new(proxy_uri) do |config|
+        config.on_response do |_code, response|
+          blacklist = [
+            'Connection',           # Always close connection
+            'Transfer-Encoding',    # Let Rails calculate this
+            'Content-Length', # Let Rails calculate this
+          ]
+
+          response.each_capitalized do |key, value|
+            next if blacklist.include?(key)
+
+            headers[key] = value
+          end
+        end
+
+        config.on_set_cookies do |_code, _response, set_cookies|
+          set_cookies.each do |key, attributes|
+            cookies[key] = attributes
+          end
+        end
+
+        config.on_redirect do |code, _response, redirect_url|
+          request_uri = Addressable::URI.parse(request.url)
+          redirect_uri = Addressable::URI.parse(redirect_url)
+
+          # Make redirect uri absolute if it's relative by
+          # joining it with the request url
+          redirect_uri = request_uri.join(redirect_url) if redirect_uri.host.nil?
+
+          if !redirect_uri.port.nil? && (redirect_uri.port == proxy_uri.port)
+            # Make sure it's consistent with our request port
+            redirect_uri.port = request.port
+          end
+
+          redirect_to redirect_uri.to_s, status: code
+          return
+        end
+
+        config.on_complete do |code, response|
+          content_type = response['Content-Type']
+          body = response.body.to_s
+
+          if content_type&.match(/image/)
+            send_data body, content_type: content_type, disposition: 'inline', status: code
+          else
+            render body: body, content_type: content_type, status: code
+          end
+        end
+      end
+
+      client.forward_request(request.env)
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ae_reverse_proxy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Appfolio
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+description: Gem for reverse proxying requests.
+email:
+- opensource@appfolio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- ae_reverse_proxy.gemspec
+- lib/ae_reverse_proxy.rb
+- lib/ae_reverse_proxy/client.rb
+- lib/ae_reverse_proxy/controller_callback_method.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Gem for reverse proxying requests.
+test_files: []