api_valve 0.0.1.alpha

checksums.yaml

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

data/README.md

@@ -0,0 +1,14 @@
+# ApiValve
+
+Lightweight API reverse proxy written in ruby. Based on rack.
+
+## Installation
+
+Just add the gem
+
+```ruby
+gem 'api_valve'
+```
+
+See the [examples](https://github.com/mkon/api_valve/tree/master/examples) section on how to create & configure your own
+proxy using this gem.

data/lib/api_valve/benchmarking.rb

@@ -0,0 +1,11 @@
+module ApiValve
+  module Benchmarking
+    def benchmark
+      result = nil
+      time = Benchmark.realtime do
+        result = yield
+      end
+      [result, time]
+    end
+  end
+end

data/lib/api_valve/error.rb

@@ -0,0 +1,13 @@
+module ApiValve
+  module Error
+    class Base < RuntimeError
+      class_attribute :http_status
+      self.http_status = :server_error
+    end
+
+    Rack::Utils::SYMBOL_TO_STATUS_CODE.each do |sym, code|
+      next unless code >= 400
+      const_set sym.to_s.camelize, Class.new(Base) { self.http_status = sym }
+    end
+  end
+end

data/lib/api_valve/error_responder.rb

@@ -0,0 +1,44 @@
+module ApiValve
+  class ErrorResponder
+    def initialize(error)
+      @error = error
+    end
+
+    def call
+      [
+        status,
+        {'Content-Type' => 'application/json'},
+        [MultiJson.dump({errors: [json_error]}, mode: :compat)]
+      ]
+    end
+
+    private
+
+    def status
+      Rack::Utils::SYMBOL_TO_STATUS_CODE[@error.http_status] || 500
+    end
+
+    def json_error
+      {
+        status: status,
+        code: json_code,
+        detail: json_detail,
+        meta: json_meta
+      }.compact
+    end
+
+    def json_code
+      @error.try(:code) || Rack::Utils::HTTP_STATUS_CODES[status]
+    end
+
+    def json_detail
+      @error.message != @error.class.to_s ? @error.message : nil
+    end
+
+    def json_meta
+      (@error.try(:to_hash).presence || {}).merge(
+        backtrace: ApiValve.expose_backtraces ? json_backtrace : nil
+      ).compact.presence
+    end
+  end
+end

data/lib/api_valve/forwarder/request.rb

@@ -0,0 +1,75 @@
+module ApiValve
+  # Wraps original request
+  # Responsible for altering the request before it is forwarded
+  class Forwarder::Request
+    attr_reader :original_request, :options
+
+    WHITELISTED_HEADERS = %w(
+      Accept
+      Content-Type
+      Forwarded
+      User-Agent
+      X-Forwarded-For
+      X-Forwarded-Host
+      X-Forwarded-Port
+      X-Forwarded-Proto
+    ).freeze
+    NOT_PREFIXED_HEADERS = %w(
+      Content-Length
+      Content-Type
+    ).freeze
+
+    def initialize(original_request, options = {})
+      @original_request = original_request
+      @options = default_options.merge options
+    end
+
+    def method
+      @method ||= original_request.request_method.downcase.to_sym
+    end
+
+    def path
+      path = options['endpoint'] || ''
+      if pattern = options['path']
+        path += pattern % options.dig('match_data').named_captures.symbolize_keys
+      else
+        path += original_request.path_info
+      end
+      path.gsub(%r{^/}, '')
+    end
+
+    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
+
+    def body
+      return unless %i(put post patch).include? method
+      original_request.body.read
+    end
+
+    def url_params
+      return unless original_request.query_string.present?
+      @url_params ||= Rack::Utils.parse_nested_query(original_request.query_string)
+    end
+
+    private
+
+    def whitelisted_headers
+      @options[:whitelisted_headers]
+    end
+
+    def default_options
+      {
+        whitelisted_headers: WHITELISTED_HEADERS
+      }
+    end
+  end
+end

data/lib/api_valve/forwarder/response.rb

@@ -0,0 +1,36 @@
+module ApiValve
+  # Wraps faraday response
+  # Responsible for altering the response before it is returned
+  class Forwarder::Response
+    attr_reader :original_response
+
+    WHITELISTED_HEADERS = %w(
+      Content-Type
+      Cache-Control
+    ).freeze
+
+    def initialize(original_response)
+      @original_response = original_response
+    end
+
+    def rack_response
+      [status, headers, [body]]
+    end
+
+    private
+
+    def status
+      original_response.status
+    end
+
+    def headers
+      WHITELISTED_HEADERS.each_with_object({}) do |k, h|
+        h[k] = original_response.headers[k]
+      end.compact
+    end
+
+    def body
+      original_response.body.to_s
+    end
+  end
+end

data/lib/api_valve/forwarder.rb

@@ -0,0 +1,75 @@
+module ApiValve
+  class Forwarder
+    autoload :Request,  'api_valve/forwarder/request'
+    autoload :Response, 'api_valve/forwarder/response'
+
+    include Benchmarking
+
+    DEFAULT_OPTIONS = {
+      response_klass: Response,
+      request_klass: Request
+    }.freeze
+
+    attr_accessor :response_klass, :request_klass
+    attr_reader :endpoint
+
+    def initialize(options = {})
+      DEFAULT_OPTIONS.merge(options).each do |k, v|
+        public_send("#{k}=", v)
+      end
+    end
+
+    def call(original_request, request_options = {})
+      request = request_klass.new(original_request, request_options)
+      response_klass.new(run_request(request)).rack_response
+    end
+
+    # Enforce trailing slash
+    def endpoint=(endpoint)
+      @endpoint = File.join(endpoint, '')
+    end
+
+    private
+
+    def run_request(request)
+      log_request request
+      response, elapsed_time = benchmark do
+        faraday.run_request(request.method, request.path, request.body, request.headers) do |req|
+          req.params.update(request.url_params) if request.url_params
+        end
+      end
+      log_response response, elapsed_time
+      response
+    end
+
+    def log_request(request)
+      ApiValve.logger.info do
+        format(
+          '-> %<method>s %<endpoint>s%<path>s',
+          method: request.method.upcase,
+          endpoint: endpoint,
+          path: request.path
+        )
+      end
+    end
+
+    def log_response(response, elapsed_time)
+      ApiValve.logger.info do
+        format(
+          '<- %<status>s in %<ms>dms',
+          status: response.status,
+          ms: elapsed_time * 1000
+        )
+      end
+    end
+
+    def faraday
+      @faraday ||= Faraday.new(
+        url: endpoint,
+        ssl: {verify: false}
+      ) do |config|
+        config.adapter Faraday.default_adapter
+      end
+    end
+  end
+end

data/lib/api_valve/middleware/error_handling.rb

@@ -0,0 +1,15 @@
+module ApiValve
+  module Middleware
+    class ErrorHandling
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        ErrorResponder.new(e).call
+      end
+    end
+  end
+end

data/lib/api_valve/proxy.rb

@@ -0,0 +1,68 @@
+require 'byebug'
+
+module ApiValve
+  class Proxy
+    include ActiveSupport::Rescuable
+
+    FORWARDER_OPTIONS = %w(endpoint).freeze
+
+    class << self
+      def from_yaml(file_path)
+        from_hash YAML.load_file(file_path)
+      end
+
+      def from_hash(config)
+        config = config.with_indifferent_access
+        forwarder = Forwarder.new(config.slice(*FORWARDER_OPTIONS))
+        new(forwarder).tap { |proxy| proxy.build_routes_from_config config }
+      end
+    end
+
+    attr_reader :forwarder, :router
+
+    def initialize(forwarder)
+      @forwarder = forwarder
+      @router = Router.new
+    end
+
+    def call(*args)
+      @router.call(*args)
+    rescue ApiValve::Error::Base => e
+      ErrorResponder.new(e).call
+    end
+
+    delegate :add_route, to: :router
+
+    def build_routes_from_config(config)
+      config['routes']&.each do |route_config|
+        method, path_regexp, req_conf = *route_config.values_at('method', 'path', 'request')
+        if route_config['raise']
+          deny method, path_regexp, with: route_config['raise']
+        else
+          forward method, path_regexp, req_conf
+        end
+      end
+      forward_all
+    end
+
+    def forward(methods, path_regexp = nil, config = {})
+      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 || {})
+        })
+      end
+    end
+
+    def forward_all
+      router.any do |request, match_data|
+        forwarder.call request, 'match_data' => match_data
+      end
+    end
+
+    def deny(methods, path_regexp = nil, with: 'Error::Forbidden')
+      Array.wrap(methods).each do |method|
+        router.public_send(method, path_regexp, ->(*_args) { raise ApiValve.const_get(with) })
+      end
+    end
+  end
+end

