sensu 0.24.1-java → 0.25.0.beta-java

data/lib/sensu/api/routes/health.rb

@@ -0,0 +1,34 @@
+require "sensu/api/utilities/transport_info"
+
+module Sensu
+  module API
+    module Routes
+      module Health
+        include Utilities::TransportInfo
+
+        HEALTH_URI = /^\/health$/
+
+        def get_health
+          if @redis.connected? && @transport.connected?
+            healthy = []
+            min_consumers = integer_parameter(@params[:consumers])
+            max_messages = integer_parameter(@params[:messages])
+            transport_info do |info|
+              if min_consumers
+                healthy << (info[:keepalives][:consumers] >= min_consumers)
+                healthy << (info[:results][:consumers] >= min_consumers)
+              end
+              if max_messages
+                healthy << (info[:keepalives][:messages] <= max_messages)
+                healthy << (info[:results][:messages] <= max_messages)
+              end
+              healthy.all? ? no_content! : precondition_failed!
+            end
+          else
+            precondition_failed!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/routes/info.rb

@@ -0,0 +1,28 @@
+require "sensu/api/utilities/transport_info"
+
+module Sensu
+  module API
+    module Routes
+      module Info
+        include Utilities::TransportInfo
+
+        INFO_URI = /^\/info$/
+
+        def get_info
+          transport_info do |info|
+            @response_content = {
+              :sensu => {
+                :version => VERSION
+              },
+              :transport => info,
+              :redis => {
+                :connected => @redis.connected?
+              }
+            }
+            respond
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/routes/request.rb

@@ -0,0 +1,33 @@
+require "sensu/api/utilities/publish_check_request"
+
+module Sensu
+  module API
+    module Routes
+      module Request
+        include Utilities::PublishCheckRequest
+
+        REQUEST_URI = /^\/request$/
+
+        def post_request
+          rules = {
+            :check => {:type => String, :nil_ok => false},
+            :subscribers => {:type => Array, :nil_ok => true}
+          }
+          read_data(rules) do |data|
+            if @settings[:checks][data[:check]]
+              check = @settings[:checks][data[:check]].dup
+              check[:name] = data[:check]
+              check[:subscribers] ||= Array.new
+              check[:subscribers] = data[:subscribers] if data[:subscribers]
+              publish_check_request(check)
+              @response_content = {:issued => Time.now.to_i}
+              accepted!
+            else
+              not_found!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/routes/resolve.rb

@@ -0,0 +1,31 @@
+require "sensu/api/utilities/resolve_event"
+
+module Sensu
+  module API
+    module Routes
+      module Resolve
+        include Utilities::ResolveEvent
+
+        RESOLVE_URI = /^\/resolve$/
+
+        def post_resolve
+          rules = {
+            :client => {:type => String, :nil_ok => false},
+            :check => {:type => String, :nil_ok => false}
+          }
+          read_data(rules) do |data|
+            @redis.hgetall("events:#{data[:client]}") do |events|
+              if events.include?(data[:check])
+                resolve_event(events[data[:check]])
+                @response_content = {:issued => Time.now.to_i}
+                accepted!
+              else
+                not_found!
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/routes/results.rb

