naplug 1.6.1

data/examples/exception+

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+module Naplug
+
+  module Examples
+
+    class ExceptionPlusPlugin
+    
+      include Naplug
+
+      EXCEPTIONS = [ ArgumentError, ZeroDivisionError, TypeError ]
+      
+      plugin do |p|
+
+        exception = EXCEPTIONS[p[:exception]]
+
+        begin
+          raise exception, "raising exception: #{exception}"
+        rescue ArgumentError => e
+          raise
+        rescue ZeroDivisionError => e
+          p.status.ok!
+          p.output! "divided by zero is infinity"
+        rescue => e
+          p.status.critical!
+          p.output! "got exception #{e.class}"
+        end
+
+      end
+      
+    end
+
+  end
+
+end
+    
+begin
+  plugin = Naplug::Examples::ExceptionPlusPlugin.new :exception => Random.rand(3)
+  plugin.exec!
+rescue Naplug::Error => e
+  plugin.eject! e
+end

data/examples/markerfile

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+class MarkerFilePlugin
+
+  include Naplug
+
+  plugin do |p|
+
+    if Time.now - File.mtime(p[:marker_file]) > p[:critical]
+      p.status.critical!
+      p.output! "marker file #{p[:marker_file]} mtime greater than #{p[:critical]} seconds"
+    else
+      p.status.ok!
+      p.output! "marker #{p[:marker_file]} is up to date"
+    end
+
+  end
+end
+
+plugin = MarkerFilePlugin.new :marker_file => '/tmp/my_marker', :critical => 120
+plugin.exec!

data/examples/markerfile++

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+class MarkerFilePlusPlusPlugin
+
+  include Naplug
+
+  plugin :mkf do |p|
+    delta, size = file_mtime_and_size p[:marker_file]
+    case
+      when (delta < p[:w_seconds] and size > p[:c_size])
+        p.status.ok!
+        p.output! "marker file %s is up to date and not empty" % [p[:marker_file]]
+      when (p[:w_seconds]..p[:c_seconds]).include?(delta), size > p[:c_size]
+        p.status.warning!
+        p.output! "marker file is %d seconds out of date" % [delta]
+      when delta >= p[:c_seconds], size == p[:c_size]
+        p.status.critical!
+        p.output! "marker file is %d seconds out of date or empty" % [delta]
+      else
+        p.outout! "marker file is in an inconsistent state"
+    end
+  end
+
+  private
+
+  def file_mtime_and_size(file)
+    fs = File.stat file
+    return Time.now - fs.mtime,fs.size
+  end
+
+end
+
+plugin = MarkerFilePlusPlusPlugin.new :marker_file => '/tmp/my_marker', :c_seconds => 120, :w_seconds => 60, :c_size => 0
+plugin.exec!

data/examples/multiplug

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+class MultiPlugPlugin
+
+  include Naplug
+
+  plugin do |p|
+
+    plugin :p1 do |p1|
+      p1.status.critical!
+      p1.output! "argument 'c' is #{p1[:c]}"
+    end
+
+    plugin :p2 do |p2|
+      p2.status.critical!
+      p2.output! "tis critical!"
+    end
+
+    plugin :p3 do |p3|
+      p3.status.warning!
+      p3.output! "tis warning!"
+    end
+  end
+
+end
+
+plugin = MultiPlugPlugin.new :shared1 => 'shared arg2', :shared2 => 'shared arg 2', :p1 => { :c => 0 }
+plugin.exec!

data/examples/multiplugin

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+class MultiPluginPlugin
+
+  include Naplug
+
+  plugin :one do |p|
+
+    plugin :p1 do |p1|
+      p1.status.ok!
+      p1.output! "#{p1.tag} args: #{p.args}"
+    end
+
+    plugin :p2 do |p2|
+      p2.status.critical!
+      p2.output! "tis critical!"
+    end
+
+    plugin :p3 do |p3|
+      p3.status.unknown!
+      p3.output! "tis unknown! #{p3.args}"
+    end
+
+  end
+
+  plugin :two do |p|
+
+    p.status.ok!
+    p.output! "plugin #{p.tag}"
+
+  end
+
+end
+
+plugin = MultiPluginPlugin.new
+plugin.one!

