spokes 0.1.1

data/lib/spokes/middleware/request_id.rb

@@ -0,0 +1,43 @@
+module Spokes
+  module Middleware
+    class RequestID
+      PATTERN = /^[\w\\-_\\.\d]+$/
+
+      def initialize(app, service_name:)
+        raise "invalid name: #{service_name}" unless service_name =~ PATTERN
+
+        @app          = app
+        @service_name = service_name
+      end
+
+      def call(env)
+        id = env['action_dispatch.request_id'] || SecureRandom.uuid
+        request_ids = extract_request_ids(env).insert(0, @service_name + ':' + id)
+
+        # make ID of the request accessible to consumers down the stack
+        env['REQUEST_ID'] = request_ids[0]
+
+        # Extract request IDs from incoming headers as well. Can be used for
+        # identifying a request across a number of components in SOA.
+        env['REQUEST_IDS'] = request_ids
+
+        Thread.current[:request_chain] = env['REQUEST_IDS']
+
+        @app.call(env)
+      end
+
+      private
+
+      def extract_request_ids(env)
+        request_ids = raw_request_ids(env)
+        request_ids.map!(&:strip)
+        request_ids
+      end
+
+      def raw_request_ids(_env)
+        %w[HTTP_REQUEST_CHAIN].each_with_object([]) do |key, _request_ids|
+        end
+      end
+    end
+  end
+end

data/lib/spokes/middleware/service_name.rb

@@ -0,0 +1,65 @@
+module Spokes
+  module Middleware
+    # Validates inbound and sets outbound Service-Name HTTP headers.
+    #
+    # Usage:
+    #
+    #   class Application < Rails::Application
+    #     config.middleware.use Spokes::Middleware::ServiceName
+    #   end
+    #
+    class ServiceName
+      include Middleware::Concerns::BadRequest
+      include Middleware::Concerns::HeaderValidation
+
+      PATTERN     = /^[\w\\-_\\.\d]+$/
+      HEADER_NAME = 'Service-Name'.freeze
+
+      def initialize(app, service_name:, exclude_paths: [])
+        raise "invalid name: #{service_name}" unless service_name =~ PATTERN
+        @app          = app
+        @service_name = service_name
+        @exclude_paths = path_to_regex(exclude_paths)
+      end
+
+      def call(env)
+        begin
+          unless exclude?(env['PATH_INFO'].chomp('/'))
+            validate_header_presence(env: env, header_name: HEADER_NAME)
+            validate_header_pattern(env: env, header_name: HEADER_NAME, pattern: PATTERN)
+          end
+        rescue Middleware::Concerns::HeaderValidation::NotValid => e
+          return bad_request(e.message)
+        end
+
+        status, headers, body = @app.call(env)
+        headers[HEADER_NAME] = @service_name
+        [status, headers, body]
+      end
+
+      private
+
+      def exclude?(path)
+        @exclude_paths.each do |regex|
+          return true if regex.match?(path)
+        end
+        false
+      end
+
+      # build out regular expression to match exclude path
+      def path_to_regex(exclude_paths)
+        reg_ex_path = []
+        exclude_paths.each do |path|
+          path_parts = path.split('/')
+          regex_paths = path_parts.inject do |out, p|
+            val = p
+            val = '(\\S*)' if p.include?(':')
+            out + '[/]' + val
+          end
+          reg_ex_path.push(Regexp.new(regex_paths))
+        end
+        reg_ex_path
+      end
+    end
+  end
+end

data/lib/spokes/version.rb

@@ -0,0 +1,3 @@
+module Spokes
+  VERSION = '0.1.1'.freeze
+end

data/lib/spokes/versioning/config/minor_versions.yml

@@ -0,0 +1,3 @@
+# "2015-07-04":
+#   default: true
+#   description: My first version.

data/lib/spokes/versioning/minor_versioning.rb

@@ -0,0 +1,71 @@
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext'
+require_relative 'railtie' if defined?(Rails)
+
+module Spokes
+  module Versioning
+    # Minor versioning mix-in for controllers.
+    #
+    # Usage:
+    #
+    #   # app/controllers/my_controller.rb
+    #   class MyController
+    #     include MinorVersioning
+    #
+    #     def index
+    #       logger.info(minor_version)
+    #     end
+    #   end
+    #
+    module MinorVersioning
+      extend ActiveSupport::Concern
+
+      API_VERSION = 'API-Version'.freeze
+
+      included do
+        include MinorVersioning
+        after_filter :set_minor_version_response_header
+      end
+
+      def set_minor_version_response_header
+        response.headers[API_VERSION] = minor_version
+      end
+
+      def minor_version
+        @minor_version ||= begin
+                             chosen_version = request.headers[API_VERSION]
+                             return chosen_version if valid_minor_version?(chosen_version)
+                             default_minor_version
+                           end
+      end
+
+      private
+
+      def default_minor_version
+        @default_minor_version ||= begin
+                                     default = find_default_version
+                                     raise('No version marked as default in the configuration.') if default.nil?
+                                     default
+                                   end
+      end
+
+      def find_default_version
+        all_minor_versions.each do |version, info|
+          return version if info[:default]
+        end
+        nil
+      end
+
+      def valid_minor_version?(version)
+        version.present? && all_minor_versions.keys.include?(version)
+      end
+
+      def all_minor_versions
+        has_versions = Rails.application.config.respond_to?(:minor_versions)
+        raise('config/minor_versions.yml doesn\'t exist.') unless has_versions
+        Rails.application.config.minor_versions
+      end
+    end
+  end
+end

data/lib/spokes/versioning/railtie.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'rails'
+
+module Spokes
+  class Railtie < Rails::Railtie
+    initializer('spokes_versioning.load_minor_versions_file') do |app|
+      config_file = Rails.root.join('config', 'minor_versions.yml')
+      if File.exist?(config_file)
+        minor_versions = YAML.load_file(config_file)
+        app.config.minor_versions = {}
+        minor_versions.map do |key, val|
+          app.config.minor_versions[key] = val.symbolize_keys
+        end
+      end
+    end
+
+    rake_tasks do
+      load 'spokes/versioning/tasks/minor_versioning.rake'
+    end
+  end
+end

data/lib/spokes/versioning/tasks/minor_versioning.rake

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+namespace :spokes do
+  namespace :versioning do
+    MINOR_VERSION_YML = File.join(File.dirname(__FILE__), '../config/minor_versions.yml').to_s.freeze
+
+    desc 'Sets up minor versioning yml'
+    task setup: :environment do
+      raise 'Minor version currently only supports Rails Applications' unless defined?(Rails)
+      next if File.exist?("#{Rails.root}/config/minor_versions.yml")
+      FileUtils.cp(MINOR_VERSION_YML, "#{Rails.root}/config", verbose: true)
+    end
+  end
+end

data/script/cibuild

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+# script/cibuild: Setup environment for CI to run tests. This is primarily
+#                 designed to run on the continuous integration server.
+
+set -e
+
+# cd to project root
+cd "$(dirname "$0")/.."
+
+# run tests
+script/test

data/script/postbuild

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+# script/postbuild: Cleanup environment after CI. This is primarily
+#                   designed to run on the continuous integration server.
+
+set -e
+
+PROJECT_NAME='spokes'
+
+[[ "${PROJECT_NAME:-}" ]] || (echo "PROJECT_NAME is required." && exit 1)
+
+# cd to project root
+cd "$(dirname "$0")/.."
+
+docker stop `docker ps -a -q -f status=exited` &> /dev/null || true &> /dev/null
+docker rm -v `docker ps -a -q -f status=exited` &> /dev/null || true &> /dev/null
+docker rmi `docker images --filter 'dangling=true' -q --no-trunc` &> /dev/null || true &> /dev/null

data/script/test

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# script/test: Run test suite for application. Optionally pass in a path to an
+#              individual test file to run a single test.
+
+set -e
+set -u
+
+export RAILS_ENV="test" RACK_ENV="test"
+PROJECT_NAME='spokes'
+
+[[ "${PROJECT_NAME:-}" ]] || (echo "PROJECT_NAME is required." && exit 1)
+
+# cd to project root
+cd "$(dirname "$0")/.."
+
+# Build deploy Docker image
+docker build --tag=$PROJECT_NAME .
+
+printf "\n===> Running tests ...\n"
+date "+%H:%M:%S"
+
+docker run --rm $PROJECT_NAME bundle exec rspec

