rack-reverse-proxy-pact 1.0.0

data/lib/rack_reverse_proxy/roundtrip.rb

@@ -0,0 +1,286 @@
+require "rack_reverse_proxy/response_builder"
+
+module RackReverseProxy
+  # FIXME: Enable them and fix issues during refactoring
+  # rubocop:disable Metrics/ClassLength
+
+  # RoundTrip represents one request-response made by rack-reverse-proxy
+  # middleware.
+  class RoundTrip
+    def initialize(app, env, global_options, rules, response_builder_klass = ResponseBuilder)
+      @app = app
+      @env = env
+      @global_options = global_options
+      @rules = rules
+      @response_builder_klass = response_builder_klass
+    end
+
+    def call
+      return app.call(env) if rule.nil?
+      return proxy_with_newrelic if new_relic?
+      proxy
+    end
+
+    private
+
+    attr_reader :app, :env, :global_options, :rules, :response_builder_klass
+
+    def new_relic?
+      global_options[:newrelic_instrumentation]
+    end
+
+    def proxy_with_newrelic
+      perform_action_with_newrelic_trace(:name => action_name, :request => source_request) do
+        proxy
+      end
+    end
+
+    def action_name
+      "#{action_path}/#{source_request.request_method}"
+    end
+
+    def action_path
+      # Rack::ReverseProxy/foo/bar#GET
+      source_request.path.gsub(%r{/\d+}, "/:id").gsub(%r{^/}, "")
+    end
+
+    def uri
+      return @_uri if defined?(@_uri)
+      @_uri = rule.get_uri(path, env, headers, source_request)
+    end
+
+    def options
+      @_options ||= global_options.dup.merge(rule.options)
+    end
+
+    def https_redirect
+      rewrite_uri(uri, source_request)
+      uri.scheme = "https"
+      [301, { "Location" => uri.to_s }, [""]]
+    end
+
+    def need_https_redirect?
+      options[:force_ssl] &&
+        options[:replace_response_host] &&
+        source_request.scheme == "http"
+    end
+
+    def target_request
+      @_target_request ||= build_target_request
+    end
+
+    def target_request_headers
+      @_target_request_headers ||= headers
+    end
+
+    def build_target_request
+      Net::HTTP.const_get(
+        source_request.request_method.capitalize
+      ).new(uri.request_uri)
+    end
+
+    def preserve_host
+      return unless options[:preserve_host]
+      target_request_headers["HOST"] = host_header
+    end
+
+    def strip_headers
+      return unless options[:stripped_headers]
+      options[:stripped_headers].each do |header|
+        target_request_headers.delete(header)
+      end
+    end
+
+    def host_header
+      return uri.host if uri.port == uri.default_port
+      "#{uri.host}:#{uri.port}"
+    end
+
+    def set_forwarded_headers
+      return unless options[:x_forwarded_headers]
+      target_request_headers["X-Forwarded-Host"] = source_request.host
+      target_request_headers["X-Forwarded-Port"] = source_request.port.to_s
+      target_request_headers["X-Forwarded-Proto"] = source_request.scheme
+    end
+
+    def initialize_http_header
+      target_request.initialize_http_header(target_request_headers)
+    end
+
+    def set_basic_auth
+      return unless need_basic_auth?
+      target_request.basic_auth(options[:username], options[:password])
+    end
+
+    def need_basic_auth?
+      options[:username] && options[:password]
+    end
+
+    def setup_body
+      return unless can_have_body? && body?
+      source_request.body.rewind
+      target_request.body_stream = source_request.body
+    end
+
+    def can_have_body?
+      target_request.request_body_permitted?
+    end
+
+    def body?
+      source_request.body
+    end
+
+    def set_content_length
+      target_request.content_length = source_request.content_length || 0
+    end
+
+    def set_content_type
+      return unless content_type?
+      target_request.content_type = source_request.content_type
+    end
+
+    def content_type?
+      source_request.content_type
+    end
+
+    def target_response
+      @_target_response ||= response_builder_klass.new(
+        target_request,
+        uri,
+        options
+      ).fetch
+    end
+
+    def response_headers
+      @_response_headers ||= begin
+      headers = build_response_headers
+      headers = headers.transform_keys(&:downcase) unless rack_version_less_than_three
+      headers
+      end
+    end
+
+    def build_response_headers
+      ["Transfer-Encoding", "Status"].inject(rack_response_headers) do |acc, header|
+        acc.delete(header)
+        acc
+      end
+    end
+
+    def rack_response_headers
+      headers = Rack::Proxy.normalize_headers(format_headers(target_response.headers))
+      rack_version_less_than_three ?  Rack::Utils::HeaderHash.new(headers) : Rack::Headers.new.merge(headers)
+    end
+
+
+    def replace_location_header
+      return unless need_replace_location?
+      rewrite_uri(response_location, source_request)
+      response_headers[set_rack_version_specific_location_header] = response_location.to_s
+    end
+
+    def response_location
+      @_response_location ||= URI(response_headers[set_rack_version_specific_location_header] || uri)
+    end
+
+    def need_replace_location?
+      response_headers[set_rack_version_specific_location_header] && options[:replace_response_host] && response_location.host
+    end
+
+    def setup_request
+      preserve_host
+      strip_headers
+      set_forwarded_headers
+      initialize_http_header
+      set_basic_auth
+      setup_body
+      set_content_length
+      set_content_type
+    end
+
+    def setup_response_headers
+      replace_location_header
+    end
+
+    def rack_response
+      [target_response.status, response_headers, target_response.body]
+    end
+
+    def proxy
+      return app.call(env) if uri.nil?
+      return https_redirect if need_https_redirect?
+
+      setup_request
+      setup_response_headers
+
+      transform_response(rack_response)
+    end
+
+    def transform_response(response)
+      rule.transform(path, env, response, uri, headers, source_request)
+    end
+
+    def format_headers(headers)
+      headers.inject({}) do |acc, (key, val)|
+        formated_key = key.split("-").map(&:capitalize).join("-")
+        acc[formated_key] = Array(val)
+        acc
+      end
+    end
+
+    def request_default_port?(req)
+      [["http", 80], ["https", 443]].include?([req.scheme, req.port])
+    end
+
+    def rewrite_uri(uri, original_req)
+      uri.scheme = original_req.scheme
+      uri.host   = original_req.host
+      uri.port   = original_req.port unless request_default_port?(original_req)
+    end
+
+    def source_request
+      @_source_request ||= Rack::Request.new(env)
+    end
+
+    def rule
+      return @_rule if defined?(@_rule)
+      @_rule = find_rule
+    end
+
+    def find_rule
+      return if matches.empty?
+      non_ambiguous_match
+      matches.first
+    end
+
+    def path
+      @_path ||= source_request.fullpath
+    end
+
+    def headers
+      Rack::Proxy.extract_http_request_headers(source_request.env)
+    end
+
+    def matches
+      @_matches ||= rules.select do |rule|
+        rule.proxy?(path, headers, source_request)
+      end
+    end
+
+    def non_ambiguous_match
+      return unless ambiguous_match?
+      raise Errors::AmbiguousMatch.new(path, matches)
+    end
+
+    def ambiguous_match?
+      matches.length > 1 && global_options[:matching] != :first
+    end
+
+    def rack_version_less_than_three
+      Rack.release.split('.').first.to_i < 3
+    end
+
+    def set_rack_version_specific_location_header
+      rack_version_less_than_three ? 'Location' : 'location'
+    end
+  end
+end

