sensu 0.24.1 → 0.25.0.beta

data/lib/sensu/api/routes.rb

@@ -0,0 +1,72 @@
+require "sensu/api/routes/info"
+require "sensu/api/routes/health"
+require "sensu/api/routes/clients"
+require "sensu/api/routes/checks"
+require "sensu/api/routes/request"
+require "sensu/api/routes/events"
+require "sensu/api/routes/resolve"
+require "sensu/api/routes/aggregates"
+require "sensu/api/routes/stashes"
+require "sensu/api/routes/results"
+
+module Sensu
+  module API
+    module Routes
+      include Info
+      include Health
+      include Clients
+      include Checks
+      include Request
+      include Events
+      include Resolve
+      include Aggregates
+      include Stashes
+      include Results
+
+      GET_METHOD = "GET".freeze
+      POST_METHOD = "POST".freeze
+      DELETE_METHOD = "DELETE".freeze
+      OPTIONS_METHOD = "OPTIONS".freeze
+
+      ROUTES = {
+        GET_METHOD => [
+          [INFO_URI, :get_info],
+          [HEALTH_URI, :get_health],
+          [CLIENTS_URI, :get_clients],
+          [CLIENT_URI, :get_client],
+          [CLIENT_HISTORY_URI, :get_client_history],
+          [CHECKS_URI, :get_checks],
+          [CHECK_URI, :get_check],
+          [EVENTS_URI, :get_events],
+          [EVENTS_CLIENT_URI, :get_events_client],
+          [EVENT_URI, :get_event],
+          [AGGREGATES_URI, :get_aggregates],
+          [AGGREGATE_URI, :get_aggregate],
+          [AGGREGATE_CLIENTS_URI, :get_aggregate_clients],
+          [AGGREGATE_CHECKS_URI, :get_aggregate_checks],
+          [AGGREGATE_RESULTS_SEVERITY_URI, :get_aggregate_results_severity],
+          [STASHES_URI, :get_stashes],
+          [STASH_URI, :get_stash],
+          [RESULTS_URI, :get_results],
+          [RESULTS_CLIENT_URI, :get_results_client],
+          [RESULT_URI, :get_result]
+        ],
+        POST_METHOD => [
+          [CLIENTS_URI, :post_clients],
+          [REQUEST_URI, :post_request],
+          [RESOLVE_URI, :post_resolve],
+          [STASHES_URI, :post_stashes],
+          [STASH_URI, :post_stash],
+          [RESULTS_URI, :post_results]
+        ],
+        DELETE_METHOD => [
+          [CLIENT_URI, :delete_client],
+          [EVENT_URI, :delete_event],
+          [AGGREGATE_URI, :delete_aggregate],
+          [STASH_URI, :delete_stash],
+          [RESULT_URI, :delete_result]
+        ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+module Sensu
+  module API
+    module Routes
+      module Aggregates
+        AGGREGATES_URI = /^\/aggregates$/
+        AGGREGATE_URI = /^\/aggregates\/([\w\.-]+)$/
+        AGGREGATE_CLIENTS_URI = /^\/aggregates\/([\w\.-]+)\/clients$/
+        AGGREGATE_CHECKS_URI = /^\/aggregates\/([\w\.-]+)\/checks$/
+        AGGREGATE_RESULTS_SEVERITY_URI = /^\/aggregates\/([\w\.-]+)\/results\/([\w\.-]+)$/
+
+        def get_aggregates
+          @redis.smembers("aggregates") do |aggregates|
+            aggregates.map! do |aggregate|
+              {:name => aggregate}
+            end
+            @response_content = aggregates
+            respond
+          end
+        end
+
+        def get_aggregate
+          aggregate = AGGREGATE_URI.match(@http_request_uri)[1]
+          @redis.smembers("aggregates:#{aggregate}") do |aggregate_members|
+            unless aggregate_members.empty?
+              @response_content = {
+                :clients => 0,
+                :checks => 0,
+                :results => {
+                  :ok => 0,
+                  :warning => 0,
+                  :critical => 0,
+                  :unknown => 0,
+                  :total => 0,
+                  :stale => 0
+                }
+              }
+              clients = []
+              checks = []
+              results = []
+              aggregate_members.each_with_index do |member, index|
+                client_name, check_name = member.split(":")
+                clients << client_name
+                checks << check_name
+                result_key = "result:#{client_name}:#{check_name}"
+                @redis.get(result_key) do |result_json|
+                  unless result_json.nil?
+                    results << Sensu::JSON.load(result_json)
+                  else
+                    @redis.srem("aggregates:#{aggregate}", member)
+                  end
+                  if index == aggregate_members.length - 1
+                    @response_content[:clients] = clients.uniq.length
+                    @response_content[:checks] = checks.uniq.length
+                    max_age = integer_parameter(@params[:max_age])
+                    if max_age
+                      result_count = results.length
+                      timestamp = Time.now.to_i - max_age
+                      results.reject! do |result|
+                        result[:executed] < timestamp
+                      end
+                      @response_content[:results][:stale] = result_count - results.length
+                    end
+                    @response_content[:results][:total] = results.length
+                    results.each do |result|
+                      severity = (SEVERITIES[result[:status]] || "unknown")
+                      @response_content[:results][severity.to_sym] += 1
+                    end
+                    respond
+                  end
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+
+        def delete_aggregate
+          aggregate = AGGREGATE_URI.match(@http_request_uri)[1]
+          @redis.smembers("aggregates") do |aggregates|
+            if aggregates.include?(aggregate)
+              @redis.srem("aggregates", aggregate) do
+                @redis.del("aggregates:#{aggregate}") do
+                  no_content!
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_aggregate_clients
+          aggregate = AGGREGATE_CLIENTS_URI.match(@http_request_uri)[1]
+          @response_content = []
+          @redis.smembers("aggregates:#{aggregate}") do |aggregate_members|
+            unless aggregate_members.empty?
+              clients = {}
+              aggregate_members.each do |member|
+                client_name, check_name = member.split(":")
+                clients[client_name] ||= []
+                clients[client_name] << check_name
+              end
+              clients.each do |client_name, checks|
+                @response_content << {
+                  :name => client_name,
+                  :checks => checks
+                }
+              end
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_aggregate_checks
+          aggregate = AGGREGATE_CHECKS_URI.match(@http_request_uri)[1]
+          @response_content = []
+          @redis.smembers("aggregates:#{aggregate}") do |aggregate_members|
+            unless aggregate_members.empty?
+              checks = {}
+              aggregate_members.each do |member|
+                client_name, check_name = member.split(":")
+                checks[check_name] ||= []
+                checks[check_name] << client_name
+              end
+              checks.each do |check_name, clients|
+                @response_content << {
+                  :name => check_name,
+                  :clients => clients
+                }
+              end
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_aggregate_results_severity
+          uri_match = AGGREGATE_RESULTS_SEVERITY_URI.match(@http_request_uri)
+          aggregate = uri_match[1]
+          severity = uri_match[2]
+          @response_content = []
+          if SEVERITIES.include?(severity)
+            @redis.smembers("aggregates:#{aggregate}") do |aggregate_members|
+              unless aggregate_members.empty?
+                summaries = Hash.new
+                max_age = integer_parameter(@params[:max_age])
+                current_timestamp = Time.now.to_i
+                aggregate_members.each_with_index do |member, index|
+                  client_name, check_name = member.split(":")
+                  result_key = "result:#{client_name}:#{check_name}"
+                  @redis.get(result_key) do |result_json|
+                    unless result_json.nil?
+                      result = Sensu::JSON.load(result_json)
+                      if SEVERITIES[result[:status]] == severity &&
+                          (max_age.nil? || result[:executed] >= (current_timestamp - max_age))
+                        summaries[check_name] ||= {}
+                        summaries[check_name][result[:output]] ||= {:total => 0, :clients => []}
+                        summaries[check_name][result[:output]][:total] += 1
+                        summaries[check_name][result[:output]][:clients] << client_name
+                      end
+                    end
+                    if index == aggregate_members.length - 1
+                      summaries.each do |check_name, outputs|
+                        summary = outputs.map do |output, output_summary|
+                          {:output => output}.merge(output_summary)
+                        end
+                        @response_content << {
+                          :check => check_name,
+                          :summary => summary
+                        }
+                      end
+                      respond
+                    end
+                  end
+                end
+              else
+                not_found!
+              end
+            end
+          else
+            bad_request!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Sensu
+  module API
+    module Routes
+      module Checks
+        CHECKS_URI = /^\/checks$/
+        CHECK_URI = /^\/checks\/([\w\.-]+)$/
+
+        def get_checks
+          @response_content = @settings.checks
+          respond
+        end
+
+        def get_check
+          check_name = CHECK_URI.match(@http_request_uri)[1]
+          if @settings[:checks][check_name]
+            @response_content = @settings[:checks][check_name].merge(:name => check_name)
+            respond
+          else
+            not_found!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+require "sensu/api/utilities/resolve_event"
+
+module Sensu
+  module API
+    module Routes
+      module Clients
+        include Utilities::ResolveEvent
+
+        CLIENTS_URI = /^\/clients$/
+        CLIENT_URI = /^\/clients\/([\w\.-]+)$/
+        CLIENT_HISTORY_URI = /^\/clients\/([\w\.-]+)\/history$/
+
+        def post_clients
+          read_data do |client|
+            client[:keepalives] = client.fetch(:keepalives, false)
+            client[:version] = VERSION
+            client[:timestamp] = Time.now.to_i
+            validator = Validators::Client.new
+            if validator.valid?(client)
+              @redis.set("client:#{client[:name]}", Sensu::JSON.dump(client)) do
+                @redis.sadd("clients", client[:name]) do
+                  @response_content = {:name => client[:name]}
+                  created!
+                end
+              end
+            else
+              bad_request!
+            end
+          end
+        end
+
+        def get_clients
+          @response_content = []
+          @redis.smembers("clients") do |clients|
+            clients = pagination(clients)
+            unless clients.empty?
+              clients.each_with_index do |client_name, index|
+                @redis.get("client:#{client_name}") do |client_json|
+                  unless client_json.nil?
+                    @response_content << Sensu::JSON.load(client_json)
+                  else
+                    @logger.error("client data missing from registry", :client_name => client_name)
+                    @redis.srem("clients", client_name)
+                  end
+                  if index == clients.length - 1
+                    respond
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        def get_client
+          client_name = CLIENT_URI.match(@http_request_uri)[1]
+          @redis.get("client:#{client_name}") do |client_json|
+            unless client_json.nil?
+              @response_content = Sensu::JSON.load(client_json)
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def get_client_history
+          client_name = CLIENT_HISTORY_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, index|
+                result_key = "#{client_name}:#{check_name}"
+                history_key = "history:#{result_key}"
+                @redis.lrange(history_key, -21, -1) do |history|
+                  history.map! do |status|
+                    status.to_i
+                  end
+                  @redis.get("result:#{result_key}") do |result_json|
+                    unless result_json.nil?
+                      result = Sensu::JSON.load(result_json)
+                      last_execution = result[:executed]
+                      unless history.empty? || last_execution.nil?
+                        item = {
+                          :check => check_name,
+                          :history => history,
+                          :last_execution => last_execution.to_i,
+                          :last_status => history.last,
+                          :last_result => result
+                        }
+                        @response_content << item
+                      end
+                    end
+                    if index == checks.length - 1
+                      respond
+                    end
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        def delete_client
+          client_name = CLIENT_URI.match(@http_request_uri)[1]
+          @redis.get("client:#{client_name}") do |client_json|
+            unless client_json.nil?
+              @redis.hgetall("events:#{client_name}") do |events|
+                events.each do |check_name, event_json|
+                  resolve_event(event_json)
+                end
+                delete_client = Proc.new do |attempts|
+                  attempts += 1
+                  @redis.hgetall("events:#{client_name}") do |events|
+                    if events.empty? || attempts == 5
+                      @logger.info("deleting client from registry", :client_name => client_name)
+                      @redis.srem("clients", client_name) do
+                        @redis.del("client:#{client_name}")
+                        @redis.del("client:#{client_name}:signature")
+                        @redis.del("events:#{client_name}")
+                        @redis.smembers("result:#{client_name}") do |checks|
+                          checks.each do |check_name|
+                            result_key = "#{client_name}:#{check_name}"
+                            @redis.del("result:#{result_key}")
+                            @redis.del("history:#{result_key}")
+                          end
+                          @redis.del("result:#{client_name}")
+                        end
+                      end
+                    else
+                      EM::Timer.new(1) do
+                        delete_client.call(attempts)
+                      end
+                    end
+                  end
+                end
+                delete_client.call(0)
+                @response_content = {:issued => Time.now.to_i}
+                accepted!
+              end
+            else
+              not_found!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "sensu/api/utilities/resolve_event"
+
+module Sensu
+  module API
+    module Routes
+      module Events
+        include Utilities::ResolveEvent
+
+        EVENTS_URI = /^\/events$/
+        EVENTS_CLIENT_URI = /^\/events\/([\w\.-]+)$/
+        EVENT_URI = /^\/events\/([\w\.-]+)\/([\w\.-]+)$/
+
+        def get_events
+          @response_content = []
+          @redis.smembers("clients") do |clients|
+            unless clients.empty?
+              clients.each_with_index do |client_name, index|
+                @redis.hgetall("events:#{client_name}") do |events|
+                  events.each do |check_name, event_json|
+                    @response_content << Sensu::JSON.load(event_json)
+                  end
+                  if index == clients.length - 1
+                    respond
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        def get_events_client
+          client_name = EVENTS_CLIENT_URI.match(@http_request_uri)[1]
+          @response_content = []
+          @redis.hgetall("events:#{client_name}") do |events|
+            events.each do |check_name, event_json|
+              @response_content << Sensu::JSON.load(event_json)
+            end
+            respond
+          end
+        end
+
+        def get_event
+          uri_match = EVENT_URI.match(@http_request_uri)
+          client_name = uri_match[1]
+          check_name = uri_match[2]
+          @redis.hgetall("events:#{client_name}") do |events|
+            event_json = events[check_name]
+            unless event_json.nil?
+              @response_content = Sensu::JSON.load(event_json)
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        def delete_event
+          uri_match = EVENT_URI.match(@http_request_uri)
+          client_name = uri_match[1]
+          check_name = uri_match[2]
+          @redis.hgetall("events:#{client_name}") do |events|
+            if events.include?(check_name)
+              resolve_event(events[check_name])
+              @response_content = {:issued => Time.now.to_i}
+              accepted!
+            else
+              not_found!
+            end
+          end
+        end
+      end
+    end
+  end
+end