auger 1.2.0

data/VERSION

@@ -0,0 +1 @@
+1.2.0

data/auger.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/auger/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ric Lister", "Grant Heffernan"]
+  gem.email         = ["rlister@gmail.com", "heffergm@gmail.com"]
+  gem.description   = %q{Auger: test-driven ops}
+  gem.summary       = %q{App && infrastructure testing DSL}
+  gem.homepage      = "https://rubygems.org/gems/auger"
+
+  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          = "auger"
+  gem.require_paths = ["lib"]
+  gem.version       = Auger::VERSION
+
+  # dependencies
+  gem.add_dependency('json'          , '>= 1.7.3')
+  gem.add_dependency('redis'         , '>= 3.0.1')
+  gem.add_dependency('net-dns'       , '>= 0.7.1')
+  gem.add_dependency('rainbow'       , '>=1.1.4')
+  gem.add_dependency('host_range'    , '>=0.0.1')
+  gem.add_dependency('cassandra-cql' , '>= 1.0.4')
+end
+

data/bin/aug

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'rainbow'
+require 'optparse'
+
+AUGER_DIR = File.dirname(File.dirname(__FILE__))
+AUGER_LIB = File.join(AUGER_DIR, 'lib')
+AUGER_CFG = (ENV['AUGER_CFG'] || File.join(AUGER_DIR, 'cfg')).split(File::PATH_SEPARATOR)
+
+## relative path to libs (in case not installed as a gem)
+$LOAD_PATH.unshift(AUGER_LIB) unless $LOAD_PATH.include?(AUGER_LIB)
+require 'auger'
+
+## set opts
+options = {}
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: aug [-h|--help] [-l|--list] [-v|--version] cfg"
+
+  if ARGV[0] == nil
+    puts opts.banner.color(:yellow)
+    exit
+  end
+
+  opts.on('-l', '--list', 'List available configs and exit.') do
+    list = AUGER_CFG.map do |dir| 
+      Dir["#{dir}/*.rb"].map{ |file| File.basename(file).sub(/\.rb$/, '') } 
+    end
+    puts list.flatten.sort
+    exit
+  end
+
+  opts.on('-h', '--help', 'Display help') do
+    puts opts
+    exit
+  end
+
+  opts.on('-v', '--version', 'Display version and exit.') do
+    puts Auger::VERSION.color(:green)
+    exit
+  end
+end
+optparse.parse!
+
+## load plugins
+Dir["#{AUGER_DIR}/lib/plugins/*.rb"].each {|file| require file }
+
+## cfg file can be e.g. 'imagine' or relative path
+cfg = 
+  if File.exists?(ARGV[0])
+    ARGV[0]
+  elsif path = AUGER_CFG.find { |path| File.exists?("#{path}/#{ARGV[0]}.rb") }
+    [path, "#{ARGV[0]}.rb"].join(File::SEPARATOR)
+  else
+    raise ArgumentError, "config #{ARGV[0]} not found"
+  end
+
+## pretty ascii output for different result outcomes
+def format_outcome(outcome)
+  case outcome
+  when TrueClass then
+    "\u2713".color(:green)
+  when MatchData then # boolean if no captures, otherwise list captures
+    (outcome.captures.empty? ? "\u2713" : outcome.captures.join(' '))
+      .color(:green)
+  when FalseClass then
+    "\u2717".color(:red)
+  when NilClass then
+    "nil".color(:red)
+  when Exception then
+    "#{outcome.class}: #{outcome.to_s}".color(:magenta)
+  else
+    outcome.to_s.color(:green)
+  end
+end
+
+Auger::Config.load(cfg).projects.each do |project|
+
+  threads = Hash.new { |h,k| h[k] = [] }
+
+  ## run tests
+  project.connections.each do |connection|
+    project.servers(connection.roles).map do |server|
+      threads[server.name] << Thread.new do
+        conn = connection.do_open(server)
+        connection.requests.map do |request|
+          response = request.do_run(conn)
+          request.tests.map do |test|
+            test.run(response)
+          end
+        end
+      end
+    end
+  end
+
+  ## width of test name column
+  max_test_length = 
+    project.connections.map{|c| c.requests.map{|r| r.tests.map{|t| t.name.length}}}.flatten.max
+
+  ## print results
+  threads.keys.each do |server|
+    puts "[#{server.color(:cyan)}]"
+    threads[server].each do |thread| 
+      results = thread.value    # this waits on thread
+      results.flatten.each do |result|
+        output = format_outcome(result.outcome)
+        puts "  %+#{max_test_length}s  %-30s" % [result.test.name, output]
+      end
+    end
+  end
+
+end

