portertech-sensu-settings 10.18.0

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

@@ -0,0 +1,238 @@
+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 non empty string")
+          else
+            invalid(client, "client subscriptions must be an array")
+          end
+        end
+
+        # Validate client safe mode.
+        # Validates: safe_mode
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_safe_mode(client)
+          must_be_boolean_if_set(client[:safe_mode]) ||
+            invalid(client, "client safe_mode must be boolean")
+        end
+
+        # Validate client socket.
+        # Validates: socket (enabled, 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_boolean_if_set(client[:socket][:enabled]) ||
+              invalid(client, "client socket enabled must be a boolean")
+            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 http_socket.
+        # Validates: http_socket (enabled, bind, port, user, password, protect_all_endpoints)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_http_socket(client)
+          http_socket = client[:http_socket]
+          must_be_a_hash_if_set(http_socket) ||
+            invalid(client, "client http_socket must be a hash")
+          if is_a_hash?(http_socket)
+            must_be_boolean_if_set(http_socket[:enabled]) ||
+              invalid(client, "client http_socket enabled must be boolean")
+            must_be_a_string_if_set(http_socket[:bind]) ||
+              invalid(client, "client http_socket bind must be a string")
+            must_be_an_integer_if_set(http_socket[:port]) ||
+              invalid(client, "client http_socket port must be an integer")
+            if either_are_set?(http_socket[:user], http_socket[:password])
+              must_be_a_string(http_socket[:user]) ||
+                invalid(client, "client http_socket user must be a string")
+              must_be_a_string(http_socket[:password]) ||
+                invalid(client, "client http_socket password must be a string")
+            end
+            must_be_boolean_if_set(http_socket[:protect_all_endpoints]) ||
+              invalid(client, "client http_socket protect_all_endpoints must be boolean")
+          end
+        end
+
+        # Validate client keepalives.
+        # Validates: keepalives
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_keepalives(client)
+          must_be_boolean_if_set(client[:keepalives]) ||
+            invalid(client, "client keepalives must be boolean")
+        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)
+            # A client keepalive may include several check attributes.
+            # Validation is necessary, although the validation failure
+            # messages may be a bit confusing.
+            validate_check_source(client[:keepalive]) if client[:keepalive][:source]
+            validate_check_aggregate(client[:keepalive])
+            validate_check_flap_detection(client[:keepalive])
+          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 client signature.
+        # Validates: signature
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_signature(client)
+          must_be_a_string_if_set(client[:signature]) ||
+            invalid(client, "client signature must be a string")
+        end
+
+        # Validate client registration handlers.
+        # Validates: registration (handler, handlers)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_registration_handlers(client)
+          must_be_a_string_if_set(client[:registration][:handler]) ||
+            invalid(client, "client registration handler must be a string")
+          must_be_an_array_if_set(client[:registration][:handlers]) ||
+            invalid(client, "client registration handlers must be an array")
+          if is_an_array?(client[:registration][:handlers])
+            items_must_be_strings(client[:registration][:handlers]) ||
+              invalid(client, "client registration handlers must each be a string")
+          end
+        end
+
+        # Validate client registration.
+        # Validates: registration
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_registration(client)
+          must_be_a_hash_if_set(client[:registration]) ||
+            invalid(client, "client registration must be a hash")
+          if is_a_hash?(client[:registration])
+            validate_client_registration_handlers(client)
+            must_be_an_integer_if_set(client[:registration][:status]) ||
+              invalid(client, "client registration status must be an integer")
+          end
+        end
+
+        # Validate client deregistration handlers.
+        # Validates: deregistration (handler, handlers)
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_deregistration_handlers(client)
+          must_be_a_string_if_set(client[:deregistration][:handler]) ||
+            invalid(client, "client deregistration handler must be a string")
+          must_be_an_array_if_set(client[:deregistration][:handlers]) ||
+            invalid(client, "client deregistration handlers must be an array")
+          if is_an_array?(client[:deregistration][:handlers])
+            items_must_be_strings(client[:deregistration][:handlers]) ||
+              invalid(client, "client deregistration handlers must each be a string")
+          end
+        end
+
+        # Validate client deregistration.
+        # Validates: deregistration
+        #
+        # @param client [Hash] sensu client definition.
+        def validate_client_deregistration(client)
+          must_be_a_hash_if_set(client[:deregistration]) ||
+            invalid(client, "client deregistration must be a hash")
+          if is_a_hash?(client[:deregistration])
+            validate_client_deregistration_handlers(client)
+            must_be_an_integer_if_set(client[:deregistration][:status]) ||
+              invalid(client, "client deregistration status must be an integer")
+          end
+        end
+
+        # Validate a Sensu client definition.
+        # Validates: name, address, safe_mode
+        #
+        # @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(/\A[\w\.-]+\z/, 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_safe_mode(client)
+            validate_client_subscriptions(client)
+            validate_client_socket(client)
+            validate_client_http_socket(client)
+            validate_client_keepalives(client)
+            validate_client_keepalive(client)
+            validate_client_redact(client)
+            validate_client_signature(client)
+            validate_client_registration(client)
+            validate_client_deregistration(client)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Sensu
+  module Settings
+    module Validators
+      module Extension
+        # Validate a Sensu extension definition.
+        # Validates: gem, version
+        #
+        # @param filter [Hash] sensu extension definition.
+        def validate_extension(extension)
+          must_be_a_string_if_set(extension[:gem]) ||
+            invalid(extension, "extension gem must be a string")
+          must_be_a_string_if_set(extension[:version]) ||
+            invalid(extension, "extension version must be a string")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Sensu
+  module Settings
+    module Validators
+      module Filter
+        # Validate filter when.
+        # Validates: when
+        #
+        # @param filter [Hash] sensu filter definition.
+        def validate_filter_when(filter)
+          validate_time_windows(filter, "filter", :when)
+        end
+
+        # 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")
+          validate_filter_when(filter) if filter[:when]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+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, handle_silenced
+        #
+        # @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")
+          must_be_boolean_if_set(handler[:handle_silenced]) ||
+            invalid(handler, "handler handle_silenced must be boolean")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Sensu
+  module Settings
+    module Validators
+      module Mutator
+        # Validate a Sensu mutator definition.
+        # Validates: command, timeout
+        #
+        # @param mutator [Hash] sensu mutator definition.
+        def validate_mutator(mutator)
+          must_be_a_string(mutator[:command]) ||
+            invalid(mutator, "mutator command must be a string")
+          must_be_a_numeric_if_set(mutator[:timeout]) ||
+            invalid(mutator, "mutator timeout must be numeric")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Sensu
+  module Settings
+    module Validators
+      module Sensu
+        # Validate Sensu spawn.
+        # Validates: limit
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu_spawn(sensu)
+          spawn = sensu[:spawn]
+          if is_a_hash?(spawn)
+            if is_an_integer?(spawn[:limit])
+              spawn[:limit] > 0 ||
+                invalid(sensu, "sensu spawn limit must be greater than 0")
+            else
+              invalid(sensu, "sensu spawn limit must be an integer")
+            end
+          else
+            invalid(sensu, "sensu spawn must be a hash")
+          end
+        end
+
+        # Validate Sensu keepalives thresholds.
+        # Validates: warning, critical
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu_keepalives_thresholds(sensu)
+          thresholds = sensu[:keepalives][:thresholds]
+          must_be_a_hash_if_set(thresholds) ||
+            invalid(sensu, "sensu keepalives thresholds must be a hash")
+          if is_a_hash?(thresholds)
+            must_be_an_integer_if_set(thresholds[:warning]) ||
+              invalid(sensu, "sensu keepalives warning threshold must be an integer")
+            must_be_an_integer_if_set(thresholds[:critical]) ||
+              invalid(sensu, "sensu keepalives critical threshold must be an integer")
+          end
+        end
+
+        # Validate Sensu keepalives handlers.
+        # Validates: handler, handlers
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu_keepalives_handlers(sensu)
+          must_be_a_string_if_set(sensu[:keepalives][:handler]) ||
+            invalid(sensu, "sensu keepalives handler must be a string")
+          must_be_an_array_if_set(sensu[:keepalives][:handlers]) ||
+            invalid(sensu, "sensu keepalives handlers must be an array")
+          if is_an_array?(sensu[:keepalives][:handlers])
+            items_must_be_strings(sensu[:keepalives][:handlers]) ||
+              invalid(sensu, "sensu keepalives handlers must each be a string")
+          end
+        end
+
+        # Validate Sensu keepalives.
+        # Validates: thresholds (warning, critical), handler, handlers
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu_keepalives(sensu)
+          if is_a_hash?(sensu[:keepalives])
+            validate_sensu_keepalives_thresholds(sensu)
+            validate_sensu_keepalives_handlers(sensu)
+          else
+            invalid(sensu, "sensu keepalives must be a hash")
+          end
+        end
+
+        # Validate Sensu server.
+        # Validates: server results_pipe, keepalives_pipe
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu_server(sensu)
+          if is_a_hash?(sensu[:server])
+            must_be_a_string_if_set(sensu[:server][:results_pipe]) ||
+              invalid(sensu, "sensu server results_pipe must be a string")
+            must_be_a_string_if_set(sensu[:server][:keepalives_pipe]) ||
+              invalid(sensu, "sensu server keepalives_pipe must be a string")
+            must_be_an_integer_if_set(sensu[:server][:max_message_size]) ||
+              invalid(sensu, "sensu server max_message_size must be an integer")
+          else
+            invalid(sensu, "sensu server must be a hash")
+          end
+        end
+
+        # Validate a Sensu definition.
+        # Validates: spawn, keepalives
+        #
+        # @param sensu [Hash] sensu definition.
+        def validate_sensu(sensu)
+          if is_a_hash?(sensu)
+            validate_sensu_spawn(sensu)
+            validate_sensu_keepalives(sensu)
+            validate_sensu_server(sensu) if sensu[:server]
+            must_be_boolean_if_set(sensu[:global_error_handler]) ||
+              invalid(sensu, "sensu global_error_handler must be boolean")
+          else
+            invalid(sensu, "sensu must be a hash")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Sensu
+  module Settings
+    module Validators
+      module Tessen
+        # Validate a Tessen definition.
+        # Validates: enabled, identity_key
+        #
+        # @param tessen [Hash] tessen definition.
+        def validate_tessen(tessen)
+          must_be_a_hash_if_set(tessen) ||
+            invalid(tessen, "tessen must be a hash")
+          if is_a_hash?(tessen)
+            must_be_boolean_if_set(tessen[:enabled]) ||
+              invalid(tessen, "tessen enabled must be boolean")
+            must_be_a_string_if_set(tessen[:identity_key]) ||
+              invalid(tessen, "tessen identity_key must be a string")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Sensu
+  module Settings
+    module Validators
+      module TimeWindow
+        # Validate time window condition
+        # Validates: begin, end
+        #
+        # @param definition [Hash] sensu definition.
+        # @param scope [String] definition scope to validate.
+        # @param attribute [String] definition attribute to validate.
+        # @param condition [Hash] to have begin and end validated.
+        def validate_time_window_condition(definition, scope, attribute, condition)
+          if is_a_hash?(condition)
+            must_be_time(condition[:begin], condition[:end]) ||
+              invalid(definition, "#{scope} #{attribute} day time window begin and end times must be valid")
+          else
+            invalid(definition, "#{scope} #{attribute} day time window must be a hash")
+          end
+        end
+
+        # Validate time windows days
+        # Validates: days
+        #
+        # @param definition [Hash] sensu definition.
+        # @param scope [String] definition scope to validate.
+        # @param attribute [String] definition attribute to validate.
+        # @param days [String] time window days to validate.
+        def validate_time_windows_days(definition, scope, attribute, days)
+          valid_days = [:all, :sunday, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday]
+          if must_be_either(valid_days, days.keys)
+            days.each do |day, conditions|
+              if is_an_array?(conditions)
+                if !conditions.empty?
+                  conditions.each do |condition|
+                    validate_time_window_condition(definition, scope, attribute, condition)
+                  end
+                else
+                  invalid(definition, "#{scope} #{attribute} days #{day} must include at least one time window")
+                end
+              else
+                invalid(definition, "#{scope} #{attribute} days #{day} must be in an array")
+              end
+            end
+          else
+            invalid(definition, "#{scope} #{attribute} days must be valid days of the week or 'all'")
+          end
+        end
+
+        # Validate time windows
+        # Validates: days
+        #
+        # @param definition [Hash] sensu definition.
+        # @param scope [String] definition scope to validate.
+        # @param attribute [String] definition attribute to validate.
+        def validate_time_windows(definition, scope, attribute)
+          if is_a_hash?(definition[attribute])
+            days = definition[attribute][:days]
+            if is_a_hash?(days)
+              if !days.empty?
+                validate_time_windows_days(definition, scope, attribute, days)
+              else
+                invalid(definition, "#{scope} #{attribute} days must include at least one day of the week or 'all'")
+              end
+            else
+              invalid(definition, "#{scope} #{attribute} days must be a hash")
+            end
+          else
+            invalid(definition, "#{scope} #{attribute} must be a hash")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Sensu
+  module Settings
+    module Validators
+      module Transport
+        # Validate a Sensu transport definition.
+        # Validates: name
+        #
+        # @param transport [Hash] sensu transport definition.
+        def validate_transport(transport)
+          if is_a_hash?(transport)
+            must_be_a_string(transport[:name]) ||
+              invalid(transport, "transport name must be a string")
+            must_be_boolean_if_set(transport[:reconnect_on_error]) ||
+              invalid(transport, "transport reconnect_on_error must be boolean")
+          else
+            invalid(transport, "transport must be a hash")
+          end
+        end
+      end
+    end
+  end
+end