aws-sdk-cloudformation 1.0.0.rc1 → 1.0.0.rc2

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.
Files changed (13) hide show
  1. checksums.yaml +4 -4
  2. data/lib/aws-sdk-cloudformation.rb +2 -2
  3. data/lib/aws-sdk-cloudformation/client.rb +2202 -1943
  4. data/lib/aws-sdk-cloudformation/client_api.rb +882 -874
  5. data/lib/aws-sdk-cloudformation/errors.rb +4 -13
  6. data/lib/aws-sdk-cloudformation/event.rb +120 -122
  7. data/lib/aws-sdk-cloudformation/resource.rb +249 -251
  8. data/lib/aws-sdk-cloudformation/stack.rb +654 -656
  9. data/lib/aws-sdk-cloudformation/stack_resource.rb +156 -158
  10. data/lib/aws-sdk-cloudformation/stack_resource_summary.rb +128 -130
  11. data/lib/aws-sdk-cloudformation/types.rb +2961 -2674
  12. data/lib/aws-sdk-cloudformation/waiters.rb +281 -232
  13. metadata +2 -2
data/lib/aws-sdk-cloudformation/waiters.rb CHANGED
@@ -1,266 +1,315 @@
1
1
  # WARNING ABOUT GENERATED CODE
2
2
  #
3
- # This file is generated. See the contributing for info on making contributions:
3
+ # This file is generated. See the contributing guide for more information:
4
4
  # https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
5
5
  #
6
6
  # WARNING ABOUT GENERATED CODE
7
7
 
8
8
  require 'aws-sdk-core/waiters'
9
9
 
10
- module Aws
11
- module CloudFormation
12
- module Waiters
13
- class StackExists
10
+ module Aws::CloudFormation
11
+ module Waiters
14
12
 
15
- # @param [Hash] options
16
- # @option options [required, Client] :client
17
- # @option options [Integer] :max_attempts (20)
18
- # @option options [Integer] :delay (5)
19
- # @option options [Proc] :before_attempt
20
- # @option options [Proc] :before_wait
21
- def initialize(options)
22
- @client = options.fetch(:client)
23
- @waiter = Aws::Waiters::Waiter.new({
24
- max_attempts: 20,
25
- delay: 5,
26
- poller: Aws::Waiters::Poller.new(
27
- operation_name: :describe_stacks,
28
- acceptors: [
29
- {
30
- "matcher" => "status",
31
- "expected" => 200,
32
- "state" => "success"
33
- },
34
- {
35
- "matcher" => "error",
36
- "expected" => "ValidationError",
37
- "state" => "retry"
38
- }
39
- ]
40
- )
41
- }.merge(options))
42
- end
13
+ # Wait until change set status is CREATE_COMPLETE.
14
+ class ChangeSetCreateComplete
43
15
 
44
- # @option (see Client#describe_stacks)
45
- # @return (see Client#describe_stacks)
46
- def wait(params = {})
47
- @waiter.wait(client: @client, params: params)
48
- end
16
+ # @param [Hash] options
17
+ # @option options [required, Client] :client
18
+ # @option options [Integer] :max_attempts (120)
19
+ # @option options [Integer] :delay (30)
20
+ # @option options [Proc] :before_attempt
21
+ # @option options [Proc] :before_wait
22
+ def initialize(options)
23
+ @client = options.fetch(:client)
24
+ @waiter = Aws::Waiters::Waiter.new({
25
+ max_attempts: 120,
26
+ delay: 30,
27
+ poller: Aws::Waiters::Poller.new(
28
+ operation_name: :describe_change_set,
29
+ acceptors: [
30
+ {
31
+ "argument" => "status",
32
+ "expected" => "CREATE_COMPLETE",
33
+ "matcher" => "path",
34
+ "state" => "success"
35
+ },
36
+ {
37
+ "argument" => "status",
38
+ "expected" => "FAILED",
39
+ "matcher" => "path",
40
+ "state" => "failure"
41
+ },
42
+ {
43
+ "expected" => "ValidationError",
44
+ "matcher" => "error",
45
+ "state" => "failure"
46
+ }
47
+ ]
48
+ )
49
+ }.merge(options))
50
+ end
51
+
52
+ # @option (see Client#describe_change_set)
53
+ # @return (see Client#describe_change_set)
54
+ def wait(params = {})
55
+ @waiter.wait(client: @client, params: params)
56
+ end
57
+
58
+ # @api private
59
+ attr_reader :waiter
49
60
 
