portertech-sensu-settings 10.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,238 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Client
5
+ # Validate client subscriptions.
6
+ # Validates: subscriptions
7
+ #
8
+ # @param client [Hash] sensu client definition.
9
+ def validate_client_subscriptions(client)
10
+ if is_an_array?(client[:subscriptions])
11
+ items_must_be_strings(client[:subscriptions]) ||
12
+ invalid(client, "client subscriptions must each be a non empty string")
13
+ else
14
+ invalid(client, "client subscriptions must be an array")
15
+ end
16
+ end
17
+
18
+ # Validate client safe mode.
19
+ # Validates: safe_mode
20
+ #
21
+ # @param client [Hash] sensu client definition.
22
+ def validate_client_safe_mode(client)
23
+ must_be_boolean_if_set(client[:safe_mode]) ||
24
+ invalid(client, "client safe_mode must be boolean")
25
+ end
26
+
27
+ # Validate client socket.
28
+ # Validates: socket (enabled, bind, port)
29
+ #
30
+ # @param client [Hash] sensu client definition.
31
+ def validate_client_socket(client)
32
+ must_be_a_hash_if_set(client[:socket]) ||
33
+ invalid(client, "client socket must be a hash")
34
+ if is_a_hash?(client[:socket])
35
+ must_be_boolean_if_set(client[:socket][:enabled]) ||
36
+ invalid(client, "client socket enabled must be a boolean")
37
+ must_be_a_string_if_set(client[:socket][:bind]) ||
38
+ invalid(client, "client socket bind must be a string")
39
+ must_be_an_integer_if_set(client[:socket][:port]) ||
40
+ invalid(client, "client socket port must be an integer")
41
+ end
42
+ end
43
+
44
+ # Validate client http_socket.
45
+ # Validates: http_socket (enabled, bind, port, user, password, protect_all_endpoints)
46
+ #
47
+ # @param client [Hash] sensu client definition.
48
+ def validate_client_http_socket(client)
49
+ http_socket = client[:http_socket]
50
+ must_be_a_hash_if_set(http_socket) ||
51
+ invalid(client, "client http_socket must be a hash")
52
+ if is_a_hash?(http_socket)
53
+ must_be_boolean_if_set(http_socket[:enabled]) ||
54
+ invalid(client, "client http_socket enabled must be boolean")
55
+ must_be_a_string_if_set(http_socket[:bind]) ||
56
+ invalid(client, "client http_socket bind must be a string")
57
+ must_be_an_integer_if_set(http_socket[:port]) ||
58
+ invalid(client, "client http_socket port must be an integer")
59
+ if either_are_set?(http_socket[:user], http_socket[:password])
60
+ must_be_a_string(http_socket[:user]) ||
61
+ invalid(client, "client http_socket user must be a string")
62
+ must_be_a_string(http_socket[:password]) ||
63
+ invalid(client, "client http_socket password must be a string")
64
+ end
65
+ must_be_boolean_if_set(http_socket[:protect_all_endpoints]) ||
66
+ invalid(client, "client http_socket protect_all_endpoints must be boolean")
67
+ end
68
+ end
69
+
70
+ # Validate client keepalives.
71
+ # Validates: keepalives
72
+ #
73
+ # @param client [Hash] sensu client definition.
74
+ def validate_client_keepalives(client)
75
+ must_be_boolean_if_set(client[:keepalives]) ||
76
+ invalid(client, "client keepalives must be boolean")
77
+ end
78
+
79
+ # Validate client keepalive handlers.
80
+ # Validates: keepalive (handler, handlers)
81
+ #
82
+ # @param client [Hash] sensu client definition.
83
+ def validate_client_keepalive_handlers(client)
84
+ must_be_a_string_if_set(client[:keepalive][:handler]) ||
85
+ invalid(client, "client keepalive handler must be a string")
86
+ must_be_an_array_if_set(client[:keepalive][:handlers]) ||
87
+ invalid(client, "client keepalive handlers must be an array")
88
+ if is_an_array?(client[:keepalive][:handlers])
89
+ items_must_be_strings(client[:keepalive][:handlers]) ||
90
+ invalid(client, "client keepalive handlers must each be a string")
91
+ end
92
+ end
93
+
94
+ # Validate client keepalive thresholds.
95
+ # Validates: keepalive (thresholds)
96
+ #
97
+ # @param client [Hash] sensu client definition.
98
+ def validate_client_keepalive_thresholds(client)
99
+ thresholds = client[:keepalive][:thresholds]
100
+ must_be_a_hash_if_set(thresholds) ||
101
+ invalid(client, "client keepalive thresholds must be a hash")
102
+ if is_a_hash?(thresholds)
103
+ must_be_an_integer_if_set(thresholds[:warning]) ||
104
+ invalid(client, "client keepalive warning threshold must be an integer")
105
+ must_be_an_integer_if_set(thresholds[:critical]) ||
106
+ invalid(client, "client keepalive critical threshold must be an integer")
107
+ end
108
+ end
109
+
110
+ # Validate client keepalive.
111
+ # Validates: keepalive
112
+ #
113
+ # @param client [Hash] sensu client definition.
114
+ def validate_client_keepalive(client)
115
+ must_be_a_hash_if_set(client[:keepalive]) ||
116
+ invalid(client, "client keepalive must be a hash")
117
+ if is_a_hash?(client[:keepalive])
118
+ validate_client_keepalive_handlers(client)
119
+ validate_client_keepalive_thresholds(client)
120
+ # A client keepalive may include several check attributes.
121
+ # Validation is necessary, although the validation failure
122
+ # messages may be a bit confusing.
123
+ validate_check_source(client[:keepalive]) if client[:keepalive][:source]
124
+ validate_check_aggregate(client[:keepalive])
125
+ validate_check_flap_detection(client[:keepalive])
126
+ end
127
+ end
128
+
129
+ # Validate client redact.
130
+ # Validates: redact
131
+ #
132
+ # @param client [Hash] sensu client definition.
133
+ def validate_client_redact(client)
134
+ must_be_an_array_if_set(client[:redact]) ||
135
+ invalid(client, "client redact must be an array")
136
+ if is_an_array?(client[:redact])
137
+ items_must_be_strings(client[:redact]) ||
138
+ invalid(client, "client redact keys must each be a string")
139
+ end
140
+ end
141
+
142
+ # Validate client signature.
143
+ # Validates: signature
144
+ #
145
+ # @param client [Hash] sensu client definition.
146
+ def validate_client_signature(client)
147
+ must_be_a_string_if_set(client[:signature]) ||
148
+ invalid(client, "client signature must be a string")
149
+ end
150
+
151
+ # Validate client registration handlers.
152
+ # Validates: registration (handler, handlers)
153
+ #
154
+ # @param client [Hash] sensu client definition.
155
+ def validate_client_registration_handlers(client)
156
+ must_be_a_string_if_set(client[:registration][:handler]) ||
157
+ invalid(client, "client registration handler must be a string")
158
+ must_be_an_array_if_set(client[:registration][:handlers]) ||
159
+ invalid(client, "client registration handlers must be an array")
160
+ if is_an_array?(client[:registration][:handlers])
161
+ items_must_be_strings(client[:registration][:handlers]) ||
162
+ invalid(client, "client registration handlers must each be a string")
163
+ end
164
+ end
165
+
166
+ # Validate client registration.
167
+ # Validates: registration
168
+ #
169
+ # @param client [Hash] sensu client definition.
170
+ def validate_client_registration(client)
171
+ must_be_a_hash_if_set(client[:registration]) ||
172
+ invalid(client, "client registration must be a hash")
173
+ if is_a_hash?(client[:registration])
174
+ validate_client_registration_handlers(client)
175
+ must_be_an_integer_if_set(client[:registration][:status]) ||
176
+ invalid(client, "client registration status must be an integer")
177
+ end
178
+ end
179
+
180
+ # Validate client deregistration handlers.
181
+ # Validates: deregistration (handler, handlers)
182
+ #
183
+ # @param client [Hash] sensu client definition.
184
+ def validate_client_deregistration_handlers(client)
185
+ must_be_a_string_if_set(client[:deregistration][:handler]) ||
186
+ invalid(client, "client deregistration handler must be a string")
187
+ must_be_an_array_if_set(client[:deregistration][:handlers]) ||
188
+ invalid(client, "client deregistration handlers must be an array")
189
+ if is_an_array?(client[:deregistration][:handlers])
190
+ items_must_be_strings(client[:deregistration][:handlers]) ||
191
+ invalid(client, "client deregistration handlers must each be a string")
192
+ end
193
+ end
194
+
195
+ # Validate client deregistration.
196
+ # Validates: deregistration
197
+ #
198
+ # @param client [Hash] sensu client definition.
199
+ def validate_client_deregistration(client)
200
+ must_be_a_hash_if_set(client[:deregistration]) ||
201
+ invalid(client, "client deregistration must be a hash")
202
+ if is_a_hash?(client[:deregistration])
203
+ validate_client_deregistration_handlers(client)
204
+ must_be_an_integer_if_set(client[:deregistration][:status]) ||
205
+ invalid(client, "client deregistration status must be an integer")
206
+ end
207
+ end
208
+
209
+ # Validate a Sensu client definition.
210
+ # Validates: name, address, safe_mode
211
+ #
212
+ # @param client [Hash] sensu client definition.
213
+ def validate_client(client)
214
+ must_be_a_hash(client) ||
215
+ invalid(client, "client must be a hash")
216
+ if is_a_hash?(client)
217
+ must_be_a_string(client[:name]) ||
218
+ invalid(client, "client name must be a string")
219
+ must_match_regex(/\A[\w\.-]+\z/, client[:name]) ||
220
+ invalid(client, "client name cannot contain spaces or special characters")
221
+ must_be_a_string(client[:address]) ||
222
+ invalid(client, "client address must be a string")
223
+ validate_client_safe_mode(client)
224
+ validate_client_subscriptions(client)
225
+ validate_client_socket(client)
226
+ validate_client_http_socket(client)
227
+ validate_client_keepalives(client)
228
+ validate_client_keepalive(client)
229
+ validate_client_redact(client)
230
+ validate_client_signature(client)
231
+ validate_client_registration(client)
232
+ validate_client_deregistration(client)
233
+ end
234
+ end
235
+ end
236
+ end
237
+ end
238
+ end
@@ -0,0 +1,18 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Extension
5
+ # Validate a Sensu extension definition.
6
+ # Validates: gem, version
7
+ #
8
+ # @param filter [Hash] sensu extension definition.
9
+ def validate_extension(extension)
10
+ must_be_a_string_if_set(extension[:gem]) ||
11
+ invalid(extension, "extension gem must be a string")
12
+ must_be_a_string_if_set(extension[:version]) ||
13
+ invalid(extension, "extension version must be a string")
14
+ end
15
+ end
16
+ end
17
+ end
18
+ end
@@ -0,0 +1,27 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Filter
5
+ # Validate filter when.
6
+ # Validates: when
7
+ #
8
+ # @param filter [Hash] sensu filter definition.
9
+ def validate_filter_when(filter)
10
+ validate_time_windows(filter, "filter", :when)
11
+ end
12
+
13
+ # Validate a Sensu filter definition.
14
+ # Validates: attributes, negate
15
+ #
16
+ # @param filter [Hash] sensu filter definition.
17
+ def validate_filter(filter)
18
+ must_be_boolean_if_set(filter[:negate]) ||
19
+ invalid(filter, "filter negate must be boolean")
20
+ must_be_a_hash(filter[:attributes]) ||
21
+ invalid(filter, "filter attributes must be a hash")
22
+ validate_filter_when(filter) if filter[:when]
23
+ end
24
+ end
25
+ end
26
+ end
27
+ end
@@ -0,0 +1,132 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Handler
5
+ # Validate pipe handler.
6
+ # Validates: command
7
+ #
8
+ # @param handler [Hash] sensu handler definition.
9
+ def validate_pipe_handler(handler)
10
+ must_be_a_string(handler[:command]) ||
11
+ invalid(handler, "handler command must be a string")
12
+ end
13
+
14
+ # Validate socket (tcp/udp) handler.
15
+ # Validates: socket (host, port)
16
+ #
17
+ # @param handler [Hash] sensu handler definition.
18
+ def validate_socket_handler(handler)
19
+ socket = handler[:socket]
20
+ if is_a_hash?(socket)
21
+ must_be_a_string(socket[:host]) ||
22
+ invalid(handler, "handler host must be a string")
23
+ must_be_an_integer(socket[:port]) ||
24
+ invalid(handler, "handler port must be an integer")
25
+ else
26
+ invalid(handler, "handler socket must be a hash")
27
+ end
28
+ end
29
+
30
+ # Validate transport handler.
31
+ # Validates: pipe (type, name, options)
32
+ #
33
+ # @param handler [Hash] sensu handler definition.
34
+ def validate_transport_handler(handler)
35
+ pipe = handler[:pipe]
36
+ if is_a_hash?(pipe)
37
+ must_be_a_string(pipe[:type]) ||
38
+ invalid(handler, "handler transport pipe type must be a string")
39
+ must_be_either(%w[direct fanout topic], pipe[:type]) ||
40
+ invalid(handler, "handler transport pipe type is invalid")
41
+ must_be_a_string(pipe[:name]) ||
42
+ invalid(handler, "handler transport pipe name must be a string")
43
+ must_be_a_hash_if_set(pipe[:options]) ||
44
+ invalid(handler, "handler transport pipe options must be a hash")
45
+ else
46
+ invalid(handler, "handler transport pipe must be a hash")
47
+ end
48
+ end
49
+
50
+ # Validate set handler.
51
+ # Validates: handlers
52
+ #
53
+ # @param handler [Hash] sensu handler definition.
54
+ def validate_set_handler(handler)
55
+ if is_an_array?(handler[:handlers])
56
+ items_must_be_strings(handler[:handlers]) ||
57
+ invalid(handler, "handler set handlers must each be a string")
58
+ else
59
+ invalid(handler, "handler set handlers must be an array")
60
+ end
61
+ end
62
+
63
+ # Validate handler type.
64
+ # Validates: type
65
+ #
66
+ # @param handler [Hash] sensu handler definition.
67
+ def validate_handler_type(handler)
68
+ must_be_a_string(handler[:type]) ||
69
+ invalid(handler, "handler type must be a string")
70
+ case handler[:type]
71
+ when "pipe"
72
+ validate_pipe_handler(handler)
73
+ when "tcp", "udp"
74
+ validate_socket_handler(handler)
75
+ when "transport"
76
+ validate_transport_handler(handler)
77
+ when "set"
78
+ validate_set_handler(handler)
79
+ else
80
+ invalid(handler, "unknown handler type")
81
+ end
82
+ end
83
+
84
+ # Validate handler filtering.
85
+ # Validates: filter, filters
86
+ #
87
+ # @param handler [Hash] sensu handler definition.
88
+ def validate_handler_filtering(handler)
89
+ must_be_an_array_if_set(handler[:filters]) ||
90
+ invalid(handler, "handler filters must be an array")
91
+ if is_an_array?(handler[:filters])
92
+ items_must_be_strings(handler[:filters]) ||
93
+ invalid(handler, "handler filters items must be strings")
94
+ end
95
+ must_be_a_string_if_set(handler[:filter]) ||
96
+ invalid(handler, "handler filter must be a string")
97
+ end
98
+
99
+ # Validate handler severities.
100
+ # Validates: severities
101
+ #
102
+ # @param handler [Hash] sensu handler definition.
103
+ def validate_handler_severities(handler)
104
+ must_be_an_array_if_set(handler[:severities]) ||
105
+ invalid(handler, "handler severities must be an array")
106
+ if is_an_array?(handler[:severities])
107
+ must_be_either(%w[ok warning critical unknown], handler[:severities]) ||
108
+ invalid(handler, "handler severities are invalid")
109
+ end
110
+ end
111
+
112
+ # Validate a Sensu handler definition.
113
+ # Validates: timeout, mutator, handle_flapping, handle_silenced
114
+ #
115
+ # @param handler [Hash] sensu handler definition.
116
+ def validate_handler(handler)
117
+ validate_handler_type(handler)
118
+ validate_handler_filtering(handler)
119
+ validate_handler_severities(handler)
120
+ must_be_a_numeric_if_set(handler[:timeout]) ||
121
+ invalid(handler, "handler timeout must be numeric")
122
+ must_be_a_string_if_set(handler[:mutator]) ||
123
+ invalid(handler, "handler mutator must be a string")
124
+ must_be_boolean_if_set(handler[:handle_flapping]) ||
125
+ invalid(handler, "handler handle_flapping must be boolean")
126
+ must_be_boolean_if_set(handler[:handle_silenced]) ||
127
+ invalid(handler, "handler handle_silenced must be boolean")
128
+ end
129
+ end
130
+ end
131
+ end
132
+ end
@@ -0,0 +1,18 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Mutator
5
+ # Validate a Sensu mutator definition.
6
+ # Validates: command, timeout
7
+ #
8
+ # @param mutator [Hash] sensu mutator definition.
9
+ def validate_mutator(mutator)
10
+ must_be_a_string(mutator[:command]) ||
11
+ invalid(mutator, "mutator command must be a string")
12
+ must_be_a_numeric_if_set(mutator[:timeout]) ||
13
+ invalid(mutator, "mutator timeout must be numeric")
14
+ end
15
+ end
16
+ end
17
+ end
18
+ end
@@ -0,0 +1,102 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Sensu
5
+ # Validate Sensu spawn.
6
+ # Validates: limit
7
+ #
8
+ # @param sensu [Hash] sensu definition.
9
+ def validate_sensu_spawn(sensu)
10
+ spawn = sensu[:spawn]
11
+ if is_a_hash?(spawn)
12
+ if is_an_integer?(spawn[:limit])
13
+ spawn[:limit] > 0 ||
14
+ invalid(sensu, "sensu spawn limit must be greater than 0")
15
+ else
16
+ invalid(sensu, "sensu spawn limit must be an integer")
17
+ end
18
+ else
19
+ invalid(sensu, "sensu spawn must be a hash")
20
+ end
21
+ end
22
+
23
+ # Validate Sensu keepalives thresholds.
24
+ # Validates: warning, critical
25
+ #
26
+ # @param sensu [Hash] sensu definition.
27
+ def validate_sensu_keepalives_thresholds(sensu)
28
+ thresholds = sensu[:keepalives][:thresholds]
29
+ must_be_a_hash_if_set(thresholds) ||
30
+ invalid(sensu, "sensu keepalives thresholds must be a hash")
31
+ if is_a_hash?(thresholds)
32
+ must_be_an_integer_if_set(thresholds[:warning]) ||
33
+ invalid(sensu, "sensu keepalives warning threshold must be an integer")
34
+ must_be_an_integer_if_set(thresholds[:critical]) ||
35
+ invalid(sensu, "sensu keepalives critical threshold must be an integer")
36
+ end
37
+ end
38
+
39
+ # Validate Sensu keepalives handlers.
40
+ # Validates: handler, handlers
41
+ #
42
+ # @param sensu [Hash] sensu definition.
43
+ def validate_sensu_keepalives_handlers(sensu)
44
+ must_be_a_string_if_set(sensu[:keepalives][:handler]) ||
45
+ invalid(sensu, "sensu keepalives handler must be a string")
46
+ must_be_an_array_if_set(sensu[:keepalives][:handlers]) ||
47
+ invalid(sensu, "sensu keepalives handlers must be an array")
48
+ if is_an_array?(sensu[:keepalives][:handlers])
49
+ items_must_be_strings(sensu[:keepalives][:handlers]) ||
50
+ invalid(sensu, "sensu keepalives handlers must each be a string")
51
+ end
52
+ end
53
+
54
+ # Validate Sensu keepalives.
55
+ # Validates: thresholds (warning, critical), handler, handlers
56
+ #
57
+ # @param sensu [Hash] sensu definition.
58
+ def validate_sensu_keepalives(sensu)
59
+ if is_a_hash?(sensu[:keepalives])
60
+ validate_sensu_keepalives_thresholds(sensu)
61
+ validate_sensu_keepalives_handlers(sensu)
62
+ else
63
+ invalid(sensu, "sensu keepalives must be a hash")
64
+ end
65
+ end
66
+
67
+ # Validate Sensu server.
68
+ # Validates: server results_pipe, keepalives_pipe
69
+ #
70
+ # @param sensu [Hash] sensu definition.
71
+ def validate_sensu_server(sensu)
72
+ if is_a_hash?(sensu[:server])
73
+ must_be_a_string_if_set(sensu[:server][:results_pipe]) ||
74
+ invalid(sensu, "sensu server results_pipe must be a string")
75
+ must_be_a_string_if_set(sensu[:server][:keepalives_pipe]) ||
76
+ invalid(sensu, "sensu server keepalives_pipe must be a string")
77
+ must_be_an_integer_if_set(sensu[:server][:max_message_size]) ||
78
+ invalid(sensu, "sensu server max_message_size must be an integer")
79
+ else
80
+ invalid(sensu, "sensu server must be a hash")
81
+ end
82
+ end
83
+
84
+ # Validate a Sensu definition.
85
+ # Validates: spawn, keepalives
86
+ #
87
+ # @param sensu [Hash] sensu definition.
88
+ def validate_sensu(sensu)
89
+ if is_a_hash?(sensu)
90
+ validate_sensu_spawn(sensu)
91
+ validate_sensu_keepalives(sensu)
92
+ validate_sensu_server(sensu) if sensu[:server]
93
+ must_be_boolean_if_set(sensu[:global_error_handler]) ||
94
+ invalid(sensu, "sensu global_error_handler must be boolean")
95
+ else
96
+ invalid(sensu, "sensu must be a hash")
97
+ end
98
+ end
99
+ end
100
+ end
101
+ end
102
+ end
@@ -0,0 +1,22 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Tessen
5
+ # Validate a Tessen definition.
6
+ # Validates: enabled, identity_key
7
+ #
8
+ # @param tessen [Hash] tessen definition.
9
+ def validate_tessen(tessen)
10
+ must_be_a_hash_if_set(tessen) ||
11
+ invalid(tessen, "tessen must be a hash")
12
+ if is_a_hash?(tessen)
13
+ must_be_boolean_if_set(tessen[:enabled]) ||
14
+ invalid(tessen, "tessen enabled must be boolean")
15
+ must_be_a_string_if_set(tessen[:identity_key]) ||
16
+ invalid(tessen, "tessen identity_key must be a string")
17
+ end
18
+ end
19
+ end
20
+ end
21
+ end
22
+ end
@@ -0,0 +1,74 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module TimeWindow
5
+ # Validate time window condition
6
+ # Validates: begin, end
7
+ #
8
+ # @param definition [Hash] sensu definition.
9
+ # @param scope [String] definition scope to validate.
10
+ # @param attribute [String] definition attribute to validate.
11
+ # @param condition [Hash] to have begin and end validated.
12
+ def validate_time_window_condition(definition, scope, attribute, condition)
13
+ if is_a_hash?(condition)
14
+ must_be_time(condition[:begin], condition[:end]) ||
15
+ invalid(definition, "#{scope} #{attribute} day time window begin and end times must be valid")
16
+ else
17
+ invalid(definition, "#{scope} #{attribute} day time window must be a hash")
18
+ end
19
+ end
20
+
21
+ # Validate time windows days
22
+ # Validates: days
23
+ #
24
+ # @param definition [Hash] sensu definition.
25
+ # @param scope [String] definition scope to validate.
26
+ # @param attribute [String] definition attribute to validate.
27
+ # @param days [String] time window days to validate.
28
+ def validate_time_windows_days(definition, scope, attribute, days)
29
+ valid_days = [:all, :sunday, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday]
30
+ if must_be_either(valid_days, days.keys)
31
+ days.each do |day, conditions|
32
+ if is_an_array?(conditions)
33
+ if !conditions.empty?
34
+ conditions.each do |condition|
35
+ validate_time_window_condition(definition, scope, attribute, condition)
36
+ end
37
+ else
38
+ invalid(definition, "#{scope} #{attribute} days #{day} must include at least one time window")
39
+ end
40
+ else
41
+ invalid(definition, "#{scope} #{attribute} days #{day} must be in an array")
42
+ end
43
+ end
44
+ else
45
+ invalid(definition, "#{scope} #{attribute} days must be valid days of the week or 'all'")
46
+ end
47
+ end
48
+
49
+ # Validate time windows
50
+ # Validates: days
51
+ #
52
+ # @param definition [Hash] sensu definition.
53
+ # @param scope [String] definition scope to validate.
54
+ # @param attribute [String] definition attribute to validate.
55
+ def validate_time_windows(definition, scope, attribute)
56
+ if is_a_hash?(definition[attribute])
57
+ days = definition[attribute][:days]
58
+ if is_a_hash?(days)
59
+ if !days.empty?
60
+ validate_time_windows_days(definition, scope, attribute, days)
61
+ else
62
+ invalid(definition, "#{scope} #{attribute} days must include at least one day of the week or 'all'")
63
+ end
64
+ else
65
+ invalid(definition, "#{scope} #{attribute} days must be a hash")
66
+ end
67
+ else
68
+ invalid(definition, "#{scope} #{attribute} must be a hash")
69
+ end
70
+ end
71
+ end
72
+ end
73
+ end
74
+ end
@@ -0,0 +1,22 @@
1
+ module Sensu
2
+ module Settings
3
+ module Validators
4
+ module Transport
5
+ # Validate a Sensu transport definition.
6
+ # Validates: name
7
+ #
8
+ # @param transport [Hash] sensu transport definition.
9
+ def validate_transport(transport)
10
+ if is_a_hash?(transport)
11
+ must_be_a_string(transport[:name]) ||
12
+ invalid(transport, "transport name must be a string")
13
+ must_be_boolean_if_set(transport[:reconnect_on_error]) ||
14
+ invalid(transport, "transport reconnect_on_error must be boolean")
15
+ else
16
+ invalid(transport, "transport must be a hash")
17
+ end
18
+ end
19
+ end
20
+ end
21
+ end
22
+ end