nagios-manage 0.5.0

data/bin/check_check.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+#
+# Check check- aggregate results from other checks in your nagios instance.
+# Reads the 'status_file' for current states.
+#
+# Useful for having lots of small checks roll up into an aggregate that
+# only alerts you once during failures, not N times.
+#
+# Also useful for business-view monitoring
+#
+
+require "rubygems"
+require "nagios/status"
+require "optparse"
+
+class Nagios::Status::Model
+  STATEMAP = {
+    "0" => "OK",
+    "1" => "WARNING",
+    "2" => "CRITICAL",
+    "3" => "UNKNOWN",
+  }
+
+  def initialize(path)
+    @path = path
+    @status = Nagios::Status.new
+    update
+  end # def initialize
+
+  def update
+    @status.parsestatus(@path)
+  end # def update
+
+  def services(service_pattern=nil, host_pattern=nil)
+    matches = []
+    self.hosts(host_pattern).each do |host, hostinfo|
+      hostinfo["servicestatus"].each do |name, status| 
+        next if service_pattern and !service_pattern.match(name)
+
+        # Skip silenced or checks in scheduled downtime.
+        next if status["notifications_enabled"].to_i == 0
+        next if status["scheduled_downtime_depth"].to_i > 0
+
+        # Only report checks that are in 'hard' state.
+        # If not in hard state, report 'last_hard_state' instead.
+        if status["state_type"] != "1" # not in hard state
+          status["current_state"] = status["last_hard_state"]
+          # TODO(sissel): record that this service is currently 
+          # in a soft state transition.
+        end
+
+        # TODO(sissel): Maybe also skip checks that are 'acknowledged'
+        matches << status
+      end
+    end # hosts().each 
+    return matches
+  end # def services
+
+  def hosts(pattern=nil)
+    if pattern
+      return @status.status["hosts"]
+      #.reject { |name,hostinfo| !pattern.match(name) }
+    else
+      return @status.status["hosts"]
+    end # if pattern
+  end # def hosts
+
+  # TODO(sissel): add a proper 'status' model that
+  # has HostStatus, ServiceStatus, etc.
+
+end # class Nagios::Status::Model
+
+Settings = Struct.new(:nagios_cfg, :status_path, :service_pattern, :host_pattern)
+def main(args)
+  progname = File.basename($0)
+  settings = Settings.new
+  settings.nagios_cfg = "/etc/nagios3/nagios.cfg" # debian/ubuntu default
+
+  opts = OptionParser.new do |opts|
+    opts.banner = "Usage: #{progname} [options]"
+
+    opts.on("-f NAGIOS_CFG", "--config NAGIOS_CFG",
+            "Path to your nagios.cfg (I will use the status_file setting") do |val|
+      settings.nagios_cfg = val
+    end
+
+    opts.on("-s REGEX", "--service REGEX",
+            "Aggregate only services matching the given pattern") do |val|
+      settings.service_pattern = val
+    end
+
+    opts.on("-h REGEX", "--host REGEX",
+            "Aggregate only services from hosts matching the given pattern") do |val|
+      settings.host_pattern = val
+    end
+  end # OptionParser.new
+
+  opts.parse!(args)
+
+  # hacky parsing, for now
+  status_line = File.new(settings.nagios_cfg, "r").readlines.grep(/^\s*status_file\s*=/).first.chomp
+  settings.status_path = status_line.split(/\s*=\s*/)[1]
+  status = Nagios::Status::Model.new(settings.status_path)
+
+  results = Hash.new { |h,k| h[k] = 0 }
+  service_pattern = nil
+  if settings.service_pattern
+    service_pattern = Regexp.new(settings.service_pattern)
+  end
+
+  host_pattern = nil
+  if settings.host_pattern
+    host_pattern = Regexp.new(settings.host_pattern)
+  end
+
+  Nagios::Status::Model::STATEMAP.values.each do |state|
+    results[state] = []
+  end
+
+  # Collect check results by state
+  status.services(service_pattern, host_pattern).each do |service_status|
+    state = Nagios::Status::Model::STATEMAP[service_status["current_state"]] 
+    if state == nil
+      state = "UNKNOWN(state=#{service_status["current_state"]})"
+    end
+
+    results[state] << service_status
+  end
+
+  # Output a summary line
+  ["OK", "WARNING", "CRITICAL", "UNKNOWN"].each do | state|
+    print "#{state}=#{results[state].length} "
+  end
+  print "services=/#{settings.service_pattern}/ "
+  print "hosts=/#{settings.host_pattern}/ "
+  puts
+
+  # More data output
+  ["WARNING", "CRITICAL", "UNKNOWN"].each do |state|
+    if results[state] && results[state].count > 0
+      puts "Services in #{state}:"
+      results[state].sort { |a,b| a["host_name"] <=> b["host_name"] }.each do |service|
+        puts "  #{service["host_name"]} => #{service["service_description"]}"
+      end
+    end # if results[state]
+  end # for each non-OK state
+    
+
+  #total = results.values.reduce(0) { |sum, val| sum += val }
+  return 0
+end
+
+exit(main(ARGV))

