flapjack 0.9.6 → 1.0.0rc1

data/bin/flapjack-nsca-receiver

@@ -1,246 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Nagios.cfg should be enabled with a command_file:
-#
-# command_file=/var/lib/nagios3/rw/nagios.cmd
-#
-# The format this script expects looks like:
-#   [$TIMET] PROCESS_SERVICE_CHECK_RESULT;$HOSTNAME$;$SERVICEDESC$;$SERVICESTATE$;$SERVICEOUTPUT$;$SERVICEPERFDATA$
-#
-
-unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-  $: << File.dirname(__FILE__) + '/../lib'
-end
-
-require 'optparse'
-require 'ostruct'
-require 'redis'
-
-require 'oj'
-Oj.default_options = { :indent => 0, :mode => :strict }
-
-require 'dante'
-
-require 'flapjack/configuration'
-require 'flapjack/data/event'
-
-# Nsca example line for a storage-device check:
-#[1393410685] PROCESS_SERVICE_CHECK_RESULT;db1.dev;STORAGE;0;Raid Set # 000 (800.0GB) is Normal.
-
-def process_input(opts)
-  redis = opts[:redis]
-  fifo  = File.new(opts[:fifo])
-  begin
-    while line = fifo.gets
-      skip unless line
-      split_line = line.split(" ")
-
-      timestamp, passivecheck = split_line
-      split_passive = passivecheck.split(";")
-      timestamp = timestamp.delete('[]')
-
-      check_long_output = ''
-      object_type, entity, check, state, check_output = split_passive
-
-      case
-      when (split_line.length < 2 || split_passive.length < 5)
-        puts "ERROR - rejecting this line; illegal format: [#{line}]"
-        next
-      when (timestamp !~ /^\d+$/)
-        puts "ERROR - rejecting this line; timestamp look like a timestamp: [#{line}]"
-        next
-      when (object_type != 'PROCESS_SERVICE_CHECK_RESULT')
-        puts "ERROR - rejecting this line; identifier 'PROCESS_SERVICE_CHECK_RESULT' is missing: [#{line}]"
-        next
-      end
-
-      puts "#{object_type}, #{timestamp}, #{entity}, #{check}, #{state}, #{check_output}"
-
-      state = {'0' => 'ok', '1' => 'warning', '2' => 'critical'}[state.downcase] || 'unknown'
-      event = {
-        'entity'    => entity,
-        'check'     => check,
-        'type'      => 'service',
-        'state'     => state,
-        'summary'   => check_output,
-        'details'   => nil,
-        'time'      => timestamp,
-      }
-      Flapjack::Data::Event.add(event, :redis => redis)
-    end
-  rescue Redis::CannotConnectError
-    puts "Error, unable to to connect to the redis server (#{$!})"
-  end
-end
-
-def main(opts)
-  fifo = opts[:fifo]
-  redis = Redis.new(opts[:redis_options])
-  while true
-    process_input(:redis => redis, :fifo => fifo)
-    puts "Whoops with the fifo, restarting main loop in 10 seconds"
-    sleep 10
-  end
-end
-
-options = OpenStruct.new
-options.config    = Flapjack::Configuration::DEFAULT_CONFIG_PATH
-options.daemonize = nil
-
-exe = File.basename(__FILE__)
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: #{exe} COMMAND [OPTIONS]"
-
-  opts.separator  ""
-  opts.separator  "Commands"
-  opts.separator  "     start #{" " * 25} start #{exe}"
-  opts.separator  "     stop #{" " * 26} stop #{exe}"
-  opts.separator  "     restart #{" " * 23} (re)start #{exe}"
-  opts.separator  "     status #{" " * 24} see if #{exe} is running"
-  opts.separator  ""
-  opts.separator  "Options"
-
-  opts.on("-c", "--config [PATH]", String, "PATH to the config file to use") do |c|
-    options.config = c
-  end
-
-  opts.on("-f", "--fifo FIFO", String, "Path to the nagios perfdata named pipe") do |f|
-    options.fifo = f
-  end
-
-  opts.on("-d", "--[no-]daemonize", "Daemonize?") do |d|
-    options.daemonize = d
-  end
-
-  opts.on("-p", "--pidfile [PATH]", String, "PATH to the pidfile to write to") do |pid|
-    options.pidfile = pid
-  end
-
-  opts.on("-l", "--logfile [PATH]", String, "PATH to the logfile to write to") do |l|
-    options.logfile = l
-  end
-
-  opts.on_tail("-h", "--help", "Show this usage message") do
-    puts opts
-    puts '
-Required Nagios Configuration Changes
--------------------------------------
-
-flapjack-nsca-receiver reads events from the nagios "command file" read from by Nagios, written to by the Nsca-daemon.
-
-The named pipe is automatically created by _nagios_ if it is enabled
-in the configfile:
-
-  # modified lines:
-  command_file=/var/lib/nagios3/rw/nagios.cmd
-
-The Nsca daemon is optionally writing to a tempfile if the named pipe does
-not exist.
-
-Details on the wiki: https://github.com/flapjack/flapjack/wiki/USING#XXX
-'
-
-    exit
-  end
-
-end
-optparse.parse!(ARGV)
-
-FLAPJACK_ENV = ENV['FLAPJACK_ENV'] || 'production'
-
-config = Flapjack::Configuration.new
-config.load(options.config)
-config_env = config.all
-redis_options = config.for_redis
-
-if config_env.nil? || config_env.empty?
-  puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{options.config}'"
-  puts optparse
-  exit 1
-end
-
-config_nr = config_env['nsca-receiver'] || {}
-
-pidfile = options.pidfile.nil? ?
-            (config_nr['pid_file'] || "/var/run/flapjack/#{exe}.pid") :
-            options.pidfile
-
-logfile = options.logfile.nil? ?
-            (config_nr['log_file'] || "/var/log/flapjack/#{exe}.log") :
-            options.logfile
-
-fifo = options.fifo.nil? ?
-         (config_nr['fifo'] || '/var/lib/nagios3/rw/nagios.cmd') :
-         options.fifo
-
-daemonize = options.daemonize.nil? ?
-              !!config_nr['daemonize'] :
-              options.daemonize
-
-
-runner = Dante::Runner.new(exe, :pid_path => pidfile, :log_path => logfile)
-case ARGV[0]
-when "start", "restart"
-  unless File.exist?(fifo)
-    raise "No fifo (named pipe) file found at #{fifo}"
-  end
-  unless File.pipe?(fifo)
-    raise "The file at #{fifo} is not a named pipe, try using mkfifo to make one"
-  end
-  unless File.readable?(fifo)
-    raise "The fifo (named pipe) at #{fifo} is unreadable"
-  end
-end
-
-case ARGV[0]
-when "start"
-  if runner.daemon_running?
-    puts "#{exe} is already running."
-    exit 1
-  else
-    print "#{exe} starting..."
-    runner.execute(:daemonize => daemonize) {
-      main(:redis_options => redis_options, :fifo => fifo)
-    }
-    puts " done."
-  end
-
-when "stop"
-  if runner.daemon_running?
-    print "#{exe} stopping..."
-    runner.execute(:kill => true)
-    puts " done."
-  else
-    puts "#{exe} is not running."
-    exit 1
-  end
-
-when "restart"
-  print "#{exe} restarting..."
-  runner.execute(:daemonize => true, :restart => true) {
-    main(:redis_options => redis_options, :fifo => fifo)
-  }
-  puts " done."
-
-when "status"
-  uptime = (runner.daemon_running?) ? Time.now - File.stat(pidfile).ctime : 0
-  if runner.daemon_running?
-    puts "#{exe} is running: #{uptime}"
-  else
-    puts "#{exe} is not running"
-    exit 3
-  end
-
-else
-  if ARGV.nil? || ARGV.empty?
-    puts "No command provided"
-  else
-    puts "Unknown command provided: '#{ARGV[0]}'"
-  end
-  puts "\n#{optparse}"
-  exit 1
-
-end
-
-

