status_lib 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p484

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in status_lib.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, notification: false, all_after_pass: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kevin McConnell
+
+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,29 @@
+# StatusLib
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'status_lib'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install status_lib
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/guard

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'guard' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('guard', 'guard')

data/lib/status_lib/cache.rb

@@ -0,0 +1,33 @@
+class StatusLib::Cache
+  class << self
+    def fetch(item, options={})
+      expires_in = options[:expires_in]
+      stored = items[item]
+      if stored.nil? || expired?(expires_in, timestamps[item])
+        stored = items[item] = yield
+        timestamps[item] = Time.now
+      end
+      stored
+    end
+
+    def clear!
+      @timestamps = @cached_items = nil
+    end
+
+    private
+
+    def items
+      @cached_items ||= {}
+    end
+
+    def timestamps
+      @timestamps ||= {}
+    end
+
+    def expired?(duration, recorded_time)
+      return false if duration.nil?
+      return true if recorded_time.nil?
+      (Time.now - recorded_time) > duration
+    end
+  end
+end

data/lib/status_lib/config.rb

@@ -0,0 +1,61 @@
+class StatusLib::Config
+  DEFAULT_CACHE_TIME        = 5
+  DEFAULT_API_CALL_TIMEOUT  = 1
+  DEFAULT_DOWN_DURATION     = 0
+  DEFAULT_BLOCK_TIMEOUT     = 5
+
+  ATTRIBUTES = [:server,
+                :exception_handler, :stats_handler,
+                :cache_time, :api_call_timeout,
+                :down_duration, :block_timeout]
+
+  attr_reader *ATTRIBUTES
+
+  def initialize
+    reset_to_defaults
+  end
+
+  def update(args)
+    ATTRIBUTES.each do |arg|
+      self.instance_variable_set("@#{arg}", args[arg] || defaults[arg]) if args.include?(arg)
+    end
+    clear_memoized
+  end
+
+  def status_info
+    @status_info ||= StatusLib::StatusInfo.new(status_api)
+  end
+
+  def status_api
+    @status_api ||= status_api_for_config
+  end
+
+  private
+
+  def reset_to_defaults
+    update(Hash[ATTRIBUTES.map { |attr| [attr, nil] }])
+  end
+
+  def defaults
+    {
+      cache_time:         DEFAULT_CACHE_TIME,
+      api_call_timeout:   DEFAULT_API_CALL_TIMEOUT,
+      down_duration:      DEFAULT_DOWN_DURATION,
+      block_timeout:      DEFAULT_BLOCK_TIMEOUT,
+      stats_handler:      NullStatsHandler
+    }
+  end
+
+  def clear_memoized
+    @status_info = nil
+    @status_api = nil
+  end
+
+  def status_api_for_config
+    if server.nil?
+      StatusLib::NullStatusApi.new
+    else
+      StatusLib::StatusApi.new
+    end
+  end
+end

data/lib/status_lib/null_object.rb

@@ -0,0 +1,6 @@
+module NullObject
+  def method_missing(meth, *args, &block)
+    return meth.call(*args, &block) if respond_to?(meth)
+    yield if block_given?
+  end
+end

data/lib/status_lib/null_stats_handler.rb

@@ -0,0 +1,3 @@
+class NullStatsHandler
+  extend NullObject
+end

data/lib/status_lib/status_api.rb