data/examples/multiplugins

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug'
+
+class MultiPluginPlugin
+
+  include Naplug
+
+  plugin :one do |p|
+
+    plugin :p1 do |p1|
+      p1.status.ok!
+      p1.output! "#{p.tag}:#{p1.tag} #{p[:instance]}"
+    end
+
+    plugin :p2 do |p2|
+      p2.status.ok!
+      p2.output! "#{p.tag}:#{p2.tag} #{p[:instance]}"
+    end
+
+    plugin :p3 do |p3|
+      p3.status.ok!
+      p3.output! "#{p.tag}:#{p3.tag} #{p[:instance]}"
+    end
+
+  end
+
+  plugin :two do |p|
+
+    p.status.ok!
+    p.output! "plugin #{p.tag}"
+
+  end
+
+end
+
+
+x1 = MultiPluginPlugin.new :instance => :x1, :one => { :p1 => { :instance => :x1 }}
+x2 = MultiPluginPlugin.new :instance => :x2, :one => { :p1 => { :instance => :x2 }}
+x1.one!

data/examples/status

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'rubygems'
+require 'naplug/status'
+
+module Naplug
+
+  module Examples
+
+    puts "All statuses:"
+    Naplug::Status.states.each do |state|
+      status = Naplug::Status.new state
+      puts "  status #{status} has exit code #{status.to_i}"
+    end
+
+    puts "Working with a status:"
+    status = Naplug::Status.new
+    puts "  status #{status} has exit code #{status.to_i} after initialization"
+    status.ok
+    puts "  status #{status} has exit code #{status.to_i} after status.ok"
+
+    puts "Comparing statuses:"
+    status1 = Naplug::Status.new :warning
+    if status < status1
+      puts "  status [#{status}] < status1 [#{status1}] is true"
+    end
+
+  end
+
+end

data/lib/naplug/about.rb

@@ -0,0 +1,5 @@
+require 'naplug/version'
+module Naplug
+  ME = :naplug
+  ABOUT = "#{ME} v#{VERSION}\nhttps://github.com/gerirgaudi/#{ME}\nCopyright (c) 2014 by Evernote Corporation\nLicensed under the Apache License, Version 2.0 (http://www.apache.org/licenses/LICENSE-2.0)"
+end

data/lib/naplug/helpers.rb

@@ -0,0 +1,55 @@
+require 'json'
+require 'naplug/status'
+
+module Naplug
+
+  module Helpers
+
+    module Thresholds
+
+      def hashify_json_thresholds(tag,thres_json=nil)
+        thresholds = { tag => {} }
+        plug = nil
+        thres_proc = Proc.new do |json_element|
+          case
+            when (json_element.is_a? String and json_element.match(/\d*:\d*:\d*:\d*/))
+              thresholds[:main][plug] = Hash[Status.states.zip json_element.split(':',-1).map { |v| v.nil? ? nil : v.to_i } ]
+            when Symbol
+              plug = json_element
+            else
+              nil
+          end
+        end
+        JSON.recurse_proc(JSON.parse(thres_json, :symbolize_names => true),&thres_proc) if thres_json
+        thresholds
+      end
+
+    end
+
+    module Hashes
+
+      # Thx Avdi Grimm! http://devblog.avdi.org/2009/11/20/hash-transforms-in-ruby/
+      def transform_hash(original, options={}, &block)
+        original.inject({}){|result, (key,value)|
+          value = if options[:deep] && Hash === value
+                    transform_hash(value, options, &block)
+                  else
+                    value
+                  end
+          block.call(result,key,value)
+          result
+        }
+      end
+
+      def symbolify_keys(hash)
+        transform_hash(hash) {|h, key, value|
+          h[key.to_sym] = value
+        }
+      end
+
+
+    end
+
+  end
+
+end

data/lib/naplug/output.rb

