nagira 0.2.5

data/lib/app/routes/put.rb

@@ -0,0 +1,52 @@
+class Nagira < Sinatra::Base
+
+  # @method parse_input_data
+  # @overload before("Parse PUT request body")
+  # 
+  # Process the data before on each HTTP request.
+  #
+  # @return [Array] @input Sets @input instance variable. 
+  #
+  before do 
+    if request.put?
+      data = request.body.read
+      @input = case @format
+              when :json then JSON.parse    data
+              when :xml  then Hash.from_xml data
+              when :yaml then YAML.load     data
+              end
+      # Make sure we always return an Array
+      @input = [@input] if @input.is_a? Hash
+    end
+  end
+
+  # Define helpers for put methods
+  helpers do 
+
+    # Helper to send PUT update to Nagios::ExternalCommands
+    #
+    # @param [Hash] params 
+    # @param [Symbol] action Nagios external command name
+    #
+    # FIXME: This only accepts single service. Modify to use Arrays too 
+    def put_update action, params
+      res = $nagios[:commands].write(params.merge({ :action => action }))
+      { :status => res[:result], :object => res[:data]}
+    end
+  end
+
+    # Small helper to submit data to ::Nagios::ExternalCommands
+    # object. For status updates sends external coond via
+    # ::Nagios::ExternalCommands.send method.
+    def update_service_status params
+      put_update :PROCESS_SERVICE_CHECK_RESULT, params
+    end
+
+    # Small helper to submit data to ::Nagios::ExternalCommands
+    # object. For host status updates sends external command via
+    # ::Nagios::ExternalCommands.write method.
+    def update_host_status params
+      put_update :PROCESS_HOST_CHECK_RESULT, params
+    end
+  
+end

data/lib/app/routes/put/status.rb