data/lib/rack_reverse_proxy/rule.rb

@@ -0,0 +1,206 @@
+module RackReverseProxy
+  # Rule understands which urls need to be proxied
+  class Rule
+    # FIXME: It needs to be hidden
+    attr_reader :options
+
+    def initialize(spec, url = nil, options = {})
+      @has_custom_url = url.nil?
+      @url = url
+      @options = options
+      @spec = build_matcher(spec)
+    end
+
+    def proxy?(path, *args)
+      matches(path, *args).any?
+    end
+
+    def get_uri(path, env, *args)
+      Candidate.new(
+        self,
+        has_custom_url,
+        path,
+        env,
+        matches(path, *args)
+      ).build_uri
+    end
+
+    def transform(path, env, response, request_uri, *args)
+      Candidate.new(
+        self,
+        has_custom_url,
+        path,
+        env,
+        matches(path, *args)
+      ).transform(response, request_uri)
+    end
+
+    def to_s
+      %("#{spec}" => "#{url}")
+    end
+
+    private
+
+    attr_reader :spec, :url, :has_custom_url
+
+    def matches(path, *args)
+      Matches.new(
+        spec,
+        url,
+        path,
+        options[:accept_headers],
+        has_custom_url,
+        *args
+      )
+    end
+
+    def build_matcher(spec)
+      return /^#{spec}/ if spec.is_a?(String)
+      return spec if spec.respond_to?(:match)
+      return spec if spec.respond_to?(:call)
+      raise ArgumentError, "Invalid Rule for reverse_proxy"
+    end
+
+    # Candidate represents a request being matched
+    class Candidate
+      def initialize(rule, has_custom_url, path, env, matches)
+        @rule = rule
+        @env = env
+        @path = path
+        @has_custom_url = has_custom_url
+        @matches = matches
+
+        @url = evaluate(matches.custom_url)
+      end
+
+      def build_uri
+        return nil unless url
+        raw_uri
+      end
+
+      def transform(response, request_uri)
+        matches.transform(response, request_uri)
+      end
+
+      private
+
+      attr_reader :rule, :url, :has_custom_url, :path, :env, :matches
+
+      def raw_uri
+        return substitute_matches if with_substitutions?
+        return just_uri if has_custom_url
+        uri_with_path
+      end
+
+      def just_uri
+        URI.parse(url)
+      end
+
+      def uri_with_path
+        URI.join(url, path)
+      end
+
+      def evaluate(url)
+        return unless url
+        return url.call(env) if lazy?(url)
+        url.clone
+      end
+
+      def lazy?(url)
+        url.respond_to?(:call)
+      end
+
+      def with_substitutions?
+        url =~ /\$\d/
+      end
+
+      def substitute_matches
+        URI(matches.substitute(url))
+      end
+    end
+
+    # Matches represents collection of matched objects for Rule
+    class Matches
+      # rubocop:disable Metrics/ParameterLists
+
+      # FIXME: eliminate :url, :accept_headers, :has_custom_url
+      def initialize(spec, url, path, accept_headers, has_custom_url, headers, rackreq, *_)
+        @spec = spec
+        @url = url
+        @path = path
+        @has_custom_url = has_custom_url
+        @rackreq = rackreq
+
+        @headers = headers if accept_headers
+        @spec_arity = spec.method(spec_match_method_name).arity
+      end
+
+      def any?
+        found.any?
+      end
+
+      def custom_url
+        return url unless has_custom_url
+        found.map do |match|
+          match.url(path)
+        end.first
+      end
+
+      def substitute(url)
+        found.each_with_index.inject(url) do |acc, (match, i)|
+          acc.gsub("$#{i}", match)
+        end
+      end
+
+      def transform(response, request_uri)
+        found.inject(response) do |accumulator, match|
+          if match.respond_to?(:transform)
+            match.transform(accumulator, request_uri)
+          else
+            accumulator
+          end
+        end
+      end
+
+      private
+
+      attr_reader :spec, :url, :path, :headers, :rackreq, :spec_arity, :has_custom_url
+
+      def found
+        @_found ||= find_matches
+      end
+
+      def find_matches
+        Array(
+          spec.send(spec_match_method_name, *spec_params)
+        )
+      end
+
+      def spec_params
+        @_spec_params ||= _spec_params
+      end
+
+      def _spec_params
+        [
+          path,
+          headers,
+          rackreq
+        ][0...spec_param_count]
+      end
+
+      def spec_param_count
+        @_spec_param_count ||= _spec_param_count
+      end
+
+      def _spec_param_count
+        return 1 if spec_arity == -1
+        spec_arity
+      end
+
+      def spec_match_method_name
+        return :match if spec.respond_to?(:match)
+        :call
+      end
+    end
+  end
+end

