aws-sdk-ec2 1.0.0.rc2 → 1.0.0.rc3
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.
- checksums.yaml +4 -4
- data/lib/aws-sdk-ec2.rb +2 -2
- data/lib/aws-sdk-ec2/classic_address.rb +198 -200
- data/lib/aws-sdk-ec2/client.rb +17169 -14563
- data/lib/aws-sdk-ec2/client_api.rb +6458 -6301
- data/lib/aws-sdk-ec2/dhcp_options.rb +158 -160
- data/lib/aws-sdk-ec2/errors.rb +4 -13
- data/lib/aws-sdk-ec2/image.rb +404 -406
- data/lib/aws-sdk-ec2/instance.rb +1423 -1422
- data/lib/aws-sdk-ec2/internet_gateway.rb +178 -180
- data/lib/aws-sdk-ec2/key_pair.rb +98 -100
- data/lib/aws-sdk-ec2/key_pair_info.rb +102 -104
- data/lib/aws-sdk-ec2/network_acl.rb +326 -328
- data/lib/aws-sdk-ec2/network_interface.rb +428 -430
- data/lib/aws-sdk-ec2/network_interface_association.rb +126 -128
- data/lib/aws-sdk-ec2/placement_group.rb +400 -399
- data/lib/aws-sdk-ec2/resource.rb +2696 -2659
- data/lib/aws-sdk-ec2/route.rb +229 -231
- data/lib/aws-sdk-ec2/route_table.rb +243 -245
- data/lib/aws-sdk-ec2/route_table_association.rb +148 -150
- data/lib/aws-sdk-ec2/security_group.rb +515 -517
- data/lib/aws-sdk-ec2/snapshot.rb +431 -433
- data/lib/aws-sdk-ec2/subnet.rb +981 -977
- data/lib/aws-sdk-ec2/tag.rb +185 -187
- data/lib/aws-sdk-ec2/types.rb +24081 -20965
- data/lib/aws-sdk-ec2/volume.rb +513 -512
- data/lib/aws-sdk-ec2/vpc.rb +1671 -1649
- data/lib/aws-sdk-ec2/vpc_address.rb +189 -191
- data/lib/aws-sdk-ec2/vpc_peering_connection.rb +219 -221
- data/lib/aws-sdk-ec2/waiters.rb +1252 -1210
- metadata +2 -2
data/lib/aws-sdk-ec2/waiters.rb
CHANGED
|
@@ -1,1334 +1,1376 @@
|
|
|
1
1
|
# WARNING ABOUT GENERATED CODE
|
|
2
2
|
#
|
|
3
|
-
# This file is generated. See the contributing for
|
|
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
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
# @option (see Client#describe_instances)
|
|
46
|
-
# @return (see Client#describe_instances)
|
|
47
|
-
def wait(params = {})
|
|
48
|
-
@waiter.wait(client: @client, params: params)
|
|
49
|
-
end
|
|
50
|
-
|
|
51
|
-
# @api private
|
|
52
|
-
attr_reader :waiter
|
|
10
|
+
module Aws::EC2
|
|
11
|
+
module Waiters
|
|
12
|
+
|
|
13
|
+
class BundleTaskComplete
|
|
14
|
+
|
|
15
|
+
# @param [Hash] options
|
|
16
|
+
# @option options [required, Client] :client
|
|
17
|
+
# @option options [Integer] :max_attempts (40)
|
|
18
|
+
# @option options [Integer] :delay (15)
|
|
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: 40,
|
|
25
|
+
delay: 15,
|
|
26
|
+
poller: Aws::Waiters::Poller.new(
|
|
27
|
+
operation_name: :describe_bundle_tasks,
|
|
28
|
+
acceptors: [
|
|
29
|
+
{
|
|
30
|
+
"expected" => "complete",
|
|
31
|
+
"matcher" => "pathAll",
|
|
32
|
+
"state" => "success",
|
|
33
|
+
"argument" => "bundle_tasks[].state"
|
|
34
|
+
},
|
|
35
|
+
{
|
|
36
|
+
"expected" => "failed",
|
|
37
|
+
"matcher" => "pathAny",
|
|
38
|
+
"state" => "failure",
|
|
39
|
+
"argument" => "bundle_tasks[].state"
|
|
40
|
+
}
|
|
41
|
+
]
|
|
42
|
+
)
|
|
43
|
+
}.merge(options))
|
|
44
|
+
end
|
|
53
45
|
|
|
46
|
+
# @option (see Client#describe_bundle_tasks)
|
|
47
|
+
# @return (see Client#describe_bundle_tasks)
|
|
48
|
+
def wait(params = {})
|
|
49
|
+
@waiter.wait(client: @client, params: params)
|
|
54
50
|
end
|
|
55
51
|
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
# @param [Hash] options
|
|
59
|
-
# @option options [required, Client] :client
|
|
60
|
-
# @option options [Integer] :max_attempts (40)
|
|
61
|
-
# @option options [Integer] :delay (15)
|
|
62
|
-
# @option options [Proc] :before_attempt
|
|
63
|
-
# @option options [Proc] :before_wait
|
|
64
|
-
def initialize(options)
|
|
65
|
-
@client = options.fetch(:client)
|
|
66
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
67
|
-
max_attempts: 40,
|
|
68
|
-
delay: 15,
|
|
69
|
-
poller: Aws::Waiters::Poller.new(
|
|
70
|
-
operation_name: :describe_bundle_tasks,
|
|
71
|
-
acceptors: [
|
|
72
|
-
{
|
|
73
|
-
"expected" => "complete",
|
|
74
|
-
"matcher" => "pathAll",
|
|
75
|
-
"state" => "success",
|
|
76
|
-
"argument" => "bundle_tasks[].state"
|
|
77
|
-
},
|
|
78
|
-
{
|
|
79
|
-
"expected" => "failed",
|
|
80
|
-
"matcher" => "pathAny",
|
|
81
|
-
"state" => "failure",
|
|
82
|
-
"argument" => "bundle_tasks[].state"
|
|
83
|
-
}
|
|
84
|
-
]
|
|
85
|
-
)
|
|
86
|
-
}.merge(options))
|
|
87
|
-
end
|
|
88
|
-
|
|
89
|
-
# @option (see Client#describe_bundle_tasks)
|
|
90
|
-
# @return (see Client#describe_bundle_tasks)
|
|
91
|
-
def wait(params = {})
|
|
92
|
-
@waiter.wait(client: @client, params: params)
|
|
93
|
-
end
|
|
94
|
-
|
|
95
|
-
# @api private
|
|
96
|
-
attr_reader :waiter
|
|
52
|
+
# @api private
|
|
53
|
+
attr_reader :waiter
|
|
97
54
|
|
|
55
|
+
end
|
|
56
|
+
|
|
57
|
+
class ConversionTaskCancelled
|
|
58
|
+
|
|
59
|
+
# @param [Hash] options
|
|
60
|
+
# @option options [required, Client] :client
|
|
61
|
+
# @option options [Integer] :max_attempts (40)
|
|
62
|
+
# @option options [Integer] :delay (15)
|
|
63
|
+
# @option options [Proc] :before_attempt
|
|
64
|
+
# @option options [Proc] :before_wait
|
|
65
|
+
def initialize(options)
|
|
66
|
+
@client = options.fetch(:client)
|
|
67
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
68
|
+
max_attempts: 40,
|
|
69
|
+
delay: 15,
|
|
70
|
+
poller: Aws::Waiters::Poller.new(
|
|
71
|
+
operation_name: :describe_conversion_tasks,
|
|
72
|
+
acceptors: [{
|
|
73
|
+
"expected" => "cancelled",
|
|
74
|
+
"matcher" => "pathAll",
|
|
75
|
+
"state" => "success",
|
|
76
|
+
"argument" => "conversion_tasks[].state"
|
|
77
|
+
}]
|
|
78
|
+
)
|
|
79
|
+
}.merge(options))
|
|
98
80
|
end
|
|
99
81
|
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
82
|
+
# @option (see Client#describe_conversion_tasks)
|
|
83
|
+
# @return (see Client#describe_conversion_tasks)
|
|
84
|
+
def wait(params = {})
|
|
85
|
+
@waiter.wait(client: @client, params: params)
|
|
86
|
+
end
|
|
87
|
+
|
|
88
|
+
# @api private
|
|
89
|
+
attr_reader :waiter
|
|
90
|
+
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
class ConversionTaskCompleted
|
|
94
|
+
|
|
95
|
+
# @param [Hash] options
|
|
96
|
+
# @option options [required, Client] :client
|
|
97
|
+
# @option options [Integer] :max_attempts (40)
|
|
98
|
+
# @option options [Integer] :delay (15)
|
|
99
|
+
# @option options [Proc] :before_attempt
|
|
100
|
+
# @option options [Proc] :before_wait
|
|
101
|
+
def initialize(options)
|
|
102
|
+
@client = options.fetch(:client)
|
|
103
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
104
|
+
max_attempts: 40,
|
|
105
|
+
delay: 15,
|
|
106
|
+
poller: Aws::Waiters::Poller.new(
|
|
107
|
+
operation_name: :describe_conversion_tasks,
|
|
108
|
+
acceptors: [
|
|
109
|
+
{
|
|
110
|
+
"expected" => "completed",
|
|
117
111
|
"matcher" => "pathAll",
|
|
118
112
|
"state" => "success",
|
|
119
113
|
"argument" => "conversion_tasks[].state"
|
|
120
|
-
}
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
114
|
+
},
|
|
115
|
+
{
|
|
116
|
+
"expected" => "cancelled",
|
|
117
|
+
"matcher" => "pathAny",
|
|
118
|
+
"state" => "failure",
|
|
119
|
+
"argument" => "conversion_tasks[].state"
|
|
120
|
+
},
|
|
121
|
+
{
|
|
122
|
+
"expected" => "cancelling",
|
|
123
|
+
"matcher" => "pathAny",
|
|
124
|
+
"state" => "failure",
|
|
125
|
+
"argument" => "conversion_tasks[].state"
|
|
126
|
+
}
|
|
127
|
+
]
|
|
128
|
+
)
|
|
129
|
+
}.merge(options))
|
|
130
|
+
end
|
|
124
131
|
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
132
|
+
# @option (see Client#describe_conversion_tasks)
|
|
133
|
+
# @return (see Client#describe_conversion_tasks)
|
|
134
|
+
def wait(params = {})
|
|
135
|
+
@waiter.wait(client: @client, params: params)
|
|
136
|
+
end
|
|
130
137
|
|
|
131
|
-
|
|
132
|
-
|
|
138
|
+
# @api private
|
|
139
|
+
attr_reader :waiter
|
|
133
140
|
|
|
134
|
-
|
|
141
|
+
end
|
|
135
142
|
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
"matcher" => "pathAny",
|
|
161
|
-
"state" => "failure",
|
|
162
|
-
"argument" => "conversion_tasks[].state"
|
|
163
|
-
},
|
|
164
|
-
{
|
|
165
|
-
"expected" => "cancelling",
|
|
166
|
-
"matcher" => "pathAny",
|
|
167
|
-
"state" => "failure",
|
|
168
|
-
"argument" => "conversion_tasks[].state"
|
|
169
|
-
}
|
|
170
|
-
]
|
|
171
|
-
)
|
|
172
|
-
}.merge(options))
|
|
173
|
-
end
|
|
174
|
-
|
|
175
|
-
# @option (see Client#describe_conversion_tasks)
|
|
176
|
-
# @return (see Client#describe_conversion_tasks)
|
|
177
|
-
def wait(params = {})
|
|
178
|
-
@waiter.wait(client: @client, params: params)
|
|
179
|
-
end
|
|
180
|
-
|
|
181
|
-
# @api private
|
|
182
|
-
attr_reader :waiter
|
|
143
|
+
class ConversionTaskDeleted
|
|
144
|
+
|
|
145
|
+
# @param [Hash] options
|
|
146
|
+
# @option options [required, Client] :client
|
|
147
|
+
# @option options [Integer] :max_attempts (40)
|
|
148
|
+
# @option options [Integer] :delay (15)
|
|
149
|
+
# @option options [Proc] :before_attempt
|
|
150
|
+
# @option options [Proc] :before_wait
|
|
151
|
+
def initialize(options)
|
|
152
|
+
@client = options.fetch(:client)
|
|
153
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
154
|
+
max_attempts: 40,
|
|
155
|
+
delay: 15,
|
|
156
|
+
poller: Aws::Waiters::Poller.new(
|
|
157
|
+
operation_name: :describe_conversion_tasks,
|
|
158
|
+
acceptors: [{
|
|
159
|
+
"expected" => "deleted",
|
|
160
|
+
"matcher" => "pathAll",
|
|
161
|
+
"state" => "success",
|
|
162
|
+
"argument" => "conversion_tasks[].state"
|
|
163
|
+
}]
|
|
164
|
+
)
|
|
165
|
+
}.merge(options))
|
|
166
|
+
end
|
|
183
167
|
|
|
168
|
+
# @option (see Client#describe_conversion_tasks)
|
|
169
|
+
# @return (see Client#describe_conversion_tasks)
|
|
170
|
+
def wait(params = {})
|
|
171
|
+
@waiter.wait(client: @client, params: params)
|
|
184
172
|
end
|
|
185
173
|
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
174
|
+
# @api private
|
|
175
|
+
attr_reader :waiter
|
|
176
|
+
|
|
177
|
+
end
|
|
178
|
+
|
|
179
|
+
class CustomerGatewayAvailable
|
|
180
|
+
|
|
181
|
+
# @param [Hash] options
|
|
182
|
+
# @option options [required, Client] :client
|
|
183
|
+
# @option options [Integer] :max_attempts (40)
|
|
184
|
+
# @option options [Integer] :delay (15)
|
|
185
|
+
# @option options [Proc] :before_attempt
|
|
186
|
+
# @option options [Proc] :before_wait
|
|
187
|
+
def initialize(options)
|
|
188
|
+
@client = options.fetch(:client)
|
|
189
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
190
|
+
max_attempts: 40,
|
|
191
|
+
delay: 15,
|
|
192
|
+
poller: Aws::Waiters::Poller.new(
|
|
193
|
+
operation_name: :describe_customer_gateways,
|
|
194
|
+
acceptors: [
|
|
195
|
+
{
|
|
196
|
+
"expected" => "available",
|
|
203
197
|
"matcher" => "pathAll",
|
|
204
198
|
"state" => "success",
|
|
205
|
-
"argument" => "
|
|
206
|
-
}
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
199
|
+
"argument" => "customer_gateways[].state"
|
|
200
|
+
},
|
|
201
|
+
{
|
|
202
|
+
"expected" => "deleted",
|
|
203
|
+
"matcher" => "pathAny",
|
|
204
|
+
"state" => "failure",
|
|
205
|
+
"argument" => "customer_gateways[].state"
|
|
206
|
+
},
|
|
207
|
+
{
|
|
208
|
+
"expected" => "deleting",
|
|
209
|
+
"matcher" => "pathAny",
|
|
210
|
+
"state" => "failure",
|
|
211
|
+
"argument" => "customer_gateways[].state"
|
|
212
|
+
}
|
|
213
|
+
]
|
|
214
|
+
)
|
|
215
|
+
}.merge(options))
|
|
216
|
+
end
|
|
210
217
|
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
218
|
+
# @option (see Client#describe_customer_gateways)
|
|
219
|
+
# @return (see Client#describe_customer_gateways)
|
|
220
|
+
def wait(params = {})
|
|
221
|
+
@waiter.wait(client: @client, params: params)
|
|
222
|
+
end
|
|
216
223
|
|
|
217
|
-
|
|
218
|
-
|
|
224
|
+
# @api private
|
|
225
|
+
attr_reader :waiter
|
|
219
226
|
|
|
220
|
-
|
|
227
|
+
end
|
|
221
228
|
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
229
|
-
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
"matcher" => "pathAny",
|
|
247
|
-
"state" => "failure",
|
|
248
|
-
"argument" => "customer_gateways[].state"
|
|
249
|
-
},
|
|
250
|
-
{
|
|
251
|
-
"expected" => "deleting",
|
|
252
|
-
"matcher" => "pathAny",
|
|
253
|
-
"state" => "failure",
|
|
254
|
-
"argument" => "customer_gateways[].state"
|
|
255
|
-
}
|
|
256
|
-
]
|
|
257
|
-
)
|
|
258
|
-
}.merge(options))
|
|
259
|
-
end
|
|
260
|
-
|
|
261
|
-
# @option (see Client#describe_customer_gateways)
|
|
262
|
-
# @return (see Client#describe_customer_gateways)
|
|
263
|
-
def wait(params = {})
|
|
264
|
-
@waiter.wait(client: @client, params: params)
|
|
265
|
-
end
|
|
266
|
-
|
|
267
|
-
# @api private
|
|
268
|
-
attr_reader :waiter
|
|
229
|
+
class ExportTaskCancelled
|
|
230
|
+
|
|
231
|
+
# @param [Hash] options
|
|
232
|
+
# @option options [required, Client] :client
|
|
233
|
+
# @option options [Integer] :max_attempts (40)
|
|
234
|
+
# @option options [Integer] :delay (15)
|
|
235
|
+
# @option options [Proc] :before_attempt
|
|
236
|
+
# @option options [Proc] :before_wait
|
|
237
|
+
def initialize(options)
|
|
238
|
+
@client = options.fetch(:client)
|
|
239
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
240
|
+
max_attempts: 40,
|
|
241
|
+
delay: 15,
|
|
242
|
+
poller: Aws::Waiters::Poller.new(
|
|
243
|
+
operation_name: :describe_export_tasks,
|
|
244
|
+
acceptors: [{
|
|
245
|
+
"expected" => "cancelled",
|
|
246
|
+
"matcher" => "pathAll",
|
|
247
|
+
"state" => "success",
|
|
248
|
+
"argument" => "export_tasks[].state"
|
|
249
|
+
}]
|
|
250
|
+
)
|
|
251
|
+
}.merge(options))
|
|
252
|
+
end
|
|
269
253
|
|
|
254
|
+
# @option (see Client#describe_export_tasks)
|
|
255
|
+
# @return (see Client#describe_export_tasks)
|
|
256
|
+
def wait(params = {})
|
|
257
|
+
@waiter.wait(client: @client, params: params)
|
|
270
258
|
end
|
|
271
259
|
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
# @param [Hash] options
|
|
275
|
-
# @option options [required, Client] :client
|
|
276
|
-
# @option options [Integer] :max_attempts (40)
|
|
277
|
-
# @option options [Integer] :delay (15)
|
|
278
|
-
# @option options [Proc] :before_attempt
|
|
279
|
-
# @option options [Proc] :before_wait
|
|
280
|
-
def initialize(options)
|
|
281
|
-
@client = options.fetch(:client)
|
|
282
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
283
|
-
max_attempts: 40,
|
|
284
|
-
delay: 15,
|
|
285
|
-
poller: Aws::Waiters::Poller.new(
|
|
286
|
-
operation_name: :describe_export_tasks,
|
|
287
|
-
acceptors: [{
|
|
288
|
-
"expected" => "cancelled",
|
|
289
|
-
"matcher" => "pathAll",
|
|
290
|
-
"state" => "success",
|
|
291
|
-
"argument" => "export_tasks[].state"
|
|
292
|
-
}]
|
|
293
|
-
)
|
|
294
|
-
}.merge(options))
|
|
295
|
-
end
|
|
260
|
+
# @api private
|
|
261
|
+
attr_reader :waiter
|
|
296
262
|
|
|
297
|
-
|
|
298
|
-
# @return (see Client#describe_export_tasks)
|
|
299
|
-
def wait(params = {})
|
|
300
|
-
@waiter.wait(client: @client, params: params)
|
|
301
|
-
end
|
|
263
|
+
end
|
|
302
264
|
|
|
303
|
-
|
|
304
|
-
|
|
265
|
+
class ExportTaskCompleted
|
|
266
|
+
|
|
267
|
+
# @param [Hash] options
|
|
268
|
+
# @option options [required, Client] :client
|
|
269
|
+
# @option options [Integer] :max_attempts (40)
|
|
270
|
+
# @option options [Integer] :delay (15)
|
|
271
|
+
# @option options [Proc] :before_attempt
|
|
272
|
+
# @option options [Proc] :before_wait
|
|
273
|
+
def initialize(options)
|
|
274
|
+
@client = options.fetch(:client)
|
|
275
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
276
|
+
max_attempts: 40,
|
|
277
|
+
delay: 15,
|
|
278
|
+
poller: Aws::Waiters::Poller.new(
|
|
279
|
+
operation_name: :describe_export_tasks,
|
|
280
|
+
acceptors: [{
|
|
281
|
+
"expected" => "completed",
|
|
282
|
+
"matcher" => "pathAll",
|
|
283
|
+
"state" => "success",
|
|
284
|
+
"argument" => "export_tasks[].state"
|
|
285
|
+
}]
|
|
286
|
+
)
|
|
287
|
+
}.merge(options))
|
|
288
|
+
end
|
|
305
289
|
|
|
290
|
+
# @option (see Client#describe_export_tasks)
|
|
291
|
+
# @return (see Client#describe_export_tasks)
|
|
292
|
+
def wait(params = {})
|
|
293
|
+
@waiter.wait(client: @client, params: params)
|
|
306
294
|
end
|
|
307
295
|
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
# @param [Hash] options
|
|
311
|
-
# @option options [required, Client] :client
|
|
312
|
-
# @option options [Integer] :max_attempts (40)
|
|
313
|
-
# @option options [Integer] :delay (15)
|
|
314
|
-
# @option options [Proc] :before_attempt
|
|
315
|
-
# @option options [Proc] :before_wait
|
|
316
|
-
def initialize(options)
|
|
317
|
-
@client = options.fetch(:client)
|
|
318
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
319
|
-
max_attempts: 40,
|
|
320
|
-
delay: 15,
|
|
321
|
-
poller: Aws::Waiters::Poller.new(
|
|
322
|
-
operation_name: :describe_export_tasks,
|
|
323
|
-
acceptors: [{
|
|
324
|
-
"expected" => "completed",
|
|
325
|
-
"matcher" => "pathAll",
|
|
326
|
-
"state" => "success",
|
|
327
|
-
"argument" => "export_tasks[].state"
|
|
328
|
-
}]
|
|
329
|
-
)
|
|
330
|
-
}.merge(options))
|
|
331
|
-
end
|
|
296
|
+
# @api private
|
|
297
|
+
attr_reader :waiter
|
|
332
298
|
|
|
333
|
-
|
|
334
|
-
# @return (see Client#describe_export_tasks)
|
|
335
|
-
def wait(params = {})
|
|
336
|
-
@waiter.wait(client: @client, params: params)
|
|
337
|
-
end
|
|
299
|
+
end
|
|
338
300
|
|
|
339
|
-
|
|
340
|
-
|
|
301
|
+
class ImageAvailable
|
|
302
|
+
|
|
303
|
+
# @param [Hash] options
|
|
304
|
+
# @option options [required, Client] :client
|
|
305
|
+
# @option options [Integer] :max_attempts (40)
|
|
306
|
+
# @option options [Integer] :delay (15)
|
|
307
|
+
# @option options [Proc] :before_attempt
|
|
308
|
+
# @option options [Proc] :before_wait
|
|
309
|
+
def initialize(options)
|
|
310
|
+
@client = options.fetch(:client)
|
|
311
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
312
|
+
max_attempts: 40,
|
|
313
|
+
delay: 15,
|
|
314
|
+
poller: Aws::Waiters::Poller.new(
|
|
315
|
+
operation_name: :describe_images,
|
|
316
|
+
acceptors: [
|
|
317
|
+
{
|
|
318
|
+
"state" => "success",
|
|
319
|
+
"matcher" => "pathAll",
|
|
320
|
+
"argument" => "images[].state",
|
|
321
|
+
"expected" => "available"
|
|
322
|
+
},
|
|
323
|
+
{
|
|
324
|
+
"state" => "failure",
|
|
325
|
+
"matcher" => "pathAny",
|
|
326
|
+
"argument" => "images[].state",
|
|
327
|
+
"expected" => "failed"
|
|
328
|
+
}
|
|
329
|
+
]
|
|
330
|
+
)
|
|
331
|
+
}.merge(options))
|
|
332
|
+
end
|
|
341
333
|
|
|
334
|
+
# @option (see Client#describe_images)
|
|
335
|
+
# @return (see Client#describe_images)
|
|
336
|
+
def wait(params = {})
|
|
337
|
+
@waiter.wait(client: @client, params: params)
|
|
342
338
|
end
|
|
343
339
|
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
# @param [Hash] options
|
|
347
|
-
# @option options [required, Client] :client
|
|
348
|
-
# @option options [Integer] :max_attempts (40)
|
|
349
|
-
# @option options [Integer] :delay (15)
|
|
350
|
-
# @option options [Proc] :before_attempt
|
|
351
|
-
# @option options [Proc] :before_wait
|
|
352
|
-
def initialize(options)
|
|
353
|
-
@client = options.fetch(:client)
|
|
354
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
355
|
-
max_attempts: 40,
|
|
356
|
-
delay: 15,
|
|
357
|
-
poller: Aws::Waiters::Poller.new(
|
|
358
|
-
operation_name: :describe_images,
|
|
359
|
-
acceptors: [
|
|
360
|
-
{
|
|
361
|
-
"matcher" => "path",
|
|
362
|
-
"expected" => true,
|
|
363
|
-
"argument" => "length(images[]) > `0`",
|
|
364
|
-
"state" => "success"
|
|
365
|
-
},
|
|
366
|
-
{
|
|
367
|
-
"matcher" => "error",
|
|
368
|
-
"expected" => "InvalidAMIID.NotFound",
|
|
369
|
-
"state" => "retry"
|
|
370
|
-
}
|
|
371
|
-
]
|
|
372
|
-
)
|
|
373
|
-
}.merge(options))
|
|
374
|
-
end
|
|
375
|
-
|
|
376
|
-
# @option (see Client#describe_images)
|
|
377
|
-
# @return (see Client#describe_images)
|
|
378
|
-
def wait(params = {})
|
|
379
|
-
@waiter.wait(client: @client, params: params)
|
|
380
|
-
end
|
|
381
|
-
|
|
382
|
-
# @api private
|
|
383
|
-
attr_reader :waiter
|
|
340
|
+
# @api private
|
|
341
|
+
attr_reader :waiter
|
|
384
342
|
|
|
385
|
-
|
|
343
|
+
end
|
|
386
344
|
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
end
|
|
419
|
-
|
|
420
|
-
# @option (see Client#describe_images)
|
|
421
|
-
# @return (see Client#describe_images)
|
|
422
|
-
def wait(params = {})
|
|
423
|
-
@waiter.wait(client: @client, params: params)
|
|
424
|
-
end
|
|
425
|
-
|
|
426
|
-
# @api private
|
|
427
|
-
attr_reader :waiter
|
|
345
|
+
class ImageExists
|
|
346
|
+
|
|
347
|
+
# @param [Hash] options
|
|
348
|
+
# @option options [required, Client] :client
|
|
349
|
+
# @option options [Integer] :max_attempts (40)
|
|
350
|
+
# @option options [Integer] :delay (15)
|
|
351
|
+
# @option options [Proc] :before_attempt
|
|
352
|
+
# @option options [Proc] :before_wait
|
|
353
|
+
def initialize(options)
|
|
354
|
+
@client = options.fetch(:client)
|
|
355
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
356
|
+
max_attempts: 40,
|
|
357
|
+
delay: 15,
|
|
358
|
+
poller: Aws::Waiters::Poller.new(
|
|
359
|
+
operation_name: :describe_images,
|
|
360
|
+
acceptors: [
|
|
361
|
+
{
|
|
362
|
+
"matcher" => "path",
|
|
363
|
+
"expected" => true,
|
|
364
|
+
"argument" => "length(images[]) > `0`",
|
|
365
|
+
"state" => "success"
|
|
366
|
+
},
|
|
367
|
+
{
|
|
368
|
+
"matcher" => "error",
|
|
369
|
+
"expected" => "InvalidAMIID.NotFound",
|
|
370
|
+
"state" => "retry"
|
|
371
|
+
}
|
|
372
|
+
]
|
|
373
|
+
)
|
|
374
|
+
}.merge(options))
|
|
375
|
+
end
|
|
428
376
|
|
|
377
|
+
# @option (see Client#describe_images)
|
|
378
|
+
# @return (see Client#describe_images)
|
|
379
|
+
def wait(params = {})
|
|
380
|
+
@waiter.wait(client: @client, params: params)
|
|
429
381
|
end
|
|
430
382
|
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
# @param [Hash] options
|
|
434
|
-
# @option options [required, Client] :client
|
|
435
|
-
# @option options [Integer] :max_attempts (40)
|
|
436
|
-
# @option options [Integer] :delay (15)
|
|
437
|
-
# @option options [Proc] :before_attempt
|
|
438
|
-
# @option options [Proc] :before_wait
|
|
439
|
-
def initialize(options)
|
|
440
|
-
@client = options.fetch(:client)
|
|
441
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
442
|
-
max_attempts: 40,
|
|
443
|
-
delay: 15,
|
|
444
|
-
poller: Aws::Waiters::Poller.new(
|
|
445
|
-
operation_name: :describe_instances,
|
|
446
|
-
acceptors: [
|
|
447
|
-
{
|
|
448
|
-
"expected" => "running",
|
|
449
|
-
"matcher" => "pathAll",
|
|
450
|
-
"state" => "success",
|
|
451
|
-
"argument" => "reservations[].instances[].state.name"
|
|
452
|
-
},
|
|
453
|
-
{
|
|
454
|
-
"expected" => "shutting-down",
|
|
455
|
-
"matcher" => "pathAny",
|
|
456
|
-
"state" => "failure",
|
|
457
|
-
"argument" => "reservations[].instances[].state.name"
|
|
458
|
-
},
|
|
459
|
-
{
|
|
460
|
-
"expected" => "terminated",
|
|
461
|
-
"matcher" => "pathAny",
|
|
462
|
-
"state" => "failure",
|
|
463
|
-
"argument" => "reservations[].instances[].state.name"
|
|
464
|
-
},
|
|
465
|
-
{
|
|
466
|
-
"expected" => "stopping",
|
|
467
|
-
"matcher" => "pathAny",
|
|
468
|
-
"state" => "failure",
|
|
469
|
-
"argument" => "reservations[].instances[].state.name"
|
|
470
|
-
},
|
|
471
|
-
{
|
|
472
|
-
"matcher" => "error",
|
|
473
|
-
"expected" => "InvalidInstanceID.NotFound",
|
|
474
|
-
"state" => "retry"
|
|
475
|
-
}
|
|
476
|
-
]
|
|
477
|
-
)
|
|
478
|
-
}.merge(options))
|
|
479
|
-
end
|
|
480
|
-
|
|
481
|
-
# @option (see Client#describe_instances)
|
|
482
|
-
# @return (see Client#describe_instances)
|
|
483
|
-
def wait(params = {})
|
|
484
|
-
@waiter.wait(client: @client, params: params)
|
|
485
|
-
end
|
|
486
|
-
|
|
487
|
-
# @api private
|
|
488
|
-
attr_reader :waiter
|
|
383
|
+
# @api private
|
|
384
|
+
attr_reader :waiter
|
|
489
385
|
|
|
490
|
-
|
|
386
|
+
end
|
|
491
387
|
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
# @option (see Client#describe_instance_status)
|
|
525
|
-
# @return (see Client#describe_instance_status)
|
|
526
|
-
def wait(params = {})
|
|
527
|
-
@waiter.wait(client: @client, params: params)
|
|
528
|
-
end
|
|
529
|
-
|
|
530
|
-
# @api private
|
|
531
|
-
attr_reader :waiter
|
|
388
|
+
class InstanceExists
|
|
389
|
+
|
|
390
|
+
# @param [Hash] options
|
|
391
|
+
# @option options [required, Client] :client
|
|
392
|
+
# @option options [Integer] :max_attempts (40)
|
|
393
|
+
# @option options [Integer] :delay (5)
|
|
394
|
+
# @option options [Proc] :before_attempt
|
|
395
|
+
# @option options [Proc] :before_wait
|
|
396
|
+
def initialize(options)
|
|
397
|
+
@client = options.fetch(:client)
|
|
398
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
399
|
+
max_attempts: 40,
|
|
400
|
+
delay: 5,
|
|
401
|
+
poller: Aws::Waiters::Poller.new(
|
|
402
|
+
operation_name: :describe_instances,
|
|
403
|
+
acceptors: [
|
|
404
|
+
{
|
|
405
|
+
"matcher" => "path",
|
|
406
|
+
"expected" => true,
|
|
407
|
+
"argument" => "length(reservations[]) > `0`",
|
|
408
|
+
"state" => "success"
|
|
409
|
+
},
|
|
410
|
+
{
|
|
411
|
+
"matcher" => "error",
|
|
412
|
+
"expected" => "InvalidInstanceID.NotFound",
|
|
413
|
+
"state" => "retry"
|
|
414
|
+
}
|
|
415
|
+
]
|
|
416
|
+
)
|
|
417
|
+
}.merge(options))
|
|
418
|
+
end
|
|
532
419
|
|
|
420
|
+
# @option (see Client#describe_instances)
|
|
421
|
+
# @return (see Client#describe_instances)
|
|
422
|
+
def wait(params = {})
|
|
423
|
+
@waiter.wait(client: @client, params: params)
|
|
533
424
|
end
|
|
534
425
|
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
# @param [Hash] options
|
|
538
|
-
# @option options [required, Client] :client
|
|
539
|
-
# @option options [Integer] :max_attempts (40)
|
|
540
|
-
# @option options [Integer] :delay (15)
|
|
541
|
-
# @option options [Proc] :before_attempt
|
|
542
|
-
# @option options [Proc] :before_wait
|
|
543
|
-
def initialize(options)
|
|
544
|
-
@client = options.fetch(:client)
|
|
545
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
546
|
-
max_attempts: 40,
|
|
547
|
-
delay: 15,
|
|
548
|
-
poller: Aws::Waiters::Poller.new(
|
|
549
|
-
operation_name: :describe_instances,
|
|
550
|
-
acceptors: [
|
|
551
|
-
{
|
|
552
|
-
"expected" => "stopped",
|
|
553
|
-
"matcher" => "pathAll",
|
|
554
|
-
"state" => "success",
|
|
555
|
-
"argument" => "reservations[].instances[].state.name"
|
|
556
|
-
},
|
|
557
|
-
{
|
|
558
|
-
"expected" => "pending",
|
|
559
|
-
"matcher" => "pathAny",
|
|
560
|
-
"state" => "failure",
|
|
561
|
-
"argument" => "reservations[].instances[].state.name"
|
|
562
|
-
},
|
|
563
|
-
{
|
|
564
|
-
"expected" => "terminated",
|
|
565
|
-
"matcher" => "pathAny",
|
|
566
|
-
"state" => "failure",
|
|
567
|
-
"argument" => "reservations[].instances[].state.name"
|
|
568
|
-
}
|
|
569
|
-
]
|
|
570
|
-
)
|
|
571
|
-
}.merge(options))
|
|
572
|
-
end
|
|
573
|
-
|
|
574
|
-
# @option (see Client#describe_instances)
|
|
575
|
-
# @return (see Client#describe_instances)
|
|
576
|
-
def wait(params = {})
|
|
577
|
-
@waiter.wait(client: @client, params: params)
|
|
578
|
-
end
|
|
579
|
-
|
|
580
|
-
# @api private
|
|
581
|
-
attr_reader :waiter
|
|
426
|
+
# @api private
|
|
427
|
+
attr_reader :waiter
|
|
582
428
|
|
|
583
|
-
|
|
429
|
+
end
|
|
584
430
|
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
431
|
+
class InstanceRunning
|
|
432
|
+
|
|
433
|
+
# @param [Hash] options
|
|
434
|
+
# @option options [required, Client] :client
|
|
435
|
+
# @option options [Integer] :max_attempts (40)
|
|
436
|
+
# @option options [Integer] :delay (15)
|
|
437
|
+
# @option options [Proc] :before_attempt
|
|
438
|
+
# @option options [Proc] :before_wait
|
|
439
|
+
def initialize(options)
|
|
440
|
+
@client = options.fetch(:client)
|
|
441
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
442
|
+
max_attempts: 40,
|
|
443
|
+
delay: 15,
|
|
444
|
+
poller: Aws::Waiters::Poller.new(
|
|
445
|
+
operation_name: :describe_instances,
|
|
446
|
+
acceptors: [
|
|
447
|
+
{
|
|
448
|
+
"expected" => "running",
|
|
449
|
+
"matcher" => "pathAll",
|
|
450
|
+
"state" => "success",
|
|
451
|
+
"argument" => "reservations[].instances[].state.name"
|
|
452
|
+
},
|
|
453
|
+
{
|
|
454
|
+
"expected" => "shutting-down",
|
|
455
|
+
"matcher" => "pathAny",
|
|
456
|
+
"state" => "failure",
|
|
457
|
+
"argument" => "reservations[].instances[].state.name"
|
|
458
|
+
},
|
|
459
|
+
{
|
|
460
|
+
"expected" => "terminated",
|
|
461
|
+
"matcher" => "pathAny",
|
|
462
|
+
"state" => "failure",
|
|
463
|
+
"argument" => "reservations[].instances[].state.name"
|
|
464
|
+
},
|
|
465
|
+
{
|
|
466
|
+
"expected" => "stopping",
|
|
467
|
+
"matcher" => "pathAny",
|
|
468
|
+
"state" => "failure",
|
|
469
|
+
"argument" => "reservations[].instances[].state.name"
|
|
470
|
+
},
|
|
471
|
+
{
|
|
472
|
+
"matcher" => "error",
|
|
473
|
+
"expected" => "InvalidInstanceID.NotFound",
|
|
474
|
+
"state" => "retry"
|
|
475
|
+
}
|
|
476
|
+
]
|
|
477
|
+
)
|
|
478
|
+
}.merge(options))
|
|
479
|
+
end
|
|
632
480
|
|
|
481
|
+
# @option (see Client#describe_instances)
|
|
482
|
+
# @return (see Client#describe_instances)
|
|
483
|
+
def wait(params = {})
|
|
484
|
+
@waiter.wait(client: @client, params: params)
|
|
633
485
|
end
|
|
634
486
|
|
|
635
|
-
|
|
636
|
-
|
|
637
|
-
# @param [Hash] options
|
|
638
|
-
# @option options [required, Client] :client
|
|
639
|
-
# @option options [Integer] :max_attempts (6)
|
|
640
|
-
# @option options [Integer] :delay (5)
|
|
641
|
-
# @option options [Proc] :before_attempt
|
|
642
|
-
# @option options [Proc] :before_wait
|
|
643
|
-
def initialize(options)
|
|
644
|
-
@client = options.fetch(:client)
|
|
645
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
646
|
-
max_attempts: 6,
|
|
647
|
-
delay: 5,
|
|
648
|
-
poller: Aws::Waiters::Poller.new(
|
|
649
|
-
operation_name: :describe_key_pairs,
|
|
650
|
-
acceptors: [
|
|
651
|
-
{
|
|
652
|
-
"expected" => true,
|
|
653
|
-
"matcher" => "pathAll",
|
|
654
|
-
"state" => "success",
|
|
655
|
-
"argument" => "length(key_pairs[].key_name) > `0`"
|
|
656
|
-
},
|
|
657
|
-
{
|
|
658
|
-
"expected" => "InvalidKeyPair.NotFound",
|
|
659
|
-
"matcher" => "error",
|
|
660
|
-
"state" => "retry"
|
|
661
|
-
}
|
|
662
|
-
]
|
|
663
|
-
)
|
|
664
|
-
}.merge(options))
|
|
665
|
-
end
|
|
666
|
-
|
|
667
|
-
# @option (see Client#describe_key_pairs)
|
|
668
|
-
# @return (see Client#describe_key_pairs)
|
|
669
|
-
def wait(params = {})
|
|
670
|
-
@waiter.wait(client: @client, params: params)
|
|
671
|
-
end
|
|
672
|
-
|
|
673
|
-
# @api private
|
|
674
|
-
attr_reader :waiter
|
|
487
|
+
# @api private
|
|
488
|
+
attr_reader :waiter
|
|
675
489
|
|
|
676
|
-
|
|
490
|
+
end
|
|
677
491
|
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
683
|
-
|
|
684
|
-
|
|
685
|
-
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
"argument" => "nat_gateways[].state",
|
|
710
|
-
"expected" => "deleting"
|
|
711
|
-
},
|
|
712
|
-
{
|
|
713
|
-
"state" => "failure",
|
|
714
|
-
"matcher" => "pathAny",
|
|
715
|
-
"argument" => "nat_gateways[].state",
|
|
716
|
-
"expected" => "deleted"
|
|
717
|
-
},
|
|
718
|
-
{
|
|
719
|
-
"state" => "retry",
|
|
720
|
-
"matcher" => "error",
|
|
721
|
-
"expected" => "NatGatewayNotFound"
|
|
722
|
-
}
|
|
723
|
-
]
|
|
724
|
-
)
|
|
725
|
-
}.merge(options))
|
|
726
|
-
end
|
|
727
|
-
|
|
728
|
-
# @option (see Client#describe_nat_gateways)
|
|
729
|
-
# @return (see Client#describe_nat_gateways)
|
|
730
|
-
def wait(params = {})
|
|
731
|
-
@waiter.wait(client: @client, params: params)
|
|
732
|
-
end
|
|
733
|
-
|
|
734
|
-
# @api private
|
|
735
|
-
attr_reader :waiter
|
|
492
|
+
class InstanceStatusOk
|
|
493
|
+
|
|
494
|
+
# @param [Hash] options
|
|
495
|
+
# @option options [required, Client] :client
|
|
496
|
+
# @option options [Integer] :max_attempts (40)
|
|
497
|
+
# @option options [Integer] :delay (15)
|
|
498
|
+
# @option options [Proc] :before_attempt
|
|
499
|
+
# @option options [Proc] :before_wait
|
|
500
|
+
def initialize(options)
|
|
501
|
+
@client = options.fetch(:client)
|
|
502
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
503
|
+
max_attempts: 40,
|
|
504
|
+
delay: 15,
|
|
505
|
+
poller: Aws::Waiters::Poller.new(
|
|
506
|
+
operation_name: :describe_instance_status,
|
|
507
|
+
acceptors: [
|
|
508
|
+
{
|
|
509
|
+
"state" => "success",
|
|
510
|
+
"matcher" => "pathAll",
|
|
511
|
+
"argument" => "instance_statuses[].instance_status.status",
|
|
512
|
+
"expected" => "ok"
|
|
513
|
+
},
|
|
514
|
+
{
|
|
515
|
+
"matcher" => "error",
|
|
516
|
+
"expected" => "InvalidInstanceID.NotFound",
|
|
517
|
+
"state" => "retry"
|
|
518
|
+
}
|
|
519
|
+
]
|
|
520
|
+
)
|
|
521
|
+
}.merge(options))
|
|
522
|
+
end
|
|
736
523
|
|
|
524
|
+
# @option (see Client#describe_instance_status)
|
|
525
|
+
# @return (see Client#describe_instance_status)
|
|
526
|
+
def wait(params = {})
|
|
527
|
+
@waiter.wait(client: @client, params: params)
|
|
737
528
|
end
|
|
738
529
|
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
# @param [Hash] options
|
|
742
|
-
# @option options [required, Client] :client
|
|
743
|
-
# @option options [Integer] :max_attempts (10)
|
|
744
|
-
# @option options [Integer] :delay (20)
|
|
745
|
-
# @option options [Proc] :before_attempt
|
|
746
|
-
# @option options [Proc] :before_wait
|
|
747
|
-
def initialize(options)
|
|
748
|
-
@client = options.fetch(:client)
|
|
749
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
750
|
-
max_attempts: 10,
|
|
751
|
-
delay: 20,
|
|
752
|
-
poller: Aws::Waiters::Poller.new(
|
|
753
|
-
operation_name: :describe_network_interfaces,
|
|
754
|
-
acceptors: [
|
|
755
|
-
{
|
|
756
|
-
"expected" => "available",
|
|
757
|
-
"matcher" => "pathAll",
|
|
758
|
-
"state" => "success",
|
|
759
|
-
"argument" => "network_interfaces[].status"
|
|
760
|
-
},
|
|
761
|
-
{
|
|
762
|
-
"expected" => "InvalidNetworkInterfaceID.NotFound",
|
|
763
|
-
"matcher" => "error",
|
|
764
|
-
"state" => "failure"
|
|
765
|
-
}
|
|
766
|
-
]
|
|
767
|
-
)
|
|
768
|
-
}.merge(options))
|
|
769
|
-
end
|
|
770
|
-
|
|
771
|
-
# @option (see Client#describe_network_interfaces)
|
|
772
|
-
# @return (see Client#describe_network_interfaces)
|
|
773
|
-
def wait(params = {})
|
|
774
|
-
@waiter.wait(client: @client, params: params)
|
|
775
|
-
end
|
|
776
|
-
|
|
777
|
-
# @api private
|
|
778
|
-
attr_reader :waiter
|
|
530
|
+
# @api private
|
|
531
|
+
attr_reader :waiter
|
|
779
532
|
|
|
780
|
-
|
|
533
|
+
end
|
|
781
534
|
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
535
|
+
class InstanceStopped
|
|
536
|
+
|
|
537
|
+
# @param [Hash] options
|
|
538
|
+
# @option options [required, Client] :client
|
|
539
|
+
# @option options [Integer] :max_attempts (40)
|
|
540
|
+
# @option options [Integer] :delay (15)
|
|
541
|
+
# @option options [Proc] :before_attempt
|
|
542
|
+
# @option options [Proc] :before_wait
|
|
543
|
+
def initialize(options)
|
|
544
|
+
@client = options.fetch(:client)
|
|
545
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
546
|
+
max_attempts: 40,
|
|
547
|
+
delay: 15,
|
|
548
|
+
poller: Aws::Waiters::Poller.new(
|
|
549
|
+
operation_name: :describe_instances,
|
|
550
|
+
acceptors: [
|
|
551
|
+
{
|
|
552
|
+
"expected" => "stopped",
|
|
553
|
+
"matcher" => "pathAll",
|
|
798
554
|
"state" => "success",
|
|
799
|
-
"
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
811
|
-
|
|
812
|
-
|
|
813
|
-
|
|
814
|
-
|
|
555
|
+
"argument" => "reservations[].instances[].state.name"
|
|
556
|
+
},
|
|
557
|
+
{
|
|
558
|
+
"expected" => "pending",
|
|
559
|
+
"matcher" => "pathAny",
|
|
560
|
+
"state" => "failure",
|
|
561
|
+
"argument" => "reservations[].instances[].state.name"
|
|
562
|
+
},
|
|
563
|
+
{
|
|
564
|
+
"expected" => "terminated",
|
|
565
|
+
"matcher" => "pathAny",
|
|
566
|
+
"state" => "failure",
|
|
567
|
+
"argument" => "reservations[].instances[].state.name"
|
|
568
|
+
}
|
|
569
|
+
]
|
|
570
|
+
)
|
|
571
|
+
}.merge(options))
|
|
572
|
+
end
|
|
815
573
|
|
|
574
|
+
# @option (see Client#describe_instances)
|
|
575
|
+
# @return (see Client#describe_instances)
|
|
576
|
+
def wait(params = {})
|
|
577
|
+
@waiter.wait(client: @client, params: params)
|
|
816
578
|
end
|
|
817
579
|
|
|
818
|
-
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
824
|
-
|
|
825
|
-
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
580
|
+
# @api private
|
|
581
|
+
attr_reader :waiter
|
|
582
|
+
|
|
583
|
+
end
|
|
584
|
+
|
|
585
|
+
class InstanceTerminated
|
|
586
|
+
|
|
587
|
+
# @param [Hash] options
|
|
588
|
+
# @option options [required, Client] :client
|
|
589
|
+
# @option options [Integer] :max_attempts (40)
|
|
590
|
+
# @option options [Integer] :delay (15)
|
|
591
|
+
# @option options [Proc] :before_attempt
|
|
592
|
+
# @option options [Proc] :before_wait
|
|
593
|
+
def initialize(options)
|
|
594
|
+
@client = options.fetch(:client)
|
|
595
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
596
|
+
max_attempts: 40,
|
|
597
|
+
delay: 15,
|
|
598
|
+
poller: Aws::Waiters::Poller.new(
|
|
599
|
+
operation_name: :describe_instances,
|
|
600
|
+
acceptors: [
|
|
601
|
+
{
|
|
602
|
+
"expected" => "terminated",
|
|
835
603
|
"matcher" => "pathAll",
|
|
836
604
|
"state" => "success",
|
|
837
|
-
"argument" => "
|
|
838
|
-
}
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
605
|
+
"argument" => "reservations[].instances[].state.name"
|
|
606
|
+
},
|
|
607
|
+
{
|
|
608
|
+
"expected" => "pending",
|
|
609
|
+
"matcher" => "pathAny",
|
|
610
|
+
"state" => "failure",
|
|
611
|
+
"argument" => "reservations[].instances[].state.name"
|
|
612
|
+
},
|
|
613
|
+
{
|
|
614
|
+
"expected" => "stopping",
|
|
615
|
+
"matcher" => "pathAny",
|
|
616
|
+
"state" => "failure",
|
|
617
|
+
"argument" => "reservations[].instances[].state.name"
|
|
618
|
+
}
|
|
619
|
+
]
|
|
620
|
+
)
|
|
621
|
+
}.merge(options))
|
|
622
|
+
end
|
|
842
623
|
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
624
|
+
# @option (see Client#describe_instances)
|
|
625
|
+
# @return (see Client#describe_instances)
|
|
626
|
+
def wait(params = {})
|
|
627
|
+
@waiter.wait(client: @client, params: params)
|
|
628
|
+
end
|
|
629
|
+
|
|
630
|
+
# @api private
|
|
631
|
+
attr_reader :waiter
|
|
848
632
|
|
|
849
|
-
|
|
850
|
-
|
|
633
|
+
end
|
|
634
|
+
|
|
635
|
+
class KeyPairExists
|
|
636
|
+
|
|
637
|
+
# @param [Hash] options
|
|
638
|
+
# @option options [required, Client] :client
|
|
639
|
+
# @option options [Integer] :max_attempts (6)
|
|
640
|
+
# @option options [Integer] :delay (5)
|
|
641
|
+
# @option options [Proc] :before_attempt
|
|
642
|
+
# @option options [Proc] :before_wait
|
|
643
|
+
def initialize(options)
|
|
644
|
+
@client = options.fetch(:client)
|
|
645
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
646
|
+
max_attempts: 6,
|
|
647
|
+
delay: 5,
|
|
648
|
+
poller: Aws::Waiters::Poller.new(
|
|
649
|
+
operation_name: :describe_key_pairs,
|
|
650
|
+
acceptors: [
|
|
651
|
+
{
|
|
652
|
+
"expected" => true,
|
|
653
|
+
"matcher" => "path",
|
|
654
|
+
"state" => "success",
|
|
655
|
+
"argument" => "length(key_pairs[].key_name) > `0`"
|
|
656
|
+
},
|
|
657
|
+
{
|
|
658
|
+
"expected" => "InvalidKeyPair.NotFound",
|
|
659
|
+
"matcher" => "error",
|
|
660
|
+
"state" => "retry"
|
|
661
|
+
}
|
|
662
|
+
]
|
|
663
|
+
)
|
|
664
|
+
}.merge(options))
|
|
665
|
+
end
|
|
851
666
|
|
|
667
|
+
# @option (see Client#describe_key_pairs)
|
|
668
|
+
# @return (see Client#describe_key_pairs)
|
|
669
|
+
def wait(params = {})
|
|
670
|
+
@waiter.wait(client: @client, params: params)
|
|
852
671
|
end
|
|
853
672
|
|
|
854
|
-
|
|
855
|
-
|
|
856
|
-
|
|
857
|
-
|
|
858
|
-
# @option options [Integer] :max_attempts (40)
|
|
859
|
-
# @option options [Integer] :delay (15)
|
|
860
|
-
# @option options [Proc] :before_attempt
|
|
861
|
-
# @option options [Proc] :before_wait
|
|
862
|
-
def initialize(options)
|
|
863
|
-
@client = options.fetch(:client)
|
|
864
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
865
|
-
max_attempts: 40,
|
|
866
|
-
delay: 15,
|
|
867
|
-
poller: Aws::Waiters::Poller.new(
|
|
868
|
-
operation_name: :describe_spot_instance_requests,
|
|
869
|
-
acceptors: [
|
|
870
|
-
{
|
|
871
|
-
"state" => "success",
|
|
872
|
-
"matcher" => "pathAll",
|
|
873
|
-
"argument" => "spot_instance_requests[].status.code",
|
|
874
|
-
"expected" => "fulfilled"
|
|
875
|
-
},
|
|
876
|
-
{
|
|
877
|
-
"state" => "failure",
|
|
878
|
-
"matcher" => "pathAny",
|
|
879
|
-
"argument" => "spot_instance_requests[].status.code",
|
|
880
|
-
"expected" => "schedule-expired"
|
|
881
|
-
},
|
|
882
|
-
{
|
|
883
|
-
"state" => "failure",
|
|
884
|
-
"matcher" => "pathAny",
|
|
885
|
-
"argument" => "spot_instance_requests[].status.code",
|
|
886
|
-
"expected" => "canceled-before-fulfillment"
|
|
887
|
-
},
|
|
888
|
-
{
|
|
889
|
-
"state" => "failure",
|
|
890
|
-
"matcher" => "pathAny",
|
|
891
|
-
"argument" => "spot_instance_requests[].status.code",
|
|
892
|
-
"expected" => "bad-parameters"
|
|
893
|
-
},
|
|
894
|
-
{
|
|
895
|
-
"state" => "failure",
|
|
896
|
-
"matcher" => "pathAny",
|
|
897
|
-
"argument" => "spot_instance_requests[].status.code",
|
|
898
|
-
"expected" => "system-error"
|
|
899
|
-
}
|
|
900
|
-
]
|
|
901
|
-
)
|
|
902
|
-
}.merge(options))
|
|
903
|
-
end
|
|
904
|
-
|
|
905
|
-
# @option (see Client#describe_spot_instance_requests)
|
|
906
|
-
# @return (see Client#describe_spot_instance_requests)
|
|
907
|
-
def wait(params = {})
|
|
908
|
-
@waiter.wait(client: @client, params: params)
|
|
909
|
-
end
|
|
910
|
-
|
|
911
|
-
# @api private
|
|
912
|
-
attr_reader :waiter
|
|
673
|
+
# @api private
|
|
674
|
+
attr_reader :waiter
|
|
675
|
+
|
|
676
|
+
end
|
|
913
677
|
|
|
678
|
+
class NatGatewayAvailable
|
|
679
|
+
|
|
680
|
+
# @param [Hash] options
|
|
681
|
+
# @option options [required, Client] :client
|
|
682
|
+
# @option options [Integer] :max_attempts (40)
|
|
683
|
+
# @option options [Integer] :delay (15)
|
|
684
|
+
# @option options [Proc] :before_attempt
|
|
685
|
+
# @option options [Proc] :before_wait
|
|
686
|
+
def initialize(options)
|
|
687
|
+
@client = options.fetch(:client)
|
|
688
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
689
|
+
max_attempts: 40,
|
|
690
|
+
delay: 15,
|
|
691
|
+
poller: Aws::Waiters::Poller.new(
|
|
692
|
+
operation_name: :describe_nat_gateways,
|
|
693
|
+
acceptors: [
|
|
694
|
+
{
|
|
695
|
+
"state" => "success",
|
|
696
|
+
"matcher" => "pathAll",
|
|
697
|
+
"argument" => "nat_gateways[].state",
|
|
698
|
+
"expected" => "available"
|
|
699
|
+
},
|
|
700
|
+
{
|
|
701
|
+
"state" => "failure",
|
|
702
|
+
"matcher" => "pathAny",
|
|
703
|
+
"argument" => "nat_gateways[].state",
|
|
704
|
+
"expected" => "failed"
|
|
705
|
+
},
|
|
706
|
+
{
|
|
707
|
+
"state" => "failure",
|
|
708
|
+
"matcher" => "pathAny",
|
|
709
|
+
"argument" => "nat_gateways[].state",
|
|
710
|
+
"expected" => "deleting"
|
|
711
|
+
},
|
|
712
|
+
{
|
|
713
|
+
"state" => "failure",
|
|
714
|
+
"matcher" => "pathAny",
|
|
715
|
+
"argument" => "nat_gateways[].state",
|
|
716
|
+
"expected" => "deleted"
|
|
717
|
+
},
|
|
718
|
+
{
|
|
719
|
+
"state" => "retry",
|
|
720
|
+
"matcher" => "error",
|
|
721
|
+
"expected" => "NatGatewayNotFound"
|
|
722
|
+
}
|
|
723
|
+
]
|
|
724
|
+
)
|
|
725
|
+
}.merge(options))
|
|
914
726
|
end
|
|
915
727
|
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
|
|
924
|
-
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
728
|
+
# @option (see Client#describe_nat_gateways)
|
|
729
|
+
# @return (see Client#describe_nat_gateways)
|
|
730
|
+
def wait(params = {})
|
|
731
|
+
@waiter.wait(client: @client, params: params)
|
|
732
|
+
end
|
|
733
|
+
|
|
734
|
+
# @api private
|
|
735
|
+
attr_reader :waiter
|
|
736
|
+
|
|
737
|
+
end
|
|
738
|
+
|
|
739
|
+
class NetworkInterfaceAvailable
|
|
740
|
+
|
|
741
|
+
# @param [Hash] options
|
|
742
|
+
# @option options [required, Client] :client
|
|
743
|
+
# @option options [Integer] :max_attempts (10)
|
|
744
|
+
# @option options [Integer] :delay (20)
|
|
745
|
+
# @option options [Proc] :before_attempt
|
|
746
|
+
# @option options [Proc] :before_wait
|
|
747
|
+
def initialize(options)
|
|
748
|
+
@client = options.fetch(:client)
|
|
749
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
750
|
+
max_attempts: 10,
|
|
751
|
+
delay: 20,
|
|
752
|
+
poller: Aws::Waiters::Poller.new(
|
|
753
|
+
operation_name: :describe_network_interfaces,
|
|
754
|
+
acceptors: [
|
|
755
|
+
{
|
|
932
756
|
"expected" => "available",
|
|
933
757
|
"matcher" => "pathAll",
|
|
934
758
|
"state" => "success",
|
|
935
|
-
"argument" => "
|
|
936
|
-
}
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
759
|
+
"argument" => "network_interfaces[].status"
|
|
760
|
+
},
|
|
761
|
+
{
|
|
762
|
+
"expected" => "InvalidNetworkInterfaceID.NotFound",
|
|
763
|
+
"matcher" => "error",
|
|
764
|
+
"state" => "failure"
|
|
765
|
+
}
|
|
766
|
+
]
|
|
767
|
+
)
|
|
768
|
+
}.merge(options))
|
|
769
|
+
end
|
|
770
|
+
|
|
771
|
+
# @option (see Client#describe_network_interfaces)
|
|
772
|
+
# @return (see Client#describe_network_interfaces)
|
|
773
|
+
def wait(params = {})
|
|
774
|
+
@waiter.wait(client: @client, params: params)
|
|
775
|
+
end
|
|
776
|
+
|
|
777
|
+
# @api private
|
|
778
|
+
attr_reader :waiter
|
|
779
|
+
|
|
780
|
+
end
|
|
781
|
+
|
|
782
|
+
class PasswordDataAvailable
|
|
783
|
+
|
|
784
|
+
# @param [Hash] options
|
|
785
|
+
# @option options [required, Client] :client
|
|
786
|
+
# @option options [Integer] :max_attempts (40)
|
|
787
|
+
# @option options [Integer] :delay (15)
|
|
788
|
+
# @option options [Proc] :before_attempt
|
|
789
|
+
# @option options [Proc] :before_wait
|
|
790
|
+
def initialize(options)
|
|
791
|
+
@client = options.fetch(:client)
|
|
792
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
793
|
+
max_attempts: 40,
|
|
794
|
+
delay: 15,
|
|
795
|
+
poller: Aws::Waiters::Poller.new(
|
|
796
|
+
operation_name: :get_password_data,
|
|
797
|
+
acceptors: [{
|
|
798
|
+
"state" => "success",
|
|
799
|
+
"matcher" => "path",
|
|
800
|
+
"argument" => "length(password_data) > `0`",
|
|
801
|
+
"expected" => true
|
|
802
|
+
}]
|
|
803
|
+
)
|
|
804
|
+
}.merge(options))
|
|
805
|
+
end
|
|
806
|
+
|
|
807
|
+
# @option (see Client#get_password_data)
|
|
808
|
+
# @return (see Client#get_password_data)
|
|
809
|
+
def wait(params = {})
|
|
810
|
+
@waiter.wait(client: @client, params: params)
|
|
811
|
+
end
|
|
812
|
+
|
|
813
|
+
# @api private
|
|
814
|
+
attr_reader :waiter
|
|
940
815
|
|
|
941
|
-
|
|
942
|
-
# @return (see Client#describe_subnets)
|
|
943
|
-
def wait(params = {})
|
|
944
|
-
@waiter.wait(client: @client, params: params)
|
|
945
|
-
end
|
|
816
|
+
end
|
|
946
817
|
|
|
947
|
-
|
|
948
|
-
|
|
818
|
+
class SnapshotCompleted
|
|
819
|
+
|
|
820
|
+
# @param [Hash] options
|
|
821
|
+
# @option options [required, Client] :client
|
|
822
|
+
# @option options [Integer] :max_attempts (40)
|
|
823
|
+
# @option options [Integer] :delay (15)
|
|
824
|
+
# @option options [Proc] :before_attempt
|
|
825
|
+
# @option options [Proc] :before_wait
|
|
826
|
+
def initialize(options)
|
|
827
|
+
@client = options.fetch(:client)
|
|
828
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
829
|
+
max_attempts: 40,
|
|
830
|
+
delay: 15,
|
|
831
|
+
poller: Aws::Waiters::Poller.new(
|
|
832
|
+
operation_name: :describe_snapshots,
|
|
833
|
+
acceptors: [{
|
|
834
|
+
"expected" => "completed",
|
|
835
|
+
"matcher" => "pathAll",
|
|
836
|
+
"state" => "success",
|
|
837
|
+
"argument" => "snapshots[].state"
|
|
838
|
+
}]
|
|
839
|
+
)
|
|
840
|
+
}.merge(options))
|
|
841
|
+
end
|
|
949
842
|
|
|
843
|
+
# @option (see Client#describe_snapshots)
|
|
844
|
+
# @return (see Client#describe_snapshots)
|
|
845
|
+
def wait(params = {})
|
|
846
|
+
@waiter.wait(client: @client, params: params)
|
|
950
847
|
end
|
|
951
848
|
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
849
|
+
# @api private
|
|
850
|
+
attr_reader :waiter
|
|
851
|
+
|
|
852
|
+
end
|
|
853
|
+
|
|
854
|
+
class SpotInstanceRequestFulfilled
|
|
855
|
+
|
|
856
|
+
# @param [Hash] options
|
|
857
|
+
# @option options [required, Client] :client
|
|
858
|
+
# @option options [Integer] :max_attempts (40)
|
|
859
|
+
# @option options [Integer] :delay (15)
|
|
860
|
+
# @option options [Proc] :before_attempt
|
|
861
|
+
# @option options [Proc] :before_wait
|
|
862
|
+
def initialize(options)
|
|
863
|
+
@client = options.fetch(:client)
|
|
864
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
865
|
+
max_attempts: 40,
|
|
866
|
+
delay: 15,
|
|
867
|
+
poller: Aws::Waiters::Poller.new(
|
|
868
|
+
operation_name: :describe_spot_instance_requests,
|
|
869
|
+
acceptors: [
|
|
870
|
+
{
|
|
968
871
|
"state" => "success",
|
|
969
872
|
"matcher" => "pathAll",
|
|
970
|
-
"argument" => "
|
|
971
|
-
"expected" => "
|
|
972
|
-
}
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
873
|
+
"argument" => "spot_instance_requests[].status.code",
|
|
874
|
+
"expected" => "fulfilled"
|
|
875
|
+
},
|
|
876
|
+
{
|
|
877
|
+
"state" => "failure",
|
|
878
|
+
"matcher" => "pathAny",
|
|
879
|
+
"argument" => "spot_instance_requests[].status.code",
|
|
880
|
+
"expected" => "schedule-expired"
|
|
881
|
+
},
|
|
882
|
+
{
|
|
883
|
+
"state" => "failure",
|
|
884
|
+
"matcher" => "pathAny",
|
|
885
|
+
"argument" => "spot_instance_requests[].status.code",
|
|
886
|
+
"expected" => "canceled-before-fulfillment"
|
|
887
|
+
},
|
|
888
|
+
{
|
|
889
|
+
"state" => "failure",
|
|
890
|
+
"matcher" => "pathAny",
|
|
891
|
+
"argument" => "spot_instance_requests[].status.code",
|
|
892
|
+
"expected" => "bad-parameters"
|
|
893
|
+
},
|
|
894
|
+
{
|
|
895
|
+
"state" => "failure",
|
|
896
|
+
"matcher" => "pathAny",
|
|
897
|
+
"argument" => "spot_instance_requests[].status.code",
|
|
898
|
+
"expected" => "system-error"
|
|
899
|
+
}
|
|
900
|
+
]
|
|
901
|
+
)
|
|
902
|
+
}.merge(options))
|
|
903
|
+
end
|
|
904
|
+
|
|
905
|
+
# @option (see Client#describe_spot_instance_requests)
|
|
906
|
+
# @return (see Client#describe_spot_instance_requests)
|
|
907
|
+
def wait(params = {})
|
|
908
|
+
@waiter.wait(client: @client, params: params)
|
|
909
|
+
end
|
|
976
910
|
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
end
|
|
911
|
+
# @api private
|
|
912
|
+
attr_reader :waiter
|
|
913
|
+
|
|
914
|
+
end
|
|
982
915
|
|
|
983
|
-
|
|
984
|
-
|
|
916
|
+
class SubnetAvailable
|
|
917
|
+
|
|
918
|
+
# @param [Hash] options
|
|
919
|
+
# @option options [required, Client] :client
|
|
920
|
+
# @option options [Integer] :max_attempts (40)
|
|
921
|
+
# @option options [Integer] :delay (15)
|
|
922
|
+
# @option options [Proc] :before_attempt
|
|
923
|
+
# @option options [Proc] :before_wait
|
|
924
|
+
def initialize(options)
|
|
925
|
+
@client = options.fetch(:client)
|
|
926
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
927
|
+
max_attempts: 40,
|
|
928
|
+
delay: 15,
|
|
929
|
+
poller: Aws::Waiters::Poller.new(
|
|
930
|
+
operation_name: :describe_subnets,
|
|
931
|
+
acceptors: [{
|
|
932
|
+
"expected" => "available",
|
|
933
|
+
"matcher" => "pathAll",
|
|
934
|
+
"state" => "success",
|
|
935
|
+
"argument" => "subnets[].state"
|
|
936
|
+
}]
|
|
937
|
+
)
|
|
938
|
+
}.merge(options))
|
|
939
|
+
end
|
|
985
940
|
|
|
941
|
+
# @option (see Client#describe_subnets)
|
|
942
|
+
# @return (see Client#describe_subnets)
|
|
943
|
+
def wait(params = {})
|
|
944
|
+
@waiter.wait(client: @client, params: params)
|
|
986
945
|
end
|
|
987
946
|
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
1012
|
-
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
)
|
|
1018
|
-
}.merge(options))
|
|
1019
|
-
end
|
|
1020
|
-
|
|
1021
|
-
# @option (see Client#describe_volumes)
|
|
1022
|
-
# @return (see Client#describe_volumes)
|
|
1023
|
-
def wait(params = {})
|
|
1024
|
-
@waiter.wait(client: @client, params: params)
|
|
1025
|
-
end
|
|
1026
|
-
|
|
1027
|
-
# @api private
|
|
1028
|
-
attr_reader :waiter
|
|
947
|
+
# @api private
|
|
948
|
+
attr_reader :waiter
|
|
949
|
+
|
|
950
|
+
end
|
|
951
|
+
|
|
952
|
+
class SystemStatusOk
|
|
953
|
+
|
|
954
|
+
# @param [Hash] options
|
|
955
|
+
# @option options [required, Client] :client
|
|
956
|
+
# @option options [Integer] :max_attempts (40)
|
|
957
|
+
# @option options [Integer] :delay (15)
|
|
958
|
+
# @option options [Proc] :before_attempt
|
|
959
|
+
# @option options [Proc] :before_wait
|
|
960
|
+
def initialize(options)
|
|
961
|
+
@client = options.fetch(:client)
|
|
962
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
963
|
+
max_attempts: 40,
|
|
964
|
+
delay: 15,
|
|
965
|
+
poller: Aws::Waiters::Poller.new(
|
|
966
|
+
operation_name: :describe_instance_status,
|
|
967
|
+
acceptors: [{
|
|
968
|
+
"state" => "success",
|
|
969
|
+
"matcher" => "pathAll",
|
|
970
|
+
"argument" => "instance_statuses[].system_status.status",
|
|
971
|
+
"expected" => "ok"
|
|
972
|
+
}]
|
|
973
|
+
)
|
|
974
|
+
}.merge(options))
|
|
975
|
+
end
|
|
1029
976
|
|
|
977
|
+
# @option (see Client#describe_instance_status)
|
|
978
|
+
# @return (see Client#describe_instance_status)
|
|
979
|
+
def wait(params = {})
|
|
980
|
+
@waiter.wait(client: @client, params: params)
|
|
1030
981
|
end
|
|
1031
982
|
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
1039
|
-
|
|
1040
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
1043
|
-
|
|
1044
|
-
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1048
|
-
|
|
1049
|
-
|
|
1050
|
-
|
|
1051
|
-
|
|
1052
|
-
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
|
|
1056
|
-
|
|
1057
|
-
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1064
|
-
|
|
1065
|
-
|
|
1066
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
# @api private
|
|
1071
|
-
attr_reader :waiter
|
|
983
|
+
# @api private
|
|
984
|
+
attr_reader :waiter
|
|
985
|
+
|
|
986
|
+
end
|
|
987
|
+
|
|
988
|
+
class VolumeAvailable
|
|
989
|
+
|
|
990
|
+
# @param [Hash] options
|
|
991
|
+
# @option options [required, Client] :client
|
|
992
|
+
# @option options [Integer] :max_attempts (40)
|
|
993
|
+
# @option options [Integer] :delay (15)
|
|
994
|
+
# @option options [Proc] :before_attempt
|
|
995
|
+
# @option options [Proc] :before_wait
|
|
996
|
+
def initialize(options)
|
|
997
|
+
@client = options.fetch(:client)
|
|
998
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
999
|
+
max_attempts: 40,
|
|
1000
|
+
delay: 15,
|
|
1001
|
+
poller: Aws::Waiters::Poller.new(
|
|
1002
|
+
operation_name: :describe_volumes,
|
|
1003
|
+
acceptors: [
|
|
1004
|
+
{
|
|
1005
|
+
"expected" => "available",
|
|
1006
|
+
"matcher" => "pathAll",
|
|
1007
|
+
"state" => "success",
|
|
1008
|
+
"argument" => "volumes[].state"
|
|
1009
|
+
},
|
|
1010
|
+
{
|
|
1011
|
+
"expected" => "deleted",
|
|
1012
|
+
"matcher" => "pathAny",
|
|
1013
|
+
"state" => "failure",
|
|
1014
|
+
"argument" => "volumes[].state"
|
|
1015
|
+
}
|
|
1016
|
+
]
|
|
1017
|
+
)
|
|
1018
|
+
}.merge(options))
|
|
1019
|
+
end
|
|
1072
1020
|
|
|
1021
|
+
# @option (see Client#describe_volumes)
|
|
1022
|
+
# @return (see Client#describe_volumes)
|
|
1023
|
+
def wait(params = {})
|
|
1024
|
+
@waiter.wait(client: @client, params: params)
|
|
1073
1025
|
end
|
|
1074
1026
|
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
# @option options [Integer] :max_attempts (40)
|
|
1080
|
-
# @option options [Integer] :delay (15)
|
|
1081
|
-
# @option options [Proc] :before_attempt
|
|
1082
|
-
# @option options [Proc] :before_wait
|
|
1083
|
-
def initialize(options)
|
|
1084
|
-
@client = options.fetch(:client)
|
|
1085
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
1086
|
-
max_attempts: 40,
|
|
1087
|
-
delay: 15,
|
|
1088
|
-
poller: Aws::Waiters::Poller.new(
|
|
1089
|
-
operation_name: :describe_volumes,
|
|
1090
|
-
acceptors: [
|
|
1091
|
-
{
|
|
1092
|
-
"expected" => "in-use",
|
|
1093
|
-
"matcher" => "pathAll",
|
|
1094
|
-
"state" => "success",
|
|
1095
|
-
"argument" => "volumes[].state"
|
|
1096
|
-
},
|
|
1097
|
-
{
|
|
1098
|
-
"expected" => "deleted",
|
|
1099
|
-
"matcher" => "pathAny",
|
|
1100
|
-
"state" => "failure",
|
|
1101
|
-
"argument" => "volumes[].state"
|
|
1102
|
-
}
|
|
1103
|
-
]
|
|
1104
|
-
)
|
|
1105
|
-
}.merge(options))
|
|
1106
|
-
end
|
|
1107
|
-
|
|
1108
|
-
# @option (see Client#describe_volumes)
|
|
1109
|
-
# @return (see Client#describe_volumes)
|
|
1110
|
-
def wait(params = {})
|
|
1111
|
-
@waiter.wait(client: @client, params: params)
|
|
1112
|
-
end
|
|
1113
|
-
|
|
1114
|
-
# @api private
|
|
1115
|
-
attr_reader :waiter
|
|
1027
|
+
# @api private
|
|
1028
|
+
attr_reader :waiter
|
|
1029
|
+
|
|
1030
|
+
end
|
|
1116
1031
|
|
|
1032
|
+
class VolumeDeleted
|
|
1033
|
+
|
|
1034
|
+
# @param [Hash] options
|
|
1035
|
+
# @option options [required, Client] :client
|
|
1036
|
+
# @option options [Integer] :max_attempts (40)
|
|
1037
|
+
# @option options [Integer] :delay (15)
|
|
1038
|
+
# @option options [Proc] :before_attempt
|
|
1039
|
+
# @option options [Proc] :before_wait
|
|
1040
|
+
def initialize(options)
|
|
1041
|
+
@client = options.fetch(:client)
|
|
1042
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1043
|
+
max_attempts: 40,
|
|
1044
|
+
delay: 15,
|
|
1045
|
+
poller: Aws::Waiters::Poller.new(
|
|
1046
|
+
operation_name: :describe_volumes,
|
|
1047
|
+
acceptors: [
|
|
1048
|
+
{
|
|
1049
|
+
"expected" => "deleted",
|
|
1050
|
+
"matcher" => "pathAll",
|
|
1051
|
+
"state" => "success",
|
|
1052
|
+
"argument" => "volumes[].state"
|
|
1053
|
+
},
|
|
1054
|
+
{
|
|
1055
|
+
"matcher" => "error",
|
|
1056
|
+
"expected" => "InvalidVolume.NotFound",
|
|
1057
|
+
"state" => "success"
|
|
1058
|
+
}
|
|
1059
|
+
]
|
|
1060
|
+
)
|
|
1061
|
+
}.merge(options))
|
|
1117
1062
|
end
|
|
1118
1063
|
|
|
1119
|
-
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
1132
|
-
|
|
1133
|
-
|
|
1134
|
-
|
|
1135
|
-
|
|
1064
|
+
# @option (see Client#describe_volumes)
|
|
1065
|
+
# @return (see Client#describe_volumes)
|
|
1066
|
+
def wait(params = {})
|
|
1067
|
+
@waiter.wait(client: @client, params: params)
|
|
1068
|
+
end
|
|
1069
|
+
|
|
1070
|
+
# @api private
|
|
1071
|
+
attr_reader :waiter
|
|
1072
|
+
|
|
1073
|
+
end
|
|
1074
|
+
|
|
1075
|
+
class VolumeInUse
|
|
1076
|
+
|
|
1077
|
+
# @param [Hash] options
|
|
1078
|
+
# @option options [required, Client] :client
|
|
1079
|
+
# @option options [Integer] :max_attempts (40)
|
|
1080
|
+
# @option options [Integer] :delay (15)
|
|
1081
|
+
# @option options [Proc] :before_attempt
|
|
1082
|
+
# @option options [Proc] :before_wait
|
|
1083
|
+
def initialize(options)
|
|
1084
|
+
@client = options.fetch(:client)
|
|
1085
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1086
|
+
max_attempts: 40,
|
|
1087
|
+
delay: 15,
|
|
1088
|
+
poller: Aws::Waiters::Poller.new(
|
|
1089
|
+
operation_name: :describe_volumes,
|
|
1090
|
+
acceptors: [
|
|
1091
|
+
{
|
|
1092
|
+
"expected" => "in-use",
|
|
1136
1093
|
"matcher" => "pathAll",
|
|
1137
1094
|
"state" => "success",
|
|
1138
|
-
"argument" => "
|
|
1139
|
-
}
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
|
|
1095
|
+
"argument" => "volumes[].state"
|
|
1096
|
+
},
|
|
1097
|
+
{
|
|
1098
|
+
"expected" => "deleted",
|
|
1099
|
+
"matcher" => "pathAny",
|
|
1100
|
+
"state" => "failure",
|
|
1101
|
+
"argument" => "volumes[].state"
|
|
1102
|
+
}
|
|
1103
|
+
]
|
|
1104
|
+
)
|
|
1105
|
+
}.merge(options))
|
|
1106
|
+
end
|
|
1107
|
+
|
|
1108
|
+
# @option (see Client#describe_volumes)
|
|
1109
|
+
# @return (see Client#describe_volumes)
|
|
1110
|
+
def wait(params = {})
|
|
1111
|
+
@waiter.wait(client: @client, params: params)
|
|
1112
|
+
end
|
|
1113
|
+
|
|
1114
|
+
# @api private
|
|
1115
|
+
attr_reader :waiter
|
|
1116
|
+
|
|
1117
|
+
end
|
|
1118
|
+
|
|
1119
|
+
class VpcAvailable
|
|
1120
|
+
|
|
1121
|
+
# @param [Hash] options
|
|
1122
|
+
# @option options [required, Client] :client
|
|
1123
|
+
# @option options [Integer] :max_attempts (40)
|
|
1124
|
+
# @option options [Integer] :delay (15)
|
|
1125
|
+
# @option options [Proc] :before_attempt
|
|
1126
|
+
# @option options [Proc] :before_wait
|
|
1127
|
+
def initialize(options)
|
|
1128
|
+
@client = options.fetch(:client)
|
|
1129
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1130
|
+
max_attempts: 40,
|
|
1131
|
+
delay: 15,
|
|
1132
|
+
poller: Aws::Waiters::Poller.new(
|
|
1133
|
+
operation_name: :describe_vpcs,
|
|
1134
|
+
acceptors: [{
|
|
1135
|
+
"expected" => "available",
|
|
1136
|
+
"matcher" => "pathAll",
|
|
1137
|
+
"state" => "success",
|
|
1138
|
+
"argument" => "vpcs[].state"
|
|
1139
|
+
}]
|
|
1140
|
+
)
|
|
1141
|
+
}.merge(options))
|
|
1142
|
+
end
|
|
1143
1143
|
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1144
|
+
# @option (see Client#describe_vpcs)
|
|
1145
|
+
# @return (see Client#describe_vpcs)
|
|
1146
|
+
def wait(params = {})
|
|
1147
|
+
@waiter.wait(client: @client, params: params)
|
|
1148
|
+
end
|
|
1149
|
+
|
|
1150
|
+
# @api private
|
|
1151
|
+
attr_reader :waiter
|
|
1152
|
+
|
|
1153
|
+
end
|
|
1149
1154
|
|
|
1150
|
-
|
|
1151
|
-
|
|
1155
|
+
class VpcExists
|
|
1156
|
+
|
|
1157
|
+
# @param [Hash] options
|
|
1158
|
+
# @option options [required, Client] :client
|
|
1159
|
+
# @option options [Integer] :max_attempts (5)
|
|
1160
|
+
# @option options [Integer] :delay (1)
|
|
1161
|
+
# @option options [Proc] :before_attempt
|
|
1162
|
+
# @option options [Proc] :before_wait
|
|
1163
|
+
def initialize(options)
|
|
1164
|
+
@client = options.fetch(:client)
|
|
1165
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1166
|
+
max_attempts: 5,
|
|
1167
|
+
delay: 1,
|
|
1168
|
+
poller: Aws::Waiters::Poller.new(
|
|
1169
|
+
operation_name: :describe_vpcs,
|
|
1170
|
+
acceptors: [
|
|
1171
|
+
{
|
|
1172
|
+
"matcher" => "status",
|
|
1173
|
+
"expected" => 200,
|
|
1174
|
+
"state" => "success"
|
|
1175
|
+
},
|
|
1176
|
+
{
|
|
1177
|
+
"matcher" => "error",
|
|
1178
|
+
"expected" => "InvalidVpcID.NotFound",
|
|
1179
|
+
"state" => "retry"
|
|
1180
|
+
}
|
|
1181
|
+
]
|
|
1182
|
+
)
|
|
1183
|
+
}.merge(options))
|
|
1184
|
+
end
|
|
1152
1185
|
|
|
1186
|
+
# @option (see Client#describe_vpcs)
|
|
1187
|
+
# @return (see Client#describe_vpcs)
|
|
1188
|
+
def wait(params = {})
|
|
1189
|
+
@waiter.wait(client: @client, params: params)
|
|
1153
1190
|
end
|
|
1154
1191
|
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
# @api private
|
|
1193
|
-
attr_reader :waiter
|
|
1192
|
+
# @api private
|
|
1193
|
+
attr_reader :waiter
|
|
1194
|
+
|
|
1195
|
+
end
|
|
1196
|
+
|
|
1197
|
+
class VpcPeeringConnectionDeleted
|
|
1198
|
+
|
|
1199
|
+
# @param [Hash] options
|
|
1200
|
+
# @option options [required, Client] :client
|
|
1201
|
+
# @option options [Integer] :max_attempts (40)
|
|
1202
|
+
# @option options [Integer] :delay (15)
|
|
1203
|
+
# @option options [Proc] :before_attempt
|
|
1204
|
+
# @option options [Proc] :before_wait
|
|
1205
|
+
def initialize(options)
|
|
1206
|
+
@client = options.fetch(:client)
|
|
1207
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1208
|
+
max_attempts: 40,
|
|
1209
|
+
delay: 15,
|
|
1210
|
+
poller: Aws::Waiters::Poller.new(
|
|
1211
|
+
operation_name: :describe_vpc_peering_connections,
|
|
1212
|
+
acceptors: [
|
|
1213
|
+
{
|
|
1214
|
+
"expected" => "deleted",
|
|
1215
|
+
"matcher" => "pathAll",
|
|
1216
|
+
"state" => "success",
|
|
1217
|
+
"argument" => "vpc_peering_connections[].status.code"
|
|
1218
|
+
},
|
|
1219
|
+
{
|
|
1220
|
+
"matcher" => "error",
|
|
1221
|
+
"expected" => "InvalidVpcPeeringConnectionID.NotFound",
|
|
1222
|
+
"state" => "success"
|
|
1223
|
+
}
|
|
1224
|
+
]
|
|
1225
|
+
)
|
|
1226
|
+
}.merge(options))
|
|
1227
|
+
end
|
|
1194
1228
|
|
|
1229
|
+
# @option (see Client#describe_vpc_peering_connections)
|
|
1230
|
+
# @return (see Client#describe_vpc_peering_connections)
|
|
1231
|
+
def wait(params = {})
|
|
1232
|
+
@waiter.wait(client: @client, params: params)
|
|
1195
1233
|
end
|
|
1196
1234
|
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
1205
|
-
|
|
1206
|
-
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
|
|
1220
|
-
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
)
|
|
1233
|
-
}.merge(options))
|
|
1234
|
-
end
|
|
1235
|
-
|
|
1236
|
-
# @option (see Client#describe_vpn_connections)
|
|
1237
|
-
# @return (see Client#describe_vpn_connections)
|
|
1238
|
-
def wait(params = {})
|
|
1239
|
-
@waiter.wait(client: @client, params: params)
|
|
1240
|
-
end
|
|
1241
|
-
|
|
1242
|
-
# @api private
|
|
1243
|
-
attr_reader :waiter
|
|
1235
|
+
# @api private
|
|
1236
|
+
attr_reader :waiter
|
|
1237
|
+
|
|
1238
|
+
end
|
|
1239
|
+
|
|
1240
|
+
class VpcPeeringConnectionExists
|
|
1241
|
+
|
|
1242
|
+
# @param [Hash] options
|
|
1243
|
+
# @option options [required, Client] :client
|
|
1244
|
+
# @option options [Integer] :max_attempts (40)
|
|
1245
|
+
# @option options [Integer] :delay (15)
|
|
1246
|
+
# @option options [Proc] :before_attempt
|
|
1247
|
+
# @option options [Proc] :before_wait
|
|
1248
|
+
def initialize(options)
|
|
1249
|
+
@client = options.fetch(:client)
|
|
1250
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1251
|
+
max_attempts: 40,
|
|
1252
|
+
delay: 15,
|
|
1253
|
+
poller: Aws::Waiters::Poller.new(
|
|
1254
|
+
operation_name: :describe_vpc_peering_connections,
|
|
1255
|
+
acceptors: [
|
|
1256
|
+
{
|
|
1257
|
+
"matcher" => "status",
|
|
1258
|
+
"expected" => 200,
|
|
1259
|
+
"state" => "success"
|
|
1260
|
+
},
|
|
1261
|
+
{
|
|
1262
|
+
"matcher" => "error",
|
|
1263
|
+
"expected" => "InvalidVpcPeeringConnectionID.NotFound",
|
|
1264
|
+
"state" => "retry"
|
|
1265
|
+
}
|
|
1266
|
+
]
|
|
1267
|
+
)
|
|
1268
|
+
}.merge(options))
|
|
1269
|
+
end
|
|
1244
1270
|
|
|
1271
|
+
# @option (see Client#describe_vpc_peering_connections)
|
|
1272
|
+
# @return (see Client#describe_vpc_peering_connections)
|
|
1273
|
+
def wait(params = {})
|
|
1274
|
+
@waiter.wait(client: @client, params: params)
|
|
1245
1275
|
end
|
|
1246
1276
|
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
|
|
1273
|
-
|
|
1274
|
-
|
|
1275
|
-
|
|
1276
|
-
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1277
|
+
# @api private
|
|
1278
|
+
attr_reader :waiter
|
|
1279
|
+
|
|
1280
|
+
end
|
|
1281
|
+
|
|
1282
|
+
class VpnConnectionAvailable
|
|
1283
|
+
|
|
1284
|
+
# @param [Hash] options
|
|
1285
|
+
# @option options [required, Client] :client
|
|
1286
|
+
# @option options [Integer] :max_attempts (40)
|
|
1287
|
+
# @option options [Integer] :delay (15)
|
|
1288
|
+
# @option options [Proc] :before_attempt
|
|
1289
|
+
# @option options [Proc] :before_wait
|
|
1290
|
+
def initialize(options)
|
|
1291
|
+
@client = options.fetch(:client)
|
|
1292
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1293
|
+
max_attempts: 40,
|
|
1294
|
+
delay: 15,
|
|
1295
|
+
poller: Aws::Waiters::Poller.new(
|
|
1296
|
+
operation_name: :describe_vpn_connections,
|
|
1297
|
+
acceptors: [
|
|
1298
|
+
{
|
|
1299
|
+
"expected" => "available",
|
|
1300
|
+
"matcher" => "pathAll",
|
|
1301
|
+
"state" => "success",
|
|
1302
|
+
"argument" => "vpn_connections[].state"
|
|
1303
|
+
},
|
|
1304
|
+
{
|
|
1305
|
+
"expected" => "deleting",
|
|
1306
|
+
"matcher" => "pathAny",
|
|
1307
|
+
"state" => "failure",
|
|
1308
|
+
"argument" => "vpn_connections[].state"
|
|
1309
|
+
},
|
|
1310
|
+
{
|
|
1311
|
+
"expected" => "deleted",
|
|
1312
|
+
"matcher" => "pathAny",
|
|
1313
|
+
"state" => "failure",
|
|
1314
|
+
"argument" => "vpn_connections[].state"
|
|
1315
|
+
}
|
|
1316
|
+
]
|
|
1317
|
+
)
|
|
1318
|
+
}.merge(options))
|
|
1319
|
+
end
|
|
1288
1320
|
|
|
1321
|
+
# @option (see Client#describe_vpn_connections)
|
|
1322
|
+
# @return (see Client#describe_vpn_connections)
|
|
1323
|
+
def wait(params = {})
|
|
1324
|
+
@waiter.wait(client: @client, params: params)
|
|
1289
1325
|
end
|
|
1290
1326
|
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
|
|
1295
|
-
# @option options [Integer] :max_attempts (40)
|
|
1296
|
-
# @option options [Integer] :delay (15)
|
|
1297
|
-
# @option options [Proc] :before_attempt
|
|
1298
|
-
# @option options [Proc] :before_wait
|
|
1299
|
-
def initialize(options)
|
|
1300
|
-
@client = options.fetch(:client)
|
|
1301
|
-
@waiter = Aws::Waiters::Waiter.new({
|
|
1302
|
-
max_attempts: 40,
|
|
1303
|
-
delay: 15,
|
|
1304
|
-
poller: Aws::Waiters::Poller.new(
|
|
1305
|
-
operation_name: :describe_vpc_peering_connections,
|
|
1306
|
-
acceptors: [
|
|
1307
|
-
{
|
|
1308
|
-
"matcher" => "status",
|
|
1309
|
-
"expected" => 200,
|
|
1310
|
-
"state" => "success"
|
|
1311
|
-
},
|
|
1312
|
-
{
|
|
1313
|
-
"matcher" => "error",
|
|
1314
|
-
"expected" => "InvalidVpcPeeringConnectionID.NotFound",
|
|
1315
|
-
"state" => "retry"
|
|
1316
|
-
}
|
|
1317
|
-
]
|
|
1318
|
-
)
|
|
1319
|
-
}.merge(options))
|
|
1320
|
-
end
|
|
1321
|
-
|
|
1322
|
-
# @option (see Client#describe_vpc_peering_connections)
|
|
1323
|
-
# @return (see Client#describe_vpc_peering_connections)
|
|
1324
|
-
def wait(params = {})
|
|
1325
|
-
@waiter.wait(client: @client, params: params)
|
|
1326
|
-
end
|
|
1327
|
-
|
|
1328
|
-
# @api private
|
|
1329
|
-
attr_reader :waiter
|
|
1327
|
+
# @api private
|
|
1328
|
+
attr_reader :waiter
|
|
1329
|
+
|
|
1330
|
+
end
|
|
1330
1331
|
|
|
1332
|
+
class VpnConnectionDeleted
|
|
1333
|
+
|
|
1334
|
+
# @param [Hash] options
|
|
1335
|
+
# @option options [required, Client] :client
|
|
1336
|
+
# @option options [Integer] :max_attempts (40)
|
|
1337
|
+
# @option options [Integer] :delay (15)
|
|
1338
|
+
# @option options [Proc] :before_attempt
|
|
1339
|
+
# @option options [Proc] :before_wait
|
|
1340
|
+
def initialize(options)
|
|
1341
|
+
@client = options.fetch(:client)
|
|
1342
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
1343
|
+
max_attempts: 40,
|
|
1344
|
+
delay: 15,
|
|
1345
|
+
poller: Aws::Waiters::Poller.new(
|
|
1346
|
+
operation_name: :describe_vpn_connections,
|
|
1347
|
+
acceptors: [
|
|
1348
|
+
{
|
|
1349
|
+
"expected" => "deleted",
|
|
1350
|
+
"matcher" => "pathAll",
|
|
1351
|
+
"state" => "success",
|
|
1352
|
+
"argument" => "vpn_connections[].state"
|
|
1353
|
+
},
|
|
1354
|
+
{
|
|
1355
|
+
"expected" => "pending",
|
|
1356
|
+
"matcher" => "pathAny",
|
|
1357
|
+
"state" => "failure",
|
|
1358
|
+
"argument" => "vpn_connections[].state"
|
|
1359
|
+
}
|
|
1360
|
+
]
|
|
1361
|
+
)
|
|
1362
|
+
}.merge(options))
|
|
1363
|
+
end
|
|
1364
|
+
|
|
1365
|
+
# @option (see Client#describe_vpn_connections)
|
|
1366
|
+
# @return (see Client#describe_vpn_connections)
|
|
1367
|
+
def wait(params = {})
|
|
1368
|
+
@waiter.wait(client: @client, params: params)
|
|
1331
1369
|
end
|
|
1370
|
+
|
|
1371
|
+
# @api private
|
|
1372
|
+
attr_reader :waiter
|
|
1373
|
+
|
|
1332
1374
|
end
|
|
1333
1375
|
end
|
|
1334
1376
|
end
|