@@ -0,0 +1,139 @@
+class Nagira < Sinatra::Base
+
+
+  # @method put_status
+  # @overload put("/_status")
+  #
+  # Submit JSON Hash for multiple services,  on multiple hosts.
+  put "/_status" do
+    "TODO: Not implemented"
+  end
+
+  # @method put_status_host_name
+  # @overload put("/_status/:host_name")
+  #
+  # Update hoststatus information only for the given host. URL
+  # hostname always override hostname given in the JSON file.
+  #
+  # == Example
+  #
+  #        $ curl -i -H "Accept: application/json" -d @host.json -X
+  #            PUT http://localhost:4567/_status/svaroh
+  #
+  #          => {"status": true, "object": [{"data": {"host_name":"svaroh",
+  #          "status_code": "0", "plugin_output": "ping OK", "action":
+  #          "PROCESS_HOST_CHECK_RESULT"}, "result":true, "messages": []}]}
+  #
+  # == Example JSON
+  #
+  #     {
+  #      "status_code":"0",
+  #      "plugin_output" : "ping OK"
+  #     }                               
+  put "/_status/:host_name" do
+    @data = update_host_status @input.first.merge({
+                                                    'host_name' => params['host_name']
+                                                  })
+    nil
+  end
+
+  # Same as /_status/:host_name (Not implemented)
+  #
+  # @method put__host_status_host_name
+  # @overload put("/_host_status/:host_name")
+  #
+  put "/_host_status/:host_name" do 
+    "Not implemented: TODO"
+  end
+  
+  # @method put_status_host_name_services
+  # @overload put("/_status/:host_name/_services")
+  #
+  # Update multiple services on the same host.
+  #
+  # Hostname from URL always overrides host_name if it's is provided
+  # in the JSON data.
+  #
+  # == Example return JSON data
+  #
+  #   $ curl -i -H "Accept: application/json" -d @dat_m.json -X PUT
+  #   http://localhost:4567/_status/svaroh/_services
+  #
+  #     [{"status":true, "object":[{"data":{"host_name":"svaroh",
+  #     "service_description":"PING", "return_code":"0",
+  #     "plugin_output":"OK",
+  #     "action":"PROCESS_SERVICE_CHECK_RESULT"}, "result":true,
+  #     "messages":[]}]}, {"status":true,
+  #     "object":[{"data":{"host_name":"svaroh",
+  #     "service_description":"Apache", "return_code":"r20",
+  #     "plugin_output":"cwfailedOK",
+  #     "action":"PROCESS_SERVICE_CHECK_RESULT"}, "result":true,
+  #     "messages":[]}]}]%
+  #
+  # == Example JSON for submit
+  #
+  # All attributes provided in the example below are requried for host
+  # service status information:
+  # - host_name
+  # - service_description
+  # - return_code
+  # - plugin_output
+  #
+  #
+  #     [{ "host_name":"viy",
+  #        "service_description":"PING",
+  #        "return_code":"0",
+  #        "plugin_output":"64 bytes from 127.0.0.1: icmp_seq=0 ttl=64 time=0.046 ms "
+  #       },
+  #
+  #     {"host_name":"svaroh",
+  #        "service_description":"Apache",
+  #        "return_code":"2",
+  #        "plugin_output":"HTTP GEt failed"
+  #        }
+  #       ]
+  #
+  #
+  put "/_status/:host_name/_services" do
+
+    data = []
+    @input.each do |datum|
+      # FIXME - this calls update for each service. Should be batching them together
+      data << update_service_status(
+                                    datum.merge({ 
+                                                  'host_name' => params['host_name']
+                                                })
+                                    )
+    end
+    @data = data
+    nil
+
+  end
+  
+  # Update single service on a single host by JSON data.
+  put "/_status/:host_name/_services/:service_description" do
+    @data = update_service_status \
+    @input.first.merge({ 
+                         'service_description' => params['service_description'],
+                         'host_name' => params['host_name']
+                       })
+    nil
+  end
+
+  # @method put_status_as_http_parms
+  # @overload  put(/_status/:host_name/_services/:service_description/_return_code/:return_code/_plugin_output/:plugin_output)
+  # 
+  # Update single service status on a single host. Use data provided
+  # in RESTful path as parameters.
+  #
+  # == Example
+  #      curl  -d "test data" \
+  #        -X PUT http://localhost:4567/_status/viy/_services/PING/_return_code/0/_plugin_output/OK
+  #       # => ok
+  put "/_status/:host_name/_services/:service_description/_return_code/:return_code/_plugin_output/:plugin_output" do 
+
+    @data = update_service_status params
+    nil
+  end
+  
+end

data/lib/nagira.rb

@@ -0,0 +1,55 @@
+require 'active_model/serialization'
+require 'active_model/serializers/xml' # for Hash.to_xml
+
+require 'active_support/inflector'
+require 'active_support/inflector/inflections'
+require 'active_support/core_ext/hash/slice' # for Hash.slice
+
+require 'json'
+require 'yaml'
+require 'sinatra'
+require 'sinatra/reloader'
+
+$: << File.dirname(__FILE__) << File.dirname(File.dirname(__FILE__))
+
+require 'config/defaults'
+
+require "app/routes/get/config"
+require "app/routes/get/objects"
+require "app/routes/get/status"
+
+require "app/routes/put"
+require "app/routes/put/status"
+
+
+#
+# environment file must go after default, some settings override
+# defaults.
+#
+require 'config/environment'
+require 'nagira/nagios'
+
+class Nagira < Sinatra::Base
+
+  VERSION  = File.read(File.expand_path(File.dirname(__FILE__)) + '/../version.txt').strip
+  GITHUB   = "http://dmytro.github.com/nagira/"
+
+  # Get all routes that Nagira provides. 
+  def api 
+    api = { }
+    
+    param_regex = Regexp.new '\(\[\^\\\\\/\?\#\]\+\)'
+    Nagira.routes.keys.each do |method|
+      api[method] ||= []
+      Nagira.routes[method].each do |r|
+        path = r[0].inspect[3..-3]
+        r[1].each do |parm|
+          path.sub!(param_regex,":#{parm}")
+        end
+        path.gsub!('\\','')
+        api[method] << path unless path.empty? 
+      end
+    end
+    api
+  end
+end

