rack-delegate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c1d5ca6de8d7bac5979e2ac16460b6a801bc313
+  data.tar.gz: 28804039fe13751a0beaa1e18f05dede5ca5553d
+SHA512:
+  metadata.gz: 58696d495777a91a8df345f57ee8eaf43ab238fbf812b9b004d2741b6680b5fc6b0bd3b2404c927a28ea7bf584781ab215dfb226efafff5885466df8ac8b61ff
+  data.tar.gz: ee8b16bc8edcdcf0d5595bbcb7c5b22f729fb45940a3b2b2d4128698547ae88b8500175dea5c229283eb42447330e853502476966f07a9116a915a9eda1d9feb

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.tags

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rack-delegate.gemspec
+gemspec
+
+gem 'bundler', '~> 1.9'
+gem 'rake', '~> 10.0'
+
+gem 'minitest'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Genadi Samokovarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# Rack Delegate
+
+Rack level reverse proxy. Route requests to services with pure Ruby if that's
+your boat. The boat won't be pretty fast, but you can deploy it on your
+Heroku's, and what-not-fancy-cloud-services, without a bit of complications.
+
+The proxy can sit after the request authentication, or before it, depending on
+the services you have to route requests to. You can rewrite requests URLs, and
+even the whole `Net::HTTP::Reqest` to be sent out.
+
+## Installation
+
+Put this in the application `Gemfile`:
+
+```ruby
+gem 'rack-delegate'
+```
+
+`rack-delegate` requires Ruby 2.0 and above.
+
+## Usage
+
+To use `rack-delegate`, you first need to configure a delegator proxy. You can
+do that with `Rack::Delegate.configure`. Note that `Rack::Delegate.configure`,
+actually creates a middleware, which we can insert in an arbitrary stack later
+on.
+
+```ruby
+Macro::ApiGateway = Rack::Delegate.configure do
+  # Strips the leading /api out of the outgoing requests.
+  rewrite { path.gsub!(%r{\A/api}, '') }
+
+  # Don't proxy requests without them matching on the condition in the block.
+  constraints { |request| Version.new('v1').matches?(request) }
+
+  # With the rewrite on, requests you /api/users will go to
+  # http://users-service.intern/users.
+  from %r{\A/api/users},    to: 'http://users-service.intern'
+
+  # Requests go to http://payments-service.intern/payments.
+  from %r{\A/api/payments}, to: 'http://payments-service.intern'
+end
+
+module Macro
+  class Appplication
+    middleware.use ApiGateway
+  end
+end
+```
+
+Yes, you can insert multiple `Rack::Delegate` middleware instances in your
+stack. Say, one for requests that don't require authentication and one for
+requests that do.
+
+_(Given that the request authentication is a middleware itself.)_
+
+```ruby
+Macro::UnauthenticatedGateway = Rack::Delegate.configure do
+  rewrite { path.gsub!(%r{\A/api}, '') }
+
+  from %r{\A/registration}, to: 'http://registration-service.intern'
+end
+
+Macro::AuthenticatedGateway = Rack::Delegate.configure do
+  rewrite { path.gsub!(%r{\A/api}, '') }
+
+  from %r{\A/api/users},    to: 'http://users-service.intern'
+  from %r{\A/api/payments}, to: 'http://payments-service.intern'
+end
+
+module Macro
+  class Appplication
+    middleware.insert_before "Auth", UnauthenticatedGateway
+    middleware.insert_after "Auth", AuthenticatedGateway
+  end
+end
+```
+
+## Why
+
+![but](https://raw.githubusercontent.com/gsamokovarov/rack-delegate/master/.but.jpg)
+
+A question well asked, dear sir! Going micro-services early may bite you. Going
+micro-services for the sake of it may bite you. Going micro-services, because
+you can't manage that shitty app, well... may result in shitty services as
+well.
+
+Anyway, if you wanna go that route, you can do it quickly with Ruby and
+prototype. And if you do, you may as well need a better API gateway than this
+one. [OpenResty] may be useful for you.
+
+[OpenResty]: https://openresty.org/

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rack/delegate"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rack/delegate.rb

@@ -0,0 +1,31 @@
+require 'rack'
+
+module Rack
+  module Delegate
+    autoload :Rewriter, 'rack/delegate/rewriter'
+    autoload :NetHttpRequestBuilder, 'rack/delegate/net_http_request_builder'
+    autoload :Delegator, 'rack/delegate/delegator'
+    autoload :NetworkErrorResponse, 'rack/delegate/network_error_response'
+    autoload :Constraint, 'rack/delegate/constraint'
+    autoload :Action, 'rack/delegate/action'
+    autoload :ConstrainedAction, 'rack/delegate/constrained_action'
+    autoload :Configuration, 'rack/delegate/configuration'
+    autoload :Dispatcher, 'rack/delegate/dispatcher'
+
+    def self.configure(&block)
+      dispatcher = Dispatcher.configure(&block)
+
+      Struct.new(:app) do
+        define_method :call do |env|
+          request = Request.new(env)
+
+          if action = dispatcher.dispatch(request)
+            action.call(env)
+          else
+            app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rack/delegate/action.rb

@@ -0,0 +1,11 @@
+module Rack
+  module Delegate
+    class Action < Struct.new(:pattern, :delegator)
+      def dispatch(request)
+        pattern.match(request.fullpath) do
+          throw :dispatched, delegator
+        end
+      end
+    end
+  end
+end

data/lib/rack/delegate/configuration.rb

@@ -0,0 +1,57 @@
+module Rack
+  module Delegate
+    class Configuration
+      def self.from_block(&block)
+        config = new
+        config.instance_eval(&block)
+        config.actions
+      end
+
+      attr_reader :actions
+
+      def initialize
+        @actions = []
+        @constraints = []
+        @rewriter = Rewriter.new
+        @changer = Rewriter.new
+      end
+
+      def from(pattern, to:, constraints: nil)
+        action = Action.new(pattern, Delegator.new(to, @rewriter, @changer))
+        action = Rack::Timeout.new(action) if timeout?
+
+        constraints = Array(constraints).concat(@constraints)
+        action = ConstrainedAction.new(action, constraints) unless constraints.empty?
+
+        @actions << action
+      end
+
+      def rewrite(&block)
+        @rewriter = Rewriter.new do |uri|
+          uri.instance_eval(&block)
+          uri
+        end
+      end
+
+      def change
+        @changer = Rewriter.new do |request|
+          yield request
+          request
+        end
+      end
+
+      private
+
+      def constraints(*args, &block)
+        @constraints << args.flatten << block
+      end
+
+      def timeout?
+        require 'rack/timeout'
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+end

data/lib/rack/delegate/constrained_action.rb

@@ -0,0 +1,17 @@
+module Rack
+  module Delegate
+    class ConstrainedAction < Struct.new(:action, :constraints)
+      def dispatch(request)
+        if appropriate?(request)
+          action.dispatch(request)
+        end
+      end
+
+      private
+
+      def appropriate?(request)
+        Constraint.new(constraints) === request
+      end
+    end
+  end
+end

data/lib/rack/delegate/constraint.rb

@@ -0,0 +1,27 @@
+module Rack
+  module Delegate
+    class Constraint
+      def initialize(*constraints)
+        @constraints = constraints.flatten.compact
+      end
+
+      def ===(request)
+        @constraints.all? do |constraint|
+          invoke_polyglot_constraint(constraint, request)
+        end
+      end
+
+      private
+
+      SUPPORTED_CONSTRAINTS_INTERFACE = [:matches?, :call, :===]
+
+      def invoke_polyglot_constraint(constraint, request)
+        method = SUPPORTED_CONSTRAINTS_INTERFACE.find do |method|
+          constraint.respond_to?(method)
+        end
+        constraint.public_send(method, request)
+      end
+    end
+  end
+end
+

data/lib/rack/delegate/delegator.rb

@@ -0,0 +1,55 @@
+require 'timeout_errors'
+
+module Rack
+  module Delegate
+    class Delegator
+      class << self
+        attr_accessor :network_error_response
+      end
+
+      def initialize(url, uri_rewriter, net_http_request_rewriter)
+        @url = URI(url)
+        @uri_rewriter = uri_rewriter
+        @net_http_request_rewriter = net_http_request_rewriter
+      end
+
+      def call(env)
+        rack_request = Request.new(env)
+        net_http_request = NetHttpRequestBuilder.new(rack_request, @uri_rewriter, @net_http_request_rewriter).build
+
+        http_response = Net::HTTP.start(*net_http_options) do |http|
+          http.request(net_http_request)
+        end
+
+        convert_to_rack_response(http_response)
+      rescue TimeoutErrors
+        # TODO: Should I let the error in as an input?
+        network_error_response.call(env)
+      end
+
+      private
+
+      def net_http_options
+        [@url.host, @url.port, https: @url.scheme == 'https']
+      end
+
+      def network_error_response
+        self.class.network_error_response ||= NetworkErrorResponse
+      end
+
+      def convert_to_rack_response(http_response)
+        status = http_response.code
+        headers = normalize_headers_for(http_response)
+        body = Array(http_response.body)
+
+        [status, headers, body]
+      end
+
+      def normalize_headers_for(http_response)
+        http_response.to_hash.tap do |headers|
+          headers.delete('status')
+        end
+      end
+    end
+  end
+end

data/lib/rack/delegate/dispatcher.rb

@@ -0,0 +1,19 @@
+module Rack
+  module Delegate
+    class Dispatcher < Struct.new(:actions)
+      def self.configure(&block)
+        new(Configuration.from_block(&block))
+      end
+
+      def dispatch(request)
+        catch :dispatched do
+          actions.each do |action|
+            action.dispatch(request)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rack/delegate/net_http_request_builder.rb

@@ -0,0 +1,54 @@
+require 'net/http'
+
+module Rack
+  module Delegate
+    class NetHttpRequestBuilder < Struct.new(:rack_request, :uri_rewriter, :net_http_request_rewriter)
+      def build
+        net_http_request_class.new(url).tap do |net_http_request|
+          delegate_rack_headers_to(net_http_request)
+          delegate_rack_body_to(net_http_request)
+
+          rewrite_net_http_request(net_http_request)
+        end
+      end
+
+      private
+
+      def http_method
+        rack_request.request_method.capitalize
+      end
+
+      def net_http_request_class
+        Net::HTTP.const_get(http_method)
+      end
+
+      def url
+        uri_rewriter.rewrite(URI(rack_request.url))
+      end
+
+      def delegate_rack_headers_to(net_http_request)
+        net_http_request.initialize_http_header(headers_from_rack_request(rack_request))
+      end
+
+      def delegate_rack_body_to(net_http_request)
+        return unless net_http_request.request_body_permitted?
+
+        begin
+          net_http_request.body = rack_request.body.read
+        ensure
+          rack_request.body.rewind
+        end
+      end
+
+      def rewrite_net_http_request(net_http_request)
+        net_http_request_rewriter.rewrite(net_http_request)
+      end
+
+      def headers_from_rack_request(rack_request)
+        rack_request.env
+          .select  { |key, _| key.start_with?('HTTP_') }
+          .collect { |key, value| [key.sub(/^HTTP_/, '').tr('_', '-'), value] }
+      end
+    end
+  end
+end

data/lib/rack/delegate/network_error_response.rb

@@ -0,0 +1,17 @@
+module Rack
+  module Delegate
+    class NetworkErrorResponse < Struct.new(:env)
+      def self.call(env)
+        new(env).call
+      end
+
+      def call
+        status = 504
+        headers = {'Content-Type' => 'text/plain'}
+        body = ["Gateway Timeout\n"]
+
+        [status, headers, body]
+      end
+    end
+  end
+end

data/lib/rack/delegate/rewriter.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Delegate
+    class Rewriter
+      def initialize(&rewriter)
+        @rewriter = rewriter || proc { |id| id }
+      end
+
+      def rewrite(object)
+        @rewriter.call(object)
+      end
+    end
+  end
+end

data/lib/rack/delegate/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  module Delegate
+    VERSION = "0.1.0"
+  end
+end

data/rack-delegate.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'rack/delegate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-delegate"
+  spec.version       = Rack::Delegate::VERSION
+  spec.authors       = ["Genadi Samokovarov"]
+  spec.email         = ["gsamokovarov@gmail.com"]
+
+  spec.summary       = "Rack level reverse proxy."
+  spec.description   = "Rack level reverse proxy."
+  spec.homepage      = "https://github.com/gsamokovarov/rack-delegate"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack"
+  spec.add_dependency "timeout_errors"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: rack-delegate
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Genadi Samokovarov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-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: timeout_errors
+  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'
+description: Rack level reverse proxy.
+email:
+- gsamokovarov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".but.jpg"
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rack/delegate.rb
+- lib/rack/delegate/action.rb
+- lib/rack/delegate/configuration.rb
+- lib/rack/delegate/constrained_action.rb
+- lib/rack/delegate/constraint.rb
+- lib/rack/delegate/delegator.rb
+- lib/rack/delegate/dispatcher.rb
+- lib/rack/delegate/net_http_request_builder.rb
+- lib/rack/delegate/network_error_response.rb
+- lib/rack/delegate/rewriter.rb
+- lib/rack/delegate/version.rb
+- rack-delegate.gemspec
+homepage: https://github.com/gsamokovarov/rack-delegate
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Rack level reverse proxy.
+test_files: []