portertech-sensu-settings 10.18.0

data/lib/sensu/settings/rules.rb

@@ -0,0 +1,166 @@
+module Sensu
+  module Settings
+    module Rules
+      # Check that a value is a hash.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_hash(value)
+        value.is_a?(Hash)
+      end
+      alias_method :is_a_hash?, :must_be_a_hash
+
+      # Check that a value is a hash, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_hash_if_set(value)
+        value.nil? ? true : must_be_a_hash(value)
+      end
+
+      # Check that a value is an array.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_array(value)
+        value.is_a?(Array)
+      end
+      alias_method :is_an_array?, :must_be_an_array
+
+      # Check that a value is an array, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_array_if_set(value)
+        value.nil? ? true : must_be_an_array(value)
+      end
+
+      # Check that a value is a string.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_string(value)
+        value.is_a?(String)
+      end
+      alias_method :is_a_string?, :must_be_a_string
+
+      # Check that a value is a string, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_string_if_set(value)
+        value.nil? ? true : must_be_a_string(value)
+      end
+
+      # Check that a value is an integer.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_integer(value)
+        value.is_a?(Integer)
+      end
+      alias_method :is_an_integer?, :must_be_an_integer
+
+      # Check that a value is an integer, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_integer_if_set(value)
+        value.nil? ? true : must_be_an_integer(value)
+      end
+
+      # Check that a value is numeric.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_numeric(value)
+        value.is_a?(Numeric)
+      end
+
+      # Check that a value is numeric, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_numeric_if_set(value)
+        value.nil? ? true : must_be_a_numeric(value)
+      end
+
+      # Check that a value matches a regular expression.
+      #
+      # @param regex [Regexp] pattern to compare with value.
+      # @param value [Object] to check if matches pattern.
+      # @return [TrueClass, FalseClass]
+      def must_match_regex(regex, value)
+        value.is_a?(String) && (value =~ regex) == 0
+      end
+
+      # Check if a value is boolean.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_boolean(value)
+        !!value == value
+      end
+
+      # Check if a value is boolean, if set (no nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_boolean_if_set(value)
+        value.nil? ? true : must_be_boolean(value)
+      end
+
+      # Check that value items are all strings and not empty.
+      #
+      # @param value [Array] with items to check.
+      # @param regex [Regexp] to validate string items with.
+      # @return [TrueClass, FalseClass]
+      def items_must_be_strings(value, regex=nil)
+        value.all? do |item|
+          item.is_a?(String) && !item.empty? &&
+            (regex.nil? || item =~ regex)
+        end
+      end
+
+      # Check if either of the values are set (not nil).
+      #
+      # @param values [Array<Object>] to check if not nil.
+      # @return [TrueClass, FalseClass]
+      def either_are_set?(*values)
+        values.any? do |value|
+          !value.nil?
+        end
+      end
+
+      # Check if values are valid times (can be parsed).
+      #
+      # @param values [Array<Object>] to check if valid time.
+      # @return [TrueClass, FalseClass]
+      def must_be_time(*values)
+        values.all? do |value|
+          Time.parse(value) rescue false
+        end
+      end
+
+      # Check if values are allowed.
+      #
+      # @param allowed [Array<Object>] allowed values.
+      # @param values [Array<Object>] to check if allowed.
+      # @return [TrueClass, FalseClass]
+      def must_be_either(allowed, *values)
+        values.flatten.all? do |value|
+          allowed.include?(value)
+        end
+      end
+
+      # Check if values are allowed, if set (not nil).
+      #
+      # @param allowed [Array<Object>] allowed values.
+      # @param values [Array<Object>] to check if allowed.
+      # @return [TrueClass, FalseClass]
+      def must_be_either_if_set(allowed, *values)
+        values[0].nil? ? true : must_be_either(allowed, values)
+      end
+    end
+  end
+end

data/lib/sensu/settings/validator.rb

@@ -0,0 +1,88 @@
+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_sensu(settings[:sensu])
+        validate_transport(settings[:transport])
+        validate_categories(settings)
+        case service
+        when "server"
+          validate_tessen(settings[:tessen])
+        when "client"
+          validate_client(settings[:client])
+        when "api"
+          validate_api(settings[:api])
+        when "rspec"
+          validate_client(settings[:client])
+          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. This method also validates each object type,
+      # ensuring that they are hashes.
+      #
+      # @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|
+              if details.is_a?(Hash)
+                send(validate_method, details.merge(:name => name.to_s))
+              else
+                object_type = category[0..-2]
+                invalid(details, "#{object_type} must be a hash")
+              end
+            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/api.rb