@@ -0,0 +1,31 @@
+module Naplug
+
+  class Output
+    # Implements Text Output and Long Text elements from the Nagios Plugin API
+    # * Nagios v3: http://nagios.sourceforge.net/docs/nagioscore/3/en/pluginapi.html
+    # * Nagios v4: http://nagios.sourceforge.net/docs/nagioscore/4/en/pluginapi.html
+
+    attr_accessor :text_output
+    attr_reader :long_text
+
+    def initialize(text_output = 'uninitialized plugin')
+      @text_output = text_output
+      @long_text = []
+    end
+
+    # Pushes the given long text strings on the end of long text. Returns the long_text
+    # @return [Array<String>] array of long text strings
+    def push(*long_text)
+      @long_text.push long_text
+    end
+
+    def to_s(output = :text_output)
+      case output
+        when :text_output then @text_output
+        when :long_text   then @long_text.joing "\n"
+        else nil
+      end
+    end
+
+  end
+end

data/lib/naplug/performancedata.rb

@@ -0,0 +1,52 @@
+module Naplug
+
+  class PerformanceData
+
+    attr_reader :tag, :data
+
+    class MissingLabel < StandardError; end
+    class InvalidField < StandardError; end
+    class ThatIsNoHash < StandardError; end
+
+    FIELDS = [:label, :value, :uom, :warn, :crit, :min, :max] # label=value[UOM];[warn];[crit];[min];[max]
+
+    def initialize(tag)
+      @tag = tag
+      @data = Hash.new
+    end
+
+    def to_s(label = nil)
+      label_ary = label.nil? ? @data.keys : [label]
+      label_ary.map do |l|
+        '%s=%s%s;%s;%s;%s;%s' % FIELDS.map { |k| @data[l][k] }
+      end.join(' ').strip
+    end
+
+    def []=(label,value,args = {})
+      raise ThatIsNoHash, 'hash of fields is not a hash' unless args.is_a? Hash
+      args.keys.each { |field| raise InvalidField unless FIELDS.include? field }
+      raise MissingLabel, 'missing label' unless label
+      @data[label] = { :label => label, :value => value }.merge args
+    end
+    alias_method :store, :[]=
+
+    def [](label)
+      @data[label]
+    end
+    alias_method :fetch, :[]
+
+    def delete(label)
+      @data.delete(label)
+    end
+
+    def has_label?(label)
+      @data.has_key? label
+    end
+    alias_method :include?, :has_label?
+
+    def fields
+      FIELDS
+    end
+
+  end
+end

data/lib/naplug/plugin.rb