data/cfg/examples/elasticsearch.rb

@@ -0,0 +1,75 @@
+require 'json'
+
+project "Elasticsearch" do
+  server "localhost"
+ 
+  http 9200 do
+    get "/_cluster/health" do
+
+      # this runs after request returns, but before tests
+      # use it to munge response body from json string into a hash
+      before_tests do |r|
+        if r['Content-Type'].respond_to?(:match) and r['Content-Type'].match /application\/json/
+          begin 
+            r.body = JSON.parse(r.body)
+          rescue JSON::ParserError
+            puts "error parsing JSON in response body"
+          end
+        end
+      end
+
+      # simple as it gets... did we get 200 back?
+      test "Status 200" do |r|
+        r.code == '200'
+      end
+
+      # an array of stats we want to collect
+      stats = %w[
+        cluster_name
+        status
+        timed_out
+        number_of_nodes
+        number_of_data_nodes
+        active_primary_shards
+        active_shards
+        relocating_shards
+        initializing_shards
+        unassigned_shards
+      ]
+
+      # loop through each stat
+      # if the body is a hash, return the value
+      stats.each do |stat|
+        test "#{stat}" do |r|
+          if r.body.is_a? Hash
+            r.body[stat]
+          else
+            false
+          end
+        end
+      end
+
+      # I've discovered that a typical fail case with elasticsearch is 
+      #   that on occassion, nodes will come up and not join the cluster
+      # This is an easy way to see if the number of nodes that the host 
+      #   actually sees (actual_data_nodes) matches what we're
+      #   expecting (expected_data_nodes).
+      # TODO: dynamically update expected_data_nodes based on defined hosts:
+      test "Expected vs Actual Nodes" do |r|
+        if r.body.is_a? Hash
+          expected_data_nodes = 8
+          actual_data_nodes = r.body['number_of_data_nodes']
+
+          if expected_data_nodes == actual_data_nodes
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end
+

data/cfg/examples/redis.rb

@@ -0,0 +1,31 @@
+project "Redis" do
+  server "localhost"
+
+  telnet 6379 do
+    timeout "3"
+    binmode false
+
+    tests = %w[
+      role
+      redis_version
+      uptime_in_days
+      used_memory_human
+      blocked_clients
+      connected_slaves
+      connected_clients
+    ]
+
+
+    # issue an info command followed by quit,
+    #   otherwise, we'll hang on an open port.
+   
+    cmd "info\n\nquit\n\n" do
+      tests.each do |t|
+        test "#{t}" do |r|
+          r.match /#{t}:(.+)/
+        end
+      end
+    end
+  end
+end
+

data/cfg/examples/riak.rb

@@ -0,0 +1,42 @@
+project "Riak" do
+  server "localhost"
+
+  riak_stats = %w[
+    riak_kv_vnodes_running
+    vnode_gets
+    vnode_puts
+    cpu_nprocs
+  ]
+  
+  http 8098 do
+    get "/stats" do
+
+      riak_stats.each do |t|
+        test "#{t}" do |r|
+          r.body.match /"#{t}":(\d+)/
+        end
+      end
+
+      test "CPU Avg 1/5/15" do |r|
+        r.body.match(/"cpu_avg1":(\d+),"cpu_avg5":(\d+),"cpu_avg15":(\d+)/).captures.join("/")
+      end
+    end
+  end
+
+  riak_ports = {
+    epmd_port:    4369,
+    handoff_port: 8099,
+    pb_port:      8087,
+  }
+
+  riak_ports.each do |name, num|
+    socket num do
+      open? do 
+        test "#{name} open?" do |r|
+          r
+        end
+      end
+    end
+  end
+end
+

data/cfg/examples/webserver.rb

