sensu-settings 0.0.1

data/lib/sensu/settings/validator.rb

@@ -0,0 +1,76 @@
+require "sensu/settings/rules"
+require "sensu/settings/validators"
+require "sensu/settings/constants"
+
+module Sensu
+  module Settings
+    class Validator
+      include Rules
+      include Validators
+
+      # @!attribute [r] failures
+      #   @return [Array] validation failures.
+      attr_reader :failures
+
+      def initialize
+        @failures = []
+      end
+
+      # Run the validator.
+      #
+      # @param settings [Hash] sensu settings to validate.
+      # @param service [String] sensu service to validate for.
+      # @return [Array] validation failures.
+      def run(settings, service=nil)
+        validate_categories(settings)
+        validate_transport(settings[:transport])
+        case service
+        when "client"
+          validate_client(settings[:client])
+        when "api"
+          validate_api(settings[:api])
+        end
+        @failures
+      end
+
+      def reset!
+        failure_count = @failures.size
+        @failures = []
+        failure_count
+      end
+      alias_method :reset, :reset!
+
+      private
+
+      # Validate setting categories: checks, filters, mutators, and
+      # handlers.
+      #
+      # @param settings [Hash] sensu settings to validate.
+      def validate_categories(settings)
+        CATEGORIES.each do |category|
+          if is_a_hash?(settings[category])
+            validate_method = ("validate_" + category.to_s.chop).to_sym
+            settings[category].each do |name, details|
+              send(validate_method, details.merge(:name => name.to_s))
+            end
+          else
+            invalid(settings[category], "#{category} must be a hash")
+          end
+        end
+      end
+
+      # Record an invalid object with a message.
+      #
+      # @param object [Object] invalid object.
+      # @param message [String] message explaining why the object is
+      #   invalid.
+      # @return [Array] current validation failures.
+      def invalid(object, message)
+        @failures << {
+          :object => object,
+          :message => message
+        }
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators.rb

@@ -0,0 +1,23 @@
+require "sensu/settings/validators/subdue"
+require "sensu/settings/validators/check"
+require "sensu/settings/validators/filter"
+require "sensu/settings/validators/mutator"
+require "sensu/settings/validators/handler"
+require "sensu/settings/validators/client"
+require "sensu/settings/validators/api"
+require "sensu/settings/validators/transport"
+
+module Sensu
+  module Settings
+    module Validators
+      include Subdue
+      include Check
+      include Filter
+      include Mutator
+      include Handler
+      include Client
+      include API
+      include Transport
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Sensu
+  module Settings
+    module Validators
+      module API
+        # Validate API authentication.
+        # Validates: user, password
+        #
+        # @param api [Hash] sensu api definition.
+        def validate_api_authentication(api)
+          if either_are_set?(api[:user], api[:password])
+            must_be_a_string(api[:user]) ||
+              invalid(api, "api user must be a string")
+            must_be_a_string(api[:password]) ||
+              invalid(api, "api password must be a string")
+          end
+        end
+
+        # Validate a Sensu API definition.
+        # Validates: port, bind
+        #
+        # @param api [Hash] sensu api definition.
+        def validate_api(api)
+          if is_a_hash?(api)
+            must_be_an_integer(api[:port]) ||
+              invalid(api, "api port must be an integer")
+            must_be_a_string_if_set(api[:bind]) ||
+              invalid(api, "api bind must be a string")
+            validate_api_authentication(api)
+          else
+            invalid(api, "api must be a hash")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/check.rb

@@ -0,0 +1,78 @@
+module Sensu
+  module Settings
+    module Validators
+      module Check
+        # Validate check scheduling.
+        # Validates: interval, standalone, subscribers
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_scheduling(check)
+          must_be_boolean_if_set(check[:publish]) ||
+            invalid(check, "check publish must be boolean")
+          unless check[:publish] == false
+            (must_be_an_integer(check[:interval]) && check[:interval] > 0) ||
+              invalid(check, "check interval must be an integer")
+          end
+          must_be_boolean_if_set(check[:standalone]) ||
+            invalid(check, "check standalone must be boolean")
+          unless check[:standalone]
+            if is_an_array?(check[:subscribers])
+              items_must_be_strings(check[:subscribers]) ||
+                invalid(check, "check subscribers must each be a string")
+            else
+              invalid(check, "check subscribers must be an array")
+            end
+          end
+        end
+
+        # Validate check handling.
+        # Validates: handler, handlers
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_handling(check)
+          must_be_a_string_if_set(check[:handler]) ||
+            invalid(check, "check handler must be a string")
+          must_be_an_array_if_set(check[:handlers]) ||
+            invalid(check, "check handlers must be an array")
+          if is_an_array?(check[:handlers])
+            items_must_be_strings(check[:handlers]) ||
+              invalid(check, "check handlers must each be a string")
+          end
+        end
+
+        # Validate check flap detection.
+        # Validates: low_flap_threshold, high_flap_threshold
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_flap_detection(check)
+          if either_are_set?(check[:low_flap_threshold], check[:high_flap_threshold])
+            must_be_an_integer(check[:low_flap_threshold]) ||
+              invalid(check, "check low flap threshold must be an integer")
+            must_be_an_integer(check[:high_flap_threshold]) ||
+              invalid(check, "check high flap threshold must be an integer")
+          end
+        end
+
+        # Validate a Sensu check definition.
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check(check)
+          must_be_a_string(check[:name]) ||
+            invalid(check, "check name must be a string")
+          must_match_regex(/^[\w\.-]+$/, check[:name]) ||
+            invalid(check, "check name cannot contain spaces or special characters")
+          must_be_a_string(check[:command]) ||
+            invalid(check, "check command must be a string")
+          must_be_a_numeric_if_set(check[:timeout]) ||
+            invalid(check, "check timeout must be numeric")
+          validate_check_scheduling(check)
+          validate_check_handling(check)
+          validate_check_flap_detection(check)
+          if check[:subdue]
+            validate_subdue(check)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/client.rb