@@ -0,0 +1,116 @@
+require "sensu/api/utilities/publish_check_result"
+
+module Sensu
+  module API
+    module Routes
+      module Results
+        include Utilities::PublishCheckResult
+
+        RESULTS_URI = /^\/results$/
+        RESULTS_CLIENT_URI = /^\/results\/([\w\.-]+)$/
+        RESULT_URI = /^\/results\/([\w\.-]+)\/([\w\.-]+)$/
+
+        def post_results
+          rules = {
+            :name => {:type => String, :nil_ok => false, :regex => /\A[\w\.-]+\z/},
+            :output => {:type => String, :nil_ok => false},
+            :status => {:type => Integer, :nil_ok => true},
+            :source => {:type => String, :nil_ok => true, :regex => /\A[\w\.-]+\z/}
+          }
+          read_data(rules) do |data|
+            publish_check_result("sensu-api", data)
+            @response_content = {:issued => Time.now.to_i}
+            accepted!
+          end
+        end
+
+        def get_results
+          @response_content = []
+          @redis.smembers("clients") do |clients|
+            unless clients.empty?
+              clients.each_with_index do |client_name, client_index|
+                @redis.smembers("result:#{client_name}") do |checks|
+                  if !checks.empty?
+                    checks.each_with_index do |check_name, check_index|
+                      result_key = "result:#{client_name}:#{check_name}"
+                      @redis.get(result_key) do |result_json|
+                        unless result_json.nil?
+                          check = Sensu::JSON.load(result_json)
+                          @response_content << {:client => client_name, :check => check}
+                        end
+                        if client_index == clients.length - 1 && check_index == checks.length - 1
+                          respond
+                        end
+                      end
+                    end
+                  elsif client_index == clients.length - 1
+                    respond
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        def get_results_client
+          client_name = RESULTS_CLIENT_URI.match(@http_request_uri)[1]
+          @response_content = []
+          @redis.smembers("result:#{client_name}") do |checks|
+            unless checks.empty?
+              checks.each_with_index do |check_name, check_index|
+                result_key = "result:#{client_name}:#{check_name}"
+                @redis.get(result_key) do |result_json|
+                  unless result_json.nil?
+                    check = Sensu::JSON.load(result_json)
+                    @response_content << {:client => client_name, :check => check}
+                  end
+                  if check_index == checks.length - 1
+                    respond
+                  end
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_result
+          uri_match = RESULT_URI.match(@http_request_uri)
+          client_name = uri_match[1]
+          check_name = uri_match[2]
+          result_key = "result:#{client_name}:#{check_name}"
+          @redis.get(result_key) do |result_json|
+            unless result_json.nil?
+              check = Sensu::JSON.load(result_json)
+              @response_content = {:client => client_name, :check => check}
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def delete_result
+          uri_match = RESULT_URI.match(@http_request_uri)
+          client_name = uri_match[1]
+          check_name = uri_match[2]
+          result_key = "result:#{client_name}:#{check_name}"
+          @redis.exists(result_key) do |result_exists|
+            if result_exists
+              @redis.srem("result:#{client_name}", check_name) do
+                @redis.del(result_key) do
+                  no_content!
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/routes/stashes.rb

@@ -0,0 +1,102 @@
+module Sensu
+  module API
+    module Routes
+      module Stashes
+        STASHES_URI = /^\/stashes$/
+        STASH_URI = /^\/stash(?:es)?\/(.*)$/
+
+        def post_stash
+          path = STASH_URI.match(@http_request_uri)[1]
+          read_data do |data|
+            @redis.set("stash:#{path}", Sensu::JSON.dump(data)) do
+              @redis.sadd("stashes", path) do
+                @response_content = {:path => path}
+                created!
+              end
+            end
+          end
+        end
+
+        def get_stash
+          path = STASH_URI.match(@http_request_uri)[1]
+          @redis.get("stash:#{path}") do |stash_json|
+            unless stash_json.nil?
+              @response_content = Sensu::JSON.load(stash_json)
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def delete_stash
+          path = STASH_URI.match(@http_request_uri)[1]
+          @redis.exists("stash:#{path}") do |stash_exists|
+            if stash_exists
+              @redis.srem("stashes", path) do
+                @redis.del("stash:#{path}") do
+                  no_content!
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_stashes
+          @response_content = []
+          @redis.smembers("stashes") do |stashes|
+            unless stashes.empty?
+              stashes = pagination(stashes)
+              stashes.each_with_index do |path, index|
+                @redis.get("stash:#{path}") do |stash_json|
+                  @redis.ttl("stash:#{path}") do |ttl|
+                    unless stash_json.nil?
+                      item = {
+                        :path => path,
+                        :content => Sensu::JSON.load(stash_json),
+                        :expire => ttl
+                      }
+                      @response_content << item
+                    else
+                      @redis.srem("stashes", path)
+                    end
+                    if index == stashes.length - 1
+                      respond
+                    end
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        def post_stashes
+          rules = {
+            :path => {:type => String, :nil_ok => false},
+            :content => {:type => Hash, :nil_ok => false},
+            :expire => {:type => Integer, :nil_ok => true}
+          }
+          read_data(rules) do |data|
+            stash_key = "stash:#{data[:path]}"
+            @redis.set(stash_key, Sensu::JSON.dump(data[:content])) do
+              @redis.sadd("stashes", data[:path]) do
+                @response_content = {:path => data[:path]}
+                if data[:expire]
+                  @redis.expire(stash_key, data[:expire]) do
+                    created!
+                  end
+                else
+                  created!
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/utilities/publish_check_request.rb