data/bin/flapjack-populator

@@ -1,132 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'ostruct'
-
-require 'oj'
-Oj.default_options = { :indent => 0, :mode => :strict }
-
-require 'redis'
-
-# add lib to the default include path
-unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-  $: << File.dirname(__FILE__) + '/../lib'
-end
-
-require 'flapjack/configuration'
-require 'flapjack/data/contact'
-require 'flapjack/data/entity'
-require 'flapjack/data/event'
-
-options = OpenStruct.new
-options.config = Flapjack::Configuration::DEFAULT_CONFIG_PATH
-
-exe = File.basename(__FILE__)
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: #{exe} COMMAND [OPTIONS]"
-
-  opts.separator  ""
-  opts.separator  "Commands:"
-  opts.separator  "     import-entities"
-  opts.separator  "     import-contacts"
-  opts.separator  "     purge-events    purge queued monitoring events"
-  opts.separator  ""
-  opts.separator  "Options"
-
-  opts.on("-c", "--config [PATH]", String, "PATH to the config file to use") do |c|
-    options.config = c
-  end
-
-  opts.on("-f", "--from [FILE]", String, "path to the FILE to import") do |f|
-    options.from = f
-  end
-
-end
-optparse.parse!(ARGV)
-
-bail_with_usage = proc do |message|
-  puts message
-  puts "\n#{optparse}"
-  exit(false)
-end
-
-if options.help
-  puts optparse
-  exit
-elsif options.version
-  puts Flapjack::VERSION
-  exit
-elsif !["import-contacts", "import-entities", "purge-events"].include?(ARGV[0])
-  message = if ARGV.nil? || ARGV.empty?
-              "No command provided"
-            else
-              "Unknown command provided: '#{ARGV[0]}'"
-            end
-  bail_with_usage.call message
-end
-
-FLAPJACK_ENV = ENV['FLAPJACK_ENV'] || 'production'
-
-config = Flapjack::Configuration.new
-config.load(options.config)
-config_env = config.all
-redis_options = config.for_redis
-
-if config_env.nil? || config_env.empty?
-  puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{options.config}'"
-  exit(false)
-end
-
-case ARGV[0]
-when "import-contacts"
-  unless options.from
-    bail_with_usage.call "No import file provided with --from, eg. --from contacts.json"
-  end
-  contacts = Oj.load(File.new(options.from))
-
-  if contacts && contacts.is_a?(Enumerable) && contacts.any? {|e| !e['id'].nil?}
-    @persistence = Redis.new(redis_options)
-    contacts.each do |contact|
-      unless contact['id']
-        puts "Contact not imported as it has no id: " + contact.inspect
-        next
-      end
-      Flapjack::Data::Contact.add(contact, :redis => @persistence)
-    end
-    @persistence.quit
-  end
-
-when "import-entities"
-  unless options.from
-    bail_with_usage.call "No import file provided with --from, eg. --from contacts.json"
-  end
-  entities = Oj.load(File.new(options.from))
-
-  if entities && entities.is_a?(Enumerable) && entities.any? {|e| !e['id'].nil?}
-    @persistence = Redis.new(redis_options)
-    entities.each do |entity|
-      unless entity['id']
-        puts "Entity not imported as it has no id: " + entity.inspect
-        next
-      end
-      Flapjack::Data::Entity.add(entity, :redis => @persistence)
-    end
-    @persistence.quit
-  end
-
-when "purge-events"
-  @persistence = Redis.new(redis_options)
-  events_size = @persistence.llen('events')
-  puts "purging #{events_size} events..."
-  etq = "events.#{Time.now.to_i}"
-  puts "renaming 'events' to '#{etq}'"
-  @persistence.rename('events', etq)
-  puts "setting expiry of '#{etq}' to 8 hours"
-  @persistence.expire(etq, (60 * 60 * 8))
-  @persistence.quit
-
-else
-  bail_with_usage.call "You need to give me something to do, eg. a command like 'import-entities', 'import-clients', etc."
-end
-

