portertech-sensu 1.10.0

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

@@ -0,0 +1,44 @@
+module Sensu
+  module API
+    module Routes
+      module Checks
+        CHECKS_URI = /^\/checks$/
+        CHECK_URI = /^\/checks\/([\w\.-]+)$/
+
+        # GET /checks
+        def get_checks
+          checks = @settings.checks.reject { |check| check[:standalone] }
+          @response_content = pagination(checks)
+          respond
+        end
+
+        # GET /checks/:check_name
+        def get_check
+          check_name = parse_uri(CHECK_URI).first
+          if @settings[:checks][check_name] && !@settings[:checks][check_name][:standalone]
+            @response_content = @settings[:checks][check_name].merge(:name => check_name)
+            respond
+          else
+            not_found!
+          end
+        end
+
+        # DELETE /checks/:check_name
+        def delete_check
+          check_name = parse_uri(CHECK_URI).first
+          @redis.smembers("clients") do |clients|
+            result_keys = clients.map {|client_name| "result:#{client_name}:#{check_name}"}
+            history_keys = clients.map {|client_name| "history:#{client_name}:#{check_name}"}
+            last_ok_keys = clients.map {|client_name| "history:#{client_name}:#{check_name}:last_ok"}
+            keys = result_keys.concat(history_keys).concat(last_ok_keys)
+            keys.each do |key|
+              @redis.del(key)
+            end
+          end
+          @response_content = {:issued => Time.now.to_i}
+          accepted!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+require "sensu/api/validators/client"
+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$/
+
+        # POST /clients
+        def post_clients
+          read_data do |client|
+            client[:keepalives] = client.fetch(:keepalives, false)
+            client[:version] = VERSION
+            client[:timestamp] = Time.now.to_i
+            client[:subscriptions] ||= []
+            validator = Validators::Client.new
+            if validator.valid?(client)
+              client[:subscriptions] = (client[:subscriptions] + ["client:#{client[:name]}"]).uniq
+              @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
+
+        # GET /clients
+        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?
+                    client = Sensu::JSON.load(client_json)
+                    @response_content << redact_sensitive(client, client[:redact])
+                  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
+
+        # GET /clients/:client_name
+        def get_client
+          client_name = parse_uri(CLIENT_URI).first
+          @redis.get("client:#{client_name}") do |client_json|
+            unless client_json.nil?
+              client = Sensu::JSON.load(client_json)
+              @response_content = redact_sensitive(client, client[:redact])
+              respond
+            else
+              not_found!
+            end
+          end
+        end
+
+        # GET /clients/:client_name/history
+        def get_client_history
+          client_name = parse_uri(CLIENT_HISTORY_URI).first
+          @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
+
+        # DELETE /clients/:client_name
+        def delete_client
+          client_name = parse_uri(CLIENT_URI).first
+          client_key = "client:#{client_name}"
+          signature_key = "#{client_key}:signature"
+          @redis.get(client_key) do |client_json|
+            unless client_json.nil?
+              @redis.set(signature_key, "invalidated") if @params[:invalidate]
+              @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_key)
+                        invalidate_expire = integer_parameter(@params[:invalidate_expire])
+                        if @params[:invalidate] && invalidate_expire
+                          @redis.expire(signature_key, invalidate_expire)
+                        else
+                          @redis.del(signature_key)
+                        end
+                        @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}")
+                            @redis.del("history:#{result_key}:last_ok")
+                          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,86 @@
+require "sensu/api/utilities/resolve_event"
+
+module Sensu
+  module API
+    module Routes
+      module Events
+        include Utilities::ResolveEvent
+
+        EVENTS_URI = /^\/(?:events|incidents)$/
+        EVENTS_CLIENT_URI = /^\/(?:events|incidents)\/([\w\.-]+)$/
+        EVENT_URI = /^\/(?:events|incidents)\/([\w\.-]+)\/([\w\.-]+)$/
+
+        # GET /events
+        def get_events
+          @response_content = []
+          raw_event_json = []
+          @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|
+                    raw_event_json << event_json
+                  end
+                  if index == clients.length - 1
+                    raw_event_json = pagination(raw_event_json)
+                    raw_event_json.each do |event_json|
+                      @response_content << Sensu::JSON.load(event_json)
+                    end
+                    respond
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        # GET /events/:client_name
+        def get_events_client
+          client_name = parse_uri(EVENTS_CLIENT_URI).first
+          @response_content = []
+          raw_event_json = []
+          @redis.hgetall("events:#{client_name}") do |events|
+            events.each do |check_name, event_json|
+              raw_event_json << event_json
+            end
+            raw_event_json = pagination(raw_event_json)
+            raw_event_json.each do |event_json|
+              @response_content << Sensu::JSON.load(event_json)
+            end
+            respond
+          end
+        end
+
+        # GET /events/:client_name/:check_name
+        def get_event
+          client_name, check_name = parse_uri(EVENT_URI)
+          @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
+
+        # DELETE /events/:client_name/:check_name
+        def delete_event
+          client_name, check_name = parse_uri(EVENT_URI)
+          @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

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