50
- # @api private
51
- attr_reader :waiter
61
+ end
62
+
63
+ # Wait until stack status is CREATE_COMPLETE.
64
+ class StackCreateComplete
65
+
66
+ # @param [Hash] options
67
+ # @option options [required, Client] :client
68
+ # @option options [Integer] :max_attempts (120)
69
+ # @option options [Integer] :delay (30)
70
+ # @option options [Proc] :before_attempt
71
+ # @option options [Proc] :before_wait
72
+ def initialize(options)
73
+ @client = options.fetch(:client)
74
+ @waiter = Aws::Waiters::Waiter.new({
75
+ max_attempts: 120,
76
+ delay: 30,
77
+ poller: Aws::Waiters::Poller.new(
78
+ operation_name: :describe_stacks,
79
+ acceptors: [
80
+ {
81
+ "argument" => "stacks[].stack_status",
82
+ "expected" => "CREATE_COMPLETE",
83
+ "matcher" => "pathAll",
84
+ "state" => "success"
85
+ },
86
+ {
87
+ "argument" => "stacks[].stack_status",
88
+ "expected" => "CREATE_FAILED",
89
+ "matcher" => "pathAny",
90
+ "state" => "failure"
91
+ },
92
+ {
93
+ "argument" => "stacks[].stack_status",
94
+ "expected" => "DELETE_COMPLETE",
95
+ "matcher" => "pathAny",
96
+ "state" => "failure"
97
+ },
98
+ {
99
+ "argument" => "stacks[].stack_status",
100
+ "expected" => "DELETE_FAILED",
101
+ "matcher" => "pathAny",
102
+ "state" => "failure"
103
+ },
104
+ {
105
+ "argument" => "stacks[].stack_status",
106
+ "expected" => "ROLLBACK_FAILED",
107
+ "matcher" => "pathAny",
108
+ "state" => "failure"
109
+ },
110
+ {
111
+ "argument" => "stacks[].stack_status",
112
+ "expected" => "ROLLBACK_COMPLETE",
113
+ "matcher" => "pathAny",
114
+ "state" => "failure"
115
+ },
116
+ {
117
+ "expected" => "ValidationError",
118
+ "matcher" => "error",
119
+ "state" => "failure"
120
+ }
121
+ ]
122
+ )
123
+ }.merge(options))
124
+ end
52
125
 
126
+ # @option (see Client#describe_stacks)
127
+ # @return (see Client#describe_stacks)
128
+ def wait(params = {})
129
+ @waiter.wait(client: @client, params: params)
53
130
  end
54
131
 
55
- class StackCreateComplete
132
+ # @api private
133
+ attr_reader :waiter
56
134
 