data/spec/config/env_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Spokes::Config::Env do
+  after do
+    %w[HOMER_SIMPSON TEST_STRING_VAR TEST_INT_VAR TEST_FLOAT_VAR TEST_ARRAY_VAR TEST_SYMBOL_VAR TEST_BOOL_VAR].each do |w|
+      ENV.delete(w)
+    end
+  end
+
+  describe '#manditory' do
+    let(:env_loader) do
+      lambda do
+        Spokes::Config::Env.load do
+          mandatory :homer_simpson, string
+        end
+      end
+    end
+
+    it 'raises error if variable is not set' do
+      expect(env_loader).to raise_error(KeyError)
+    end
+
+    it 'exposes variable once loaded' do
+      ENV['HOMER_SIMPSON'] = 'doh'
+      expect(env_loader.call.homer_simpson).to eq('doh')
+    end
+  end
+
+  describe '#optional' do
+    let(:env_loader) do
+      lambda do
+        Spokes::Config::Env.load do
+          optional :homer_simpson, string
+        end
+      end
+    end
+
+    it 'exposes variable once loaded' do
+      ENV['HOMER_SIMPSON'] = 'doh'
+      expect(env_loader.call.homer_simpson).to eq('doh')
+    end
+
+    it 'value is nil when variable is not set' do
+      expect(env_loader.call.homer_simpson).to eq(nil)
+    end
+  end
+
+  describe '#default' do
+    let(:env_loader) do
+      lambda do
+        Spokes::Config::Env.load do
+          default :homer_simpson, 'derp', string
+        end
+      end
+    end
+
+    it 'exposes variable once loaded' do
+      ENV['HOMER_SIMPSON'] = 'doh'
+      expect(env_loader.call.homer_simpson).to eq('doh')
+    end
+
+    it 'uses default value when varible is not set' do
+      expect(env_loader.call.homer_simpson).to eq('derp')
+    end
+  end
+
+  describe 'type casting' do
+    let(:env_loader) do
+      lambda do
+        Spokes::Config::Env.load do
+          optional :test_bool_var, bool
+          optional :test_float_var, float
+          optional :test_string_var, string
+          optional :test_symbol_var, symbol
+          optional :test_array_var, array
+          optional :test_int_var, int
+        end
+      end
+    end
+
+    it 'does nothing to strings' do
+      ENV['TEST_STRING_VAR'] = 'stringy'
+      expect(env_loader.call.test_string_var).to eq('stringy')
+    end
+
+    it 'casts to integer' do
+      ENV['TEST_INT_VAR'] = '123'
+      expect(env_loader.call.test_int_var).to eq(123)
+    end
+
+    it 'casts to float' do
+      ENV['TEST_FLOAT_VAR'] = '1.23'
+      expect(env_loader.call.test_float_var).to eq(1.23)
+    end
+
+    it 'casts to array' do
+      ENV['TEST_ARRAY_VAR'] = 'hello,world'
+      expect(env_loader.call.test_array_var).to eq(%w[hello world])
+    end
+
+    it 'casts to symbol' do
+      ENV['TEST_SYMBOL_VAR'] = 'howdy'
+      expect(env_loader.call.test_symbol_var).to eq(:howdy)
+    end
+
+    it 'casts to boolean' do
+      ENV['TEST_BOOL_VAR'] = 'true'
+      expect(env_loader.call.test_bool_var).to eq(true)
+    end
+  end
+end