data/lib/api_valve/router.rb

@@ -0,0 +1,74 @@
+module ApiValve
+  class Router
+    METHODS = %i(get post put patch delete head).freeze
+
+    Route = Struct.new(:regexp, :block) do
+      delegate :call, to: :block
+
+      def match(path_info)
+        return {} if regexp.nil? # return empty 'match data' on catch all
+        regexp.match(path_info)
+      end
+    end
+
+    def initialize
+      reset_routes
+    end
+
+    def call(env)
+      match Rack::Request.new(env)
+    end
+
+    def delete(path = nil, callee = nil)
+      add_route :delete, path, callee || Proc.new
+    end
+
+    def get(path = nil, callee = nil)
+      add_route :get, path, callee || Proc.new
+    end
+
+    def head(path = nil, callee = nil)
+      add_route :head, path, callee || Proc.new
+    end
+
+    def patch(path = nil, callee = nil)
+      add_route :patch, path, callee || Proc.new
+    end
+
+    def post(path = nil, callee = nil)
+      add_route :post, path, callee || Proc.new
+    end
+
+    def put(path = nil, callee = nil)
+      add_route :put, path, callee || Proc.new
+    end
+
+    def any(path = nil, callee = nil)
+      add_route METHODS, path, callee || Proc.new
+    end
+
+    def reset_routes
+      @routes = Hash[METHODS.map { |v| [v, []] }].freeze
+    end
+
+    private
+
+    def add_route(methods, regexp, callee)
+      Array.wrap(methods).each do |method|
+        @routes[method] << Route.new(regexp, callee)
+      end
+    end
+
+    def match(request)
+      # For security reasons do not allow URLs that could break out of the proxy namespace on the
+      # server. Preferably an nxing/apache rewrite will kill these URLs before they hit us
+      raise 'URL not supported' if request.path_info.include?('/../')
+      @routes && @routes[request.request_method.downcase.to_sym].each do |route|
+        if match_data = route.match(request.path_info)
+          return route.call request, match_data
+        end
+      end
+      raise Error::NotFound, 'Endpoint not found'
+    end
+  end
+end