57
- # @param [Hash] options
58
- # @option options [required, Client] :client
59
- # @option options [Integer] :max_attempts (120)
60
- # @option options [Integer] :delay (30)
61
- # @option options [Proc] :before_attempt
62
- # @option options [Proc] :before_wait
63
- def initialize(options)
64
- @client = options.fetch(:client)
65
- @waiter = Aws::Waiters::Waiter.new({
66
- max_attempts: 120,
67
- delay: 30,
68
- poller: Aws::Waiters::Poller.new(
69
- "description" => "Wait until stack status is CREATE_COMPLETE.",
70
- operation_name: :describe_stacks,
71
- acceptors: [
72
- {
73
- "argument" => "stacks[].stack_status",
74
- "expected" => "CREATE_COMPLETE",
75
- "matcher" => "pathAll",
76
- "state" => "success"
77
- },
78
- {
79
- "argument" => "stacks[].stack_status",
80
- "expected" => "CREATE_FAILED",
81
- "matcher" => "pathAny",
82
- "state" => "failure"
83
- },
84
- {
85
- "argument" => "stacks[].stack_status",
86
- "expected" => "DELETE_COMPLETE",
87
- "matcher" => "pathAny",
88
- "state" => "failure"
89
- },
90
- {
91
- "argument" => "stacks[].stack_status",
92
- "expected" => "DELETE_FAILED",
93
- "matcher" => "pathAny",
94
- "state" => "failure"
95
- },
96
- {
97
- "argument" => "stacks[].stack_status",
98
- "expected" => "ROLLBACK_FAILED",
99
- "matcher" => "pathAny",
100
- "state" => "failure"
101
- },
102
- {
103
- "argument" => "stacks[].stack_status",
104
- "expected" => "ROLLBACK_COMPLETE",
105
- "matcher" => "pathAny",
106
- "state" => "failure"
107
- },
108
- {
109
- "expected" => "ValidationError",
110
- "matcher" => "error",
111
- "state" => "failure"
112
- }
113
- ]
114
- )
115
- }.merge(options))
116
- end
135
+ end
117
136
 
118
- # @option (see Client#describe_stacks)
119
- # @return (see Client#describe_stacks)
120
- def wait(params = {})
121
- @waiter.wait(client: @client, params: params)
122
- end
137
+ # Wait until stack status is DELETE_COMPLETE.
138
+ class StackDeleteComplete
123
139
 
124
- # @api private
125
- attr_reader :waiter
140
+ # @param [Hash] options
141
+ # @option options [required, Client] :client
142
+ # @option options [Integer] :max_attempts (120)
143
+ # @option options [Integer] :delay (30)
144
+ # @option options [Proc] :before_attempt
145
+ # @option options [Proc] :before_wait
146
+ def initialize(options)
147
+ @client = options.fetch(:client)
148
+ @waiter = Aws::Waiters::Waiter.new({
149
+ max_attempts: 120,
150
+ delay: 30,
151
+ poller: Aws::Waiters::Poller.new(
152
+ operation_name: :describe_stacks,
153
+ acceptors: [
154
+ {
155
+ "argument" => "stacks[].stack_status",
156
+ "expected" => "DELETE_COMPLETE",
157
+ "matcher" => "pathAll",
158
+ "state" => "success"
159
+ },
160
+ {
161
+ "expected" => "ValidationError",
162
+ "matcher" => "error",
163
+ "state" => "success"
164
+ },
165
+ {
166
+ "argument" => "stacks[].stack_status",
167
+ "expected" => "DELETE_FAILED",
168
+ "matcher" => "pathAny",
169
+ "state" => "failure"
170
+ },
171
+ {
172
+ "argument" => "stacks[].stack_status",
173
+ "expected" => "CREATE_FAILED",
174
+ "matcher" => "pathAny",
175
+ "state" => "failure"
176
+ },
177
+ {
178
+ "argument" => "stacks[].stack_status",
179
+ "expected" => "ROLLBACK_FAILED",
180
+ "matcher" => "pathAny",
181
+ "state" => "failure"
182
+ },
183
+ {
184
+ "argument" => "stacks[].stack_status",
185
+ "expected" => "UPDATE_ROLLBACK_FAILED",
186
+ "matcher" => "pathAny",
187
+ "state" => "failure"
188
+ },
189
+ {
190
+ "argument" => "stacks[].stack_status",
191
+ "expected" => "UPDATE_ROLLBACK_IN_PROGRESS",
192
+ "matcher" => "pathAny",
193
+ "state" => "failure"
194
+ }
195
+ ]
196
+ )
197
+ }.merge(options))
198
+ end
126
199
 
200
+ # @option (see Client#describe_stacks)
201
+ # @return (see Client#describe_stacks)
202
+ def wait(params = {})
203
+ @waiter.wait(client: @client, params: params)
127
204
  end
128
205
 
