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: 3b72060ac7d2d00a2ee8000742859c896e324348
4
- data.tar.gz: f046fadfdf30a6903de547f1057e1c224f6ea164
3
+ metadata.gz: b64aa23746136cc7473c09f762548e1b28569ecc
4
+ data.tar.gz: d5e237d8ac9a6d11d01ea6e803240abd3343626f
5
5
  SHA512:
6
- metadata.gz: c1f1e7e3c5de6ddda912f5c9fdf7dfd2e7f082749f06419c6b0c021708a97715258adc7aacfdd6f5800c91af4dfa53cd9a77eb0a4127cbcc3b1036ac7cfe7936
7
- data.tar.gz: d7c2d58918d6429dcf1346973e4d6068c176a7099b7bdb309750b904718c8d52c9bdbc965a7e6c3401706fe947c14b0f947375fdde3035d2025d0eb16b6370f2
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.11.0'
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.11.0'
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.11.0
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-24 00:00:00.000000000 Z
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