litmus_paper 0.0.3

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@litmus_paper --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 litmus_paper.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/litmus_paper.png)](http://travis-ci.org/braintree/litmus_paper)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'litmus_paper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install litmus_paper
+
+## 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 'litmus_paper'
+require 'litmus_paper/cli/server'
+
+LitmusPaper::CLI::Server.new.start

data/bin/litmusctl

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

data/config.ru

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
+require 'litmus_paper'
+
+use Rack::CommonLogger, LitmusPaper::Logger.new
+run LitmusPaper::App

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/litmus_paper/app.rb

@@ -0,0 +1,63 @@
+module LitmusPaper
+  class App < Sinatra::Base
+    get "/" do
+      output = "Services monitored:\n"
+      output +=  LitmusPaper.services.keys.join("\n")
+
+      text 200, output
+    end
+
+    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 = LitmusPaper.services[params[:service]]
+      if service.nil?
+        text 404, "NOT FOUND", { "X-Health" => "0" }
+      else
+        health = service.current_health
+        response_code = health.ok? ? 200 : 503
+        body = "Health: #{health.value}\n"
+        body << health.summary
+        text response_code, body, { "X-Health" => health.value.to_s }
+      end
+    end
+
+    get "/test/error" do
+      raise "an error"
+    end
+
+    error do
+      text 500, "Server Error"
+    end
+
+    def text(response_code, body, headers ={})
+      [response_code, { "Content-Type" => "text/plain" }.merge(headers), 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/litmus_paper/cli/admin.rb

@@ -0,0 +1,97 @@
+module LitmusPaper
+  module CLI
+    class Admin
+      def run(argv = ARGV)
+        command = argv.shift
+        send(command, argv)
+      end
+
+      def list(args)
+        options = _default_options
+        opt_parser = _extend_default_parser(options) do |opts|
+          opts.banner = "Usage: litmusctl list [options]"
+        end
+        opt_parser.parse! args
+
+        request = Net::HTTP::Get.new("/")
+        _litmus_request(options[:host], options[:port], request)
+      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/litmus_paper/cli/server.rb

@@ -0,0 +1,62 @@
+module LitmusPaper
+  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
+
+        LitmusPaper.configure(options[:litmus_config])
+        LitmusPaper.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/litmus_paper/configuration.rb

@@ -0,0 +1,27 @@
+module LitmusPaper
+  class Configuration
+    def initialize(config_file_path)
+      @config_file_path = config_file_path
+      @services = {}
+    end
+
+    def evaluate(file = @config_file_path)
+      config_contents = File.read(file)
+      instance_eval(config_contents)
+      @services
+    end
+
+    def include_files(glob_pattern)
+      full_glob_pattern = File.expand_path(glob_pattern, File.dirname(@config_file_path))
+      Dir.glob(full_glob_pattern).each do |file|
+        evaluate(file)
+      end
+    end
+
+    def service(name, &block)
+      service = Service.new(name.to_s)
+      block.call(service)
+      @services[name.to_s] = service
+    end
+  end
+end

data/lib/litmus_paper/dependency/http.rb

@@ -0,0 +1,40 @@
+module LitmusPaper
+  module Dependency
+    class HTTP
+      def initialize(uri, options = {})
+        @uri = uri
+        @expected_content = Regexp.new(options.fetch(:content, '.*'))
+        @method = options.fetch(:method, 'GET')
+      end
+
+      def available?
+        response = _make_request
+        _successful_response?(response) && _body_matches?(response)
+      rescue Exception
+        false
+      end
+
+      def _make_request
+        uri = URI.parse(@uri)
+        request = Net::HTTP.const_get(@method.capitalize).new(uri.normalize.path)
+        request.set_form_data({})
+
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          http.request(request)
+        end
+      end
+
+      def _successful_response?(response)
+        response.is_a? Net::HTTPSuccess
+      end
+
+      def _body_matches?(response)
+        (response.body =~ @expected_content) ? true : false
+      end
+
+      def to_s
+        "Dependency::HTTP(#{@uri})"
+      end
+    end
+  end
+end

data/lib/litmus_paper/dependency/tcp.rb

@@ -0,0 +1,24 @@
+module LitmusPaper
+  module Dependency
+    class TCP
+      def initialize(ip, port)
+        @ip, @port = ip, port
+      end
+
+      def available?
+        Timeout.timeout(5) do
+          socket = TCPSocket.new(@ip, @port)
+          socket.close
+        end
+        true
+      rescue Exception
+        false
+      end
+
+      def to_s
+        "Dependency::TCP(tcp://#{@ip}:#{@port})"
+      end
+    end
+  end
+end
+

data/lib/litmus_paper/forced_health.rb

@@ -0,0 +1,18 @@
+module LitmusPaper
+  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/litmus_paper/health.rb

@@ -0,0 +1,35 @@
+module LitmusPaper
+  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}: #{health}\n"
+    end
+
+    def ensure(dependency)
+      available = dependency.available?
+
+      @dependencies_available &&= available
+      @summary << "#{dependency}: #{available ? 'OK' : 'FAIL'}\n"
+    end
+  end
+end

data/lib/litmus_paper/logger.rb

@@ -0,0 +1,15 @@
+module LitmusPaper
+  class Logger
+    extend Forwardable
+    def_delegators :@syslog, :debug, :info
+
+    def initialize
+      @syslog = SyslogLogger.new("litmus_paper")
+    end
+
+    def write(message)
+      @syslog.info(message)
+    end
+
+  end
+end

data/lib/litmus_paper/metric/available_memory.rb

@@ -0,0 +1,36 @@
+module LitmusPaper
+  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
+
+      def to_s
+        "Metric::AvailableMemory(#{@weight})"
+      end
+    end
+  end
+end

data/lib/litmus_paper/metric/cpu_load.rb

@@ -0,0 +1,26 @@
+module LitmusPaper
+  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
+
+      def to_s
+        "Metric::CPULoad(#{@weight})"
+      end
+    end
+  end
+end

data/lib/litmus_paper/service.rb

@@ -0,0 +1,51 @@
+module LitmusPaper
+  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 = LitmusPaper::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, LitmusPaper::StatusFile.new('down', @name)],
+        [100, LitmusPaper::StatusFile.new('up', @name)],
+        [0, LitmusPaper::StatusFile.new('global_down')],
+        [100, LitmusPaper::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/litmus_paper/status_file.rb

@@ -0,0 +1,26 @@
+module LitmusPaper
+  class StatusFile
+    def initialize(*filenames)
+      @path = File.join(LitmusPaper.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/litmus_paper/version.rb

@@ -0,0 +1,3 @@
+module LitmusPaper
+  VERSION = "0.0.3"
+end