129
- class StackDeleteComplete
206
+ # @api private
207
+ attr_reader :waiter
130
208
 
131
- # @param [Hash] options
132
- # @option options [required, Client] :client
133
- # @option options [Integer] :max_attempts (120)
134
- # @option options [Integer] :delay (30)
135
- # @option options [Proc] :before_attempt
136
- # @option options [Proc] :before_wait
137
- def initialize(options)
138
- @client = options.fetch(:client)
139
- @waiter = Aws::Waiters::Waiter.new({
140
- max_attempts: 120,
141
- delay: 30,
142
- poller: Aws::Waiters::Poller.new(
143
- "description" => "Wait until stack status is DELETE_COMPLETE.",
144
- operation_name: :describe_stacks,
145
- acceptors: [
146
- {
147
- "argument" => "stacks[].stack_status",
148
- "expected" => "DELETE_COMPLETE",
149
- "matcher" => "pathAll",
150
- "state" => "success"
151
- },
152
- {
153
- "expected" => "ValidationError",
154
- "matcher" => "error",
155
- "state" => "success"
156
- },
157
- {
158
- "argument" => "stacks[].stack_status",
159
- "expected" => "DELETE_FAILED",
160
- "matcher" => "pathAny",
161
- "state" => "failure"
162
- },
163
- {
164
- "argument" => "stacks[].stack_status",
165
- "expected" => "CREATE_FAILED",
166
- "matcher" => "pathAny",
167
- "state" => "failure"
168
- },
169
- {
170
- "argument" => "stacks[].stack_status",
171
- "expected" => "ROLLBACK_FAILED",
172
- "matcher" => "pathAny",
173
- "state" => "failure"
174
- },
175
- {
176
- "argument" => "stacks[].stack_status",
177
- "expected" => "UPDATE_ROLLBACK_FAILED",
178
- "matcher" => "pathAny",
179
- "state" => "failure"
180
- },
181
- {
182
- "argument" => "stacks[].stack_status",
183
- "expected" => "UPDATE_ROLLBACK_IN_PROGRESS",
184
- "matcher" => "pathAny",
185
- "state" => "failure"
186
- }
187
- ]
188
- )
189
- }.merge(options))
190
- end
209
+ end
191
210
 
192
- # @option (see Client#describe_stacks)
193
- # @return (see Client#describe_stacks)
194
- def wait(params = {})
195
- @waiter.wait(client: @client, params: params)
196
- end
211
+ class StackExists
197
212
 
198
- # @api private
199
- attr_reader :waiter
213
+ # @param [Hash] options
214
+ # @option options [required, Client] :client
215
+ # @option options [Integer] :max_attempts (20)
216
+ # @option options [Integer] :delay (5)
217
+ # @option options [Proc] :before_attempt
218
+ # @option options [Proc] :before_wait
219
+ def initialize(options)
220
+ @client = options.fetch(:client)
221
+ @waiter = Aws::Waiters::Waiter.new({
222
+ max_attempts: 20,
223
+ delay: 5,
224
+ poller: Aws::Waiters::Poller.new(
225
+ operation_name: :describe_stacks,
226
+ acceptors: [
227
+ {
228
+ "matcher" => "status",
229
+ "expected" => 200,
230
+ "state" => "success"
231
+ },
232
+ {
233
+ "matcher" => "error",
234
+ "expected" => "ValidationError",
235
+ "state" => "retry"
236
+ }
237
+ ]
238
+ )
239
+ }.merge(options))
240
+ end
200
241
 
242
+ # @option (see Client#describe_stacks)
243
+ # @return (see Client#describe_stacks)
244
+ def wait(params = {})
245
+ @waiter.wait(client: @client, params: params)
201
246
  end
202
247
 
203
- class StackUpdateComplete
248
+ # @api private
249
+ attr_reader :waiter
204
250
 