@@ -0,0 +1,56 @@
+project "Webserver Nginx" do
+  server "www.wickedcoolurl.com", :fqdn, :port => 80
+  server "frontend-r[01-04]", :app, :port => 6666
+  server "data-r[01-04]", :data
+
+  http do
+    roles :fqdn, :app
+
+    get "/status" do
+      header "Location: www.wickedcoolurl.com"
+
+      test "Site is up?" do |r|
+        r.body.match /the site is up/
+      end
+    end
+  end
+
+  https do
+    roles :fqdn
+
+    get "/index.html" do
+      test "Index" do |r|
+        r.body.match /HEAD/
+      end
+    end
+  end
+  https do
+    roles :app
+    insecure true
+
+    get "/index.html" do
+      test "Index" do |r|
+        r.body.match /HEAD/
+      end
+    end
+  end
+
+  telnet do
+    roles :fqdn, :app
+    timeout "3"
+    binmode false
+    
+    cmd "HEAD / HTTP/1.1\n\n" do
+      test "Telnet Port 80" do |r|
+        r.match /Server: (nginx\/[\d\.]+)/
+      end
+    end
+  end
+
+  socket 9999 do
+    roles :data
+
+    open? { test "Port 9999 is open?" }
+  end
+end
+

data/lib/auger.rb

@@ -0,0 +1,12 @@
+require 'auger/version'
+require 'auger/config'
+require 'auger/project'
+require 'auger/server'
+require 'auger/connection'
+require 'auger/request'
+require 'auger/test'
+require 'auger/result'
+
+module Auger
+  ##
+end

data/lib/auger/config.rb

@@ -0,0 +1,22 @@
+module Auger
+
+  class Config
+    attr_accessor :projects
+    def self.load(filename)
+      config = new
+      config.instance_eval(File.read(filename))
+      config
+    end
+    
+    def initialize
+      @projects = []
+      self
+    end
+    
+    def project(name, &block)
+      @projects << Project.load(name, &block)
+    end
+
+  end
+
+end

data/lib/auger/connection.rb

@@ -0,0 +1,39 @@
+module Auger
+
+  class Connection
+    attr_accessor :requests, :connection, :response, :roles, :options
+
+    def self.load(port, &block)
+      connection = new(port)
+      connection.instance_eval(&block)
+      connection
+    end
+
+    def initialize(port)
+      @options = {:port => port}
+      @roles = []
+      @requests = []
+    end
+
+    def roles(*names)
+      @roles += names if names
+      @roles
+    end
+
+    def method_missing(method, arg)
+      @options[method] = arg
+    end
+
+    ## call plugin open() and return plugin-specific connection object, or exception
+    def do_open(server)
+      options = @options.merge(server.options)
+      begin
+        self.open(server.name, options)
+      rescue => e
+        e
+      end
+    end
+    
+  end
+  
+end

data/lib/auger/project.rb

@@ -0,0 +1,64 @@
+require 'host_range'
+
+module Auger
+
+  class Project
+    attr_accessor :name, :fqdns, :hosts, :connections, :roles
+    
+    def self.load(name, &block)
+      project = new(name)
+      project.instance_eval(&block)
+      project
+    end
+
+    def initialize(name)
+      @name = name
+      @hosts = []
+      @fqdns = []
+      @connections = []
+      @roles = Hash.new { |h,k| h[k] = [] }
+      self
+    end
+
+    def role(name, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      servers = args.map { |arg| HostRange.parse(arg) }.flatten
+      #servers.each { |server| roles[name] << server }
+      servers.each { |server| roles[name] << Auger::Server.new(server, options) }
+    end
+
+    def server(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      roles = []
+      servers = []
+      args.each do |arg|
+        case arg
+        when Symbol then roles << arg
+        when String then servers << arg
+        else raise ArgumentError, "illegal argument to server: #{arg}"
+        end
+      end
+      roles = [nil] if roles.empty? # default role
+      roles.each { |name| role(name, *servers, options) }
+    end
+
+    alias :hosts :server
+
+    ## return array of servers for given array of roles (default to all)
+    def servers(roles = [])
+      (roles.empty? ? @roles.values : @roles.values_at(*roles))
+        .flatten
+    end
+
+    alias :host :hosts
+
+    ## add fqdn or return list of fqdns
+    def fqdns(*ranges)
+      ranges.empty? ? @fqdns.flatten : @fqdns << [*ranges].map {|r| HostRange.parse(r)}
+    end
+
+    alias :fqdn :fqdns
+
+  end
+  
+end