@@ -0,0 +1,57 @@
+module Sensu
+  module API
+    module Utilities
+      module PublishCheckRequest
+        # Determine the Sensu Transport publish options for a
+        # subscription. If a subscription begins with a Transport pipe
+        # type, either "direct:" or "roundrobin:", the subscription uses
+        # a direct Transport pipe. If a subscription does not specify a
+        # Transport pipe type, a fanout Transport pipe is used.
+        #
+        # @param subscription [String]
+        # @param message [String]
+        # @return [Array] containing the Transport publish options:
+        #   the Transport pipe type, pipe, and the message to be
+        #   published.
+        def transport_publish_options(subscription, message)
+          _, raw_type = subscription.split(":", 2).reverse
+          case raw_type
+          when "direct", "roundrobin"
+            [:direct, subscription, message]
+          else
+            [:fanout, subscription, message]
+          end
+        end
+
+        # Publish a check request to the Transport. A check request is
+        # composed of a check `:name`, an `:issued` timestamp, a check
+        # `:command` if available, and a check `:extension if available.
+        # The check request is published to a Transport pipe, for each
+        # of the check `:subscribers` in its definition, eg. "webserver".
+        # JSON serialization is used when publishing the check request
+        # payload to the Transport pipes. Transport errors are logged.
+        #
+        # @param check [Hash] definition.
+        def publish_check_request(check)
+          payload = check.merge(:issued => Time.now.to_i)
+          @logger.info("publishing check request", {
+            :payload => payload,
+            :subscribers => check[:subscribers]
+          })
+          check[:subscribers].each do |subscription|
+            options = transport_publish_options(subscription.to_s, Sensu::JSON.dump(payload))
+            @transport.publish(*options) do |info|
+              if info[:error]
+                @logger.error("failed to publish check request", {
+                  :subscription => subscription,
+                  :payload => payload,
+                  :error => info[:error].to_s
+                })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/api/utilities/publish_check_result.rb

@@ -0,0 +1,36 @@
+module Sensu
+  module API
+    module Utilities
+      module PublishCheckResult
+        # Publish a check result to the Transport for processing. A
+        # check result is composed of a client name and a check
+        # definition, containing check `:output` and `:status`. A client
+        # signature is added to the check result payload if one is
+        # registered for the client. JSON serialization is used when
+        # publishing the check result payload to the Transport pipe.
+        # Transport errors are logged.
+        #
+        # @param client_name [String]
+        # @param check [Hash]
+        def publish_check_result(client_name, check)
+          check[:issued] = Time.now.to_i
+          check[:executed] = Time.now.to_i
+          check[:status] ||= 0
+          payload = {
+            :client => client_name,
+            :check => check
+          }
+          @logger.info("publishing check result", :payload => payload)
+          @transport.publish(:direct, "results", Sensu::JSON.dump(payload)) do |info|
+            if info[:error]
+              @logger.error("failed to publish check result", {
+                :payload => payload,
+                :error => info[:error].to_s
+              })
+            end
+          end
+        end
+      end
+    end
+  end
+end