205
- # @param [Hash] options
206
- # @option options [required, Client] :client
207
- # @option options [Integer] :max_attempts (120)
208
- # @option options [Integer] :delay (30)
209
- # @option options [Proc] :before_attempt
210
- # @option options [Proc] :before_wait
211
- def initialize(options)
212
- @client = options.fetch(:client)
213
- @waiter = Aws::Waiters::Waiter.new({
214
- max_attempts: 120,
215
- delay: 30,
216
- poller: Aws::Waiters::Poller.new(
217
- "description" => "Wait until stack status is UPDATE_COMPLETE.",
218
- operation_name: :describe_stacks,
219
- acceptors: [
220
- {
221
- "argument" => "stacks[].stack_status",
222
- "expected" => "UPDATE_COMPLETE",
223
- "matcher" => "pathAll",
224
- "state" => "success"
225
- },
226
- {
227
- "expected" => "UPDATE_FAILED",
228
- "matcher" => "pathAny",
229
- "state" => "failure",
230
- "argument" => "stacks[].stack_status"
231
- },
232
- {
233
- "argument" => "stacks[].stack_status",
234
- "expected" => "UPDATE_ROLLBACK_FAILED",
235
- "matcher" => "pathAny",
236
- "state" => "failure"
237
- },
238
- {
239
- "expected" => "UPDATE_ROLLBACK_COMPLETE",
240
- "matcher" => "pathAny",
241
- "state" => "failure",
242
- "argument" => "stacks[].stack_status"
243
- },
244
- {
245
- "expected" => "ValidationError",
246
- "matcher" => "error",
247
- "state" => "failure"
248
- }
249
- ]
250
- )
251
- }.merge(options))
252
- end
251
+ end
253
252
 
254
- # @option (see Client#describe_stacks)
255
- # @return (see Client#describe_stacks)
256
- def wait(params = {})
257
- @waiter.wait(client: @client, params: params)
258
- end
253
+ # Wait until stack status is UPDATE_COMPLETE.
254
+ class StackUpdateComplete
259
255
 
260
- # @api private
261
- attr_reader :waiter
256
+ # @param [Hash] options
257
+ # @option options [required, Client] :client
258
+ # @option options [Integer] :max_attempts (120)
259
+ # @option options [Integer] :delay (30)
260
+ # @option options [Proc] :before_attempt
261
+ # @option options [Proc] :before_wait
262
+ def initialize(options)
263
+ @client = options.fetch(:client)
264
+ @waiter = Aws::Waiters::Waiter.new({
265
+ max_attempts: 120,
266
+ delay: 30,
267
+ poller: Aws::Waiters::Poller.new(
268
+ operation_name: :describe_stacks,
269
+ acceptors: [
270
+ {
271
+ "argument" => "stacks[].stack_status",
272
+ "expected" => "UPDATE_COMPLETE",
273
+ "matcher" => "pathAll",
274
+ "state" => "success"
275
+ },
276
+ {
277
+ "expected" => "UPDATE_FAILED",
278
+ "matcher" => "pathAny",
279
+ "state" => "failure",
280
+ "argument" => "stacks[].stack_status"
281
+ },
282
+ {
283
+ "argument" => "stacks[].stack_status",
284
+ "expected" => "UPDATE_ROLLBACK_FAILED",
285
+ "matcher" => "pathAny",
286
+ "state" => "failure"
287
+ },
288
+ {
289
+ "expected" => "UPDATE_ROLLBACK_COMPLETE",
290
+ "matcher" => "pathAny",
291
+ "state" => "failure",
292
+ "argument" => "stacks[].stack_status"
293
+ },
294
+ {
295
+ "expected" => "ValidationError",
296
+ "matcher" => "error",
297
+ "state" => "failure"
298
+ }
299
+ ]
300
+ )
301
+ }.merge(options))
302
+ end
262
303
 
304
+ # @option (see Client#describe_stacks)
305
+ # @return (see Client#describe_stacks)
306
+ def wait(params = {})
307
+ @waiter.wait(client: @client, params: params)
263
308
  end
309
+
310
+ # @api private
311
+ attr_reader :waiter
312
+
264
313
  end
265
314
  end
266
315
  end