@@ -0,0 +1,113 @@
+module Sensu
+  module Settings
+    module Validators
+      module Client
+        # Validate client subscriptions.
+        # Validates: subscriptions
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_subscriptions(client)
+          if is_an_array?(client[:subscriptions])
+            items_must_be_strings(client[:subscriptions]) ||
+              invalid(client, "client subscriptions must each be a string")
+          else
+            invalid(client, "client subscriptions must be an array")
+          end
+        end
+
+        # Validate client socket.
+        # Validates: socket (bind, port)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_socket(client)
+          must_be_a_hash_if_set(client[:socket]) ||
+            invalid(client, "client socket must be a hash")
+          if is_a_hash?(client[:socket])
+            must_be_a_string_if_set(client[:socket][:bind]) ||
+              invalid(client, "client socket bind must be a string")
+            must_be_an_integer_if_set(client[:socket][:port]) ||
+              invalid(client, "client socket port must be an integer")
+          end
+        end
+
+        # Validate client keepalive handlers.
+        # Validates: keepalive (handler, handlers)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_keepalive_handlers(client)
+          must_be_a_string_if_set(client[:keepalive][:handler]) ||
+            invalid(client, "client keepalive handler must be a string")
+          must_be_an_array_if_set(client[:keepalive][:handlers]) ||
+            invalid(client, "client keepalive handlers must be an array")
+          if is_an_array?(client[:keepalive][:handlers])
+            items_must_be_strings(client[:keepalive][:handlers]) ||
+              invalid(client, "client keepalive handlers must each be a string")
+          end
+        end
+
+        # Validate client keepalive thresholds.
+        # Validates: keepalive (thresholds)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_keepalive_thresholds(client)
+          thresholds = client[:keepalive][:thresholds]
+          must_be_a_hash_if_set(thresholds) ||
+            invalid(client, "client keepalive thresholds must be a hash")
+          if is_a_hash?(thresholds)
+            must_be_an_integer_if_set(thresholds[:warning]) ||
+              invalid(client, "client keepalive warning threshold must be an integer")
+            must_be_an_integer_if_set(thresholds[:critical]) ||
+              invalid(client, "client keepalive critical threshold must be an integer")
+          end
+        end
+
+        # Validate client keepalive.
+        # Validates: keepalive
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_keepalive(client)
+          must_be_a_hash_if_set(client[:keepalive]) ||
+            invalid(client, "client keepalive must be a hash")
+          if is_a_hash?(client[:keepalive])
+            validate_client_keepalive_handlers(client)
+            validate_client_keepalive_thresholds(client)
+          end
+        end
+
+        # Validate client redact.
+        # Validates: redact
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_redact(client)
+          must_be_an_array_if_set(client[:redact]) ||
+            invalid(client, "client redact must be an array")
+          if is_an_array?(client[:redact])
+            items_must_be_strings(client[:redact]) ||
+              invalid(client, "client redact keys must each be a string")
+          end
+        end
+
+        # Validate a Sensu client definition.
+        # Validates: name, address
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client(client)
+          must_be_a_hash(client) ||
+            invalid(client, "client must be a hash")
+          if is_a_hash?(client)
+            must_be_a_string(client[:name]) ||
+              invalid(client, "client name must be a string")
+            must_match_regex(/^[\w\.-]+$/, client[:name]) ||
+              invalid(client, "client name cannot contain spaces or special characters")
+            must_be_a_string(client[:address]) ||
+              invalid(client, "client address must be a string")
+            validate_client_subscriptions(client)
+            validate_client_socket(client)
+            validate_client_keepalive(client)
+            validate_client_redact(client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/filter.rb

@@ -0,0 +1,18 @@
+module Sensu
+  module Settings
+    module Validators
+      module Filter
+        # Validate a Sensu filter definition.
+        # Validates: attributes, negate
+        #
+        # @param filter [Hash] sensu filter definition.
+        def validate_filter(filter)
+          must_be_boolean_if_set(filter[:negate]) ||
+            invalid(filter, "filter negate must be boolean")
+          must_be_a_hash(filter[:attributes]) ||
+            invalid(filter, "filter attributes must be a hash")
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/handler.rb

@@ -0,0 +1,133 @@
+module Sensu
+  module Settings
+    module Validators
+      module Handler
+        # Validate pipe handler.
+        # Validates: command
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_pipe_handler(handler)
+          must_be_a_string(handler[:command]) ||
+            invalid(handler, "handler command must be a string")
+        end
+
+        # Validate socket (tcp/udp) handler.
+        # Validates: socket (host, port)
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_socket_handler(handler)
+          socket = handler[:socket]
+          if is_a_hash?(socket)
+            must_be_a_string(socket[:host]) ||
+              invalid(handler, "handler host must be a string")
+            must_be_an_integer(socket[:port]) ||
+              invalid(handler, "handler port must be an integer")
+          else
+            invalid(handler, "handler socket must be a hash")
+          end
+        end
+
+        # Validate transport handler.
+        # Validates: pipe (type, name, options)
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_transport_handler(handler)
+          pipe = handler[:pipe]
+          if is_a_hash?(pipe)
+            must_be_a_string(pipe[:type]) ||
+              invalid(handler, "handler transport pipe type must be a string")
+            must_be_either(%w[direct fanout topic], pipe[:type]) ||
+              invalid(handler, "handler transport pipe type is invalid")
+            must_be_a_string(pipe[:name]) ||
+              invalid(handler, "handler transport pipe name must be a string")
+            must_be_a_hash_if_set(pipe[:options]) ||
+              invalid(handler, "handler transport pipe options must be a hash")
+          else
+            invalid(handler, "handler transport pipe must be a hash")
+          end
+        end
+
+        # Validate set handler.
+        # Validates: handlers
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_set_handler(handler)
+          if is_an_array?(handler[:handlers])
+            items_must_be_strings(handler[:handlers]) ||
+              invalid(handler, "handler set handlers must each be a string")
+          else
+            invalid(handler, "handler set handlers must be an array")
+          end
+        end
+
+        # Validate handler type.
+        # Validates: type
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_handler_type(handler)
+          must_be_a_string(handler[:type]) ||
+            invalid(handler, "handler type must be a string")
+          case handler[:type]
+          when "pipe"
+            validate_pipe_handler(handler)
+          when "tcp", "udp"
+            validate_socket_handler(handler)
+          when "transport"
+            validate_transport_handler(handler)
+          when "set"
+            validate_set_handler(handler)
+          else
+            invalid(handler, "unknown handler type")
+          end
+        end
+
+        # Validate handler filtering.
+        # Validates: filter, filters
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_handler_filtering(handler)
+          must_be_an_array_if_set(handler[:filters]) ||
+            invalid(handler, "handler filters must be an array")
+          if is_an_array?(handler[:filters])
+            items_must_be_strings(handler[:filters]) ||
+              invalid(handler, "handler filters items must be strings")
+          end
+          must_be_a_string_if_set(handler[:filter]) ||
+            invalid(handler, "handler filter must be a string")
+        end
+
+        # Validate handler severities.
+        # Validates: severities
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_handler_severities(handler)
+          must_be_an_array_if_set(handler[:severities]) ||
+            invalid(handler, "handler severities must be an array")
+          if is_an_array?(handler[:severities])
+            must_be_either(%w[ok warning critical unknown], handler[:severities]) ||
+              invalid(handler, "handler severities are invalid")
+          end
+        end
+
+        # Validate a Sensu handler definition.
+        # Validates: timeout, mutator, handle_flapping
+        #
+        # @param handler [Hash] sensu handler definition.
+        def validate_handler(handler)
+          validate_handler_type(handler)
+          validate_handler_filtering(handler)
+          validate_handler_severities(handler)
+          must_be_a_numeric_if_set(handler[:timeout]) ||
+            invalid(handler, "handler timeout must be numeric")
+          must_be_a_string_if_set(handler[:mutator]) ||
+            invalid(handler, "handler mutator must be a string")
+          must_be_boolean_if_set(handler[:handle_flapping]) ||
+            invalid(handler, "handler handle_flapping must be boolean")
+          if handler[:subdue]
+            validate_subdue(handler)
+          end
+        end
+      end
+    end
+  end
+end