@@ -0,0 +1,155 @@
+require 'ostruct'
+
+require 'naplug/status'
+require 'naplug/output'
+require 'naplug/performancedata'
+
+module Naplug
+
+  class Plugin
+
+    attr_reader :block, :plugins, :tag
+
+    class DuplicatePlugin < StandardError; end
+
+    def initialize(tag, meta = false, block)
+      @tag = tag
+      @block = block
+      @plugins = Hash.new
+
+      @_args = Hash.new
+      @_data = OpenStruct.new :status => Status.new, :output => Output.new, :payload => nil, :perfdata => nil
+      @_meta = OpenStruct.new :status => meta, :enabled => true, :debug => true
+
+      begin; instance_eval &block ; rescue => e; nil ; end
+
+    end
+
+    # @param format [Symbol] the format type, `:text` or `:html`
+    # @return [True, False<String>, nil] the object or objects to
+    #   find in the database. Can be nil.@return [String] the object converted into the expected format.
+    # # true if this plugin is a metaplugin, false otherwise
+    def is_meta?
+      @_meta.status
+    end
+
+    # enable execution of the plugin; metaplugins are always enabled
+    def enable!
+      is_meta? ? nil : @_meta.enabled = true
+    end
+
+    # disable execution of the plugin; metaplugins cannot be disabled
+    def disable!
+      is_meta? ? nil : @_meta.enabled = false
+    end
+
+    # true when plugin is enabled; false otherwise
+    def is_enabled?
+      @_meta.enabled
+    end
+
+    # true when the plugin is disabled; false otherwise
+    def is_disabled?
+      not @_meta.enabled
+    end
+
+    # true when a plugin contains plugs
+    def has_plugins?
+      @plugins.empty? ? false : true
+    end
+    alias_method :has_plugs?, :has_plugins?
+
+    # @return [Status] plugin status
+    def status
+      @_data.status
+    end
+
+    # Gets plugin text output
+    # @return [String] plugin text output
+    def output
+      @_data.output
+    end
+
+    # Sets plugin text output
+    # @param text_output [String] plugin text output
+    # @return [String] new plugin text output
+    def output!(text_output)
+      @_data.output.text_output = text_output
+    end
+
+    def long_output
+      @_data.output.long_output
+    end
+
+    def long_output!(long_output)
+      @_data.output.push long_output
+    end
+
+    # returns the performance data of the plugin as a PerformanceData object
+    def perfdata
+      @_data.perfdata
+    end
+
+    def perfdata!(label,value,f = {})
+      @_data.perfdata ||= PerformanceData.new @tag
+      @_data.perfdata.store label, value, f
+    end
+
+    def payload
+      @_data.payload
+    end
+
+    def payload!(p)
+      @_data.payload = p
+    end
+
+    def args
+      @_args
+    end
+
+    def args!(args)
+      @_args.merge! args
+      @plugins.each do |tag,plug|
+        plug_args = args.key?(tag) ? args[tag] : {}
+        shared_args = args.select { |t,a| not @plugins.keys.include? t }
+        plug.args! shared_args.merge! plug_args
+      end
+    end
+
+    def [](k)
+      @_args[k]
+    end
+
+    def []=(k,v)
+      @_args[k] = v
+    end
+
+    def to_s
+      '%s: %s' % [status,output]
+    end
+
+    def eval
+      unless @plugins.empty?
+        wcu_plugins = @plugins.values.select { |plug| plug.status.not_ok? }
+        plugins = wcu_plugins.empty? ? @plugins.values : wcu_plugins
+        output! plugins.map { |plug| "[#{plug.status.to_y}#{plug.tag} #{plug.output}]" }.join(' ')
+        @_data.status = plugins.map { |plug| plug.status }.max
+      end
+    end
+
+    private
+
+    def plugin(tag, &block)
+      raise DuplicatePlugin, "duplicate definition of #{tag}" if @plugins.key? tag
+      @plugins[tag] = Plugin.new tag, block
+      self.define_singleton_method tag do
+        @plugins[tag]
+      end
+    end
+
+    def debug?
+      @_meta.debug
+    end
+
+  end
+end

data/lib/naplug/status.rb

@@ -0,0 +1,62 @@
+require 'ostruct'
+
+module Naplug
+
+  class Status
+
+    include Comparable
+
+    class InvalidStatus < StandardError; end
+
+    STATUS = {
+        :ok       =>  OpenStruct.new({ :i => 0, :s => 'OK',       :y => '+' }),
+        :warning  =>  OpenStruct.new({ :i => 1, :s => 'WARNING',  :y => '-' }),
+        :critical =>  OpenStruct.new({ :i => 2, :s => 'CRITICAL', :y => '!' }),
+        :unknown  =>  OpenStruct.new({ :i => 3, :s => 'UNKNOWN',  :y => '*' })
+    }
+
+    def self.states
+      STATUS.keys
+    end
+
+    def initialize(state = :unknown)
+      @status = state
+    end
+
+    STATUS.keys.each do |state|
+      define_method "#{state}!".to_sym do
+        @status = state
+      end
+    end
+
+    STATUS.keys.each do |state|
+      define_method "#{state}?".to_sym do
+        @status == state ? true : false
+      end
+      define_method "not_#{state}?".to_sym do
+        @status == state ? false : true
+      end
+    end
+
+    def to_s
+      STATUS[@status].s
+    end
+
+    def to_i
+      STATUS[@status].i
+    end
+
+    def to_y
+      STATUS[@status].y
+    end
+
+    def <=>(other)
+      case
+        when self.to_i < other.to_i then -1
+        when self.to_i > other.to_i then 1
+        else 0
+      end
+    end
+
+  end
+end

data/lib/naplug/version.rb

@@ -0,0 +1,3 @@
+module Naplug
+  VERSION = '1.6.1'
+end