nagira 0.5.1 → 0.5.2

data/app/concerns/output_typeable.rb

@@ -0,0 +1,22 @@
+module OutputTypeable
+  def list?
+    @output == :list
+  end
+
+  def state?
+    @output == :state
+  end
+
+  def full?
+    @output == :full
+  end
+
+  def body_with_list(body)
+    if list?
+      body.keys
+    else
+      body
+    end
+  end
+
+end

data/app/controllers/api_help_controller.rb

@@ -0,0 +1,25 @@
+class Nagira < Sinatra::Base
+
+  # Parse routes, exposed by Sinatra and build human readable list of
+  # API endpoints.
+  class ApiHelpController
+    # Get all routes that Nagira provides.
+    def self.get
+      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
+end

data/app/controllers/host_status_controller.rb

@@ -0,0 +1,82 @@
+class Nagira < Sinatra::Base
+  class HostStatusController
+    include OutputTypeable
+
+    def initialize(status, output: nil, hostname: nil)
+      @status = status
+      @output = output
+      @hostname = hostname
+      @http_status = 200
+    end
+    attr_accessor :http_status
+
+    # Type of the output for data: full, normal, state or list
+    attr_accessor :output
+
+    # [optional] hostname, if not given then return data for all hosts
+    attr_accessor :hostname
+
+    # Get host status, depending on the type of output required: full,
+    # normal, state or list.
+    def get
+      body = case
+             when full?  ; then status
+             when state? ; then state
+             when list?  ; then list
+
+             else normal
+             end
+      [@http_status, body]
+    end
+
+    # Update host status
+    def put(params)
+      Writer.new(:PROCESS_HOST_CHECK_RESULT)
+        .put(with_host(params))
+    end
+
+    def with_host(params)
+      params.merge({'host_name' => hostname})
+    end
+
+    # Status data: for all hosts or single host if hostname provided.
+    #
+    # @return [Hash] Nagios parsed data (Parser.status)
+    def status
+      if hostname
+        { hostname => @status[hostname] }
+      else
+        @status
+      end
+        .tap { |x| @http_status = 404 if x.values.compact.empty? }
+    end
+
+    private
+
+    # List of hosts
+    def list
+      status.keys
+    end
+
+    # Short state of the host: only hostname and state
+    def state
+      normal.inject({  }) { |hash,elem|
+        hash[elem.first] = elem.last.slice("host_name", "current_state")
+        hash
+      }
+    end
+
+    # Normal is 'reduced' hoststate: excluding services, i.e. only
+    # hoststate
+    def normal
+      status.inject({  }) do |hash,elem|
+        hash[elem.first] = elem.last.try(:[], 'hoststatus')
+        hash
+      end
+    end
+
+  end
+
+end
+
+#  LocalWords:  hoststate hoststatus

data/{lib/nagira/hostgroup.rb → app/controllers/hostgroup_controller.rb}

@@ -1,5 +1,5 @@
 class Nagira < Sinatra::Base
-  class Hostgroup
+  class HostgroupController
     attr_reader :objects, :status, :name, :hostgroup, :data
 
     def initialize(name)

data/app/controllers/resource_status_controler.rb

@@ -0,0 +1,65 @@
+class Nagira < Sinatra::Base
+  class ResourceStatusController
+
+    include OutputTypeable
+
+    # @param nagios_status [Hash] output of  the Nagios status file parser
+    # @param output [Symbol(:state, :list)] Output data: full, short state or list
+    # @param hostname [String]
+    # @param service_name [String]
+    #
+    # @param resource [String] Resource to be reported. Currently
+    #     supported 'servicestatus', 'servicecomments', 'hostcomments'
+    def initialize(nagios_status, output: nil, hostname: nil, service_name: nil, resource: "servicestatus")
+
+      @nagios_status = nagios_status
+      @output = output
+      @hostname = hostname
+      @service_name = service_name
+      @resource = if resource == 'services'
+                    "servicestatus"
+                  else
+                    resource
+                  end
+    end
+
+    # Return status of the resource
+    def get
+      case
+      when state?; then  slice
+      when list?; then  list
+      else
+        with_service_name
+      end
+    end
+
+    private
+
+    # Narrow the status hash to include only 3 keys host_name,
+    # current_state and service_description
+    def slice
+      with_service_name.inject({  }) do |hash, elem|
+        hash[elem.first] = elem.last.slice("host_name", "current_state", "service_description")
+        hash
+      end
+    end
+
+    #
+    # @return [Array] List of resources (services, servicecomments).
+    #
+    # Note: _hostcomments is an Array, return full array if status
+    # data structure is not Hash.
+    def list
+      if status.respond_to? :keys
+        status.keys
+      else
+        status
+      end
+    end
+
+    include HostStatusNameConcerneable
+
+  end
+end
+
+#  LocalWords:  param servicestatus servicecomments hostcomments