@@ -0,0 +1,62 @@
+require 'json'
+require 'net/http'
+require 'timeout'
+require 'uri'
+
+class StatusLib::ApiDownError < Exception; end
+
+class StatusLib::NullStatusApi
+  def get_status_list
+  end
+
+  def send_status_update(name, status, expires)
+  end
+end
+
+class StatusLib::StatusApi
+  def get_status_list
+    response = send_request('GET', "/api/status")
+    parse_status_response(response.body)
+  end
+
+  def send_status_update(name, status, expires)
+    if expires.kind_of?(Time)
+      expires = expires.utc.to_i
+    end
+
+    payload = { status: status, expires: expires }.to_json
+
+    response = send_request('PUT', "/api/status/#{name}", payload)
+    response_successful(response)
+  end
+
+  private
+
+  def parse_status_response(body)
+    Hash[
+      JSON.parse(body).map { |name, status| [name.to_sym, status.to_sym ] }
+    ]
+  end
+
+  def http_request
+    uri = URI.parse(StatusLib.config.server)
+    http = Net::HTTP.new(uri.host, uri.port)
+  end
+
+  def send_request(*args)
+    Timeout::timeout(StatusLib.config.api_call_timeout) do
+      response = http_request.send_request(*args)
+      raise ArgumentError.new("service not found") if response.code == "404"
+      raise StatusLib::ApiDownError unless response_successful(response)
+      response
+    end
+  rescue ArgumentError
+    raise
+  rescue
+    raise StatusLib::ApiDownError
+  end
+
+  def response_successful(response)
+    response.kind_of? Net::HTTPSuccess
+  end
+end

data/lib/status_lib/status_info.rb

@@ -0,0 +1,72 @@
+class StatusLib::StatusInfo
+  def initialize(api)
+    @api      = api
+    @statuses = {}
+    @expiries = {}
+    @updates  = {}
+  end
+
+  def up?(name)
+    sync_status_list
+    status = @statuses[name]
+    expiry = @expiries[name]
+
+    if status == :down && (expiry.nil? || expiry > now)
+      return false
+    else
+      return true
+    end
+  end
+
+  def switch(name, status, options={})
+    unless [:up, :down].include?(status)
+      raise ArgumentError.new("unknown status")
+    end
+
+    expires = options.fetch(:for, StatusLib.config.down_duration)
+    expires = now + expires unless expires.nil?
+
+    @statuses[name] = status
+    @expiries[name] = expires
+
+    add_pending_update(name, status, expires)
+    send_pending_updates
+
+    StatusLib.config.stats_handler.increment("status.change.#{name}.#{status}")
+  end
+
+  private
+
+  def now
+    Time.now
+  end
+
+  def sync_status_list
+    expires_in = StatusLib.config.cache_time
+
+    @statuses = StatusLib::Cache.fetch('statuses', expires_in: expires_in) do
+      send_pending_updates
+      begin
+        @api.get_status_list || @statuses
+      rescue StatusLib::ApiDownError
+        # couldn't get the info; just use our local copy
+        @statuses
+      end
+    end
+  end
+
+  def add_pending_update(name, status, expires)
+    @updates.delete(name)
+    @updates[name] = [status, expires]
+  end
+
+  def send_pending_updates
+    @updates.delete_if do |name, args|
+      begin
+        @api.send_status_update(name, *args)
+      rescue StatusLib::ApiDownError
+        false
+      end
+    end
+  end
+end

data/lib/status_lib/version.rb

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

data/lib/status_lib.rb