@@ -0,0 +1,65 @@
+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 API endpoints.
+        # Validates: endpoints
+        #
+        # @param api [Hash] sensu api definition.
+        def validate_api_endpoints(api)
+          if is_an_array?(api[:endpoints])
+            api[:endpoints].each do |endpoint|
+              if is_a_hash?(endpoint)
+                if endpoint[:url]
+                  must_be_a_string(endpoint[:url]) ||
+                    invalid(api, "api endpoint url must be a string")
+                else
+                  must_be_a_string(endpoint[:host]) ||
+                    invalid(api, "api endpoint host must be a string")
+                  must_be_an_integer(endpoint[:port]) ||
+                    invalid(api, "api endpoint port must be an integer")
+                  must_be_boolean_if_set(endpoint[:ssl]) ||
+                    invalid(api, "api endpoint ssl must be a boolean")
+                end
+              else
+                invalid(api, "api endpoints must each be a hash")
+              end
+            end
+          else
+            invalid(api, "api endpoints must be an array")
+          end
+        end
+
+        # Validate a Sensu API definition.
+        # Validates: port, bind
+        #
+        # @param api [Hash] sensu api definition.
+        def validate_api(api)
+          must_be_a_hash_if_set(api) ||
+            invalid(api, "api must be a hash")
+          if is_a_hash?(api)
+            must_be_an_integer_if_set(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)
+            validate_api_endpoints(api) if api[:endpoints]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,253 @@
+require "parse-cron"
+
+module Sensu
+  module Settings
+    module Validators
+      module Check
+        # Validate check name.
+        # Validates: name
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_name(check)
+          must_be_a_string(check[:name]) ||
+            invalid(check, "check name must be a string")
+          must_match_regex(/\A[\w\.-]+\z/, check[:name]) ||
+            invalid(check, "check name cannot contain spaces or special characters")
+        end
+
+        # Validate check execution.
+        # Validates: command, extension, timeout
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_execution(check)
+          must_be_a_string_if_set(check[:command]) ||
+            invalid(check, "check command must be a string")
+          must_be_a_string_if_set(check[:extension]) ||
+            invalid(check, "check extension must be a string")
+          (!check[:command].nil? ^ !check[:extension].nil?) ||
+            invalid(check, "either check command or extension must be set")
+          must_be_a_numeric_if_set(check[:timeout]) ||
+            invalid(check, "check timeout must be numeric")
+          must_be_boolean_if_set(check[:stdin]) ||
+            invalid(check, "check stdin must be boolean")
+        end
+
+        # Validate check source.
+        # Validates: source
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_source(check)
+          if is_a_string?(check[:source])
+            must_match_regex(/\A[\w\.-]*([:]{3}[\w\|\.-]+[:]{3}[\w\.-]*|[\w\.-]+)\z/, check[:source]) ||
+              invalid(check, "check source cannot contain spaces, special characters, or invalid tokens")
+          else
+            invalid(check, "check source must be a string")
+          end
+        end
+
+        # Validate check cron.
+        # Validates: cron
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_cron(check)
+          must_be_a_string(check[:cron]) ||
+            invalid(check, "check cron must be a string")
+          begin
+            cron_parser = CronParser.new(check[:cron])
+            cron_parser.next(Time.now)
+          rescue ArgumentError
+            invalid(check, "check cron string must use the cron syntax")
+          end
+        end
+
+        # Validate check scheduling.
+        # Validates: publish, 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
+            if check[:cron]
+              validate_check_cron(check)
+            else
+              (must_be_an_integer(check[:interval]) && check[:interval] > 0) ||
+                invalid(check, "check interval must be an integer greater than 0")
+            end
+          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 proxy requests.
+        # Validates: proxy_requests (client_attributes, splay, splay_coverage)
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_proxy_requests(check)
+          if is_a_hash?(check[:proxy_requests])
+            proxy_requests = check[:proxy_requests]
+            must_be_a_hash(proxy_requests[:client_attributes]) ||
+              invalid(check, "check proxy_requests client_attributes must be a hash")
+            must_be_boolean_if_set(proxy_requests[:splay]) ||
+              invalid(check, "check proxy_requests splay must be boolean")
+            if proxy_requests[:splay_coverage]
+              (must_be_an_integer(proxy_requests[:splay_coverage]) &&
+                proxy_requests[:splay_coverage] > 0 &&
+                proxy_requests[:splay_coverage] < 100) ||
+                invalid(check, "check proxy_requests splay_coverage must be an integer greater than 0 and less than 100")
+            end
+          else
+            invalid(check, "check proxy_requests must be a hash")
+          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 ttl.
+        # Validates: ttl, ttl_status
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_ttl(check)
+          if is_an_integer?(check[:ttl])
+            check[:ttl] > 0 ||
+              invalid(check, "check ttl must be greater than 0")
+          else
+            invalid(check, "check ttl must be an integer")
+          end
+          must_be_an_integer_if_set(check[:ttl_status]) ||
+            invalid(check, "check ttl_status must be an integer")
+        end
+
+        # Validate check aggregate.
+        # Validates: aggregate
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_aggregate(check)
+          if check[:aggregates]
+            if is_an_array?(check[:aggregates])
+              items_must_be_strings(check[:aggregates], /\A[\w\.:|-]+\z/) ||
+                invalid(check, "check aggregates items must be strings without spaces or special characters")
+            else
+              invalid(check, "check aggregates must be an array")
+            end
+          end
+          if check[:aggregate]
+            if is_a_string?(check[:aggregate])
+              must_match_regex(/\A[\w\.:|-]+\z/, check[:aggregate]) ||
+                invalid(check, "check aggregate cannot contain spaces or special characters")
+            else
+              must_be_boolean(check[:aggregate]) ||
+                invalid(check, "check aggregate must be a string (name) or boolean")
+            end
+          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 check hook execution.
+        # Validates: command, timeout
+        #
+        # @param check [Hash] sensu check definition.
+        # @param hook [Hash] sensu check hook definition.
+        def validate_check_hook_execution(check, hook)
+          must_be_a_string(hook[:command]) ||
+            invalid(check, "check hook command must be a string")
+          must_be_a_numeric_if_set(hook[:timeout]) ||
+            invalid(check, "check hook timeout must be numeric")
+          must_be_boolean_if_set(hook[:stdin]) ||
+            invalid(check, "check hook stdin must be boolean")
+        end
+
+        # Validate check hooks.
+        # Validates: hooks
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_hooks(check)
+          if check[:hooks].is_a?(Hash)
+            check[:hooks].each do |key, hook|
+              must_be_either(%w[ok warning critical unknown], key.to_s) ||
+                (0..255).map {|i| i.to_s}.include?(key.to_s) ||
+                key.to_s == "non-zero" ||
+                invalid(check, "check hook key must be a severity, status, or 'non-zero'")
+              validate_check_hook_execution(check, hook)
+            end
+          else
+            invalid(check, "check hooks must be a hash")
+          end
+        end
+
+        # Validate check truncate output.
+        # Validates: truncate_output, truncate_output_length
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_truncate_output(check)
+          must_be_boolean_if_set(check[:truncate_output]) ||
+            invalid(check, "check truncate_output must be boolean")
+          if check[:truncate_output_length]
+            (must_be_an_integer(check[:truncate_output_length]) &&
+             check[:truncate_output_length] > 0) ||
+              invalid(check, "check truncate_output_length must be an integer greater than 0")
+          end
+        end
+
+        # Validate check subdue.
+        # Validates: subdue
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check_subdue(check)
+          validate_time_windows(check, "check", :subdue)
+        end
+
+        # Validate a Sensu check definition.
+        #
+        # @param check [Hash] sensu check definition.
+        def validate_check(check)
+          validate_check_name(check)
+          validate_check_execution(check)
+          validate_check_source(check) if check[:source]
+          validate_check_scheduling(check)
+          validate_check_proxy_requests(check) if check[:proxy_requests]
+          validate_check_handling(check)
+          validate_check_ttl(check) if check[:ttl]
+          validate_check_aggregate(check)
+          validate_check_flap_detection(check)
+          validate_check_hooks(check) if check[:hooks]
+          validate_check_truncate_output(check)
+          validate_check_subdue(check) if check[:subdue]
+        end
+      end
+    end
+  end
+end