flapjack 0.4.10

data/lib/flapjack/checks/http_content

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'open-uri'
+
+page = ARGV[0]
+string = ARGV[1]
+
+exit 2 unless page && string
+
+body = open(page).read
+if body =~  /#{string}/
+  exit 0
+else
+  exit 2
+end

data/lib/flapjack/cli/notifier.rb

@@ -0,0 +1,245 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ostruct'
+require 'optparse'
+require 'log4r'
+require 'log4r/outputter/syslogoutputter'
+require File.join(File.dirname(__FILE__), '..', 'database')
+require File.join(File.dirname(__FILE__), '..', 'notifier')
+require File.join(File.dirname(__FILE__), '..', 'result')
+
+module Flapjack
+  class NotifierOptions
+    def self.parse(args)
+      options = OpenStruct.new
+      opts = OptionParser.new do |opts|
+        # the available command line options
+        opts.on('-b', '--beanstalk HOST', 'location of the beanstalkd') do |host|
+          options.host = host
+        end
+        opts.on('-p', '--port PORT', 'beanstalkd port') do |port|
+          options.port = port.to_i
+        end
+        opts.on('-r', '--recipients FILE', 'recipients file') do |recipients|
+          options.recipients = recipients.to_s
+        end
+        opts.on('-c', '--config FILE', 'config file') do |config|
+          options.config_filename = config.to_s
+        end
+        opts.on('-d', '--database-uri URI', 'location of the checks database') do |db|
+          options.database_uri = db.to_s
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      # parse the options
+      begin
+        opts.parse!(args)
+      rescue OptionParser::MissingArgument => e
+        # if an --option is missing it's argument
+        puts e.message.capitalize + "\n\n"
+        puts opts
+        exit 1
+      end
+ 
+      # default the host + port
+      options.host ||= 'localhost'
+      options.port ||= 11300
+  
+      @errors = []
+      # check that recipients file exists
+      if options.recipients
+        unless File.exists?(options.recipients.to_s)
+          @errors << "The specified recipients file doesn't exist!"
+        end
+      else
+        @errors << "You need to specify a recipients file with [-r|--recipients]."
+      end
+
+      # check that config file exists
+      if options.config_filename 
+        unless File.exists?(options.config_filename.to_s)
+          @errors << "The specified config file doesn't exist!"
+        end
+      else
+        options.config_filename ||= "/etc/flapjack/flapjack-notifier.yaml"
+        unless File.exists?(options.config_filename.to_s)
+          @errors << "The default config file (#{options.config_filename}) doesn't exist!"
+          @errors << "Set one up, or specify one with [-c|--config]."
+        end
+      end
+
+      # if there are errors, print them out and exit
+      if @errors.size > 0
+        puts "Errors:"
+        @errors.each do |error|
+          puts "  - #{error}"
+        end
+        puts
+        puts opts
+        exit 2
+      end
+  
+      options
+    end
+  end
+  
+  class NotifierCLI
+    attr_accessor :log, :recipients, :results_queue, :config
+    attr_accessor :notifier, :notifiers
+    attr_accessor :condition
+  
+    def initialize(opts={})
+      @log = opts[:logger]
+      @log ||= Log4r::Logger.new("notifier")
+    end
+  
+    def setup_loggers
+      @log.add(Log4r::StdoutOutputter.new('notifier'))
+      @log.add(Log4r::SyslogOutputter.new('notifier'))
+    end
+  
+    def setup_recipients(opts={})
+  
+      if opts[:yaml]
+        yaml = opts[:yaml]
+      else
+        opts[:filename] ||= File.join(Dir.pwd, "recipients.yaml")
+        yaml = YAML::load(File.read(opts[:filename]))
+      end
+ 
+      # FIXME: add error detection for passing in dumb things
+
+      @recipients = yaml.map do |r|
+        OpenStruct.new(r)
+      end
+    end
+
+    def setup_config(opts={})
+      if opts[:yaml]
+        yaml = opts[:yaml]
+      else
+        opts[:filename] ||= File.join(Dir.pwd, "flapjack-notifier.yaml")
+        yaml = YAML::load(File.read(opts[:filename]))
+      end
+
+      @config = OpenStruct.new(yaml)
+    end
+
+    def setup_database(opts={})
+      uri = (opts[:database_uri] || @config.database_uri)
+      raise ArgumentError, "database URI wasn't specified!" unless uri
+      DataMapper.setup(:default, uri)
+      validate_database
+    end
+
+    def validate_database
+      begin
+        DataMapper.repository(:default).adapter.execute("SELECT 'id' FROM 'checks';")
+      rescue Sqlite3Error
+        @log.warning("The specified database doesn't appear to have any structure!")
+        @log.warning("You need to investigate this.")
+      end
+      # FIXME: add more rescues in here!
+    end
+
+    def initialize_notifiers(opts={})
+      notifiers_directory = opts[:notifiers_directory] 
+      notifiers_directory ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'notifiers'))
+
+      raise ArgumentError, "notifiers directory doesn't exist!" unless File.exists?(notifiers_directory)
+      
+      @notifiers = []
+    
+      @config.notifiers.each_pair do |notifier, config|
+        filename = File.join(notifiers_directory, notifier.to_s, 'init')
+        if File.exists?(filename + '.rb')
+          @log.debug("Loading the #{notifier.to_s.capitalize} notifier")
+          require filename
+          config.merge!(:logger => @log, :website_uri => @config.website_uri)
+          @notifiers << Flapjack::Notifiers.const_get("#{notifier.to_s.capitalize}").new(config)
+        else
+          @log.warning("Flapjack::Notifiers::#{notifier.to_s.capitalize} doesn't exist!") 
+        end
+      end
+
+      @notifiers
+    end
+
+    # Sets up notifier to do the grunt work of notifying people when checks 
+    # return badly. 
+    #
+    # Accepts a list of recipients (:recipients) and a logger (:logger) as 
+    # arguments. If neither of these are specified, it will default to an 
+    # existing list of recipients and the current logger.
+    #
+    # Sets up and returns @notifier, an instance of Flapjack::Notifier
+    def setup_notifier(opts={})
+      recipients = (opts[:recipients] || @recipients)
+      log = (opts[:logger] || @log)
+      initialize_notifiers
+      notifiers = @notifiers # should we accept a list of notifiers?
+      @notifier = Flapjack::Notifier.new(:logger => log,
+                                         :notifiers => notifiers,
+                                         :recipients => recipients)
+    end
+  
+    def process_loop
+      @log.info("Processing results...")
+      loop do
+        process_result
+      end
+    end
+
+    # FIXME: we're doing a lookup twice - optimise out
+    def save_result(result)
+      if check = Check.get(result.id)
+        check.status = result.retval
+        check.save
+      else
+        @log.error("Got result for check #{result.id}, but it doesn't exist!")
+      end
+    end
+
+    # FIXME: we're doing a lookup twice - optimise out
+    def any_parents_warning_or_critical?(result)
+      if check = Check.get(result.id)
+        check.worst_parent_status > 0 ? true : false 
+      else
+        @log.error("Got result for check #{result.id}, but it doesn't exist!")
+      end
+    end
+
+    def process_result
+      @log.debug("Waiting for new result...")
+      result_job = @results_queue.reserve # blocks until a job is reserved
+      result = Flapjack::Result.new(YAML::load(result_job.body))
+      
+      @log.info("Processing result for check '#{result.id}'")
+      if result.warning? || result.critical?
+        if any_parents_warning_or_critical?(result)
+          @log.info("Not notifying on check '#{result.id}' as parent is failing.")
+        else
+          @log.info("Notifying on check '#{result.id}'")
+          @notifier.notify!(result)
+        end
+        
+        @log.info("Creating event for check '#{result.id}'")
+        event = Event.new(:check_id => result.id)
+        raise unless event.save
+      end
+
+      @log.info("Storing status of check in database")
+      save_result(result)
+
+      @log.debug("Deleting result for check '#{result.id}' from queue")
+      result_job.delete
+    end
+  
+  end
+  
+end