data/lib/api_valve.rb

@@ -0,0 +1,38 @@
+require 'active_support/configurable'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/module'
+require 'active_support/rescuable'
+require 'benchmark'
+require 'faraday'
+require 'multi_json'
+require 'logger'
+
+module ApiValve
+  autoload :Benchmarking,   'api_valve/benchmarking'
+  autoload :Error,          'api_valve/error'
+  autoload :ErrorResponder, 'api_valve/error_responder'
+  autoload :Forwarder,      'api_valve/forwarder'
+  autoload :Proxy,          'api_valve/proxy'
+  autoload :Router,         'api_valve/router'
+
+  include ActiveSupport::Configurable
+
+  module Middleware
+    autoload :ErrorHandling, 'api_valve/middleware/error_handling'
+  end
+
+  config_accessor :logger do
+    Logger.new(STDOUT)
+  end
+
+  config_accessor :expose_backtraces do
+    false
+  end
+
+  # :nocov:
+  def self.configure
+    yield config
+  end
+  # :nocov:
+end

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: api_valve
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha
+platform: ruby
+authors:
+- mkon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  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: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.22.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.22.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: 
+email:
+- konstantin@munteanu.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/api_valve.rb
+- lib/api_valve/benchmarking.rb
+- lib/api_valve/error.rb
+- lib/api_valve/error_responder.rb
+- lib/api_valve/forwarder.rb
+- lib/api_valve/forwarder/request.rb
+- lib/api_valve/forwarder/response.rb
+- lib/api_valve/middleware/error_handling.rb
+- lib/api_valve/proxy.rb
+- lib/api_valve/router.rb
+homepage: https://github.com/mkon/api_valve
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Lightweight ruby/rack API reverse proxy or gateway
+test_files: []