data/bin/flapper

@@ -1,152 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'ostruct'
-require 'eventmachine'
-require 'socket'
-require 'dante'
-
-module Flapper
-  def receive_data data
-    send_data ">>>you sent: #{data}"
-    close_connection if data =~ /quit/i
-  end
-end
-
-def local_ip
-  # turn off reverse DNS resolution temporarily
-  orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
-
-  UDPSocket.open do |s|
-    s.connect '64.233.187.99', 1
-    s.addr.last
-  end
-ensure
-  Socket.do_not_reverse_lookup = orig
-end
-
-def main(bind_ip, bind_port, frequency)
-  raise "bind_port must be an integer" unless bind_port.is_a?(Integer)
-  start_every = frequency
-  stop_after  = frequency.to_f / 2
-
-  EM.run {
-
-    puts "#{Time.now}: starting server on #{bind_ip}:#{bind_port}"
-    server_init = EM.start_server bind_ip, bind_port, Flapper
-    EM.add_timer(stop_after) do
-      puts "#{Time.now}: stopping server"
-      EM.stop_server(server_init)
-    end
-
-    EM.add_periodic_timer(start_every) do
-      puts "#{Time.now}: starting server on #{bind_ip}:#{bind_port}"
-      server = EM.start_server bind_ip, bind_port, Flapper
-      EM.add_timer(stop_after) do
-        puts "#{Time.now}: stopping server"
-        EM.stop_server(server)
-      end
-    end
-  }
-end
-
-options = OpenStruct.new
-options.daemonize = nil
-
-exe = File.basename(__FILE__)
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: #{exe} COMMAND [OPTIONS]"
-
-  opts.separator  ""
-  opts.separator  "Commands"
-  opts.separator  "     start #{" " * 25} start #{exe}"
-  opts.separator  "     stop #{" " * 26} stop #{exe}"
-  opts.separator  "     restart #{" " * 23} (re)start #{exe}"
-  opts.separator  "     status #{" " * 24} see if #{exe} is running"
-  opts.separator  ""
-  opts.separator  "Options"
-
-  opts.on("-d", "--[no-]daemonize", "Daemonize?") do |d|
-    options.daemonize = d
-  end
-
-  opts.on("-p", "--pidfile [PATH]", String, "PATH to the pidfile to write to") do |pid|
-    options.pidfile = pid
-  end
-
-  opts.on("-l", "--logfile [PATH]", String, "PATH to the logfile to write to") do |l|
-    options.log_path = l
-  end
-
-  opts.on("-b", "--bind-ip [ADDRESS]", String, "ADDRESS (IPv4 or IPv6) for flapper to bind to") do |b|
-    options.bind_ip = b
-  end
-
-  opts.on("-P", "--bind-port [PORT]", String, "PORT for flapper to bind to (default: 12345)") do |p|
-    options.bind_port = p.to_i
-  end
-
-  opts.on("-f", "--frequency [SECONDS]", String, "oscillate with a frequency of SECONDS [120]") do |f|
-    options.frequency = f.to_f
-  end
-
-end.parse!(ARGV)
-
-daemonize = options.daemonize.nil? ? true : options.daemonize
-pidfile   = options.pidfile   || "/var/run/flapjack/#{exe}.pid"
-logfile   = options.log_path  || "/var/log/flapjack/#{exe}.log"
-bind_ip   = options.bind_ip   || local_ip
-bind_port = options.bind_port || 12345
-frequency = options.frequency || 120.0
-
-runner = Dante::Runner.new(exe, :pid_path => pidfile, :log_path => logfile)
-
-case ARGV[0]
-when "start"
-  if runner.daemon_running?
-    puts "#{exe} is already running."
-    exit 1
-  else
-    print "#{exe} starting..."
-    runner.execute(:daemonize => daemonize) {
-      main(bind_ip, bind_port, frequency)
-    }
-    puts " done."
-  end
-
-when "stop"
-  if runner.daemon_running?
-    print "#{exe} stopping..."
-    runner.execute(:kill => true)
-    puts " done."
-  else
-    puts "#{exe} is not running."
-    exit 1
-  end
-
-when "restart"
-  print "#{exe} restarting..."
-  runner.execute(:daemonize => true, :restart => true) {
-    main(bind_ip, bind_port, frequency)
-  }
-  puts " done."
-
-when "status"
-  uptime = (runner.daemon_running?) ? (Time.now - File.stat(pidfile).ctime) : 0
-  if runner.daemon_running?
-    puts "#{exe} is running: #{uptime}"
-  else
-    puts "#{exe} is not running"
-    exit 3
-  end
-
-else
-  if ARGV.nil? || ARGV.empty?
-    puts "No command provided"
-  else
-    puts "Unknown command provided: '#{ARGV[0]}'"
-  end
-  exit 1
-
-end