data/lib/nagira/background_parse.rb

@@ -0,0 +1,28 @@
+require 'nagios'
+
+module Nagios
+  ##
+  # Background parsing of status.dat file in separate thread. Runs on
+  # regular intervals slightly shorter than :ttl
+  #
+  class BackgroundParser
+
+    ##
+    # 
+    # If :ttl is not defined set to 0 and do not run
+    # background parsing.
+    #
+    def initialize
+      interval = [::DEFAULT[:ttl],1].max || nil
+      if interval && ::DEFAULT[:start_background_parser]
+        puts "[#{Time.now}] Starting background parser thread with interval #{interval} sec"
+        $bg = Thread.new {
+          loop {
+            $nagios[:status].parse
+            sleep interval
+          } #loop
+        } # thread
+      end
+    end
+  end
+end

data/lib/nagira/nagios.rb

@@ -0,0 +1,20 @@
+module Nagios
+
+  require 'nagira/timed_parse'
+  require 'nagira/background_parse'
+
+  # Extensions to Nagios::Status and Objects classes for use with
+  # Nagira: keep track of file modification times and parse only
+  # changed files.
+  class Config
+    include Nagios::TimedParse
+  end
+
+  class Status
+    include Nagios::TimedParse
+  end
+
+  class Nagios::Objects
+    include Nagios::TimedParse
+  end
+end

data/lib/nagira/timed_parse.rb

@@ -0,0 +1,77 @@
+require 'nagios'
+
+module Nagios
+  # Keep track of last parsed time and last changed time of the
+  # status/cache file to avoid parsing on each HTTP request.
+  module TimedParse
+
+    # Set some minimum interval for re-parsing of the status file:
+    # even if file changes often, we do not want to parse it more
+    # often, then this number of seconds.
+
+    TTL = ::DEFAULT[:ttl] || 0
+
+    # Override constructor and parse method from ::Nagios::Objects or
+    # ::Nagios::Status classes, add instance variables to handle
+    # modification and parseing times of status file.
+    # Original methods are aliased:
+    # - initialize -> constructor
+    # - parse -> parse!
+    # See also
+    # http://www.ruby-forum.com/topic/969161
+    def self.included(base)
+      base.class_eval do
+        alias_method :parse!, :parse
+        alias_method :constructor, :initialize
+
+        # @method initialize
+        # Extend current constructor with some additional data to
+        # track file change time
+        #
+        # @param [String] file Path to status file
+        # @param [Fixnum] parse_interval Number of seconds between
+        #     re-parsing of the file
+        def initialize(file, parse_interval=TTL)
+          constructor(file)
+
+          # Time when status file was last time parsed, set it to 0 secs
+          # epoch to make sure it will be parsed
+          @last_parsed = Time.at(0)
+
+          # Last time file was changed
+          @last_changed = File.mtime(@path)
+          @parse_interval = parse_interval
+        end
+
+
+        # Extend original parse method: parse file only if it needs
+        # parsing and set time of parser run to current time.
+        def parse
+          if need_parsing?
+            parse!
+            @last_parsed = Time.now
+          end
+        end
+      end
+    end
+
+    attr_accessor :last_parsed, :parse_interval
+      
+    def last_changed
+      @last_changed = File.mtime(@path)
+    end
+
+    # Return true if file is changed since it was parsed last time
+    def changed?
+      self.last_changed > self.last_parsed
+    end
+    
+    # Check if:
+    # - file changed?
+    # - was it parsed recently?
+    def need_parsing?
+      changed? && ((Time.now - self.last_parsed) > @parse_interval)
+    end
+    
+  end
+end