data/lib/rack_reverse_proxy/version.rb

@@ -0,0 +1,4 @@
+#:nodoc:
+module RackReverseProxy
+  VERSION = "1.0.0".freeze
+end

data/lib/rack_reverse_proxy.rb

@@ -0,0 +1,8 @@
+require "rack_reverse_proxy/version"
+require "rack_reverse_proxy/errors"
+require "rack_reverse_proxy/rule"
+require "rack_reverse_proxy/middleware"
+
+# A Reverse Proxy for Rack
+module RackReverseProxy
+end

data/rack-reverse-proxy.gemspec

@@ -0,0 +1,49 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rack_reverse_proxy/version"
+
+# rubocop:disable
+Gem::Specification.new do |spec|
+  spec.name          = "rack-reverse-proxy-pact"
+  spec.version       = RackReverseProxy::VERSION
+
+  spec.authors = [
+    "Jon Swope",
+    "Ian Ehlert",
+    "Roman Ernst",
+    "Oleksii Fedorov"
+  ]
+
+  spec.email = [
+    "jaswope@gmail.com",
+    "ehlertij@gmail.com",
+    "rernst@farbenmeer.net",
+    "waterlink000@gmail.com"
+  ]
+
+  spec.summary       = "A Simple Reverse Proxy for Rack"
+  spec.description   = <<eos
+A Rack based reverse proxy for basic needs.
+Useful for testing or in cases where webserver configuration is unavailable.
+eos
+
+  spec.homepage      = "https://github.com/waterlink/rack-reverse-proxy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  if ENV['RACK_VERSION'] == '2'
+    spec.add_dependency 'rack', ">= 1.0.0", '< 3.0'
+  else
+    spec.add_dependency 'rack', '>= 3.0', '< 4.0'
+    spec.add_dependency 'rackup', '~> 2.0'
+  end
+  spec.add_dependency "rack-proxy", "~> 0.6", ">= 0.6.1"
+
+  spec.add_development_dependency "bundler", ">= 1.7", "< 3.0"
+  spec.add_development_dependency "rake", ">= 10.3"
+end
+# rubocop:enable

data/script/rubocop

@@ -0,0 +1,5 @@
+#/usr/bin/env bash
+
+if ruby -e 'exit(1) unless RUBY_VERSION.to_f >= 2.0'; then
+  bundle exec rubocop
+fi