data/bin/receive-events

@@ -1,179 +0,0 @@
-#!/usr/bin/env ruby
-
-unless $:.include?(File.dirname(__FILE__) + '/../lib/')
-  $: << File.dirname(__FILE__) + '/../lib'
-end
-
-require 'optparse'
-require 'ostruct'
-require 'redis'
-
-require 'oj'
-Oj.default_options = { :indent => 0, :mode => :strict }
-
-require 'flapjack/configuration'
-require 'flapjack/data/event'
-
-def pike(message)
-  puts "piking out: #{message}"
-  exit 1
-end
-
-def send_event(event, opts)
-  Flapjack::Data::Event.add(event, :redis => opts[:redis])
-end
-
-def receive(opts)
-  redis = Redis.new(opts[:redis_options])
-  source_redis = Redis.new(:url => opts[:source])
-
-  archives = get_archive_keys_stats(source_redis)
-  raise "found no archives!" unless archives && archives.length > 0
-
-  puts "found archives: #{archives.inspect}"
-
-  # each archive bucket is a redis list that is written
-  # with brpoplpush, that is newest items are added to the left (head)
-  # of the list, so oldest events are to be found at the tail of the list.
-  #
-  # the index of these archives, in the 'archives' array, also stores the
-  # redis key names for each bucket in oldest to newest
-  events_sent = 0
-  case
-  when opts[:all]
-    archive_key = archives[0][:name]
-    cursor      = -1
-  when opts[:last], opts[:time]
-    raise "Sorry, unimplemented"
-  else
-    # wait for the next event to be archived, so point the cursor at a non-existant
-    # slot in the list, the one before the 0'th
-    archive_key = archives[-1][:name]
-    cursor      = -1 - archives[-1][:size]
-  end
-
-  puts archive_key
-
-  loop do
-    new_archive_key = false
-    # something to read at cursor?
-    event = source_redis.lindex(archive_key, cursor)
-    if event
-      send_event(event, :redis => redis)
-      events_sent += 1
-      print "#{events_sent} " if events_sent % 1000 == 0
-      cursor -= 1
-    else
-      puts "\narchive key: #{archive_key}, cursor: #{cursor}"
-      # do we need to look at the next archive bucket?
-      archives = get_archive_keys_stats(source_redis)
-      i = archives.index {|a| a[:name] == archive_key }
-      if archives[i][:size] = (cursor.abs + 1)
-        if archives[i + 1]
-          archive_key = archives[i + 1][:name]
-          puts archive_key
-          cursor = -1
-          new_archive_key = true
-        else
-          return unless opts[:follow]
-        end
-      end
-      sleep 1 unless new_archive_key
-    end
-  end
-end
-
-def get_archive_keys_stats(source_redis)
-  source_redis.keys("events_archive:*").sort.map {|a|
-    { :name => a,
-      :size => source_redis.llen(a) }
-  }
-end
-
-options = OpenStruct.new
-options.config    = Flapjack::Configuration::DEFAULT_CONFIG_PATH
-options.daemonize = nil
-
-exe = File.basename(__FILE__)
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: #{exe} COMMAND [OPTIONS]"
-
-  opts.separator  ""
-  opts.separator  "Commands"
-  opts.separator  "     help"
-  opts.separator  ""
-  opts.separator  "Options"
-
-  opts.on("-c", "--config [PATH]", String, "PATH to the config file to use") do |c|
-    options.config = c
-  end
-
-  opts.on("-s", "--source URL", String, "URL of source redis database, eg redis://localhost:6379/0") do |s|
-    options.source = s
-  end
-
-  opts.on("-f", "--follow", String, "keep reading events as they are archived on the source") do |f|
-    options.follow = true
-  end
-
-  opts.on("-a", "--all", String, "replay all archived events from the source") do |a|
-    options.all = true
-  end
-
-  opts.on("-l", "--last COUNT", String, "replay the last COUNT events from the source") do |l|
-    options.count = l
-  end
-
-  opts.on("-t", "--time TIME", String, "replay all events archived on the source since TIME") do |t|
-    options.since = t
-  end
-
-end
-optparse.parse!(ARGV)
-
-FLAPJACK_ENV = ENV['FLAPJACK_ENV'] || 'production'
-
-config = Flapjack::Configuration.new
-config.load(options.config)
-config_env = config.all
-redis_options = config.for_redis
-
-if config_env.nil? || config_env.empty?
-  puts "No config data for environment '#{FLAPJACK_ENV}' found in '#{options.config}'"
-  puts "\n#{optparse}"
-  exit 1
-end
-
-case ARGV[0]
-when "help"
-  puts optparse
-  exit
-else
-  unless ARGV.nil? || ARGV.empty?
-    puts "Unknown command provided: '#{ARGV[0]}'"
-    puts "\n#{optparse}"
-    exit 1
-  end
-end
-
-unless options.source
-  puts "--source URL is required"
-  puts "\n#{optparse}"
-  exit 1
-end
-
-unless options.follow || options.all
-  puts "one or both of --follow or --all is required"
-  puts "\n#{optparse}"
-  exit 1
-end
-
-receive(:follow => options.follow,
-        :all => options.all,
-        :source => options.source,
-        :last => options.last,
-        :time => options.time,
-        :redis_options => redis_options)
-
-