aws-sdk-databasemigrationservice 1.11.0 → 1.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: b64aa23746136cc7473c09f762548e1b28569ecc
|
4
|
+
data.tar.gz: d5e237d8ac9a6d11d01ea6e803240abd3343626f
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: f8e928d8e167bd98363786ad7a4b5030cdc1551b8cc08df47ee996b28b01ce17a427d4786e90805f746afde29a52020de8dc594c47579264b391c441a3e65eb1
|
7
|
+
data.tar.gz: ca165c37caa6d8516d0875a07865dbbef7e444296070b8603950b89a507a2117bfb1b3a2649660038063fd49fe8d551b085c443142b5f140f9b0b42c19cc2b72
|
@@ -12,6 +12,7 @@ require_relative 'aws-sdk-databasemigrationservice/types'
|
|
12
12
|
require_relative 'aws-sdk-databasemigrationservice/client_api'
|
13
13
|
require_relative 'aws-sdk-databasemigrationservice/client'
|
14
14
|
require_relative 'aws-sdk-databasemigrationservice/errors'
|
15
|
+
require_relative 'aws-sdk-databasemigrationservice/waiters'
|
15
16
|
require_relative 'aws-sdk-databasemigrationservice/resource'
|
16
17
|
require_relative 'aws-sdk-databasemigrationservice/customizations'
|
17
18
|
|
@@ -42,6 +43,6 @@ require_relative 'aws-sdk-databasemigrationservice/customizations'
|
|
42
43
|
# @service
|
43
44
|
module Aws::DatabaseMigrationService
|
44
45
|
|
45
|
-
GEM_VERSION = '1.
|
46
|
+
GEM_VERSION = '1.12.0'
|
46
47
|
|
47
48
|
end
|
@@ -4284,14 +4284,141 @@ module Aws::DatabaseMigrationService
|
|
4284
4284
|
params: params,
|
4285
4285
|
config: config)
|
4286
4286
|
context[:gem_name] = 'aws-sdk-databasemigrationservice'
|
4287
|
-
context[:gem_version] = '1.
|
4287
|
+
context[:gem_version] = '1.12.0'
|
4288
4288
|
Seahorse::Client::Request.new(handlers, context)
|
4289
4289
|
end
|
4290
4290
|
|
4291
|
+
# Polls an API operation until a resource enters a desired state.
|
4292
|
+
#
|
4293
|
+
# ## Basic Usage
|
4294
|
+
#
|
4295
|
+
# A waiter will call an API operation until:
|
4296
|
+
#
|
4297
|
+
# * It is successful
|
4298
|
+
# * It enters a terminal state
|
4299
|
+
# * It makes the maximum number of attempts
|
4300
|
+
#
|
4301
|
+
# In between attempts, the waiter will sleep.
|
4302
|
+
#
|
4303
|
+
# # polls in a loop, sleeping between attempts
|
4304
|
+
# client.waiter_until(waiter_name, params)
|
4305
|
+
#
|
4306
|
+
# ## Configuration
|
4307
|
+
#
|
4308
|
+
# You can configure the maximum number of polling attempts, and the
|
4309
|
+
# delay (in seconds) between each polling attempt. You can pass
|
4310
|
+
# configuration as the final arguments hash.
|
4311
|
+
#
|
4312
|
+
# # poll for ~25 seconds
|
4313
|
+
# client.wait_until(waiter_name, params, {
|
4314
|
+
# max_attempts: 5,
|
4315
|
+
# delay: 5,
|
4316
|
+
# })
|
4317
|
+
#
|
4318
|
+
# ## Callbacks
|
4319
|
+
#
|
4320
|
+
# You can be notified before each polling attempt and before each
|
4321
|
+
# delay. If you throw `:success` or `:failure` from these callbacks,
|
4322
|
+
# it will terminate the waiter.
|
4323
|
+
#
|
4324
|
+
# started_at = Time.now
|
4325
|
+
# client.wait_until(waiter_name, params, {
|
4326
|
+
#
|
4327
|
+
# # disable max attempts
|
4328
|
+
# max_attempts: nil,
|
4329
|
+
#
|
4330
|
+
# # poll for 1 hour, instead of a number of attempts
|
4331
|
+
# before_wait: -> (attempts, response) do
|
4332
|
+
# throw :failure if Time.now - started_at > 3600
|
4333
|
+
# end
|
4334
|
+
# })
|
4335
|
+
#
|
4336
|
+
# ## Handling Errors
|
4337
|
+
#
|
4338
|
+
# When a waiter is unsuccessful, it will raise an error.
|
4339
|
+
# All of the failure errors extend from
|
4340
|
+
# {Aws::Waiters::Errors::WaiterFailed}.
|
4341
|
+
#
|
4342
|
+
# begin
|
4343
|
+
# client.wait_until(...)
|
4344
|
+
# rescue Aws::Waiters::Errors::WaiterFailed
|
4345
|
+
# # resource did not enter the desired state in time
|
4346
|
+
# end
|
4347
|
+
#
|
4348
|
+
# ## Valid Waiters
|
4349
|
+
#
|
4350
|
+
# The following table lists the valid waiter names, the operations they call,
|
4351
|
+
# and the default `:delay` and `:max_attempts` values.
|
4352
|
+
#
|
4353
|
+
# | waiter_name | params | :delay | :max_attempts |
|
4354
|
+
# | ------------------------------ | --------------------------------- | -------- | ------------- |
|
4355
|
+
# | endpoint_deleted | {#describe_endpoints} | 5 | 60 |
|
4356
|
+
# | replication_instance_available | {#describe_replication_instances} | 60 | 60 |
|
4357
|
+
# | replication_instance_deleted | {#describe_replication_instances} | 15 | 60 |
|
4358
|
+
# | replication_task_deleted | {#describe_replication_tasks} | 15 | 60 |
|
4359
|
+
# | replication_task_ready | {#describe_replication_tasks} | 15 | 60 |
|
4360
|
+
# | replication_task_running | {#describe_replication_tasks} | 15 | 60 |
|
4361
|
+
# | replication_task_stopped | {#describe_replication_tasks} | 15 | 60 |
|
4362
|
+
# | test_connection_succeeds | {#test_connection} | 5 | 60 |
|
4363
|
+
#
|
4364
|
+
# @raise [Errors::FailureStateError] Raised when the waiter terminates
|
4365
|
+
# because the waiter has entered a state that it will not transition
|
4366
|
+
# out of, preventing success.
|
4367
|
+
#
|
4368
|
+
# @raise [Errors::TooManyAttemptsError] Raised when the configured
|
4369
|
+
# maximum number of attempts have been made, and the waiter is not
|
4370
|
+
# yet successful.
|
4371
|
+
#
|
4372
|
+
# @raise [Errors::UnexpectedError] Raised when an error is encounted
|
4373
|
+
# while polling for a resource that is not expected.
|
4374
|
+
#
|
4375
|
+
# @raise [Errors::NoSuchWaiterError] Raised when you request to wait
|
4376
|
+
# for an unknown state.
|
4377
|
+
#
|
4378
|
+
# @return [Boolean] Returns `true` if the waiter was successful.
|
4379
|
+
# @param [Symbol] waiter_name
|
4380
|
+
# @param [Hash] params ({})
|
4381
|
+
# @param [Hash] options ({})
|
4382
|
+
# @option options [Integer] :max_attempts
|
4383
|
+
# @option options [Integer] :delay
|
4384
|
+
# @option options [Proc] :before_attempt
|
4385
|
+
# @option options [Proc] :before_wait
|
4386
|
+
def wait_until(waiter_name, params = {}, options = {})
|
4387
|
+
w = waiter(waiter_name, options)
|
4388
|
+
yield(w.waiter) if block_given? # deprecated
|
4389
|
+
w.wait(params)
|
4390
|
+
end
|
4391
|
+
|
4291
4392
|
# @api private
|
4292
4393
|
# @deprecated
|
4293
4394
|
def waiter_names
|
4294
|
-
|
4395
|
+
waiters.keys
|
4396
|
+
end
|
4397
|
+
|
4398
|
+
private
|
4399
|
+
|
4400
|
+
# @param [Symbol] waiter_name
|
4401
|
+
# @param [Hash] options ({})
|
4402
|
+
def waiter(waiter_name, options = {})
|
4403
|
+
waiter_class = waiters[waiter_name]
|
4404
|
+
if waiter_class
|
4405
|
+
waiter_class.new(options.merge(client: self))
|
4406
|
+
else
|
4407
|
+
raise Aws::Waiters::Errors::NoSuchWaiterError.new(waiter_name, waiters.keys)
|
4408
|
+
end
|
4409
|
+
end
|
4410
|
+
|
4411
|
+
def waiters
|
4412
|
+
{
|
4413
|
+
endpoint_deleted: Waiters::EndpointDeleted,
|
4414
|
+
replication_instance_available: Waiters::ReplicationInstanceAvailable,
|
4415
|
+
replication_instance_deleted: Waiters::ReplicationInstanceDeleted,
|
4416
|
+
replication_task_deleted: Waiters::ReplicationTaskDeleted,
|
4417
|
+
replication_task_ready: Waiters::ReplicationTaskReady,
|
4418
|
+
replication_task_running: Waiters::ReplicationTaskRunning,
|
4419
|
+
replication_task_stopped: Waiters::ReplicationTaskStopped,
|
4420
|
+
test_connection_succeeds: Waiters::TestConnectionSucceeds
|
4421
|
+
}
|
4295
4422
|
end
|
4296
4423
|
|
4297
4424
|
class << self
|
@@ -0,0 +1,544 @@
|
|
1
|
+
# WARNING ABOUT GENERATED CODE
|
2
|
+
#
|
3
|
+
# This file is generated. See the contributing guide for more information:
|
4
|
+
# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
|
5
|
+
#
|
6
|
+
# WARNING ABOUT GENERATED CODE
|
7
|
+
|
8
|
+
require 'aws-sdk-core/waiters'
|
9
|
+
|
10
|
+
module Aws::DatabaseMigrationService
|
11
|
+
module Waiters
|
12
|
+
|
13
|
+
# Wait until testing endpoint is deleted.
|
14
|
+
class EndpointDeleted
|
15
|
+
|
16
|
+
# @param [Hash] options
|
17
|
+
# @option options [required, Client] :client
|
18
|
+
# @option options [Integer] :max_attempts (60)
|
19
|
+
# @option options [Integer] :delay (5)
|
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: 60,
|
26
|
+
delay: 5,
|
27
|
+
poller: Aws::Waiters::Poller.new(
|
28
|
+
operation_name: :describe_endpoints,
|
29
|
+
acceptors: [
|
30
|
+
{
|
31
|
+
"expected" => "ResourceNotFoundFault",
|
32
|
+
"matcher" => "error",
|
33
|
+
"state" => "success"
|
34
|
+
},
|
35
|
+
{
|
36
|
+
"argument" => "endpoints[].status",
|
37
|
+
"expected" => "active",
|
38
|
+
"matcher" => "pathAny",
|
39
|
+
"state" => "failure"
|
40
|
+
},
|
41
|
+
{
|
42
|
+
"argument" => "endpoints[].status",
|
43
|
+
"expected" => "creating",
|
44
|
+
"matcher" => "pathAny",
|
45
|
+
"state" => "failure"
|
46
|
+
}
|
47
|
+
]
|
48
|
+
)
|
49
|
+
}.merge(options))
|
50
|
+
end
|
51
|
+
|
52
|
+
# @option (see Client#describe_endpoints)
|
53
|
+
# @return (see Client#describe_endpoints)
|
54
|
+
def wait(params = {})
|
55
|
+
@waiter.wait(client: @client, params: params)
|
56
|
+
end
|
57
|
+
|
58
|
+
# @api private
|
59
|
+
attr_reader :waiter
|
60
|
+
|
61
|
+
end
|
62
|
+
|
63
|
+
# Wait until DMS replication instance is available.
|
64
|
+
class ReplicationInstanceAvailable
|
65
|
+
|
66
|
+
# @param [Hash] options
|
67
|
+
# @option options [required, Client] :client
|
68
|
+
# @option options [Integer] :max_attempts (60)
|
69
|
+
# @option options [Integer] :delay (60)
|
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: 60,
|
76
|
+
delay: 60,
|
77
|
+
poller: Aws::Waiters::Poller.new(
|
78
|
+
operation_name: :describe_replication_instances,
|
79
|
+
acceptors: [
|
80
|
+
{
|
81
|
+
"argument" => "replication_instances[].replication_instance_status",
|
82
|
+
"expected" => "available",
|
83
|
+
"matcher" => "pathAll",
|
84
|
+
"state" => "success"
|
85
|
+
},
|
86
|
+
{
|
87
|
+
"argument" => "replication_instances[].replication_instance_status",
|
88
|
+
"expected" => "deleting",
|
89
|
+
"matcher" => "pathAny",
|
90
|
+
"state" => "failure"
|
91
|
+
},
|
92
|
+
{
|
93
|
+
"argument" => "replication_instances[].replication_instance_status",
|
94
|
+
"expected" => "incompatible-credentials",
|
95
|
+
"matcher" => "pathAny",
|
96
|
+
"state" => "failure"
|
97
|
+
},
|
98
|
+
{
|
99
|
+
"argument" => "replication_instances[].replication_instance_status",
|
100
|
+
"expected" => "incompatible-network",
|
101
|
+
"matcher" => "pathAny",
|
102
|
+
"state" => "failure"
|
103
|
+
},
|
104
|
+
{
|
105
|
+
"argument" => "replication_instances[].replication_instance_status",
|
106
|
+
"expected" => "inaccessible-encryption-credentials",
|
107
|
+
"matcher" => "pathAny",
|
108
|
+
"state" => "failure"
|
109
|
+
}
|
110
|
+
]
|
111
|
+
)
|
112
|
+
}.merge(options))
|
113
|
+
end
|
114
|
+
|
115
|
+
# @option (see Client#describe_replication_instances)
|
116
|
+
# @return (see Client#describe_replication_instances)
|
117
|
+
def wait(params = {})
|
118
|
+
@waiter.wait(client: @client, params: params)
|
119
|
+
end
|
120
|
+
|
121
|
+
# @api private
|
122
|
+
attr_reader :waiter
|
123
|
+
|
124
|
+
end
|
125
|
+
|
126
|
+
# Wait until DMS replication instance is deleted.
|
127
|
+
class ReplicationInstanceDeleted
|
128
|
+
|
129
|
+
# @param [Hash] options
|
130
|
+
# @option options [required, Client] :client
|
131
|
+
# @option options [Integer] :max_attempts (60)
|
132
|
+
# @option options [Integer] :delay (15)
|
133
|
+
# @option options [Proc] :before_attempt
|
134
|
+
# @option options [Proc] :before_wait
|
135
|
+
def initialize(options)
|
136
|
+
@client = options.fetch(:client)
|
137
|
+
@waiter = Aws::Waiters::Waiter.new({
|
138
|
+
max_attempts: 60,
|
139
|
+
delay: 15,
|
140
|
+
poller: Aws::Waiters::Poller.new(
|
141
|
+
operation_name: :describe_replication_instances,
|
142
|
+
acceptors: [
|
143
|
+
{
|
144
|
+
"argument" => "replication_instances[].replication_instance_status",
|
145
|
+
"expected" => "available",
|
146
|
+
"matcher" => "pathAny",
|
147
|
+
"state" => "failure"
|
148
|
+
},
|
149
|
+
{
|
150
|
+
"expected" => "ResourceNotFoundFault",
|
151
|
+
"matcher" => "error",
|
152
|
+
"state" => "success"
|
153
|
+
}
|
154
|
+
]
|
155
|
+
)
|
156
|
+
}.merge(options))
|
157
|
+
end
|
158
|
+
|
159
|
+
# @option (see Client#describe_replication_instances)
|
160
|
+
# @return (see Client#describe_replication_instances)
|
161
|
+
def wait(params = {})
|
162
|
+
@waiter.wait(client: @client, params: params)
|
163
|
+
end
|
164
|
+
|
165
|
+
# @api private
|
166
|
+
attr_reader :waiter
|
167
|
+
|
168
|
+
end
|
169
|
+
|
170
|
+
# Wait until DMS replication task is deleted.
|
171
|
+
class ReplicationTaskDeleted
|
172
|
+
|
173
|
+
# @param [Hash] options
|
174
|
+
# @option options [required, Client] :client
|
175
|
+
# @option options [Integer] :max_attempts (60)
|
176
|
+
# @option options [Integer] :delay (15)
|
177
|
+
# @option options [Proc] :before_attempt
|
178
|
+
# @option options [Proc] :before_wait
|
179
|
+
def initialize(options)
|
180
|
+
@client = options.fetch(:client)
|
181
|
+
@waiter = Aws::Waiters::Waiter.new({
|
182
|
+
max_attempts: 60,
|
183
|
+
delay: 15,
|
184
|
+
poller: Aws::Waiters::Poller.new(
|
185
|
+
operation_name: :describe_replication_tasks,
|
186
|
+
acceptors: [
|
187
|
+
{
|
188
|
+
"argument" => "replication_tasks[].status",
|
189
|
+
"expected" => "ready",
|
190
|
+
"matcher" => "pathAny",
|
191
|
+
"state" => "failure"
|
192
|
+
},
|
193
|
+
{
|
194
|
+
"argument" => "replication_tasks[].status",
|
195
|
+
"expected" => "creating",
|
196
|
+
"matcher" => "pathAny",
|
197
|
+
"state" => "failure"
|
198
|
+
},
|
199
|
+
{
|
200
|
+
"argument" => "replication_tasks[].status",
|
201
|
+
"expected" => "stopped",
|
202
|
+
"matcher" => "pathAny",
|
203
|
+
"state" => "failure"
|
204
|
+
},
|
205
|
+
{
|
206
|
+
"argument" => "replication_tasks[].status",
|
207
|
+
"expected" => "running",
|
208
|
+
"matcher" => "pathAny",
|
209
|
+
"state" => "failure"
|
210
|
+
},
|
211
|
+
{
|
212
|
+
"argument" => "replication_tasks[].status",
|
213
|
+
"expected" => "failed",
|
214
|
+
"matcher" => "pathAny",
|
215
|
+
"state" => "failure"
|
216
|
+
},
|
217
|
+
{
|
218
|
+
"expected" => "ResourceNotFoundFault",
|
219
|
+
"matcher" => "error",
|
220
|
+
"state" => "success"
|
221
|
+
}
|
222
|
+
]
|
223
|
+
)
|
224
|
+
}.merge(options))
|
225
|
+
end
|
226
|
+
|
227
|
+
# @option (see Client#describe_replication_tasks)
|
228
|
+
# @return (see Client#describe_replication_tasks)
|
229
|
+
def wait(params = {})
|
230
|
+
@waiter.wait(client: @client, params: params)
|
231
|
+
end
|
232
|
+
|
233
|
+
# @api private
|
234
|
+
attr_reader :waiter
|
235
|
+
|
236
|
+
end
|
237
|
+
|
238
|
+
# Wait until DMS replication task is ready.
|
239
|
+
class ReplicationTaskReady
|
240
|
+
|
241
|
+
# @param [Hash] options
|
242
|
+
# @option options [required, Client] :client
|
243
|
+
# @option options [Integer] :max_attempts (60)
|
244
|
+
# @option options [Integer] :delay (15)
|
245
|
+
# @option options [Proc] :before_attempt
|
246
|
+
# @option options [Proc] :before_wait
|
247
|
+
def initialize(options)
|
248
|
+
@client = options.fetch(:client)
|
249
|
+
@waiter = Aws::Waiters::Waiter.new({
|
250
|
+
max_attempts: 60,
|
251
|
+
delay: 15,
|
252
|
+
poller: Aws::Waiters::Poller.new(
|
253
|
+
operation_name: :describe_replication_tasks,
|
254
|
+
acceptors: [
|
255
|
+
{
|
256
|
+
"argument" => "replication_tasks[].status",
|
257
|
+
"expected" => "ready",
|
258
|
+
"matcher" => "pathAll",
|
259
|
+
"state" => "success"
|
260
|
+
},
|
261
|
+
{
|
262
|
+
"argument" => "replication_tasks[].status",
|
263
|
+
"expected" => "starting",
|
264
|
+
"matcher" => "pathAny",
|
265
|
+
"state" => "failure"
|
266
|
+
},
|
267
|
+
{
|
268
|
+
"argument" => "replication_tasks[].status",
|
269
|
+
"expected" => "running",
|
270
|
+
"matcher" => "pathAny",
|
271
|
+
"state" => "failure"
|
272
|
+
},
|
273
|
+
{
|
274
|
+
"argument" => "replication_tasks[].status",
|
275
|
+
"expected" => "stopping",
|
276
|
+
"matcher" => "pathAny",
|
277
|
+
"state" => "failure"
|
278
|
+
},
|
279
|
+
{
|
280
|
+
"argument" => "replication_tasks[].status",
|
281
|
+
"expected" => "stopped",
|
282
|
+
"matcher" => "pathAny",
|
283
|
+
"state" => "failure"
|
284
|
+
},
|
285
|
+
{
|
286
|
+
"argument" => "replication_tasks[].status",
|
287
|
+
"expected" => "failed",
|
288
|
+
"matcher" => "pathAny",
|
289
|
+
"state" => "failure"
|
290
|
+
},
|
291
|
+
{
|
292
|
+
"argument" => "replication_tasks[].status",
|
293
|
+
"expected" => "modifying",
|
294
|
+
"matcher" => "pathAny",
|
295
|
+
"state" => "failure"
|
296
|
+
},
|
297
|
+
{
|
298
|
+
"argument" => "replication_tasks[].status",
|
299
|
+
"expected" => "testing",
|
300
|
+
"matcher" => "pathAny",
|
301
|
+
"state" => "failure"
|
302
|
+
},
|
303
|
+
{
|
304
|
+
"argument" => "replication_tasks[].status",
|
305
|
+
"expected" => "deleting",
|
306
|
+
"matcher" => "pathAny",
|
307
|
+
"state" => "failure"
|
308
|
+
}
|
309
|
+
]
|
310
|
+
)
|
311
|
+
}.merge(options))
|
312
|
+
end
|
313
|
+
|
314
|
+
# @option (see Client#describe_replication_tasks)
|
315
|
+
# @return (see Client#describe_replication_tasks)
|
316
|
+
def wait(params = {})
|
317
|
+
@waiter.wait(client: @client, params: params)
|
318
|
+
end
|
319
|
+
|
320
|
+
# @api private
|
321
|
+
attr_reader :waiter
|
322
|
+
|
323
|
+
end
|
324
|
+
|
325
|
+
# Wait until DMS replication task is running.
|
326
|
+
class ReplicationTaskRunning
|
327
|
+
|
328
|
+
# @param [Hash] options
|
329
|
+
# @option options [required, Client] :client
|
330
|
+
# @option options [Integer] :max_attempts (60)
|
331
|
+
# @option options [Integer] :delay (15)
|
332
|
+
# @option options [Proc] :before_attempt
|
333
|
+
# @option options [Proc] :before_wait
|
334
|
+
def initialize(options)
|
335
|
+
@client = options.fetch(:client)
|
336
|
+
@waiter = Aws::Waiters::Waiter.new({
|
337
|
+
max_attempts: 60,
|
338
|
+
delay: 15,
|
339
|
+
poller: Aws::Waiters::Poller.new(
|
340
|
+
operation_name: :describe_replication_tasks,
|
341
|
+
acceptors: [
|
342
|
+
{
|
343
|
+
"argument" => "replication_tasks[].status",
|
344
|
+
"expected" => "running",
|
345
|
+
"matcher" => "pathAll",
|
346
|
+
"state" => "success"
|
347
|
+
},
|
348
|
+
{
|
349
|
+
"argument" => "replication_tasks[].status",
|
350
|
+
"expected" => "ready",
|
351
|
+
"matcher" => "pathAny",
|
352
|
+
"state" => "failure"
|
353
|
+
},
|
354
|
+
{
|
355
|
+
"argument" => "replication_tasks[].status",
|
356
|
+
"expected" => "creating",
|
357
|
+
"matcher" => "pathAny",
|
358
|
+
"state" => "failure"
|
359
|
+
},
|
360
|
+
{
|
361
|
+
"argument" => "replication_tasks[].status",
|
362
|
+
"expected" => "stopping",
|
363
|
+
"matcher" => "pathAny",
|
364
|
+
"state" => "failure"
|
365
|
+
},
|
366
|
+
{
|
367
|
+
"argument" => "replication_tasks[].status",
|
368
|
+
"expected" => "stopped",
|
369
|
+
"matcher" => "pathAny",
|
370
|
+
"state" => "failure"
|
371
|
+
},
|
372
|
+
{
|
373
|
+
"argument" => "replication_tasks[].status",
|
374
|
+
"expected" => "failed",
|
375
|
+
"matcher" => "pathAny",
|
376
|
+
"state" => "failure"
|
377
|
+
},
|
378
|
+
{
|
379
|
+
"argument" => "replication_tasks[].status",
|
380
|
+
"expected" => "modifying",
|
381
|
+
"matcher" => "pathAny",
|
382
|
+
"state" => "failure"
|
383
|
+
},
|
384
|
+
{
|
385
|
+
"argument" => "replication_tasks[].status",
|
386
|
+
"expected" => "testing",
|
387
|
+
"matcher" => "pathAny",
|
388
|
+
"state" => "failure"
|
389
|
+
},
|
390
|
+
{
|
391
|
+
"argument" => "replication_tasks[].status",
|
392
|
+
"expected" => "deleting",
|
393
|
+
"matcher" => "pathAny",
|
394
|
+
"state" => "failure"
|
395
|
+
}
|
396
|
+
]
|
397
|
+
)
|
398
|
+
}.merge(options))
|
399
|
+
end
|
400
|
+
|
401
|
+
# @option (see Client#describe_replication_tasks)
|
402
|
+
# @return (see Client#describe_replication_tasks)
|
403
|
+
def wait(params = {})
|
404
|
+
@waiter.wait(client: @client, params: params)
|
405
|
+
end
|
406
|
+
|
407
|
+
# @api private
|
408
|
+
attr_reader :waiter
|
409
|
+
|
410
|
+
end
|
411
|
+
|
412
|
+
# Wait until DMS replication task is stopped.
|
413
|
+
class ReplicationTaskStopped
|
414
|
+
|
415
|
+
# @param [Hash] options
|
416
|
+
# @option options [required, Client] :client
|
417
|
+
# @option options [Integer] :max_attempts (60)
|
418
|
+
# @option options [Integer] :delay (15)
|
419
|
+
# @option options [Proc] :before_attempt
|
420
|
+
# @option options [Proc] :before_wait
|
421
|
+
def initialize(options)
|
422
|
+
@client = options.fetch(:client)
|
423
|
+
@waiter = Aws::Waiters::Waiter.new({
|
424
|
+
max_attempts: 60,
|
425
|
+
delay: 15,
|
426
|
+
poller: Aws::Waiters::Poller.new(
|
427
|
+
operation_name: :describe_replication_tasks,
|
428
|
+
acceptors: [
|
429
|
+
{
|
430
|
+
"argument" => "replication_tasks[].status",
|
431
|
+
"expected" => "stopped",
|
432
|
+
"matcher" => "pathAll",
|
433
|
+
"state" => "success"
|
434
|
+
},
|
435
|
+
{
|
436
|
+
"argument" => "replication_tasks[].status",
|
437
|
+
"expected" => "ready",
|
438
|
+
"matcher" => "pathAny",
|
439
|
+
"state" => "failure"
|
440
|
+
},
|
441
|
+
{
|
442
|
+
"argument" => "replication_tasks[].status",
|
443
|
+
"expected" => "creating",
|
444
|
+
"matcher" => "pathAny",
|
445
|
+
"state" => "failure"
|
446
|
+
},
|
447
|
+
{
|
448
|
+
"argument" => "replication_tasks[].status",
|
449
|
+
"expected" => "starting",
|
450
|
+
"matcher" => "pathAny",
|
451
|
+
"state" => "failure"
|
452
|
+
},
|
453
|
+
{
|
454
|
+
"argument" => "replication_tasks[].status",
|
455
|
+
"expected" => "running",
|
456
|
+
"matcher" => "pathAny",
|
457
|
+
"state" => "failure"
|
458
|
+
},
|
459
|
+
{
|
460
|
+
"argument" => "replication_tasks[].status",
|
461
|
+
"expected" => "failed",
|
462
|
+
"matcher" => "pathAny",
|
463
|
+
"state" => "failure"
|
464
|
+
},
|
465
|
+
{
|
466
|
+
"argument" => "replication_tasks[].status",
|
467
|
+
"expected" => "modifying",
|
468
|
+
"matcher" => "pathAny",
|
469
|
+
"state" => "failure"
|
470
|
+
},
|
471
|
+
{
|
472
|
+
"argument" => "replication_tasks[].status",
|
473
|
+
"expected" => "testing",
|
474
|
+
"matcher" => "pathAny",
|
475
|
+
"state" => "failure"
|
476
|
+
},
|
477
|
+
{
|
478
|
+
"argument" => "replication_tasks[].status",
|
479
|
+
"expected" => "deleting",
|
480
|
+
"matcher" => "pathAny",
|
481
|
+
"state" => "failure"
|
482
|
+
}
|
483
|
+
]
|
484
|
+
)
|
485
|
+
}.merge(options))
|
486
|
+
end
|
487
|
+
|
488
|
+
# @option (see Client#describe_replication_tasks)
|
489
|
+
# @return (see Client#describe_replication_tasks)
|
490
|
+
def wait(params = {})
|
491
|
+
@waiter.wait(client: @client, params: params)
|
492
|
+
end
|
493
|
+
|
494
|
+
# @api private
|
495
|
+
attr_reader :waiter
|
496
|
+
|
497
|
+
end
|
498
|
+
|
499
|
+
# Wait until testing connection succeeds.
|
500
|
+
class TestConnectionSucceeds
|
501
|
+
|
502
|
+
# @param [Hash] options
|
503
|
+
# @option options [required, Client] :client
|
504
|
+
# @option options [Integer] :max_attempts (60)
|
505
|
+
# @option options [Integer] :delay (5)
|
506
|
+
# @option options [Proc] :before_attempt
|
507
|
+
# @option options [Proc] :before_wait
|
508
|
+
def initialize(options)
|
509
|
+
@client = options.fetch(:client)
|
510
|
+
@waiter = Aws::Waiters::Waiter.new({
|
511
|
+
max_attempts: 60,
|
512
|
+
delay: 5,
|
513
|
+
poller: Aws::Waiters::Poller.new(
|
514
|
+
operation_name: :test_connection,
|
515
|
+
acceptors: [
|
516
|
+
{
|
517
|
+
"argument" => "connection.status",
|
518
|
+
"expected" => "successful",
|
519
|
+
"matcher" => "path",
|
520
|
+
"state" => "success"
|
521
|
+
},
|
522
|
+
{
|
523
|
+
"argument" => "connection.status",
|
524
|
+
"expected" => "failed",
|
525
|
+
"matcher" => "path",
|
526
|
+
"state" => "failure"
|
527
|
+
}
|
528
|
+
]
|
529
|
+
)
|
530
|
+
}.merge(options))
|
531
|
+
end
|
532
|
+
|
533
|
+
# @option (see Client#test_connection)
|
534
|
+
# @return (see Client#test_connection)
|
535
|
+
def wait(params = {})
|
536
|
+
@waiter.wait(client: @client, params: params)
|
537
|
+
end
|
538
|
+
|
539
|
+
# @api private
|
540
|
+
attr_reader :waiter
|
541
|
+
|
542
|
+
end
|
543
|
+
end
|
544
|
+
end
|
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: aws-sdk-databasemigrationservice
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 1.
|
4
|
+
version: 1.12.0
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- Amazon Web Services
|
8
8
|
autorequire:
|
9
9
|
bindir: bin
|
10
10
|
cert_chain: []
|
11
|
-
date: 2018-10-
|
11
|
+
date: 2018-10-30 00:00:00.000000000 Z
|
12
12
|
dependencies:
|
13
13
|
- !ruby/object:Gem::Dependency
|
14
14
|
name: aws-sdk-core
|
@@ -59,6 +59,7 @@ files:
|
|
59
59
|
- lib/aws-sdk-databasemigrationservice/errors.rb
|
60
60
|
- lib/aws-sdk-databasemigrationservice/resource.rb
|
61
61
|
- lib/aws-sdk-databasemigrationservice/types.rb
|
62
|
+
- lib/aws-sdk-databasemigrationservice/waiters.rb
|
62
63
|
homepage: http://github.com/aws/aws-sdk-ruby
|
63
64
|
licenses:
|
64
65
|
- Apache-2.0
|