@@ -0,0 +1,119 @@
+require 'status_lib/version'
+
+require 'status_lib/cache'
+require 'status_lib/config'
+require 'status_lib/null_object'
+require 'status_lib/null_stats_handler'
+require 'status_lib/status_api'
+require 'status_lib/status_info'
+
+require 'timeout'
+
+module StatusLib
+  class ServiceDownError < StandardError
+    attr_reader :original_exception
+
+    def initialize(original_exception = nil)
+      super("Service is down")
+      @original_exception = original_exception
+    end
+  end
+
+  class << self
+    attr_reader :server
+
+    # Checks whether a particular service is up or down.
+    #
+    # Params:
+    #  +name+:: the name of the service to check
+    #
+    def up?(name)
+      status_info.up?(name)
+    end
+
+    # Sets the status of a service to up or down
+    #
+    # Params:
+    #  +name+:: the name of the service to update
+    #  +status+:: the desired status; either :up or :down
+    #  +options+:: additional options.  can contain:
+    #    +:for+:: the time to keep the service down, in seconds
+    #
+    def switch(name, status, options={})
+      status_info.switch(name, status, options)
+    end
+
+    # Helper method for guarding a block of code with a curcuit breaker.
+    #
+    # If the code in the block raises an exception or exceeds its timeout, then
+    # the associated service status will be set to down for the specified
+    # interval, and a StatusLib::ServiceDownError exception will be raised.
+    #
+    # If the service is already makred down then the block won't be evaluated at
+    # all, and StatusLib::ServiceDownError will be raised immediately.
+    #
+    #  +name+:: the name of the service to update
+    #  +options+:: additional options.  can contain:
+    #    +:timeout+:: upper limit on how long the block can take to run
+    #    +:down_for+:: the time to keep the service down, in seconds
+    #
+    def with_circuit_breaker(name, options={})
+      raise ServiceDownError unless up?(name)
+
+      Timeout::timeout( determine_timeout(options) ) do
+        yield
+      end
+    rescue Timeout::Error => e
+      handle_exception(e, name, options)
+      raise e
+    rescue => e
+      handle_exception(e, name, options)
+      raise ServiceDownError.new(e)
+    end
+
+    # Configure the gem
+    #
+    # Params:
+    #  +settings+:: the configuration settings.  A hash that may contain:
+    #    +:server+:: the URL of the status page service
+    #    +:cache_time+:: time to cache status reponses from the API
+    #    +:api_call_timeout+:: maximum time to wait for a call to status API
+    #    +:down_duration+:: default time to switch a service down for
+    #    +:block_timeout+:: default time that a `with_circuit_breaker` can take
+    #
+    def configure(settings)
+      config.update(settings)
+    end
+
+    # Read configuration settings
+    #
+    # The values that are set to #configure are available here.
+    #
+    def config
+      @config ||= Config.new
+    end
+
+    private
+
+    def handle_exception(e, name, options)
+      report_exception(e)
+      switch(name, :down, options) if has_down_for?(options)
+    end
+
+    def status_info
+      config.status_info
+    end
+
+    def determine_timeout(options)
+      options.delete(:timeout) || config.block_timeout
+    end
+
+    def has_down_for?(options)
+      (options[:for] || 0) > 0
+    end
+
+    def report_exception(e)
+      config.exception_handler.call(e) unless config.exception_handler.nil?
+    end
+  end
+end

data/spec/lib/status_lib/cache_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe StatusLib::Cache do
+  let(:target) { double(:target, message: "test") }
+
+  before do
+    StatusLib::Cache.clear!
+  end
+
+  context "#fetch" do
+    context "with no prior data" do
+      it "fetches the value" do
+        value = StatusLib::Cache.fetch('key') { target.message }
+
+        expect(value).to eq('test')
+      end
+    end
+
+    context "when cached" do
+      it "does not evalute the block multiple times" do
+        value = StatusLib::Cache.fetch('key') { target.message }
+        value = StatusLib::Cache.fetch('key') { target.message }
+
+        expect(value).to eq('test')
+        expect(target).to have_received(:message).once
+      end
+    end
+
+    context "when cached for a specific amount of time" do
+      it "only evaluates the block after the timeout elapses" do
+        Timecop.freeze(0)
+        StatusLib::Cache.fetch('key', expires_in: 30) { target.message }
+        expect(target).to have_received(:message).once
+
+        Timecop.freeze(15)
+        StatusLib::Cache.fetch('key', expires_in: 30) { target.message }
+        expect(target).to have_received(:message).once
+
+        Timecop.freeze(60)
+        StatusLib::Cache.fetch('key', expires_in: 30) { target.message }
+        expect(target).to have_received(:message).twice
+      end
+    end
+  end
+end

