shunt_cache 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b68ce7d0aa2e76b446f3a797d7b3a77f472212ab
+  data.tar.gz: a4648b322d98173fdb49191d0d270dfa053c82a7
+SHA512:
+  metadata.gz: 8010ccfb4a3b57e74e8b9a39641f819d499ce1a19bead2b98b1d8aceb2592afb1c794a68cfad6cc8f77b7aa342b973ef8c0c6b6bd0502b09b5d5213d6fe31f7f
+  data.tar.gz: 638b92d052e64798182d91e1180e3f356523625b29310a7b42ce5e711d8174fbf09389c82cfaae11b1e1287aa07111b807840cf1c6ee4e15612c32311d8fcc40

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+env:
+  global:
+    - CODECLIMATE_REPO_TOKEN=345df6b93f97ec1c36c0cb074ce645c8f92aefdf13e71308c1dc626c1e0fc165
+  matrix:
+    - "AS_VERSION=3.2.0"
+    - "AS_VERSION=4.0.0"
+    - "AS_VERSION=4.1.0"

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in shunt_cache.gemspec
+gemspec
+
+as_version = ENV["AS_VERSION"] || "default"
+
+as_version = case as_version
+when "default"
+  ">= 3.2.0"
+else
+  "~> #{as_version}"
+end
+
+gem 'rack'
+gem "activesupport", as_version
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jeff Ching
+
+MIT License
+
+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,88 @@
+# ShuntCache [![Build Status](https://travis-ci.org/chingor13/shunt_cache.png)](https://travis-ci.org/chingor13/shunt_cache)  [![Code Climate](https://codeclimate.com/github/chingor13/shunt_cache.png)](https://codeclimate.com/github/chingor13/shunt_cache) [![Code Coverage](https://codeclimate.com/github/chingor13/shunt_cache/coverage.png)](https://codeclimate.com/github/chingor13/shunt_cache)
+
+Store temporary shunt status in a cache to conditionally show maintenance page.
+
+## Motivation
+
+Many load balancer programs (HAProxy, et al), can utilize an HTTP status check to determine if a server is up or down. [dplummer](https://github.com/dplummer) suggested that we could pull machines out of rotation by having their health check endpoint return with the maintenance status response.
+
+Rather than having your app know where all the load balancers are and explicitly telling them to take each server on/offline, we can rely on them to do the right thing when we report that we should be out of rotation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shunt_cache'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shunt_cache
+
+## Usage
+
+### Rails
+
+If you're using rails, the railtie will automatically be loaded. The railtie will automatically install the middleware and rake tasks.
+
+### Rake tasks
+
+* `shunt_cache:shunt` - takes the current machine out of rotation
+* `shunt_cache:unshunt` - return the machine to rotation
+* `shunt_cache:status` - prints the status of the current machine to STDOUT
+* `shunt_cache:wait_for_http` - checks the url at ENV['URL'] to see if it is up
+
+### Capistrano Deploys
+
+Assuming capistrano version 3 (nice in-sequence commands):
+
+```
+
+namespace :deploy do
+
+  desc 'Restart application'
+  task :restart do
+    on roles(:app), in: :sequence, wait: 5 do |host|
+      execute :rake, 'shunt_cache:shunt'
+      sleep(10)
+      sudo 'service myservice restart'
+      execute :rake, 'shunt_cache:wait_for_http', "URL=http://#{host}:4004/"
+      execute :rake, 'shunt_cache:unshunt'
+    end
+  end
+
+end
+
+```
+
+* First, we shunt the machine, then wait some amount of time. We assume that HAProxy or whatever load balancer we're using has removed it from rotation.
+* We can safely restart the service. 
+* We then check to make sure that our service is back up. Note this is not our health check because it should report that we're shunted.
+* Unshunt the machine because we know the service is running.
+
+## Configuration
+
+```
+
+ShuntCache::Status.configure do |config|
+  config.cache = MyCacheStore.new
+  config.key = "some key that identifies this machine/service"
+  config.logger = SomeLogger.new # optional
+end
+
+```
+
+If using rails, the configuration is set by default to use `Rails.cache` as the cache store, generates a key based off hostname and the `Rails.application` name, and sets the logger to the `Rails.logger`
+
+## Contributing
+
+1. Fork it ( https://github.com/chingor13/shunt_cache/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+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/lib/shunt_cache.rb

@@ -0,0 +1,9 @@
+require "shunt_cache/version"
+
+module ShuntCache
+  autoload :Checker, 'shunt_cache/checker'
+  autoload :Middleware, 'shunt_cache/middleware'
+  autoload :Status, 'shunt_cache/status'
+end
+
+require 'shunt_cache/railtie' if defined?(Rails)

data/lib/shunt_cache/checker.rb

@@ -0,0 +1,40 @@
+require 'net/http'
+
+module ShuntCache
+  module Checker
+
+    class << self
+      def wait_for_http(url, options = {})
+        retries = options.fetch(:retry, 10)
+        wait_time = options.fetch(:wait_time, 6)
+
+        uri = URI(url)
+
+        retries.times do
+          begin
+            response = request(uri, options)
+            code = response.code.to_i
+            return true if 200 <= code && 399 >= code
+          rescue Errno::ECONNREFUSED, Timeout::Error => e
+          end
+          sleep(wait_time)
+        end
+
+        false
+      end
+
+      def request(uri, options = {})
+        timeout = options.fetch(:timeout, 10)
+
+        response = nil
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.read_timeout = timeout
+          request = Net::HTTP::Get.new(uri.path)
+          response = http.request(request)
+        end
+        response
+      end
+
+    end
+  end
+end

data/lib/shunt_cache/middleware.rb

@@ -0,0 +1,25 @@
+module ShuntCache
+  class Middleware
+    attr_accessor :endpoint_matcher
+
+    def initialize(app, options = {})
+      @app = app
+      @endpoint_matcher = options.fetch(:endpoint) do
+        "/options/full_stack_status"
+      end
+    end
+
+    def call(env)
+      path = env.fetch('REQUEST_PATH') do
+        env.fetch('PATH_INFO') do
+          env.fetch('REQUEST_URI', '')
+        end
+      end
+      if path.match(endpoint_matcher) && ShuntCache::Status.shunted?
+        return ['503', {'Content-Type' => 'text/html'}, ['Maintenance']]
+      end
+      @app.call(env)
+    end
+
+  end
+end

data/lib/shunt_cache/railtie.rb

@@ -0,0 +1,26 @@
+module ShuntCache
+  class Railtie < ::Rails::Railtie
+
+    initializer 'shunt_cache.set_cache_store' do |app|
+      require 'socket'
+      ShuntCache::Status.configure do |status|
+        status.cache = Rails.cache
+        status.key = [
+          Rails.application.class.name.deconstantize,
+          "shunt_cache",
+          Socket.gethostname
+        ].join(":")
+        status.logger = Rails.logger
+      end
+    end
+
+    initializer 'shunt_cache.middleware' do |app|
+      app.middleware.use ShuntCache::Middleware
+    end
+
+    rake_tasks do
+      load 'shunt_cache/shunt_cache.rake'
+    end
+
+  end
+end

data/lib/shunt_cache/shunt_cache.rake

@@ -0,0 +1,26 @@
+namespace :shunt_cache do
+  desc 'Mark the site as shunted'
+  task :shunt => :environment do
+    ShuntCache::Status.shunt!
+  end
+
+  desc 'Mark the site as unshunted'
+  task :unshunt => :environment do
+    ShuntCache::Status.unshunt!
+  end
+
+  desc 'Check the site status'
+  task :status => :environment do
+    puts ShuntCache::Status.status
+  end
+
+  desc "Wait until we get a 200 or 300 ranged http response code for ENV['URL']"
+  task :wait_for_http => :environment do
+    url = ENV.fetch('URL')
+    success = ShuntCache::Checker.wait_for_http(url)
+    unless success
+      puts "error checking: #{url} - never returned with status within 200..399"
+      exit(1)
+    end
+  end
+end

data/lib/shunt_cache/status.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+require 'forwardable'
+
+module ShuntCache
+  class Status
+    include Singleton
+    class << self
+      extend Forwardable
+      def_delegators :instance, :shunt!, :unshunt!, :status, :shunted?, :clear!
+    end
+    attr_accessor :key, :cache, :logger
+
+    SHUNTED = "shunted"
+    UNSHUNTED = "ok"
+
+    def self.configure
+      yield instance
+    end
+
+    def status
+      cache.fetch(key) do
+        UNSHUNTED
+      end
+    end
+
+    def shunted?
+      status == SHUNTED
+    end
+
+    # reset to default
+    def clear!
+      cache.delete(key)
+    end
+
+    def shunt!
+      log(:info, "Shunting site with key: #{key}")
+      cache.write(key, SHUNTED)
+    end
+
+    def unshunt!
+      log(:info, "Unshunting site with key: #{key}")
+      cache.write(key, UNSHUNTED)
+    end
+
+    private
+
+    def log(level, msg)
+      logger.send(level, msg) if logger
+    end
+  end
+end

data/lib/shunt_cache/version.rb

@@ -0,0 +1,3 @@
+module ShuntCache
+  VERSION = "0.0.2"
+end

data/shunt_cache.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shunt_cache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "shunt_cache"
+  spec.version       = ShuntCache::VERSION
+  spec.authors       = ["Jeff Ching"]
+  spec.email         = ["ching.jeff@gmail.com"]
+  spec.summary       = "Cache the site status in a cache"
+  spec.description   = "Mark the site status in a cache"
+  spec.homepage      = ""
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "webmock"
+end

data/test/checker_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class CheckerTest < MiniTest::Unit::TestCase
+  TEST_URL = 'http://localhost:3000/options/full_stack_status'
+
+  def test_maintenance
+    stub_request(:get, TEST_URL)
+      .to_return(body: 'Maintenance', status: 503)
+
+    res = ShuntCache::Checker.wait_for_http(TEST_URL, {
+      wait_time: 0
+    })
+    assert_equal false, res
+  end
+
+  def test_connection_issues
+    stub_request(:get, TEST_URL)
+      .to_raise(Errno::ECONNREFUSED)
+
+    res = ShuntCache::Checker.wait_for_http(TEST_URL, {
+      wait_time: 0
+    })
+    assert_equal false, res
+  end
+
+  def test_should_retry
+    stub_request(:get, TEST_URL)
+      .to_raise(Errno::ECONNREFUSED).then
+      .to_return(body: 'OK')
+
+    res = ShuntCache::Checker.wait_for_http(TEST_URL, {
+      wait_time: 0
+    })
+    assert_equal true, res
+  end
+
+  def test_success
+    stub_request(:get, TEST_URL)
+      .to_return(body: 'OK')
+
+    res = ShuntCache::Checker.wait_for_http(TEST_URL)
+    assert_equal true, res
+  end
+
+end

data/test/middleware_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class MiddlewareTest < MiniTest::Unit::TestCase
+
+  def setup
+    super
+    @app = ShuntCache::Middleware.new(proc{[200,{},['Hello, world.']]})
+    @request = Rack::MockRequest.new(@app)
+
+    # should default to unshunted
+    cache = ActiveSupport::Cache::MemoryStore.new
+    ShuntCache::Status.configure do |status|
+      status.cache = cache
+      status.key = "test_key"
+    end
+    assert_equal false, ShuntCache::Status.shunted?
+  end
+
+  def teardown
+    ShuntCache::Status.clear!
+    super
+  end
+
+  def test_unshunted_hitting_test_endpoint
+    response = @request.get('/options/full_stack_status')
+
+    assert_unshunted(response)
+  end
+
+  def test_shunted_hitting_test_endpoint
+    ShuntCache::Status.shunt!
+
+    response = @request.get('/options/full_stack_status')
+
+    assert_shunted(response)
+  end
+
+  def test_unshunted_hitting_non_status_endpoint
+    response = @request.get('/')
+
+    assert_unshunted(response)
+  end
+
+  def test_shunted_hitting_non_status_endpoint
+    ShuntCache::Status.shunt!
+
+    response = @request.get('/')
+
+    assert_unshunted(response)
+  end
+
+  def test_custom_endpoint
+    ShuntCache::Status.shunt!
+
+    @app.endpoint_matcher = '/foo/bar'
+    response = @request.get('/foo/bar')
+
+    assert_shunted(response)
+  end
+
+  def test_custom_endpoint_regex
+    ShuntCache::Status.shunt!
+
+    @app.endpoint_matcher = /\/foo\/.*/
+    response = @request.get('/foo/bar')
+
+    assert_shunted(response)
+
+    response = @request.get('/foo/qwerty')
+    assert_shunted(response)
+  end
+
+  private
+
+  def assert_unshunted(response)
+    assert_equal 200, response.status
+    assert_equal 'Hello, world.', response.body
+  end
+
+  def assert_shunted(response)
+    assert_equal 503, response.status
+    assert_equal 'Maintenance', response.body
+  end
+
+end

data/test/status_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class StatusTest < MiniTest::Unit::TestCase
+
+  def setup
+    super
+    cache = ActiveSupport::Cache::MemoryStore.new
+    ShuntCache::Status.configure do |status|
+      status.cache = cache
+      status.key = "test_key"
+    end
+  end
+
+  def teardown
+    ShuntCache::Status.configure do |status|
+      status.cache = nil
+      status.key = nil
+    end
+
+    super
+  end
+
+  def test_defaults_to_normal
+    assert_equal false, ShuntCache::Status.shunted?
+    assert_equal ShuntCache::Status::UNSHUNTED, ShuntCache::Status.status
+  end
+
+  def test_can_shunt_and_unshunt
+    assert_equal false, ShuntCache::Status.shunted?
+
+    # shunt!
+    assert ShuntCache::Status.shunt!
+
+    # ensure that we've set the right state
+    assert_equal true, ShuntCache::Status.shunted?
+    assert_equal ShuntCache::Status::SHUNTED, ShuntCache::Status.status
+
+    # unshunt!
+    assert ShuntCache::Status.unshunt!
+
+    # ensure that we've set the right state
+    assert_equal false, ShuntCache::Status.shunted?
+    assert_equal ShuntCache::Status::UNSHUNTED, ShuntCache::Status.status
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+Bundler.require(:default, :test)
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'minitest/autorun'
+require 'webmock/minitest'  
+
+require 'active_support/cache'
+require 'pp'
+
+WebMock.disable_net_connect!(:allow => "codeclimate.com")

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: shunt_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jeff Ching
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
+description: Mark the site status in a cache
+email:
+- ching.jeff@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/shunt_cache.rb
+- lib/shunt_cache/checker.rb
+- lib/shunt_cache/middleware.rb
+- lib/shunt_cache/railtie.rb
+- lib/shunt_cache/shunt_cache.rake
+- lib/shunt_cache/status.rb
+- lib/shunt_cache/version.rb
+- shunt_cache.gemspec
+- test/checker_test.rb
+- test/middleware_test.rb
+- test/status_test.rb
+- test/test_helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Cache the site status in a cache
+test_files:
+- test/checker_test.rb
+- test/middleware_test.rb
+- test/status_test.rb
+- test/test_helper.rb
+has_rdoc: