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

Sign up to get free protection for your applications and to get access to all the features.
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