portertech-sensu 1.10.0

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

@@ -0,0 +1,182 @@
+module Sensu
+  module API
+    module Routes
+      module Silenced
+        SILENCED_URI = /^\/silenced$/
+        SILENCED_ID_URI = /^\/silenced\/ids\/([\w\.\-\*\:]+)$/
+        SILENCED_SUBSCRIPTION_URI = /^\/silenced\/subscriptions\/([\w\.\-:]+)$/
+        SILENCED_CHECK_URI = /^\/silenced\/checks\/([\w\.\-]+)$/
+        SILENCED_CLEAR_URI = /^\/silenced\/clear$/
+
+        # Fetch silenced registry entries for the provided silenced
+        # entry keys.
+        #
+        # @param silenced_keys [Array]
+        # @yield callback [entries] callback/block called after the
+        #   silenced registry entries have been fetched.
+        def fetch_silenced(silenced_keys=[])
+          entries = []
+          unless silenced_keys.empty?
+            @redis.mget(*silenced_keys) do |silenced|
+              silenced_keys.each_with_index do |silenced_key, silenced_index|
+                if silenced[silenced_index]
+                  silenced_info = Sensu::JSON.load(silenced[silenced_index])
+                  @redis.ttl(silenced_key) do |ttl|
+                    silenced_info[:expire] = ttl
+                    entries << silenced_info
+                    if silenced_index == silenced_keys.length - 1
+                      yield(entries)
+                    end
+                  end
+                else
+                  @redis.srem("silenced", silenced_key)
+                  if silenced_index == silenced_keys.length - 1
+                    @redis.ping do
+                      yield(entries)
+                    end
+                  end
+                end
+              end
+            end
+          else
+            yield(entries)
+          end
+        end
+
+        # POST /silenced
+        def post_silenced
+          rules = {
+            :subscription => {:type => String, :nil_ok => true, :regex => /\A[\w\.\-\:]+\z/},
+            :check => {:type => String, :nil_ok => true, :regex => /\A[\w\.-]+\z/},
+            :begin => {:type => Integer, :nil_ok => true},
+            :expire => {:type => Integer, :nil_ok => true},
+            :reason => {:type => String, :nil_ok => true},
+            :creator => {:type => String, :nil_ok => true},
+            :expire_on_resolve => {:type => [TrueClass, FalseClass], :nil_ok => true}
+          }
+          read_data(rules) do |data|
+            if data[:subscription] || data[:check]
+              subscription = data.fetch(:subscription, "*")
+              check = data.fetch(:check, "*")
+              silenced_id = "#{subscription}:#{check}"
+              timestamp = Time.now.to_i
+              silenced_info = {
+                :id => silenced_id,
+                :subscription => data[:subscription],
+                :check => data[:check],
+                :reason => data[:reason],
+                :creator => data[:creator],
+                :begin => data[:begin],
+                :expire_on_resolve => data.fetch(:expire_on_resolve, false),
+                :timestamp => timestamp
+              }
+              silenced_key = "silence:#{silenced_id}"
+              @redis.set(silenced_key, Sensu::JSON.dump(silenced_info)) do
+                @redis.sadd("silenced", silenced_key) do
+                  if data[:expire]
+                    expire = data[:expire]
+                    if data[:begin]
+                      diff = data[:begin] - timestamp
+                      expire += diff if diff > 0
+                    end
+                    @redis.expire(silenced_key, expire) do
+                      created!
+                    end
+                  else
+                    created!
+                  end
+                end
+              end
+            else
+              bad_request!
+            end
+          end
+        end
+
+        # GET /silenced
+        def get_silenced
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # GET /silenced/subscriptions/:subscription
+        def get_silenced_subscription
+          subscription = parse_uri(SILENCED_SUBSCRIPTION_URI).first
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys.select! do |key|
+              key =~ /^silence:#{subscription}:/
+            end
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # GET /silenced/ids/:id
+        def get_silenced_id
+          id = parse_uri(SILENCED_ID_URI).first
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys.select! do |key|
+              key =~ /#{id.gsub('*', '\*')}$/
+            end
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              if silenced.empty?
+                not_found!
+              else
+                @response_content = silenced.last
+                respond
+              end
+            end
+          end
+        end
+
+        # GET /silenced/checks/:check
+        def get_silenced_check
+          check_name = parse_uri(SILENCED_CHECK_URI).first
+          @redis.smembers("silenced") do |silenced_keys|
+            silenced_keys.select! do |key|
+              key =~ /.*:#{check_name}$/
+            end
+            silenced_keys = pagination(silenced_keys)
+            fetch_silenced(silenced_keys) do |silenced|
+              @response_content = silenced
+              respond
+            end
+          end
+        end
+
+        # POST /silenced/clear
+        def post_silenced_clear
+          rules = {
+            :id => {:type => String, :nil_ok => true},
+            :subscription => {:type => String, :nil_ok => true},
+            :check => {:type => String, :nil_ok => true, :regex => /\A[\w\.-]+\z/}
+          }
+          read_data(rules) do |data|
+            if !data[:id].nil? || (data[:subscription] || data[:check])
+              subscription = data.fetch(:subscription, "*")
+              check = data.fetch(:check, "*")
+              silenced_id = data[:id] || "#{subscription}:#{check}"
+              silenced_key = "silence:#{silenced_id}"
+              @redis.srem("silenced", silenced_key) do
+                @redis.del(silenced_key) do |deleted|
+                  deleted ? no_content! : not_found!
+                end
+              end
+            else
+              bad_request!
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module Sensu
+  module API
+    module Routes
+      module Stashes
+        STASHES_URI = /^\/stashes$/
+        STASH_URI = /^\/stash(?:es)?\/(.*)$/
+
+        # POST /stash/:path or /stashes/:path
+        def post_stash
+          path = parse_uri(STASH_URI).first
+          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
+
+        # GET /stash/:path or /stashes/:path
+        def get_stash
+          path = parse_uri(STASH_URI).first
+          @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
+
+        # DELETE /stash/:path or /stashes/:path
+        def delete_stash
+          path = parse_uri(STASH_URI).first
+          @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
+
+        # GET /stashes
+        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
+
+        # POST /stashes
+        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/routes.rb