data/lib/flapjack/cli/notifier_manager.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ostruct'
+require 'optparse' 
+
+module Flapjack
+  class NotifierManagerOptions
+    def self.parse(args)
+      options = OpenStruct.new
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: flapjack-notifier-manager <command> [options]"
+        opts.separator " "
+        opts.separator "  where <command> is one of:"
+        opts.separator "     start            start a worker"
+        opts.separator "     stop             stop all workers"
+        opts.separator "     restart          restart workers"
+        opts.separator " "
+        opts.separator "  and [options] are:"
+  
+        opts.on('-b', '--beanstalk HOST', 'location of the beanstalkd') do |host|
+          options.host = host
+        end
+        opts.on('-p', '--port PORT', 'beanstalkd port') do |port|
+          options.port = port.to_s
+        end
+        opts.on('-r', '--recipients FILE', 'recipients file') do |recipients|
+          options.recipients = File.expand_path(recipients.to_s)
+        end
+        opts.on('-c', '--config FILE', 'config file') do |config|
+          options.config_filename = config.to_s
+        end
+      end
+  
+      begin
+        opts.parse!(args)
+      rescue => e
+        puts e.message.capitalize + "\n\n"
+        puts opts
+        exit 1
+      end
+  
+      # defaults
+      options.host ||= "localhost"
+      options.port ||= 11300
+
+      @errors = []
+
+      unless ARGV[0] == "stop"
+        if options.recipients
+          unless File.exists?(options.recipients)
+            @errors << "The specified recipients file doesn't exist!"
+          end
+        else
+          @errors << "You must specify a recipients file!"
+        end
+
+        if options.config_filename 
+          unless File.exists?(options.config_filename)
+            @errors << "The specified config file dosen't exist!"
+          end
+        else 
+          @errors << "You must specify a config file!"
+        end
+      end
+
+      if @errors.size > 0
+        puts "Errors:" 
+        @errors.each do |error|
+          puts "  - #{error}"
+        end
+        puts
+        puts opts
+        exit 2
+      end
+  
+      unless %w(start stop restart).include?(args[0])
+        puts opts
+        exit 1
+      end
+  
+      options
+    end
+  end
+
+end