data/app/controllers/service_status_controler.rb

@@ -0,0 +1,50 @@
+class Nagira < Sinatra::Base
+  class ServiceStatusController
+
+    include OutputTypeable
+
+    # @param nagios_status [Hash] output of  the Nagios status file parser
+    # @param output [Symbol(:state)] Output data: full or short state
+    # @param hostname [String]
+    # @param service_name [String]
+    def initialize(nagios_status, output: nil, hostname: nil, service_name: nil)
+
+      @nagios_status = nagios_status
+      @output = output
+      @hostname = hostname
+      @service_name = service_name
+      @resource = "servicestatus"
+    end
+
+    # Read all statuses of the hosts' services. Format output: full
+    # service state hash, or state only: name and state.
+    def get
+      case
+      when state?
+        with_service_name
+          .values
+          .first
+          .slice("host_name", "current_state")
+      else
+        with_service_name
+      end
+    end
+
+    def put(params)
+      Writer.new(:PROCESS_SERVICE_CHECK_RESULT).put with_service_and_host(params)
+    end
+
+    def with_service_and_host(params)
+      params.merge({
+        'service_description' => @service_name,
+        'host_name' => @hostname
+        })
+    end
+
+    private
+    include HostStatusNameConcerneable
+
+  end
+end
+
+#  LocalWords:  param servicestatus

data/{lib/nagira/servicegroup.rb → app/controllers/servicegroups_controller.rb}

@@ -1,5 +1,5 @@
 class Nagira < Sinatra::Base
-  class Servicegroup
+  class ServicegroupController
 
     ##
     # Single member of servicegroup. In Nagios configuration it is

data/app/filters/after.rb

@@ -0,0 +1,76 @@
+class Nagira < Sinatra::Base
+  # Bad request. If you are requesting for the route that does not
+  # exist.
+  after do
+    if response.status == 404
+      halt [404, {
+              :message => "Bad route or request",
+              :error => "HTTP::Notfound"
+            }.send("to_#{@format}")
+           ]
+    end
+  end
+  ##
+  # @method   object_not_found
+  # @overload after("Object not found or bad request")
+  #
+  # If result-set of object/status search is empty return HTTP 404 .
+  # This can happen when you are requesting status for not existing
+  # host and/or service.
+  #
+  after do
+    if response.body.empty?
+      halt [404, {
+              :message => "Object not found or bad request",
+              :error => "HTTP::Notfound"
+            }.send("to_#{@format}")
+           ]
+    end
+  end
+
+  ##
+  # @method argument_error
+  # @overload after("ArgumentError")
+  #
+  # Return 400 if result of PUT operation is not success.
+  #
+  after do
+    if request.put? && ! response.body[:result]
+      halt [400, response.body.send("to_#{@format}") ]
+    end
+  end
+
+  ##
+  # @method   convert_to_active_resource
+  # @overload after("Return Array for ActiveResouce routes")
+  #
+  #
+  after do
+     response.body = response.body.values if @active_resource && response.body.is_a?(Hash)
+  end
+
+  ##
+  # @method   return_jsonp_data
+  # @overload after("Return formatted data")
+  #
+  # If it's a JSON-P request, return its data with prepended @callback
+  # function name. JSONP request is detected by +before+ method.
+  #
+  # If no callback paramete given, then simply return formatted data
+  # as XML, JSON, or YAML in response body.
+  #
+  # = Example
+  #
+  #     $ curl  'http://localhost:4567/?callback=test'
+  #         test(["{\"application\":\"Nagira\",\"version\":\"0.1.3\",\"url\":\"http://dmytro.github.com/nagira/\"}"])
+  #
+  after do
+    body(
+         if @callback
+           "#{@callback.to_s} (#{response.body.to_json})"
+         else
+           response.body.send "to_#{@format}"
+         end
+        )
+  end
+end

data/app/filters/before.rb