data/spec/lib/status_lib/config_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe StatusLib::Config do
+  shared_examples_for "it has default values" do
+    it "has no default server address" do
+      expect(config.server).to be_nil
+    end
+
+    it "uses a NullStatusApi by default" do
+      expect(config.status_api).to be_an_instance_of(StatusLib::NullStatusApi)
+    end
+
+    it "has no default exception handler" do
+      expect(config.exception_handler).to be_nil
+    end
+
+    it "has a null stats handler by default" do
+      expect(config.stats_handler).to eq(NullStatsHandler)
+    end
+
+    it "has a default cache expiry time" do
+      expect(config.cache_time).to eq(5)
+    end
+
+    it "has a default API call timeout" do
+      expect(config.api_call_timeout).to eq(1)
+    end
+
+    it "has a default down duration" do
+      expect(config.down_duration).to eq(0)
+    end
+
+    it "has a default block timeout" do
+      expect(config.block_timeout).to eq(5)
+    end
+  end
+
+  context "when initially created" do
+    let(:config) { StatusLib::Config.new }
+
+    it_behaves_like "it has default values"
+  end
+
+  context "updating" do
+    let(:config)  { StatusLib::Config.new }
+    let(:stats)   { double(:stats) }
+
+    it "sets the values form the arguments" do
+      config.update(server: "http://example.com:123",
+                    exception_handler: ->(e) { puts e },
+                    stats_handler: stats,
+                    cache_time: 60,
+                    api_call_timeout: 0.5,
+                    down_duration: 120,
+                    block_timeout: 36)
+
+      expect(config.server).to eq("http://example.com:123")
+      expect(config.exception_handler).to be_kind_of(Proc)
+      expect(config.stats_handler).to eq(stats)
+      expect(config.cache_time).to eq(60)
+      expect(config.api_call_timeout).to eq(0.5)
+      expect(config.down_duration).to eq(120)
+      expect(config.block_timeout).to eq(36)
+      expect(config.status_api).to be_an_instance_of(StatusLib::StatusApi)
+    end
+  end
+
+  context "setting back to nil" do
+    let(:config)  { StatusLib::Config.new }
+    let(:stats)   { double(:stats) }
+
+    before do
+      config.update(server: "http://example.com:123",
+                    exception_handler: ->(e) { puts e },
+                    stats_handler: stats,
+                    cache_time: 60,
+                    api_call_timeout: 0.5,
+                    down_duration: 120,
+                    block_timeout: 36)
+
+      config.update(server: nil,
+                    exception_handler: nil,
+                    stats_handler: nil,
+                    cache_time: nil,
+                    api_call_timeout: nil,
+                    down_duration: nil,
+                    block_timeout: nil)
+    end
+
+    it_behaves_like "it has default values"
+  end
+
+  context "#status_info" do
+    let(:config)  { StatusLib::Config.new }
+
+    it "has an instance of StatusInfo" do
+      expect(config.status_info).to be_an_instance_of(StatusLib::StatusInfo)
+    end
+  end
+end

data/spec/lib/status_lib/null_object_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe NullObject do
+  let(:klass)     {
+    Class.new do
+      include NullObject
+    end
+  }
+  let(:instance)  { klass.new }
+
+  it "quietly ignores method calls" do
+    expect {
+      instance.do_something_i_just_made_up('with', 'args')
+    }.to_not raise_error
+  end
+
+  context "with a block" do
+    let(:inner) { double(:inner).as_null_object }
+
+    it "calls the supplied block on ignored methods" do
+      instance.do_something_with_a_block do
+        inner.block_target('test')
+      end
+
+      expect(inner).to have_received(:block_target).with('test')
+    end
+  end
+end

data/spec/lib/status_lib/null_stats_handler_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe NullStatsHandler do
+  it "quietly ignores calls to ::increment" do
+    expect {
+      NullStatsHandler.increment('my.counter')
+    }.to_not raise_error
+  end
+end