api_valve 0.0.1.alpha → 0.0.1.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6b393476b3a17c2f66a154ed51be1d1ffe1bd8425ba4bcd3758336da16a169a
-  data.tar.gz: b320775933274fd57cd9fc1792f0f0c9b881d27b3ceb87df16328adadcf1d6cf
+  metadata.gz: 0db44e3a1e246e94e9c31ad856fef01d7b76626cfe665bd18dfa769223c385bc
+  data.tar.gz: 7a05b9b44d9606bb831da1709bacc50135115311d4517f87bdad59e17ea3340d
 SHA512:
-  metadata.gz: 2c687fb655c0eed88ff7e197c7ea02346e92a113fc1c01940195b3df15d962f2c3224ebe6de122cb42db9c07d911f055510604013f5547d8a0637f5113407cdf
-  data.tar.gz: 18409ae39eabc1d45aaf34e7cd8e8328d339a0c1123c823408dedc414096eaa0c4dc4aa3272706672b107308bef08e1f52a37d3d707f3fc9ac1cc1f0d6bdb038
+  metadata.gz: d86f709762d7cd80fe4d1d01184310ae422e38dac84c9244a968ce52cae0ede75365975d8bd86b3fc9bdc5e9dd16d34ac1e94bf3f6129d97d662cabb13ac72d8
+  data.tar.gz: a733954d49421ad1735f12c27b3361026c8a3f4d5378837090d5373dcfb75e8409adca6566b6d437cfb64d0512a8531b8de551a14cd65ed1c60771df4514e039

data/lib/api_valve/error_responder.rb

@@ -15,7 +15,9 @@ module ApiValve
     private
 
     def status
-      Rack::Utils::SYMBOL_TO_STATUS_CODE[@error.http_status] || 500
+      status = @error.try(:http_status)
+      return status if status&.is_a?(Integer)
+      Rack::Utils::SYMBOL_TO_STATUS_CODE[status] || 500
     end
 
     def json_error

data/lib/api_valve/forwarder/permission_handler.rb

@@ -0,0 +1,40 @@
+module ApiValve
+  # This class is responsible to decide if a request is allowed or not, and can
+  # be extended with more ACL related features, for example returning a list of
+  # attributes that can be read or written.
+
+  class Forwarder::PermissionHandler
+    module RequestIntegration
+      private
+
+      def permission_handler
+        permission_handler_klass.instance(@original_request, permission_handler_options)
+      end
+
+      def permission_handler_klass
+        permission_handler_options[:klass] || Forwarder::PermissionHandler
+      end
+
+      def permission_handler_options
+        @options[:permission_handler] || {}
+      end
+    end
+
+    # Returns an instance of the PermissionHandler, cached in the request env
+    # This allows re-use of the PermissionHandler by both Request and Response instances
+    def self.instance(request, options)
+      request.env['permission_handler'] ||= new(request, options)
+    end
+
+    def initialize(request, options = {})
+      @request = request
+      @options = options
+    end
+
+    # Tells the request class if the request is allowed
+    # Simple implementation is always true. Override in your implementation.
+    def request_allowed?
+      true
+    end
+  end
+end

data/lib/api_valve/forwarder/request.rb

@@ -1,7 +1,12 @@
 module ApiValve
-  # Wraps original request
-  # Responsible for altering the request before it is forwarded
+  # This class is wraps the original request. It's methods are called by
+  # the Forwarder to make the actual request in the target endpoint.
+  # So by changing the public methods in this call, we can control how the
+  # request is forwarded
+
   class Forwarder::Request
+    include Forwarder::PermissionHandler::RequestIntegration
+
     attr_reader :original_request, :options
 
     WHITELISTED_HEADERS = %w(
@@ -21,13 +26,21 @@ module ApiValve
 
     def initialize(original_request, options = {})
       @original_request = original_request
-      @options = default_options.merge options
+      @options = options.with_indifferent_access
+    end
+
+    # Is the request allowed? If it returns false, Forwarder will raise Error::Forbidden
+    def allowed?
+      permission_handler.request_allowed?
     end
 
+    # HTTP method to use when forwarding. Must return sym.
+    # Returns original request method
     def method
       @method ||= original_request.request_method.downcase.to_sym
     end
 
+    # URL path to use when forwarding
     def path
       path = options['endpoint'] || ''
       if pattern = options['path']
@@ -35,26 +48,27 @@ module ApiValve
       else
         path += original_request.path_info
       end
+      # we remove leading slash so we can use endpoints with deeper folder levels
       path.gsub(%r{^/}, '')
     end
 
+    # Returns a hash of headers to forward to the target endpoint
+    # Override to control the HTTP headers that will be passed through
     def headers
       whitelisted_headers.each_with_object({}) do |key, h|
         h[key] = header(key)
       end.merge('X-Request-Id' => Thread.current[:request_id]).compact
     end
 
-    def header(name)
-      name = "HTTP_#{name}" unless NOT_PREFIXED_HEADERS.include? name
-      name = name.upcase.tr('-', '_')
-      original_request.get_header(name)
-    end
-
+    # Returns body to forward to the target endpoint
+    # Override to control the payload that is passed through
     def body
       return unless %i(put post patch).include? method
       original_request.body.read
     end
 
+    # Returns query params to forward to the target endpoint
+    # Override to control the query parameters that can be passed through
     def url_params
       return unless original_request.query_string.present?
       @url_params ||= Rack::Utils.parse_nested_query(original_request.query_string)
@@ -62,14 +76,14 @@ module ApiValve
 
     private
 
-    def whitelisted_headers
-      @options[:whitelisted_headers]
+    def header(name)
+      name = "HTTP_#{name}" unless NOT_PREFIXED_HEADERS.include? name
+      name = name.upcase.tr('-', '_')
+      original_request.get_header(name)
     end
 
-    def default_options
-      {
-        whitelisted_headers: WHITELISTED_HEADERS
-      }
+    def whitelisted_headers
+      @options[:whitelisted_headers] || WHITELISTED_HEADERS
     end
   end
 end

data/lib/api_valve/forwarder/response.rb

@@ -1,18 +1,31 @@
 module ApiValve
   # Wraps faraday response
   # Responsible for altering the response before it is returned
+
+  # This class is wraps the original response. The rack_response method
+  # is called by the Forwarder to build the rack response that will be
+  # returned by the proxy.
+  # By changing this class, we can control how the request is published
+  # to the original caller
+
   class Forwarder::Response
-    attr_reader :original_response
+    include Forwarder::PermissionHandler::RequestIntegration
+
+    attr_reader :original_request, :original_response
 
     WHITELISTED_HEADERS = %w(
       Content-Type
       Cache-Control
+      Location
     ).freeze
 
-    def initialize(original_response)
+    def initialize(original_request, original_response, options = {})
+      @original_request = original_request
       @original_response = original_response
+      @options = options.with_indifferent_access
     end
 
+    # Must return a rack compatible response array of status code, headers and body
     def rack_response
       [status, headers, [body]]
     end
@@ -24,11 +37,15 @@ module ApiValve
     end
 
     def headers
-      WHITELISTED_HEADERS.each_with_object({}) do |k, h|
+      whitelisted_headers.each_with_object({}) do |k, h|
         h[k] = original_response.headers[k]
       end.compact
     end
 
+    def whitelisted_headers
+      @options[:whitelisted_headers] || WHITELISTED_HEADERS
+    end
+
     def body
       original_response.body.to_s
     end

data/lib/api_valve/forwarder.rb

@@ -1,35 +1,50 @@
 module ApiValve
+  # This class is responsible for forwarding the HTTP request to the
+  # designated endpoint. It is instanciated once per Proxy with relevant
+  # options, and called from the router.
+
   class Forwarder
-    autoload :Request,  'api_valve/forwarder/request'
-    autoload :Response, 'api_valve/forwarder/response'
+    autoload :PermissionHandler, 'api_valve/forwarder/permission_handler'
+    autoload :Request,           'api_valve/forwarder/request'
+    autoload :Response,          'api_valve/forwarder/response'
 
     include Benchmarking
 
-    DEFAULT_OPTIONS = {
-      response_klass: Response,
-      request_klass: Request
-    }.freeze
+    # Initialized with global options. Possible values are:
+    # request: Options for the request wrapper. See Request#new.
+    # response: Options for the response wrapper. See Response#new
+    def initialize(options = {})
+      @options = options.with_indifferent_access
+    end
 
-    attr_accessor :response_klass, :request_klass
-    attr_reader :endpoint
+    # Takes the original rack request with optional options and returns a rack response
+    # Instanciates the Request and Response classes and wraps them arround the original
+    # request and response.
+    def call(original_request, local_options = {})
+      request = request_klass.new(original_request, request_options.deep_merge(local_options))
+      raise Error::Forbidden unless request.allowed?
+      response_klass.new(original_request, run_request(request), response_options).rack_response
+    end
 
-    def initialize(options = {})
-      DEFAULT_OPTIONS.merge(options).each do |k, v|
-        public_send("#{k}=", v)
-      end
+    private
+
+    def request_klass
+      request_options[:klass] || Request
     end
 
-    def call(original_request, request_options = {})
-      request = request_klass.new(original_request, request_options)
-      response_klass.new(run_request(request)).rack_response
+    def request_options
+      # integrate permission handler options as it is instantiated in the request
+      (@options[:request] || {}).merge(@options.slice(:permission_handler))
     end
 
-    # Enforce trailing slash
-    def endpoint=(endpoint)
-      @endpoint = File.join(endpoint, '')
+    def response_klass
+      response_options[:klass] || Response
     end
 
-    private
+    def response_options
+      # integrate permission handler options as it is instantiated in the response
+      (@options[:response] || {}).merge(@options.slice(:permission_handler) || {})
+    end
 
     def run_request(request)
       log_request request
@@ -40,6 +55,8 @@ module ApiValve
       end
       log_response response, elapsed_time
       response
+    rescue Faraday::ConnectionFailed
+      raise Error::ServiceUnavailable
     end
 
     def log_request(request)
@@ -71,5 +88,10 @@ module ApiValve
         config.adapter Faraday.default_adapter
       end
     end
+
+    # Enforce trailing slash
+    def endpoint
+      @endpoint ||= File.join(@options[:endpoint], '')
+    end
   end
 end

data/lib/api_valve/proxy.rb

@@ -2,9 +2,11 @@ require 'byebug'
 
 module ApiValve
   class Proxy
-    include ActiveSupport::Rescuable
+    include ActiveSupport::Callbacks
 
-    FORWARDER_OPTIONS = %w(endpoint).freeze
+    FORWARDER_OPTIONS = %w(endpoint request response permission_handler).freeze
+
+    define_callbacks :call
 
     class << self
       def from_yaml(file_path)
@@ -18,15 +20,16 @@ module ApiValve
       end
     end
 
-    attr_reader :forwarder, :router
+    attr_reader :request, :forwarder, :router
 
     def initialize(forwarder)
       @forwarder = forwarder
       @router = Router.new
     end
 
-    def call(*args)
-      @router.call(*args)
+    def call(env)
+      @request = Rack::Request.new(env)
+      run_callbacks(:call) { @router.call(@request) }
     rescue ApiValve::Error::Base => e
       ErrorResponder.new(e).call
     end
@@ -35,20 +38,21 @@ module ApiValve
 
     def build_routes_from_config(config)
       config['routes']&.each do |route_config|
-        method, path_regexp, req_conf = *route_config.values_at('method', 'path', 'request')
+        method, path_regexp, request_override = *route_config.values_at('method', 'path', 'request')
+        method ||= %w(get head patch post put) # no method defined means all methods
         if route_config['raise']
           deny method, path_regexp, with: route_config['raise']
         else
-          forward method, path_regexp, req_conf
+          forward method, path_regexp, request_override
         end
       end
       forward_all
     end
 
-    def forward(methods, path_regexp = nil, config = {})
+    def forward(methods, path_regexp = nil, request_override = {})
       Array.wrap(methods).each do |method|
         router.public_send(method, path_regexp, proc { |request, match_data|
-          forwarder.call request, {'match_data' => match_data}.merge(config || {})
+          forwarder.call request, {'match_data' => match_data}.merge(request_override || {})
         })
       end
     end

data/lib/api_valve/router.rb

@@ -15,8 +15,8 @@ module ApiValve
       reset_routes
     end
 
-    def call(env)
-      match Rack::Request.new(env)
+    def call(request)
+      match request
     end
 
     def delete(path = nil, callee = nil)

data/lib/api_valve.rb

@@ -1,7 +1,10 @@
+require 'active_support/callbacks'
 require 'active_support/configurable'
 require 'active_support/core_ext/class'
 require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object'
 require 'active_support/core_ext/module'
+require 'active_support/json'
 require 'active_support/rescuable'
 require 'benchmark'
 require 'faraday'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: api_valve
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha
+  version: 0.0.1.beta.1
 platform: ruby
 authors:
 - mkon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-17 00:00:00.000000000 Z
+date: 2018-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -106,28 +106,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.54.0
+        version: 0.56.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.54.0
+        version: 0.56.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.22.2
+        version: 1.25.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.22.2
+        version: 1.25.1
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -183,6 +183,7 @@ files:
 - lib/api_valve/error.rb
 - lib/api_valve/error_responder.rb
 - lib/api_valve/forwarder.rb
+- lib/api_valve/forwarder/permission_handler.rb
 - lib/api_valve/forwarder/request.rb
 - lib/api_valve/forwarder/response.rb
 - lib/api_valve/middleware/error_handling.rb