@@ -0,0 +1,45 @@
+require "sensu/api/utilities/transport_info"
+
+module Sensu
+  module API
+    module Routes
+      module Health
+        include Utilities::TransportInfo
+
+        HEALTH_URI = /^\/health$/
+
+        # GET /health
+        def get_health
+          @response_content = []
+          if @redis.connected? && @transport.connected?
+            min_consumers = integer_parameter(@params[:consumers])
+            max_messages = integer_parameter(@params[:messages])
+            transport_info do |info|
+              if min_consumers
+                if info[:keepalives][:consumers] < min_consumers
+                  @response_content << "keepalive consumers (#{info[:keepalives][:consumers]}) less than min_consumers (#{min_consumers})"
+                end
+                if info[:results][:consumers] < min_consumers
+                  @response_content << "result consumers (#{info[:results][:consumers]}) less than min_consumers (#{min_consumers})"
+                end
+              end
+              if max_messages
+                if info[:keepalives][:messages] > max_messages
+                  @response_content << "keepalive messages (#{info[:keepalives][:messages]}) greater than max_messages (#{max_messages})"
+                end
+                if info[:results][:messages] > max_messages
+                  @response_content << "result messages (#{info[:results][:messages]}) greater than max_messages (#{max_messages})"
+                end
+              end
+              @response_content.empty? ? no_content! : precondition_failed!
+            end
+          else
+            @response_content << "not connected to redis" unless @redis.connected?
+            @response_content << "not connected to transport" unless @transport.connected?
+            precondition_failed!
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "sensu/api/utilities/transport_info"
+require "sensu/api/utilities/servers_info"
+
+module Sensu
+  module API
+    module Routes
+      module Info
+        include Utilities::TransportInfo
+        include Utilities::ServersInfo
+
+        INFO_URI = /^\/info$/
+
+        # GET /info
+        def get_info
+          transport_info do |transport|
+            servers_info do |servers|
+              sensu = RELEASE_INFO.merge(
+                :settings => {
+                  :hexdigest => @settings.hexdigest
+                }
+              )
+              @response_content = {
+                :sensu => sensu,
+                :transport => transport,
+                :redis => {
+                  :connected => @redis.connected?
+                },
+                :servers => servers
+              }
+              respond
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "sensu/api/utilities/publish_check_request"
+
+module Sensu
+  module API
+    module Routes
+      module Request
+        include Utilities::PublishCheckRequest
+
+        REQUEST_URI = /^\/request$/
+
+        # POST /request
+        def post_request
+          rules = {
+            :check => {:type => String, :nil_ok => false},
+            :subscribers => {:type => Array, :nil_ok => true},
+            :reason => {:type => String, :nil_ok => true},
+            :creator => {:type => String, :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]
+              check[:api_requested] = {
+                :reason => data[:reason],
+                :creator => data[:creator]
+              }
+              if check[:proxy_requests]
+                publish_proxy_check_requests(check)
+              else
+                publish_check_request(check)
+              end
+              @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,32 @@
+require "sensu/api/utilities/resolve_event"
+
+module Sensu
+  module API
+    module Routes
+      module Resolve
+        include Utilities::ResolveEvent
+
+        RESOLVE_URI = /^\/resolve$/
+
+        # POST /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,153 @@
+require "sensu/api/validators/check"
+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\.-]+)$/
+
+        # POST /results
+        def post_results
+          read_data do |check|
+            check[:status] ||= 0
+            check[:executed] ||= Time.now.to_i
+            validator = Validators::Check.new
+            if validator.valid?(check)
+              publish_check_result("sensu-api", check)
+              @response_content = {:issued => Time.now.to_i}
+              accepted!
+            else
+              bad_request!
+            end
+          end
+        end
+
+        # GET /results
+        def get_results
+          @response_content = []
+          @redis.smembers("clients") do |clients|
+            unless clients.empty?
+              result_keys = []
+              clients.each_with_index do |client_name, client_index|
+                @redis.smembers("result:#{client_name}") do |checks|
+                  checks.each do |check_name|
+                    result_keys << "result:#{client_name}:#{check_name}"
+                  end
+                  if client_index == clients.length - 1
+                    result_keys = pagination(result_keys)
+                    unless result_keys.empty?
+                      result_keys.each_with_index do |result_key, result_key_index|
+                        @redis.get(result_key) do |result_json|
+                          history_key = result_key.sub(/^result:/, "history:")
+                          @redis.lrange(history_key, -21, -1) do |history|
+                            history.map! do |status|
+                              status.to_i
+                            end
+                            unless result_json.nil?
+                              client_name = history_key.split(":")[1]
+                              check = Sensu::JSON.load(result_json)
+                              check[:history] = history
+                              @response_content << {:client => client_name, :check => check}
+                            end
+                            if result_key_index == result_keys.length - 1
+                              respond
+                            end
+                          end
+                        end
+                      end
+                    else
+                      respond
+                    end
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        # GET /results/:client_name
+        def get_results_client
+          client_name = parse_uri(RESULTS_CLIENT_URI).first
+          @response_content = []
+          @redis.smembers("result:#{client_name}") do |checks|
+            checks = pagination(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|
+                  history_key = "history:#{client_name}:#{check_name}"
+                  @redis.lrange(history_key, -21, -1) do |history|
+                    history.map! do |status|
+                      status.to_i
+                    end
+                    unless result_json.nil?
+                      check = Sensu::JSON.load(result_json)
+                      check[:history] = history
+                      @response_content << {:client => client_name, :check => check}
+                    end
+                    if check_index == checks.length - 1
+                      respond
+                    end
+                  end
+                end
+              end
+            else
+              respond
+            end
+          end
+        end
+
+        # GET /results/:client_name/:check_name
+        def get_result
+          client_name, check_name = parse_uri(RESULT_URI)
+          result_key = "result:#{client_name}:#{check_name}"
+          @redis.get(result_key) do |result_json|
+            unless result_json.nil?
+              history_key = "history:#{client_name}:#{check_name}"
+              @redis.lrange(history_key, -21, -1) do |history|
+                history.map! do |status|
+                  status.to_i
+                end
+                check = Sensu::JSON.load(result_json)
+                check[:history] = history
+                @response_content = {:client => client_name, :check => check}
+                respond
+              end
+            else
+              not_found!
+            end
+          end
+        end
+
+        # DELETE /results/:client_name/:check_name
+        def delete_result
+          client_name, check_name = parse_uri(RESULT_URI)
+          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
+                  history_key = "history:#{client_name}:#{check_name}"
+                  @redis.del(history_key) do
+                    @redis.del("#{history_key}:last_ok") do
+                      no_content!
+                    end
+                  end
+                end
+              end
+            else
+              not_found!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "sensu/utilities"
+
+module Sensu
+  module API
+    module Routes
+      module Settings
+        include Utilities
+
+        SETTINGS_URI = /^\/settings$/
+
+        # GET /settings
+        def get_settings
+          if @params[:redacted] == "false"
+            @response_content = @settings.to_hash
+          else
+            @response_content = redact_sensitive(@settings.to_hash)
+          end
+          respond
+        end
+      end
+    end
+  end
+end