data/spec/00_configuration_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "Configuration" do 
+
+  set :environment, ENV['RACK_ENV'] || :test
+
+  before { 
+    @cfg = Nagios::Config.new(Nagira.settings.nagios_cfg)
+  }
+
+  context "nagios.cfg" do
+
+    it { File.should exist @cfg.path }
+    
+    it "should be parseable" do
+      lambda { @cfg.parse }.should_not raise_error
+    end
+
+    context "parsing nagios.cfg file" do 
+
+      before { @cfg.parse }
+      
+      it "should have PATH to objects file" do 
+        @cfg.object_cache_file.should be_a_kind_of String 
+      end
+      
+      it "should have PATH to status file" do
+        @cfg.status_file.should be_a_kind_of String 
+      end
+
+    end # parsing nagios.cfg file
+  end # nagios.cfg
+  
+  context "data files" do 
+    before { @cfg.parse }
+    
+    context Nagios::Status do
+      
+      subject { Nagios::Status.new( Nagira.settings.status_cfg || @cfg.status_file ) }
+
+      it { File.should exist( subject.path ) }
+      
+      it "should be parseable" do
+        lambda { subject.parse }.should_not raise_error
+      end
+    end # Nagios::Status
+
+
+    context Nagios::Objects do
+
+      subject {  Nagios::Objects.new( Nagira.settings.objects_cfg || @cfg.object_cache_file) }
+
+      it { File.should exist subject.path }
+      
+      it "should be parseable" do
+        lambda { subject.parse }.should_not raise_error
+      end
+    end # Nagios::Objects
+
+  end # data files
+
+end

data/spec/01_nagira_response_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Nagira do 
+
+  set :environment, ENV['RACK_ENV'] || :test
+
+  include Rack::Test::Methods
+  
+  def app
+    @app ||= Nagira
+  end
+
+  TOP_PAGES = %w{ _config _objects _status _api }
+  FORMATS = %w{ xml yaml json}
+  DEFAULT_FORMAT = ::Nagira.settings.format
+  TYPES   = %w{state list}
+
+  context "simple page load" do
+    TOP_PAGES.each do |page|
+      it "/#{page} should load" do 
+        get "/#{page}"
+        last_response.should be_ok
+      end
+      
+
+        # Check 3 different formats
+        FORMATS.each do |format|
+          
+          it "should load '#{page}.#{format}' page" do
+            get "/#{page}.#{format}"
+            last_response.should be_ok
+          end
+
+      end
+    end
+  end
+
+  context "data format check" do
+
+    TOP_PAGES.each do |page|
+      context page do
+        
+        FORMATS.each do |format|
+
+        context format do
+
+            before do  
+              get "/#{page}.#{format}"
+              @header = last_response.header
+              @body = last_response.body
+            end
+            
+            it "Content-type: application/#{format}" do
+              @header['Content-Type'].should =~ /^application\/#{format}.*/ 
+            end
+
+            it "body should have content" do
+              @body.should_not be_empty
+            end
+
+            it "#{format} should be parseable" do
+              case format
+              when 'json'
+                lambda { JSON.parse    @body }.should_not raise_error
+              when 'xml'
+                lambda { Hash.from_xml @body }.should_not raise_error
+              when 'yaml'
+                lambda { YAML.load     @body }.should_not raise_error
+              end
+            end
+          end
+          
+        end
+        
+        context 'default format' do 
+          it "/#{page}.#{Nagira.settings.format} response should be the same as /#{page}" do
+            get "/#{page}.#{Nagira.settings.format}"
+            a = last_response.body
+            get "/#{page}"            
+            b = last_response.body
+            a.should eq b
+          end
+        end
+
+      end
+    end
+
+    #
+    # GET /config
+    # ----------------------------------------
+    context "/config" do 
+
+      before do
+        get "/_config.json"
+        @data = JSON.parse last_response.body
+      end
+
+      context "important items in Nagios configuration" do
+
+        # Configuration strings
+
+        %w{ log_file object_cache_file resource_file status_file
+         nagios_user nagios_group }.each do |key|
+
+          it "attribute #{key} should be a String" do
+            @data[key].should be_a_kind_of String
+          end 
+        end
+
+        # Congiration arrays
+        %w{cfg_file cfg_dir}.each do |key| 
+          it "attribute #{key} should be an Array" do
+            @data[key].should be_a_kind_of Array
+          end 
+        end
+
+      end
+    end # /config
+
+
+  end
+end