data/lib/flapjack/cli/worker.rb

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'beanstalk-client'
+require 'ostruct'
+require 'optparse'
+require 'log4r'
+require 'log4r/outputter/syslogoutputter'
+require 'flapjack/result'
+require 'flapjack/patches'
+
+module Flapjack
+  class WorkerOptions
+    def self.parse(args)
+      options = OpenStruct.new
+      opts = OptionParser.new do |opts|
+        # the available command line options
+        opts.on('-b', '--beanstalk HOST', 'location of the beanstalkd') do |host|
+          options.host = host
+        end
+        opts.on('-p', '--port PORT', 'beanstalkd port') do |port|
+          options.port = port.to_i
+        end
+        opts.on('-c', '--checks-directory DIR', 'sandboxed check directory') do |dir|
+          options.checks_directory = dir.to_s
+        end
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+
+      # parse the options
+      begin
+        opts.parse!(args)
+      rescue OptionParser::MissingArgument => e
+        # if an --option is missing it's argument
+        puts e.message.capitalize + "\n\n"
+        puts opts
+        exit 1
+      end
+ 
+      # default the port
+      options.host ||= 'localhost'
+      options.port ||= 11300
+      options.checks_directory ||= File.join(File.dirname(__FILE__), '..', 'checks')
+  
+      options
+    end
+  end
+ 
+  class Worker
+    
+    attr_accessor :jobs, :results, :log
+
+    def initialize(opts={})
+      @jobs    = Beanstalk::Pool.new(["#{opts[:host]}:#{opts[:port]}"], 'jobs')
+      @results = Beanstalk::Pool.new(["#{opts[:host]}:#{opts[:port]}"], 'results')
+      @sandbox = (opts[:check_directory] || File.expand_path(File.join(File.dirname(__FILE__), '..', 'checks')))
+
+      if opts[:logger]
+        @log = opts[:logger]
+      else
+        @log = Log4r::Logger.new('worker')
+        @log.add(Log4r::StdoutOutputter.new('worker'))
+        @log.add(Log4r::SyslogOutputter.new('worker'))
+      end
+    end
+    
+    def process_loop
+      @log.info("Booting main loop...")
+      loop do 
+        process_check
+      end
+    end
+
+    def process_check
+      # get next check off the beanstalk
+      job, check = get_check()
+
+      # do the actual check
+      result, retval = perform_check(check.command)
+
+      # report the results of the check
+      report_check(:result => result, :retval => retval, :check => check)
+     
+      # create another job for the check, delete current job
+      cleanup_job(:job => job, :check => check)
+    end
+
+    def perform_check(cmd)
+      command = "sh -c '#{@sandbox}/#{cmd}'"
+      @log.debug("Executing check: \"#{command}\"")
+      result = `#{command}`
+      retval = $?.exitstatus
+
+      return result, retval
+    end
+
+    def report_check(opts={})
+      raise ArgumentError unless (opts[:result] && opts[:retval] && opts[:check])
+
+      @log.debug "Reporting results for check id #{opts[:check].id}."
+      @results.yput({:id => opts[:check].id, 
+                     :output => opts[:result], 
+                     :retval => opts[:retval].to_i})
+    end
+
+    def cleanup_job(opts={})
+      raise ArgumentError unless (opts[:job] && opts[:check])
+
+      # add job back onto stack
+      @log.debug("Putting check back onto beanstalk.")
+      @jobs.yput(opts[:check].to_h, 65536, opts[:check].frequency)
+       
+      # FIXME: what happens when power goes out here?
+       
+      # once we're done, clean up
+      @log.debug("Deleting job.")
+      opts[:job].delete
+    end
+
+    def get_check
+      @log.debug("Waiting for check...")
+      job = @jobs.reserve
+      # FIXME: maybe wrap Result as Job now that Check is reserved?
+      check = Result.new(YAML::load(job.body))
+      @log.info("Got check with id #{check.id}")
+
+      return job, check
+    end
+
+  end
+
+end
+