ipvs_litmus 0.0.1

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/.rake_commit

@@ -0,0 +1 @@
+--without-prompt feature

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.8.7-p249@ipvs_litmus --create

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Braintree Payment Solutions LLC
+
+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,31 @@
+# IpvsLitmus
+
+Backend health tester for HA Services
+
+[![Build Status](https://secure.travis-ci.org/braintree/ipvs_litmus.png)](http://travis-ci.org/braintree/ipvs_litmus)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ipvs_litmus'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ipvs_litmus
+
+## 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 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/bin/litmus

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ipvs_litmus'
+require 'ipvs_litmus/cli/server'
+
+IPVSLitmus::CLI::Server.new.start

data/bin/litmusctl

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ipvs_litmus'
+require 'ipvs_litmus/cli/admin'
+
+IPVSLitmus::CLI::Admin.new.run

data/config.ru

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
+require 'ipvs_litmus'
+
+run IPVSLitmus::App

data/ipvs_litmus.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/ipvs_litmus/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Braintreeps"]
+  gem.email         = ["code@getbraintree.com"]
+  gem.description   = %q{Backend health tester for HA Services}
+  gem.summary       = %q{Backend health tester for HA Services}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "ipvs_litmus"
+  gem.require_paths = ["lib"]
+  gem.version       = IPVSLitmus::VERSION
+
+  gem.add_dependency "sinatra", "~> 1.3.2"
+  gem.add_dependency "facter", "~> 1.6.7"
+
+  gem.add_development_dependency "rspec", "2.9.0"
+  gem.add_development_dependency "rack-test", "0.6.1"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rake_commit", "0.13"
+end

data/lib/facts/loadaverage.rb

@@ -0,0 +1,6 @@
+Facter.add("loadaverage") do
+  setcode do
+    uptime = Facter::Util::Resolution.exec("uptime")
+    uptime.split(":").last
+  end
+end

data/lib/ipvs_litmus/app.rb

@@ -0,0 +1,48 @@
+module IPVSLitmus
+  class App < Sinatra::Base
+    post "/force/*" do
+      path = *status_file_path(params[:splat])
+      statusfile = StatusFile.new(*path)
+      statusfile.create(params[:reason])
+
+      text 201, "File created"
+    end
+
+    delete "/force/*" do
+      path = *status_file_path(params[:splat])
+      statusfile = StatusFile.new(*path)
+      if statusfile.exists?
+        statusfile.delete
+        text 200, "File deleted"
+      else
+        text 404, "NOT FOUND"
+      end
+    end
+
+    get "/:service/status" do
+      service = IPVSLitmus.services[params[:service]]
+      if service.nil?
+        text 404, "NOT FOUND"
+      else
+        health = service.current_health
+        response_code = health.ok? ? 200 : 503
+        body = "Health: #{health.value}\n"
+        body << health.summary
+        text response_code, body
+      end
+    end
+
+    def text(response_code, body)
+      [response_code, { "Content-Type" => "text/plain" }, body]
+    end
+
+    def status_file_path(splat)
+      path = splat.first.split("/")
+      if path.size == 1
+        ["global_#{path.first}"]
+      else
+        path
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/cli/admin.rb

@@ -0,0 +1,86 @@
+module IPVSLitmus
+  module CLI
+    class Admin
+      def run(argv = ARGV)
+        command = argv.shift
+        send(command, argv)
+      end
+
+      def force(args)
+        options = _default_options
+        opt_parser = _extend_default_parser(options) do |opts|
+          opts.banner = "Usage: litmusctl force <up|down> [service] [options]"
+          opts.on("-d", "--delete", "Remove status file") do
+            options[:delete] = true
+          end
+          opts.on("-r", "--reason=reason", String, "Reason for status file") do |reason|
+            options[:reason] = reason
+          end
+        end
+
+        opt_parser.parse! args
+        direction, service = args
+
+        if options[:delete]
+          request = Net::HTTP::Delete.new("/force/#{direction}/#{service}")
+        else
+          if !options.has_key?(:reason)
+            print "Reason? "
+            options[:reason] = gets.chomp
+          end
+          request = Net::HTTP::Post.new("/force/#{direction}/#{service}")
+          request.set_form_data('reason' => options[:reason])
+        end
+
+        _litmus_request(options[:host], options[:port], request)
+      end
+
+      def status(args)
+        options = _default_options
+        opt_parser = _extend_default_parser(options) do |opts|
+          opts.banner = "Usage: litmusctl status <service> [options]"
+        end
+
+        opt_parser.parse! args
+        service = args.shift
+
+        _litmus_request(options[:host], options[:port], Net::HTTP::Get.new("/#{service}/status"))
+      end
+
+      def _default_options
+        options = { :port => 9292, :host => 'localhost' }
+      end
+
+      def _extend_default_parser(options, &block)
+        OptionParser.new do |opts|
+          block.call(opts)
+
+          opts.on("-p", "--port=port", Integer, "Port litmus is running on", "Default: 9292") do |port|
+            options[:port] = port
+          end
+          opts.on("-h", "--host=ip", String, ":Host litmus is running on", "Default: localhost") do |host|
+            options[:host] = host
+          end
+          opts.on("--help", "Show this help message.") { puts opts; exit }
+        end
+      end
+
+      def _litmus_request(host, port, request)
+        begin
+          http = Net::HTTP.start(host, port)
+          response = http.request(request)
+
+          puts response.body
+          case response
+          when Net::HTTPSuccess then exit 0
+          when Net::HTTPClientError then exit 2
+          else exit 1
+          end
+        rescue Errno::ECONNREFUSED => e
+          puts "Unable to connect to litmus on #{host}:#{port}: #{e.message}"
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/cli/server.rb

@@ -0,0 +1,62 @@
+module IPVSLitmus
+  module CLI
+    class Server < Rack::Server
+      class Options
+        def parse!(args)
+          args, options = args.dup, {}
+
+          opt_parser = OptionParser.new do |opts|
+            opts.banner = "Usage: litmus [mongrel, thin, etc] [options]"
+            opts.on("-c", "--config=file", String,
+                    "Litmus configuration file", "Default: /etc/litmus.conf") { |v| options[:litmus_config] = v }
+            opts.on("-D", "--data-dir=path", String,
+                    "Litmus data directory", "Default: /etc/litmus") { |v| options[:config_dir] = v }
+
+            opts.separator ""
+
+            opts.on("-p", "--port=port", Integer,
+                    "Runs Litmus on the specified port.", "Default: 9292") { |v| options[:Port] = v }
+            opts.on("-b", "--binding=ip", String,
+                    "Binds Litmus to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+            opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:daemonize] = true }
+            opts.on("-P","--pid=pid",String,
+                    "Specifies the PID file.",
+                    "Default: rack.pid") { |v| options[:pid] = v }
+
+            opts.separator ""
+
+            opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+          end
+
+          opt_parser.parse! args
+
+          options[:config] = File.expand_path("../../../config.ru", File.dirname(__FILE__))
+          options[:server] = args.shift
+          options
+        end
+      end
+
+      def opt_parser
+        Options.new
+      end
+
+      def start
+        if !File.exists?(options[:litmus_config])
+          puts "Could not find #{options[:litmus_config]}. Specify correct location with -c file"
+          exit 1
+        end
+
+        IPVSLitmus.configure(options[:litmus_config])
+        IPVSLitmus.config_dir = options[:config_dir]
+        super
+      end
+
+      def default_options
+        super.merge(
+          :litmus_config => '/etc/litmus.conf',
+          :config_dir => '/etc/litmus'
+        )
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/configuration.rb

@@ -0,0 +1,20 @@
+module IPVSLitmus
+  class Configuration
+    def initialize(config_file_path)
+      @config_file_path = config_file_path
+    end
+
+    def evaluate
+      config_contents = File.read(@config_file_path)
+      @services = {}
+      instance_eval(config_contents)
+      @services
+    end
+
+    def service(name, &block)
+      service = Service.new(name.to_s)
+      block.call(service)
+      @services[name.to_s] = service
+    end
+  end
+end

data/lib/ipvs_litmus/dependency/http.rb

@@ -0,0 +1,27 @@
+module IPVSLitmus
+  module Dependency
+    class HTTP
+      def initialize(uri, options = {})
+        @uri = uri
+        @expected_content = Regexp.new(options.fetch(:contnet, '.*'))
+      end
+
+      def available?
+        begin
+          response = Net::HTTP.get_response(URI.parse(@uri))
+          _successful_response?(response) && _body_matches?(response)
+        rescue Exception => e
+          false
+        end
+      end
+
+      def _successful_response?(response)
+        response.is_a? Net::HTTPSuccess
+      end
+
+      def _body_matches?(response)
+        response.body =~ @expected_content
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/forced_health.rb

@@ -0,0 +1,18 @@
+module IPVSLitmus
+  class ForcedHealth
+    attr_reader :summary
+
+    def initialize(health, summary)
+      @health = health
+      @summary = summary
+    end
+
+    def value
+      @health
+    end
+
+    def ok?
+      @health > 0
+    end
+  end
+end

data/lib/ipvs_litmus/health.rb

@@ -0,0 +1,35 @@
+module IPVSLitmus
+  class Health
+
+    attr_reader :summary
+
+    def initialize
+      @value = 0
+      @dependencies_available = true
+      @summary = ""
+    end
+
+    def ok?
+      value > 0
+    end
+
+    def value
+      return 0 unless @dependencies_available
+      @value
+    end
+
+    def perform(metric)
+      health = metric.current_health
+
+      @value += health
+      @summary << "#{metric.class}: #{health}\n"
+    end
+
+    def ensure(dependency)
+      available = dependency.available?
+
+      @dependencies_available &&= available
+      @summary << "#{dependency.class}: #{available ? 'OK' : 'FAIL'}\n"
+    end
+  end
+end

data/lib/ipvs_litmus/metric/available_memory.rb

@@ -0,0 +1,32 @@
+module IPVSLitmus
+  module Metric
+    class AvailableMemory
+      MULTIPLIER = {
+        "GB" => 1024*1024*1024,
+        "MB" => 1024*1024,
+        "KB" => 1024
+      }
+
+      def initialize(weight, facter = Facter)
+        @weight = weight
+        @facter = facter
+      end
+
+      def current_health
+        @weight * memory_free / memory_total
+      end
+
+      def memory_total
+        return @memory_total unless @memory_total.nil?
+
+        size, scale = @facter.value('memorytotal').split(' ')
+        @memory_total = size.to_i * MULTIPLIER[scale]
+      end
+
+      def memory_free
+        size, scale = @facter.value('memoryfree').split(' ')
+        size.to_i * MULTIPLIER[scale]
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/metric/cpu_load.rb

@@ -0,0 +1,22 @@
+module IPVSLitmus
+  module Metric
+    class CPULoad
+      def initialize(weight, facter = Facter)
+        @weight = weight
+        @facter = facter
+      end
+
+      def current_health
+        [@weight - (@weight * load_average / processor_count), 0].max
+      end
+
+      def processor_count
+        @processor_count ||= @facter.value('processorcount').to_i
+      end
+
+      def load_average
+        @facter.value('loadaverage').split(' ').first.to_f
+      end
+    end
+  end
+end

data/lib/ipvs_litmus/service.rb

@@ -0,0 +1,51 @@
+module IPVSLitmus
+  class Service
+    def initialize(name, dependencies = [], checks = [])
+      @name = name
+      @dependencies = dependencies
+      @checks = checks
+    end
+
+    def success?
+      health > 0
+    end
+
+    def current_health
+      forced_health = _determine_forced_health
+      return forced_health unless forced_health.nil?
+
+      health = IPVSLitmus::Health.new
+      @dependencies.each do |dependency|
+        health.ensure(dependency)
+      end
+
+      @checks.each do |check|
+        health.perform(check)
+      end
+      health
+    end
+
+    def measure_health(metric_class, options)
+      @checks << metric_class.new(options[:weight])
+    end
+
+    def depends(dependency_class, *args)
+      @dependencies << dependency_class.new(*args)
+    end
+
+    def _health_files
+      @health_files ||= [
+        [0, IPVSLitmus::StatusFile.new('down', @name)],
+        [100, IPVSLitmus::StatusFile.new('up', @name)],
+        [0, IPVSLitmus::StatusFile.new('global_down')],
+        [100, IPVSLitmus::StatusFile.new('global_up')]
+      ]
+    end
+
+    def _determine_forced_health
+      _health_files.map do |health, status_file|
+        ForcedHealth.new(health, status_file.content) if status_file.exists?
+      end.compact.first
+    end
+  end
+end

data/lib/ipvs_litmus/status_file.rb

@@ -0,0 +1,26 @@
+module IPVSLitmus
+  class StatusFile
+    def initialize(*filenames)
+      @path = File.join(IPVSLitmus.config_dir, *filenames)
+    end
+
+    def content
+      File.read(@path).chomp
+    end
+
+    def create(reason)
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.open(@path, 'w') do |file|
+        file.puts(reason)
+      end
+    end
+
+    def delete
+      FileUtils.rm(@path)
+    end
+
+    def exists?
+      File.exists?(@path)
+    end
+  end
+end

data/lib/ipvs_litmus/version.rb

@@ -0,0 +1,3 @@
+module IPVSLitmus
+  VERSION = "0.0.1"
+end

data/lib/ipvs_litmus.rb

@@ -0,0 +1,44 @@
+require 'pathname'
+require 'net/http'
+require 'uri'
+
+require 'bundler/setup'
+require 'sinatra/base'
+
+require 'facter'
+require 'facts/loadaverage'
+
+require 'ipvs_litmus/app'
+require 'ipvs_litmus/configuration'
+require 'ipvs_litmus/dependency/http'
+require 'ipvs_litmus/health'
+require 'ipvs_litmus/forced_health'
+require 'ipvs_litmus/metric/available_memory'
+require 'ipvs_litmus/metric/cpu_load'
+require 'ipvs_litmus/service'
+require 'ipvs_litmus/status_file'
+
+module IPVSLitmus
+  class << self
+    attr_reader :services, :config_dir
+  end
+
+  def self.configure(filename)
+    @config_file = filename
+    @services = IPVSLitmus::Configuration.new(filename).evaluate
+  end
+
+  def self.config_dir=(path)
+    @config_dir = Pathname.new(path)
+  end
+
+  def self.reload
+    configure(@config_file)
+  end
+
+  def self.reset
+    @services = {}
+  end
+end
+
+Signal.trap("HUP") { IPVSLitmus.reload }