@@ -0,0 +1,88 @@
+require "sensu/api/routes/settings"
+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"
+require "sensu/api/routes/silenced"
+
+module Sensu
+  module API
+    module Routes
+      include Settings
+      include Info
+      include Health
+      include Clients
+      include Checks
+      include Request
+      include Events
+      include Resolve
+      include Aggregates
+      include Stashes
+      include Results
+      include Silenced
+
+      GET_METHOD = "GET".freeze
+      HEAD_METHOD = "HEAD".freeze
+      POST_METHOD = "POST".freeze
+      DELETE_METHOD = "DELETE".freeze
+      OPTIONS_METHOD = "OPTIONS".freeze
+
+      GET_ROUTES = [
+        [SETTINGS_URI, :get_settings],
+        [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],
+        [SILENCED_URI, :get_silenced],
+        [SILENCED_ID_URI, :get_silenced_id],
+        [SILENCED_SUBSCRIPTION_URI, :get_silenced_subscription],
+        [SILENCED_CHECK_URI, :get_silenced_check]
+      ]
+
+      ROUTES = {
+        GET_METHOD => GET_ROUTES,
+        HEAD_METHOD => GET_ROUTES,
+        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],
+          [SILENCED_URI, :post_silenced],
+          [SILENCED_CLEAR_URI, :post_silenced_clear]
+        ],
+        DELETE_METHOD => [
+          [CLIENT_URI, :delete_client],
+          [CHECK_URI, :delete_check],
+          [EVENT_URI, :delete_event],
+          [AGGREGATE_URI, :delete_aggregate],
+          [STASH_URI, :delete_stash],
+          [RESULT_URI, :delete_result]
+        ]
+      }
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "sensu/utilities"
+
+module Sensu
+  module API
+    module Utilities
+      module FilterResponseContent
+        include Sensu::Utilities
+
+        # Create a nested hash from a dot notation key and value.
+        #
+        # @param dot_notation [String]
+        # @param value [Object]
+        # @return [Hash]
+        def dot_notation_to_hash(dot_notation, value)
+          hash = {}
+          dot_notation.split(".").reverse.each do |key|
+            if hash.empty?
+              hash = {key.to_sym => value}
+            else
+              hash = {key.to_sym => hash}
+            end
+          end
+          hash
+        end
+
+        # Filter the response content if filter parameters have been
+        # provided. This method mutates `@response_content`, only
+        # retaining array items that match the attributes provided via
+        # filter parameters.
+        def filter_response_content!
+          if @response_content.is_a?(Array) && !@filter_params.empty?
+            attributes = {}
+            @filter_params.each do |key, value|
+              attributes = deep_merge(attributes, dot_notation_to_hash(key, value))
+            end
+            @response_content.select! do |object|
+              attributes_match?(object, attributes, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+require "sensu/utilities"
+
+module Sensu
+  module API
+    module Utilities
+      module PublishCheckRequest
+        include Sensu::Utilities
+
+        # 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.reject do |key, value|
+            [:subscribers, :interval].include?(key)
+          end
+          payload[: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
+
+        # Create and publish one or more proxy check requests. This
+        # method iterates through the Sensu client registry for clients
+        # that matched provided proxy request client attributes. A proxy
+        # check request is created for each client in the registry that
+        # matches the proxy request client attributes. Proxy check
+        # requests have their client tokens subsituted by the associated
+        # client attributes values. The check requests are published to
+        # the Transport via `publish_check_request()`.
+        #
+        # @param check [Hash] definition.
+        def publish_proxy_check_requests(check)
+          client_attributes = check[:proxy_requests][:client_attributes]
+          unless client_attributes.empty?
+            @redis.smembers("clients") do |clients|
+              clients.each do |client_name|
+                @redis.get("client:#{client_name}") do |client_json|
+                  unless client_json.nil?
+                    client = Sensu::JSON.load(client_json)
+                    if attributes_match?(client, client_attributes)
+                      @logger.debug("creating a proxy check request", {
+                        :client => client,
+                        :check => check
+                      })
+                      proxy_check, unmatched_tokens = object_substitute_tokens(deep_dup(check.dup), client)
+                      if unmatched_tokens.empty?
+                        proxy_check[:source] ||= client[:name]
+                        publish_check_request(proxy_check)
+                      else
+                        @logger.warn("failed to publish a proxy check request", {
+                          :reason => "unmatched client tokens",
+                          :unmatched_tokens => unmatched_tokens,
+                          :client => client,
+                          :check => check
+                        })
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+          }
+          @redis.get("client:#{client_name}:signature") do |signature|
+            payload[:signature] = signature unless signature.nil?
+            @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
+end

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

@@ -0,0 +1,29 @@
+require "sensu/api/utilities/publish_check_result"
+
+module Sensu
+  module API
+    module Utilities
+      module ResolveEvent
+        include PublishCheckResult
+
+        # Resolve an event. This method publishes a check result with
+        # a check status of `0` (OK) to resolve the event. The
+        # published check result uses `force_resolve` to ensure the
+        # event is resolved and removed from the registry, even if the
+        # current event has an event action of `flapping` etc.
+        #
+        # @param event_json [String] JSON formatted event data.
+        def resolve_event(event_json)
+          event = Sensu::JSON.load(event_json)
+          check = event[:check].merge(
+            :output => "Resolving on request of the API",
+            :status => 0,
+            :force_resolve => true
+          )
+          check.delete(:history)
+          publish_check_result(event[:client][:name], check)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Sensu
+  module API
+    module Utilities
+      module ServersInfo
+        # Retreive the Sensu servers info.
+        #
+        # @yield [Hash] passes servers info to the callback/block.
+        def servers_info
+          info = []
+          if @redis.connected?
+            @redis.smembers("servers") do |servers|
+              unless servers.empty?
+                servers.each_with_index do |server_id, index|
+                  @redis.get("server:#{server_id}") do |server_json|
+                    unless server_json.nil?
+                      server = Sensu::JSON.load(server_json)
+                      if server[:timestamp] >= (Time.now.to_i - 30)
+                        info << server
+                      else
+                        @redis.del("server:#{server_id}") do
+                          @redis.srem("servers", server_id)
+                        end
+                      end
+                    else
+                      @redis.srem("servers", server_id)
+                    end
+                    if index == servers.length - 1
+                      yield(info)
+                    end
+                  end
+                end
+              else
+                yield(info)
+              end
+            end
+          else
+            yield(info)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Sensu
+  module API
+    module Utilities
+      module TransportInfo
+        # Retreive the Sensu Transport info, if the API is connected
+        # to it, keepalive messages and consumers, and results
+        # messages and consumers.
+        #
+        # @yield [Hash] passes Transport info to the callback/block.
+        def transport_info
+          info = {
+            :name => @settings[:transport][:name],
+            :keepalives => {
+              :messages => nil,
+              :consumers => nil
+            },
+            :results => {
+              :messages => nil,
+              :consumers => nil
+            },
+            :connected => false
+          }
+          if @transport.connected?
+            @transport.stats("keepalives") do |stats|
+              info[:keepalives] = stats
+              if @transport.connected?
+                @transport.stats("results") do |stats|
+                  info[:results] = stats
+                  info[:connected] = @transport.connected?
+                  yield(info)
+                end
+              else
+                yield(info)
+              end
+            end
+          else
+            yield(info)
+          end
+        end
+      end
+    end
+  end
+end