data/bin/nagsrv.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/ruby
+
+# A tool to do mass operations on nagios services.  It is intended to be run on 
+# the server that hosts nagios and it needs read access to the status.log file
+# typically found in the var dir.
+#
+# Command options are broken up into several types:
+#
+# == General
+# --statusfile
+#   Where to find the status file
+#
+# == Output Selectors
+# --list-hosts
+#   List hostnames that match certain criteria
+#
+# --list-service
+#   List services that match certain criteria
+#
+# == Selectors
+# --with-service
+#   Pass a specific service name or a regex in the form
+#   /pattern/ if you pass a regex you can only pass this
+#   option once, if you pass specific services you can 
+#   use this option many times the services will be searches
+#   in an OR fasion
+#
+# --for-host
+#   Restrict the selection of services to a specific host or
+#   regex match of hosts, same regex rules as for --with-service
+#
+# --notify-enabled
+#   List only services with notifications enabled, in this mode
+#   the output will be in the form host:service
+#
+# == Actions
+# --enable-notify / --disable-notify
+#   Enable or Disable notifications for selected services
+#
+# --enable-checks / --disable-checks
+#   Enable of Disable checks for selected services
+#
+# --force-check
+#   Force checks for selected services
+#
+# --acknowledge
+#   Ackknowledge services without sending notifies
+#
+# Released under the terms of the Apache version 2 
+# license
+#
+# Please open an issue at ruby-nagios.googlecode.com
+# with any queries
+
+require 'nagios/status.rb'
+
+require 'getoptlong'
+
+def showhelp
+    begin  
+        require 'rdoc/ri/ri_paths'
+        require 'rdoc/usage'  
+        RDoc::usage
+    rescue LoadError
+        puts ("Install RDoc::usage or view the comments in the top of the script to get detailed help")
+    end
+end
+
+opts = GetoptLong.new(
+    [ '--statusfile', '-s', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--list-hosts', GetoptLong::NO_ARGUMENT],
+    [ '--list-services', GetoptLong::NO_ARGUMENT],
+    [ '--notify-enabled', GetoptLong::NO_ARGUMENT],
+    [ '--notify-disabled', GetoptLong::NO_ARGUMENT],
+    [ '--for-host', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--with-service', GetoptLong::REQUIRED_ARGUMENT],
+    [ '--enable-notify', GetoptLong::NO_ARGUMENT],
+    [ '--disable-notify', GetoptLong::NO_ARGUMENT],
+    [ '--enable-checks', GetoptLong::NO_ARGUMENT],
+    [ '--disable-checks', GetoptLong::NO_ARGUMENT],
+    [ '--force-check', GetoptLong::NO_ARGUMENT],
+    [ '--acknowledge', GetoptLong::NO_ARGUMENT]
+)
+
+statusfile = "status.log"
+listhosts = false
+withservice = []
+listservices = false
+forhost = []
+notify = nil
+action = nil
+options = nil
+
+begin
+    opts.each do |opt, arg|
+        case opt
+            when "--statusfile"
+                statusfile = arg
+            when "--list-hosts"
+                listhosts = true
+            when "--list-services"
+                listservices = true
+            when "--with-service"
+                withservice << arg
+            when "--for-host"
+                forhost << arg
+            when "--enable-notify"
+                action = "[${tstamp}] ENABLE_SVC_NOTIFICATIONS;${host};${service}"
+            when "--disable-notify"
+                action = "[${tstamp}] DISABLE_SVC_NOTIFICATIONS;${host};${service}"
+            when "--force-check"
+                action = "[${tstamp}] SCHEDULE_FORCED_SVC_CHECK;${host};${service};${tstamp}"
+            when "--enable-checks"
+                action = "[${tstamp}] ENABLE_SVC_CHECK;${host};${service};${tstamp}"
+            when "--disable-checks"
+                action = "[${tstamp}] DISABLE_SVC_CHECK;${host};${service};${tstamp}"
+            when "--acknowledge"
+                action = "[${tstamp}] ACKNOWLEDGE_SVC_PROBLEM;${host};${service};1;0;1;#{ENV['USER']};Acknowledged from CLI"
+            when "--notify-enabled"
+                notify = 1
+            when "--notify-disabled"
+                notify = 0
+        end
+    end
+rescue 
+    showhelp
+    exit 1
+end
+
+
+nagios = Nagios::Status.new
+
+nagios.parsestatus(statusfile)
+
+
+# We want hosts so abuse the action field to print just the hostname
+# and select all hosts unless other action/forhost was desigred then
+# this really is just a noop and it reverts to noral behaviour
+if listhosts
+    action = "${host}" if action == nil
+    forhost = "/." if forhost.size == 0
+end
+
+options = {:forhost => forhost, :notifyenabled => notify, :action => action, :withservice => withservice}
+services = nagios.find_services(options)
+
+puts services.join("\n")
+
+# vi:tabstop=4:expandtab:ai

data/lib/nagios/status.rb

@@ -0,0 +1,268 @@
+module Nagios
+    class Status
+        attr_reader :status
+
+        # Parses a nagios status file returning a data structure for all the data
+        def parsestatus(statusfile)
+                @status = {}
+                @status["hosts"] = {}
+
+                handler = ""
+                blocklines = []
+
+                File.readlines(statusfile).each do |line|
+                    # start of new sections
+                    if line =~ /(\w+) \{/
+                        blocklines = []
+                        handler = $1
+                    end
+
+                    # gather all the lines for the block into an array
+                    # we'll pass them to a handler for this kind of block
+                    if line =~ /\s+(\w+)=(.+)/ && handler != ""
+                        blocklines << line
+                    end
+
+                    # end of a section
+                    if line =~ /\}/ && handler != ""
+                        eval("handle_#{handler}(blocklines)")
+                        handler = ""
+                    end
+                end
+        end
+
+        # Returns a list of all hosts matching the options in options
+        def find_hosts(options = {})
+            forhost = options.fetch(:forhost, [])
+            notifications = options.fetch(:notifyenabled, nil)
+            action = options.fetch(:action, nil)
+            withservice = options.fetch(:withservice, [])
+
+            hosts = []
+            searchquery = []
+
+            # Build up a search query for find_with_properties each
+            # array member is a hash of property and a match
+            forhost.each do |host|
+                searchquery << search_term("host_name", host)
+            end
+
+            withservice.each do |s|
+                searchquery << search_term("service_description", s)
+            end
+
+            searchquery << {"notifications_enabled" => notifications.to_s} if notifications
+
+            hsts = find_with_properties(searchquery)
+
+            hsts.each do |host|
+                host_name = host["host_name"]
+
+                hosts << parse_command_template(action, host_name, "", host_name)
+            end
+
+            hosts.uniq.sort
+        end
+
+        # Returns a list of all services matching the options in options
+        def find_services(options = {})
+            forhost = options.fetch(:forhost, [])
+            notifications = options.fetch(:notifyenabled, nil)
+            action = options.fetch(:action, nil)
+            withservice = options.fetch(:withservice, [])
+
+            services = []
+            searchquery = []
+
+            # Build up a search query for find_with_properties each
+            # array member is a hash of property and a match
+            forhost.each do |host|
+                searchquery << search_term("host_name", host)
+            end
+
+            withservice.each do |s|
+                searchquery << search_term("service_description", s)
+            end
+
+            searchquery << {"notifications_enabled" => notifications.to_s} if notifications
+
+            svcs = find_with_properties(searchquery)
+
+            svcs.each do |service|
+                service_description = service["service_description"]
+                host_name = service["host_name"]
+
+                # when printing services with notifications en/dis it makes
+                # most sense to print them in host:service format, abuse the
+                # action option to get this result
+                action = "${host}:${service}" if (notifications != nil && action == nil)
+
+                services << parse_command_template(action, host_name, service_description, service_description)
+            end
+
+            services.uniq.sort
+        end
+
+        private
+
+        # Add search terms, does all the mangling of regex vs string and so on
+        def search_term(haystack, needle)
+            needle = Regexp.new(needle.gsub("\/", "")) if needle.match("^/")
+            {haystack => needle}
+        end
+
+        # Return service blocks for each service that matches any options like:
+        #
+        # "host_name" => "foo.com"
+        #
+        # The 2nd parameter can be a regex too.
+        def find_with_properties(search)
+            services = []
+            query = []
+
+            query << search if search.class == Hash
+            query = search if search.class == Array
+
+            @status["hosts"].each do |host,v|
+                find_host_services(host) do |service|
+                    matchcount = 0
+
+                    query.each do |q|
+                        q.each do |option, match|
+                            if match.class == Regexp
+                                matchcount += 1 if service[option].match(match)
+                            else
+                                matchcount += 1 if service[option] == match.to_s
+                            end
+                        end
+                    end
+
+                    if matchcount == query.size
+                        services << service
+                    end
+                end
+            end
+
+            services
+        end
+
+        # yields the hash for each service on a host
+        def find_host_services(host)
+            if @status["hosts"][host].has_key?("servicestatus")
+                @status["hosts"][host]["servicestatus"].each do |s, v|
+                    yield(@status["hosts"][host]["servicestatus"][s])
+                end
+            end
+        end
+
+        # Parses a template given with a nagios command string and populates vars
+        # else return the string given in default
+        def parse_command_template(template, host, service, default)
+            if template.nil?
+                default
+            else
+                template.gsub(/\$\{host\}/, host).gsub(/\$\{service\}/, service).gsub(/\$\{tstamp\}/, Time.now.to_i.to_s)
+            end
+        end
+
+        # Figures out the service name from a block in a nagios status file
+        def get_service_name(lines)
+            if s = lines.grep(/\s+service_description=(\w+)/).first
+                if s =~ /service_description=(.+)$/
+                    service = $1
+                else
+                    raise("Cant't parse service in block: #{s}")
+                end
+            else
+                raise("Cant't find a hostname in block")
+            end
+
+            service
+        end
+
+        # Figures out the host name from a block in a nagios status file
+        def get_host_name(lines)
+            if h = lines.grep(/\s+host_name=(\w+)/).first
+                if h =~ /host_name=(.+)$/
+                    host = $1
+                else
+                    raise("Cant't parse hostname in block: #{h}")
+                end
+            else
+                raise("Cant't find a hostname in block")
+            end
+
+            host
+        end
+
+        # Parses an info block
+        def handle_info(lines)
+            @status["info"] = {} unless @status["info"]
+
+            lines.each do |l|
+                if l =~ /\s+(\w+)=(\w+)/
+                    @status["info"][$1] = $2
+                end
+            end
+        end
+
+        # Parses a servicestatus block
+        def handle_servicestatus(lines)
+            host = get_host_name(lines)
+            service = get_service_name(lines)
+
+            @status["hosts"][host] = {} unless @status["hosts"][host]
+            @status["hosts"][host]["servicestatus"] = {} unless @status["hosts"][host]["servicestatus"]
+            @status["hosts"][host]["servicestatus"][service] = {} unless @status["hosts"][host]["servicestatus"][service]
+
+            lines.each do |l|
+                if l =~ /\s+(\w+)=(.+)$/
+                    if $1 == "host_name"
+                        @status["hosts"][host]["servicestatus"][service][$1] = host
+                    else
+                        @status["hosts"][host]["servicestatus"][service][$1] = $2
+                    end
+                end
+            end
+        end
+
+        # Parses a servicestatus block
+        def handle_contactstatus(lines)
+        end
+
+        # Parses a servicecomment block
+        def handle_servicecomment(lines)
+        end
+
+        # Parses hostcomment block
+        def handle_hostcomment(lines)
+        end
+        
+        # Parses a programstatus block
+        def handle_programstatus(lines)
+            @status["process"] = {} unless @status["process"]
+
+            lines.each do |l|
+                if l =~ /\s+(\w+)=(\w+)/
+                    @status["process"][$1] = $2
+                end
+            end
+        end
+
+        # Parses a hoststatus block
+        def handle_hoststatus(lines)
+            host = get_host_name(lines)
+
+            @status["hosts"][host] = {} unless @status["hosts"][host]
+            @status["hosts"][host]["hoststatus"] = {} unless @status["hosts"][host]["hoststatus"]
+
+            lines.each do |l|
+                if l =~ /\s+(\w+)=(\w+)/
+                    @status["hosts"][host]["hoststatus"][$1] = $2
+                end
+            end
+        end
+    end
+end
+
+# vi:tabstop=4:expandtab:ai:filetype=ruby

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: nagios-manage
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 0
+  version: 0.5.0
+platform: ruby
+authors: 
+- R.I. Pienaar, Jordan Sissel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-30 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Silence alerts, aggregate existing checks, etc.
+email: rip@devco.net, jls@semicomplete.com
+executables: 
+- check_check.rb
+- nagsrv.rb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/nagios/status.rb
+- bin/check_check.rb
+- bin/nagsrv.rb
+has_rdoc: true
+homepage: http://code.google.com/p/ruby-nagios/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: nagios-manage - a ruby tool for managing your nagios instance
+test_files: []
+