ruby-nagios 0.0.1

data/COPYING

@@ -0,0 +1,14 @@
+   Copyright 2009 R.I.Pienaar
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

data/README

@@ -0,0 +1,5 @@
+Have you ever had to disable alerts, retry a check or acknowledge outages on a large amount of services with Nagios and hated the web UI for it?
+
+This is a CLI tool and Ruby library that parses your status log file and let you query it for information or create external commands to be piped into the nagios command file.
+
+See http://code.google.com/p/ruby-nagios/ for more information

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/check_check

@@ -0,0 +1,184 @@
+#!/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|
+      #Skip hosts if the host is down - obviously the services will be too, and we should already have alerted on the host.__
+      next if hostinfo["hoststatus"]["current_state"].to_i != 0
+      # Skip hosts if there is no hostinfo (no services associated, etc).
+      next if hostinfo["servicestatus"].nil?
+      # Skip hosts if they are in scheduled downtime
+      next if hostinfo["hoststatus"]["scheduled_downtime_depth"].to_i > 0
+      hostinfo["servicestatus"].each do |name, status|
+        next if service_pattern and !service_pattern.match(name)
+
+        # Skip myself, if we are a check running from nagios.
+        next if name == ENV["NAGIOS_SERVICEDESC"]
+
+        # 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, :down_min_percent)
+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
+
+    opts.on("-p NUM", "--percent NUM",
+            "Only alert if this percentage of the cluster is down") do |val|
+      settings.down_min_percent = Float(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
+  total_results = 0.0
+  ["WARNING", "CRITICAL", "UNKNOWN"].each do |state|
+    if results[state] && results[state].size > 0
+      puts "Services in #{state}:"
+      results[state].sort { |a,b| a["host_name"] <=> b["host_name"] }.each do |service|
+        total_results += 1
+        puts "  #{service["host_name"]} => #{service["service_description"]}"
+      end
+    end # if results[state]
+  end # for each non-OK state
+
+  exitcode = 0
+
+  if settings.down_min_percent
+      if results["WARNING"].length > 0 && (results["WARNING"].length / total_results) * 100 >= settings.down_min_percent
+          exitcode = 1
+      end
+      if results["CRITICAL"].length > 0 && (results["CRITICAL"].length / total_results) * 100 >= settings.down_min_percent
+          exitcode = 2
+      end
+  else
+    if results["WARNING"].length > 0
+      exitcode = 1
+    end
+
+    if results["CRITICAL"].length > 0
+      exitcode = 2
+    end
+  end
+  return exitcode
+end
+
+exit(main(ARGV))

data/bin/nagsrv

@@ -0,0 +1,148 @@
+#!/usr/bin/env 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'
+
+require 'optparse'
+
+statusfile = "status.log"
+listhosts = false
+withservice = []
+listservices = false
+forhost = []
+notify = nil
+action = nil
+options = nil
+
+OptionParser.new do |opts|
+  opts.separator "General Options"
+  opts.on("--statusfile FILE", "-s", "Path to the Nagios status.log") do |v|
+    statusfile = v
+  end
+
+  opts.separator ""
+  opts.separator "Output Selectors"
+  opts.on("--list-hosts", "List hostnames that match certain criteria") do
+    listhosts = true
+  end
+
+  opts.on("--list-services", "List services that match certain criteria") do
+    listhosts = true
+  end
+
+  opts.separator ""
+  opts.separator "Service and Host Selectors"
+
+  opts.on("--with-service SERVICE", "Match a service or regular expression") do |v|
+    withservice << v
+  end
+
+  opts.on("--for-host HOST", "Restrict selection of services to a specific host") do |v|
+    forhost << v
+  end
+
+  opts.on("--notify-enabled", "List only services with notification enabled") do
+    notify = 1
+  end
+
+  opts.on("--notify-disabled", "List only services with notification disabled") do
+    notify = 0
+  end
+
+  opts.separator ""
+  opts.separator "Actions for Matched Services/Hosts"
+  opts.on("--enable-notify", "Enable notifications for selected services") do
+    action = "[${tstamp}] ENABLE_SVC_NOTIFICATIONS;${host};${service}"
+  end
+
+  opts.on("--disable-notify", "Disable notifications for selected services") do
+    action = "[${tstamp}] DISABLE_SVC_NOTIFICATIONS;${host};${service}"
+  end
+
+  opts.on("--enable-checks", "Enable checks for selected services") do
+    action = "[${tstamp}] ENABLE_SVC_CHECK;${host};${service};${tstamp}"
+  end
+
+  opts.on("--disable-checks", "Disable checks for selected services") do
+    action = "[${tstamp}] DISABLE_SVC_CHECK;${host};${service};${tstamp}"
+  end
+
+  opts.on("--force-check", "Force checks for selected services") do
+    action = "[${tstamp}] SCHEDULE_FORCED_SVC_CHECK;${host};${service};${tstamp}"
+  end
+
+  opts.on("--ackknowledge", "Ackknowledge services without sending notifies") do
+    action = "[${tstamp}] ACKNOWLEDGE_SVC_PROBLEM;${host};${service};1;0;1;#{ENV['USER']};Acknowledged from CLI"
+  end
+end.parse!
+
+abort "Cannot find #{statusfile}" unless File.exist?(statusfile)
+
+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")

data/lib/nagios/status.rb

@@ -0,0 +1,335 @@
+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 != "" && self.respond_to?("handle_#{handler}", include_private = true)
+          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)
+      @status['contacts'] ||= {}
+      contact = get_contact_name(lines)
+      @status['contacts'][contact] ||= {}
+      lines.each do |line|
+        match = line.match(/^\s*(.+)=(.*)$/)
+        @status['contacts'][contact][match[1]] = match[2] unless match[1] == 'contact_name'
+      end
+    end
+
+    def get_contact_name(lines)
+      if h = lines.grep(/\s+contact_name=(\w+)/).first
+        if h =~ /contact_name=(.*)$/
+          contact_name = $1
+        else
+          raise("Can't parse contact_name in block: #{h}")
+        end
+      else
+        raise("Can't parse contactstatus block")
+      end
+      return contact_name
+    end
+
+    # Parses a servicecomment block
+    def handle_servicecomment(lines)
+      host = get_host_name(lines)
+      service = get_service_name(lines)
+      @status["hosts"][host]['servicecomments'] ||= {}
+      @status["hosts"][host]['servicecomments'][service] ||= []
+      comment = {}
+      lines.each do |line|
+        match = line.match(/^\s*(.+)=(.*)$/)
+        comment[match[1]] = match[2] unless match[1] == 'service_name'
+      end
+      @status['hosts'][host]['servicecomments'][service] << comment
+    end
+
+    # Parses hostcomment block
+    def handle_hostcomment(lines)
+      host = get_host_name(lines)
+      @status['hosts'][host]['hostcomments'] ||= []
+      comment = {}
+      lines.each do |line|
+        match = line.match(/^\s*(.+)=(.*)$/)
+        comment[match[1]] = match[2] unless match[1] == 'host_name'
+      end
+      @status['hosts'][host]['hostcomments'] << comment
+    end
+
+    # Parses servicedowntime block
+    def handle_servicedowntime(lines)
+      host = get_host_name(lines)
+      service = get_service_name(lines)
+      downtime_id = get_downtime_id(lines)
+      @status["hosts"][host]["servicedowntime"] = {} unless @status["hosts"][host]["servicedowntime"]
+      @status["hosts"][host]["servicedowntime"][service] = downtime_id
+    end
+
+    # Parses hostdowntime block
+    def handle_hostdowntime(lines)
+      host = get_host_name(lines)
+      downtime_id = get_downtime_id(lines)
+      @status["hosts"][host]["hostdowntime"] = downtime_id
+    end
+
+    # Parse the downtime_id out of a block
+    def get_downtime_id(lines)
+      if h = lines.grep(/\s+downtime_id=(.*)$/).first
+        if h =~ /downtime_id=(.+)$/
+          downtime_id = $1
+        else
+          raise("Can't parse downtime_id in block: #{h}")
+        end
+      else
+        raise("Can't find downtime_id in block")
+      end
+
+      return downtime_id
+    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+)=(.+)\s*$/
+          @status["hosts"][host]["hoststatus"][$1] = $2
+        end
+      end
+    end
+  end
+end

data/ruby-nagios.gemspec

@@ -0,0 +1,15 @@
+spec = Gem::Specification.new do |s|
+  s.name = 'ruby-nagios'
+  s.version = "0.0.1"
+  s.author = 'R.I.Pienaar'
+  s.email = 'rip@devco.net'
+  s.homepage = 'http://devco.net/'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Ruby library for managing Nagios'
+  s.description = "Manage alerts, checks and acks in bulk"
+  s.files         = `git ls-files`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  s.has_rdoc = false
+  s.add_development_dependency('rake')
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-nagios
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-18 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Manage alerts, checks and acks in bulk
+email: rip@devco.net
+executables: 
+- check_check
+- nagsrv
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- COPYING
+- README
+- Rakefile
+- bin/check_check
+- bin/nagsrv
+- lib/nagios/status.rb
+- pkg/ruby-nagios-0.0.1.gem
+- ruby-nagios.gemspec
+has_rdoc: true
+homepage: http://devco.net/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- 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: Ruby library for managing Nagios
+test_files: []
+