data/spec/middleware/cors_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Spokes::Middleware::CORS, modules: true, middleware: true do
+  let(:app) { proc { [200, {}, ['hi']] } }
+  let(:stack) { Spokes::Middleware::CORS.new(app) }
+  let(:request) { Rack::MockRequest.new(stack) }
+
+  it 'does not do anything when the Origin header is not present' do
+    response = request.get('/')
+    expect(response.status).to eq(200)
+    expect(response.body).to eq('hi')
+    expect(response.headers['Access-Control-Allow-Origin']).to eq(nil)
+  end
+
+  it 'intercepts OPTION requests to render a stub (preflight request)' do
+    response = request.options('/', 'Origin' => 'http://localhost', 'HTTP_ORIGIN' => 'http://localhost')
+    expect(response.status).to eq(200)
+    expect(response.body).to eq('')
+    expect(response.headers['Access-Control-Allow-Methods']).to eq('GET, POST, PUT, PATCH, DELETE, OPTIONS')
+    expect(response.headers['Access-Control-Allow-Origin']).to eq('http://localhost')
+  end
+
+  it 'delegates other calls, adding the CORS headers to the response' do
+    response = request.get('/', 'Origin' => 'http://localhost', 'HTTP_ORIGIN' => 'http://localhost')
+    expect(response.status).to eq(200)
+    expect(response.body).to eq('hi')
+    expect(response.headers['Access-Control-Allow-Origin']).to eq('http://localhost')
+  end
+end

data/spec/middleware/health_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Spokes::Middleware::Health, modules: true, middleware: true do
+  def env(url = '/', *args)
+    Rack::MockRequest.env_for(url, *args)
+  end
+
+  let(:base_app) do
+    lambda do |_env|
+      [200, { 'Content-Type' => 'text/plain' }, ['Oi!']]
+    end
+  end
+
+  let(:app) { Rack::Lint.new Spokes::Middleware::Health.new(base_app, health_options) }
+  let(:health_options) { {} }
+  let(:status) { subject[0] }
+  let(:body) do
+    str = ''
+    subject[2].each do |s|
+      str += s
+    end
+    str
+  end
+
+  describe 'with default options' do
+    let(:health_options) { {} }
+
+    describe '/' do
+      subject { app.call env('/') }
+      it { expect(status).to eq(200) }
+      it { expect(body).to eq('Oi!') }
+    end
+
+    describe '/status' do
+      subject { app.call env('/status') }
+      it { expect(status).to eq(200) }
+      it { expect(body).to eq('OK') }
+    end
+  end
+
+  describe 'as json' do
+    let(:health_options) { {} }
+
+    describe '/' do
+      subject { app.call env('/', 'Content-Type' => 'application/json') }
+      it { expect(status).to eq(200) }
+      it { expect(body).to eq('Oi!') }
+    end
+
+    describe '/status' do
+      subject { app.call env('/status', 'CONTENT_TYPE' => 'application/json') }
+      it { expect(status).to eq(200) }
+      it { expect(JSON.parse(body)['status']).to eq('OK') }
+    end
+  end
+
+  describe 'with :fail_if' do
+    subject { app.call env('/status') }
+
+    describe '== lambda { true }' do
+      let(:health_options) { { fail_if: -> { true } } }
+
+      it { expect(status).to eq(503) }
+      it { expect(body).to eq('FAIL') }
+    end
+
+    describe '== lambda { false }' do
+      let(:health_options) { { fail_if: -> { false } } }
+      it { expect(status).to eq(200) }
+      it { expect(body).to eq('OK') }
+    end
+  end
+
+  describe 'with :status_code' do
+    let(:status_proc) { ->(healthy) { healthy ? 202 : 404 } }
+    subject { app.call env('/status') }
+
+    context 'healthy' do
+      let(:health_options) { { fail_if: -> { false }, status_code: status_proc } }
+      it { expect(status).to eq(202) }
+      it { expect(body).to eq('OK') }
+    end
+
+    context 'fail' do
+      let(:health_options) { { fail_if: -> { true }, status_code: status_proc } }
+      it { expect(status).to eq(404) }
+      it { expect(body).to eq('FAIL') }
+    end
+  end
+
+  describe 'with :simple' do
+    let(:body_proc) { ->(healthy) { healthy ? 'GOOD' : 'BAD' } }
+    subject { app.call env('/status') }
+
+    context 'healthy' do
+      let(:health_options) { { fail_if: -> { false }, simple: body_proc } }
+      it { expect(status).to eq(200) }
+      it { expect(body).to eq('GOOD') }
+    end
+
+    context 'fail' do
+      let(:health_options) { { fail_if: -> { true }, simple: body_proc } }
+      it { expect(status).to eq(503) }
+      it { expect(body).to eq('BAD') }
+    end
+  end
+end