@@ -0,0 +1,156 @@
+class Nagira < Sinatra::Base
+
+  ##
+  # Parse nagios files.
+  #
+  # Note: *.parse methods are monkey-patched here (if you have required
+  # 'lib/nagira' above) to set min parsing interval to avoid file paring
+  # on each HTTP request. File is parsed only if it was changed and if
+  # it was parsed more then 60 (default) seconds ago. See
+  # +lib/nagira/timed_parse.rb+ for mor more info.
+  #
+  # In development mode use files located under +./test/data+
+  # directory. This allows to do development on the host where Nagios is
+  # notinstalled. If you want to change this edit configuration in
+  # config/environment.rb file.
+  #
+  # See also comments in config/default.rb file regarding nagios_cfg,
+  # status_cfg, objects_cfg.
+  #
+  # @method   parse_nagios_files
+  # @overload before("Parse Nagios files")
+  before do
+    Logger.log("BackgroundParser is not running", :warning) if
+      BackgroundParser.configured? && BackgroundParser.dead?
+
+    Parser.parse
+
+    @status = Parser.status['hosts']
+    @objects = Parser.objects
+
+    #
+    # Add plural keys to use ActiveResource with Nagira
+    #
+    @objects.keys.each do |singular|
+      @objects[singular.to_s.pluralize.to_sym] = @objects[singular]
+    end
+  end
+
+  ##
+  # @method     clear_instance_data
+  # @overload before("clear data")
+  #
+  # Clear values onf instance variables before start.
+  #
+  before do
+    @data = []
+    @format = @output = nil
+  end
+
+  ##
+  # @method     strip_extensions
+  # @overload before("detect format")
+  #
+  # Detect and strip output format extension
+  #
+  # Strip extension (@format) from HTTP route and set it as instance
+  # variable @format. Valid formats are .xml, .json, .yaml. If format
+  # is not specified, it is set to default format
+  # (Nagira.settings.format).
+  #
+  # \@format can be assigned one of the symbols: :xml, :json, :yaml.
+  #
+  # = Examples
+  #
+  #     GET /_objects              # => default format
+  #     GET /_objects.json         # => :json
+  #     GET /_status/_list.yaml    # => :yaml
+  #
+  before do
+    request.path_info.sub!(/#{settings.format_extensions}/, '')
+    @format = ($1 || settings.format).to_sym
+    content_type "application/#{@format.to_s}"
+  end
+
+  ##
+  # @method   detect_ar_type
+  # @overload before('detect ActiveResource mode')
+  #
+  # Detect if this a request for ActiveResource PATH
+  #
+  before do
+    @active_resource = request.path_info =~ %r{^#{Nagira::AR_PREFIX}/}
+  end
+
+  ##
+  # @method   strip_output_type
+  # @overload before('detect output mode')
+  #
+  # Detect output mode modifier
+  #
+  # Detect and strip output type from HTTP route. Full list of
+  # output types is +:list+, +:state+ or +:full+, corresponding to
+  # (+/list, +/state+, +/full+ routes).
+  #
+  # Output type defined by route modifier appended to the end of HTTP
+  # route. If no output type specfied it is set to +:full+. Output
+  # mode can be followed by format extension (+.json+, +.xml+ or
+  # +.yaml+).
+  #
+  # = Examples
+  #
+  #     GET /_objects/_list     # => :list
+  #     GET /_status/_state     # => :state
+  #     GET /_status/:hostname  # => :full
+  #     GET /_status            # => :normal
+  #
+  before do
+    request.path_info.sub!(/\/_(list|state|full)$/, '')
+    @output = ($1 || :normal).to_sym
+  end
+
+  ##
+  # @method find_jsonp_callback
+  # @overload before('find callback name')
+  #
+  # Detects if request is using jQuery JSON-P and sets @callback
+  # variable. @callback variable is used if after method and prepends
+  # JSON data with callback function name.
+  #
+  # = Example
+  #
+  #      GET /_api?callback=jQuery12313123123 # @callback == jQuery12313123123
+  #
+  # JSONP support is based on the code from +sinatra/jsonp+ Gem
+  # https://github.com/shtirlic/sinatra-jsonp.
+  #
+  before do
+    if @format == :json
+      ['callback','jscallback','jsonp','jsoncallback'].each do |x|
+        @callback = params.delete(x) unless @callback
+      end
+    end
+  end
+
+  # @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
+      @input
+    end
+  end
+
+end