aws-sdk-mediaconnect 1.90.0 → 1.92.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 +4 -4
- data/CHANGELOG.md +10 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-mediaconnect/client.rb +2596 -69
- data/lib/aws-sdk-mediaconnect/client_api.rb +1466 -0
- data/lib/aws-sdk-mediaconnect/errors.rb +48 -0
- data/lib/aws-sdk-mediaconnect/types.rb +4283 -714
- data/lib/aws-sdk-mediaconnect/waiters.rb +443 -5
- data/lib/aws-sdk-mediaconnect.rb +1 -1
- data/sig/client.rbs +938 -6
- data/sig/errors.rbs +9 -0
- data/sig/types.rbs +1101 -0
- data/sig/waiters.rbs +70 -0
- metadata +3 -3
|
@@ -67,11 +67,18 @@ module Aws::MediaConnect
|
|
|
67
67
|
# The following table lists the valid waiter names, the operations they call,
|
|
68
68
|
# and the default `:delay` and `:max_attempts` values.
|
|
69
69
|
#
|
|
70
|
-
# | waiter_name
|
|
71
|
-
# |
|
|
72
|
-
# | flow_active
|
|
73
|
-
# | flow_deleted
|
|
74
|
-
# | flow_standby
|
|
70
|
+
# | waiter_name | params | :delay | :max_attempts |
|
|
71
|
+
# | -------------- | -------------------------- | -------- | ------------- |
|
|
72
|
+
# | flow_active | {Client#describe_flow} | 3 | 40 |
|
|
73
|
+
# | flow_deleted | {Client#describe_flow} | 3 | 40 |
|
|
74
|
+
# | flow_standby | {Client#describe_flow} | 3 | 40 |
|
|
75
|
+
# | input_active | {Client#get_router_input} | 3 | 40 |
|
|
76
|
+
# | input_deleted | {Client#get_router_input} | 3 | 40 |
|
|
77
|
+
# | input_standby | {Client#get_router_input} | 3 | 40 |
|
|
78
|
+
# | output_active | {Client#get_router_output} | 3 | 40 |
|
|
79
|
+
# | output_deleted | {Client#get_router_output} | 3 | 40 |
|
|
80
|
+
# | output_routed | {Client#get_router_output} | 3 | 40 |
|
|
81
|
+
# | output_standby | {Client#get_router_output} | 3 | 40 |
|
|
75
82
|
#
|
|
76
83
|
module Waiters
|
|
77
84
|
|
|
@@ -268,5 +275,436 @@ module Aws::MediaConnect
|
|
|
268
275
|
attr_reader :waiter
|
|
269
276
|
|
|
270
277
|
end
|
|
278
|
+
|
|
279
|
+
# Wait until the Input is ACTIVE
|
|
280
|
+
class InputActive
|
|
281
|
+
|
|
282
|
+
# @param [Hash] options
|
|
283
|
+
# @option options [required, Client] :client
|
|
284
|
+
# @option options [Integer] :max_attempts (40)
|
|
285
|
+
# @option options [Integer] :delay (3)
|
|
286
|
+
# @option options [Proc] :before_attempt
|
|
287
|
+
# @option options [Proc] :before_wait
|
|
288
|
+
def initialize(options)
|
|
289
|
+
@client = options.fetch(:client)
|
|
290
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
291
|
+
max_attempts: 40,
|
|
292
|
+
delay: 3,
|
|
293
|
+
poller: Aws::Waiters::Poller.new(
|
|
294
|
+
operation_name: :get_router_input,
|
|
295
|
+
acceptors: [
|
|
296
|
+
{
|
|
297
|
+
"matcher" => "path",
|
|
298
|
+
"argument" => "router_input.state",
|
|
299
|
+
"state" => "success",
|
|
300
|
+
"expected" => "ACTIVE"
|
|
301
|
+
},
|
|
302
|
+
{
|
|
303
|
+
"matcher" => "path",
|
|
304
|
+
"argument" => "router_input.state",
|
|
305
|
+
"state" => "retry",
|
|
306
|
+
"expected" => "STARTING"
|
|
307
|
+
},
|
|
308
|
+
{
|
|
309
|
+
"matcher" => "path",
|
|
310
|
+
"argument" => "router_input.state",
|
|
311
|
+
"state" => "retry",
|
|
312
|
+
"expected" => "UPDATING"
|
|
313
|
+
},
|
|
314
|
+
{
|
|
315
|
+
"matcher" => "error",
|
|
316
|
+
"state" => "retry",
|
|
317
|
+
"expected" => "InternalServerErrorException"
|
|
318
|
+
},
|
|
319
|
+
{
|
|
320
|
+
"matcher" => "error",
|
|
321
|
+
"state" => "retry",
|
|
322
|
+
"expected" => "ServiceUnavailableException"
|
|
323
|
+
},
|
|
324
|
+
{
|
|
325
|
+
"matcher" => "path",
|
|
326
|
+
"argument" => "router_input.state",
|
|
327
|
+
"state" => "failure",
|
|
328
|
+
"expected" => "ERROR"
|
|
329
|
+
}
|
|
330
|
+
]
|
|
331
|
+
)
|
|
332
|
+
}.merge(options))
|
|
333
|
+
end
|
|
334
|
+
|
|
335
|
+
# @option (see Client#get_router_input)
|
|
336
|
+
# @return (see Client#get_router_input)
|
|
337
|
+
def wait(params = {})
|
|
338
|
+
@waiter.wait(client: @client, params: params)
|
|
339
|
+
end
|
|
340
|
+
|
|
341
|
+
# @api private
|
|
342
|
+
attr_reader :waiter
|
|
343
|
+
|
|
344
|
+
end
|
|
345
|
+
|
|
346
|
+
# Wait until the Input is deleted
|
|
347
|
+
class InputDeleted
|
|
348
|
+
|
|
349
|
+
# @param [Hash] options
|
|
350
|
+
# @option options [required, Client] :client
|
|
351
|
+
# @option options [Integer] :max_attempts (40)
|
|
352
|
+
# @option options [Integer] :delay (3)
|
|
353
|
+
# @option options [Proc] :before_attempt
|
|
354
|
+
# @option options [Proc] :before_wait
|
|
355
|
+
def initialize(options)
|
|
356
|
+
@client = options.fetch(:client)
|
|
357
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
358
|
+
max_attempts: 40,
|
|
359
|
+
delay: 3,
|
|
360
|
+
poller: Aws::Waiters::Poller.new(
|
|
361
|
+
operation_name: :get_router_input,
|
|
362
|
+
acceptors: [
|
|
363
|
+
{
|
|
364
|
+
"matcher" => "path",
|
|
365
|
+
"argument" => "router_input.state",
|
|
366
|
+
"state" => "retry",
|
|
367
|
+
"expected" => "DELETING"
|
|
368
|
+
},
|
|
369
|
+
{
|
|
370
|
+
"matcher" => "error",
|
|
371
|
+
"state" => "retry",
|
|
372
|
+
"expected" => "InternalServerErrorException"
|
|
373
|
+
},
|
|
374
|
+
{
|
|
375
|
+
"matcher" => "error",
|
|
376
|
+
"state" => "retry",
|
|
377
|
+
"expected" => "ServiceUnavailableException"
|
|
378
|
+
},
|
|
379
|
+
{
|
|
380
|
+
"matcher" => "path",
|
|
381
|
+
"argument" => "router_input.state",
|
|
382
|
+
"state" => "failure",
|
|
383
|
+
"expected" => "ERROR"
|
|
384
|
+
},
|
|
385
|
+
{
|
|
386
|
+
"matcher" => "error",
|
|
387
|
+
"state" => "success",
|
|
388
|
+
"expected" => "NotFoundException"
|
|
389
|
+
}
|
|
390
|
+
]
|
|
391
|
+
)
|
|
392
|
+
}.merge(options))
|
|
393
|
+
end
|
|
394
|
+
|
|
395
|
+
# @option (see Client#get_router_input)
|
|
396
|
+
# @return (see Client#get_router_input)
|
|
397
|
+
def wait(params = {})
|
|
398
|
+
@waiter.wait(client: @client, params: params)
|
|
399
|
+
end
|
|
400
|
+
|
|
401
|
+
# @api private
|
|
402
|
+
attr_reader :waiter
|
|
403
|
+
|
|
404
|
+
end
|
|
405
|
+
|
|
406
|
+
# Wait until the Input is STANDBY
|
|
407
|
+
class InputStandby
|
|
408
|
+
|
|
409
|
+
# @param [Hash] options
|
|
410
|
+
# @option options [required, Client] :client
|
|
411
|
+
# @option options [Integer] :max_attempts (40)
|
|
412
|
+
# @option options [Integer] :delay (3)
|
|
413
|
+
# @option options [Proc] :before_attempt
|
|
414
|
+
# @option options [Proc] :before_wait
|
|
415
|
+
def initialize(options)
|
|
416
|
+
@client = options.fetch(:client)
|
|
417
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
418
|
+
max_attempts: 40,
|
|
419
|
+
delay: 3,
|
|
420
|
+
poller: Aws::Waiters::Poller.new(
|
|
421
|
+
operation_name: :get_router_input,
|
|
422
|
+
acceptors: [
|
|
423
|
+
{
|
|
424
|
+
"matcher" => "path",
|
|
425
|
+
"argument" => "router_input.state",
|
|
426
|
+
"state" => "success",
|
|
427
|
+
"expected" => "STANDBY"
|
|
428
|
+
},
|
|
429
|
+
{
|
|
430
|
+
"matcher" => "path",
|
|
431
|
+
"argument" => "router_input.state",
|
|
432
|
+
"state" => "retry",
|
|
433
|
+
"expected" => "STOPPING"
|
|
434
|
+
},
|
|
435
|
+
{
|
|
436
|
+
"matcher" => "error",
|
|
437
|
+
"state" => "retry",
|
|
438
|
+
"expected" => "InternalServerErrorException"
|
|
439
|
+
},
|
|
440
|
+
{
|
|
441
|
+
"matcher" => "error",
|
|
442
|
+
"state" => "retry",
|
|
443
|
+
"expected" => "ServiceUnavailableException"
|
|
444
|
+
},
|
|
445
|
+
{
|
|
446
|
+
"matcher" => "path",
|
|
447
|
+
"argument" => "router_input.state",
|
|
448
|
+
"state" => "failure",
|
|
449
|
+
"expected" => "ERROR"
|
|
450
|
+
}
|
|
451
|
+
]
|
|
452
|
+
)
|
|
453
|
+
}.merge(options))
|
|
454
|
+
end
|
|
455
|
+
|
|
456
|
+
# @option (see Client#get_router_input)
|
|
457
|
+
# @return (see Client#get_router_input)
|
|
458
|
+
def wait(params = {})
|
|
459
|
+
@waiter.wait(client: @client, params: params)
|
|
460
|
+
end
|
|
461
|
+
|
|
462
|
+
# @api private
|
|
463
|
+
attr_reader :waiter
|
|
464
|
+
|
|
465
|
+
end
|
|
466
|
+
|
|
467
|
+
# Wait until the Output is ACTIVE
|
|
468
|
+
class OutputActive
|
|
469
|
+
|
|
470
|
+
# @param [Hash] options
|
|
471
|
+
# @option options [required, Client] :client
|
|
472
|
+
# @option options [Integer] :max_attempts (40)
|
|
473
|
+
# @option options [Integer] :delay (3)
|
|
474
|
+
# @option options [Proc] :before_attempt
|
|
475
|
+
# @option options [Proc] :before_wait
|
|
476
|
+
def initialize(options)
|
|
477
|
+
@client = options.fetch(:client)
|
|
478
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
479
|
+
max_attempts: 40,
|
|
480
|
+
delay: 3,
|
|
481
|
+
poller: Aws::Waiters::Poller.new(
|
|
482
|
+
operation_name: :get_router_output,
|
|
483
|
+
acceptors: [
|
|
484
|
+
{
|
|
485
|
+
"matcher" => "path",
|
|
486
|
+
"argument" => "router_output.state",
|
|
487
|
+
"state" => "success",
|
|
488
|
+
"expected" => "ACTIVE"
|
|
489
|
+
},
|
|
490
|
+
{
|
|
491
|
+
"matcher" => "path",
|
|
492
|
+
"argument" => "router_output.state",
|
|
493
|
+
"state" => "retry",
|
|
494
|
+
"expected" => "STARTING"
|
|
495
|
+
},
|
|
496
|
+
{
|
|
497
|
+
"matcher" => "path",
|
|
498
|
+
"argument" => "router_output.state",
|
|
499
|
+
"state" => "retry",
|
|
500
|
+
"expected" => "UPDATING"
|
|
501
|
+
},
|
|
502
|
+
{
|
|
503
|
+
"matcher" => "error",
|
|
504
|
+
"state" => "retry",
|
|
505
|
+
"expected" => "InternalServerErrorException"
|
|
506
|
+
},
|
|
507
|
+
{
|
|
508
|
+
"matcher" => "error",
|
|
509
|
+
"state" => "retry",
|
|
510
|
+
"expected" => "ServiceUnavailableException"
|
|
511
|
+
},
|
|
512
|
+
{
|
|
513
|
+
"matcher" => "path",
|
|
514
|
+
"argument" => "router_output.state",
|
|
515
|
+
"state" => "failure",
|
|
516
|
+
"expected" => "ERROR"
|
|
517
|
+
}
|
|
518
|
+
]
|
|
519
|
+
)
|
|
520
|
+
}.merge(options))
|
|
521
|
+
end
|
|
522
|
+
|
|
523
|
+
# @option (see Client#get_router_output)
|
|
524
|
+
# @return (see Client#get_router_output)
|
|
525
|
+
def wait(params = {})
|
|
526
|
+
@waiter.wait(client: @client, params: params)
|
|
527
|
+
end
|
|
528
|
+
|
|
529
|
+
# @api private
|
|
530
|
+
attr_reader :waiter
|
|
531
|
+
|
|
532
|
+
end
|
|
533
|
+
|
|
534
|
+
# Wait until the Output is deleted
|
|
535
|
+
class OutputDeleted
|
|
536
|
+
|
|
537
|
+
# @param [Hash] options
|
|
538
|
+
# @option options [required, Client] :client
|
|
539
|
+
# @option options [Integer] :max_attempts (40)
|
|
540
|
+
# @option options [Integer] :delay (3)
|
|
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: 3,
|
|
548
|
+
poller: Aws::Waiters::Poller.new(
|
|
549
|
+
operation_name: :get_router_output,
|
|
550
|
+
acceptors: [
|
|
551
|
+
{
|
|
552
|
+
"matcher" => "path",
|
|
553
|
+
"argument" => "router_output.state",
|
|
554
|
+
"state" => "retry",
|
|
555
|
+
"expected" => "DELETING"
|
|
556
|
+
},
|
|
557
|
+
{
|
|
558
|
+
"matcher" => "error",
|
|
559
|
+
"state" => "retry",
|
|
560
|
+
"expected" => "InternalServerErrorException"
|
|
561
|
+
},
|
|
562
|
+
{
|
|
563
|
+
"matcher" => "error",
|
|
564
|
+
"state" => "retry",
|
|
565
|
+
"expected" => "ServiceUnavailableException"
|
|
566
|
+
},
|
|
567
|
+
{
|
|
568
|
+
"matcher" => "path",
|
|
569
|
+
"argument" => "router_output.state",
|
|
570
|
+
"state" => "failure",
|
|
571
|
+
"expected" => "ERROR"
|
|
572
|
+
},
|
|
573
|
+
{
|
|
574
|
+
"matcher" => "error",
|
|
575
|
+
"state" => "success",
|
|
576
|
+
"expected" => "NotFoundException"
|
|
577
|
+
}
|
|
578
|
+
]
|
|
579
|
+
)
|
|
580
|
+
}.merge(options))
|
|
581
|
+
end
|
|
582
|
+
|
|
583
|
+
# @option (see Client#get_router_output)
|
|
584
|
+
# @return (see Client#get_router_output)
|
|
585
|
+
def wait(params = {})
|
|
586
|
+
@waiter.wait(client: @client, params: params)
|
|
587
|
+
end
|
|
588
|
+
|
|
589
|
+
# @api private
|
|
590
|
+
attr_reader :waiter
|
|
591
|
+
|
|
592
|
+
end
|
|
593
|
+
|
|
594
|
+
# Wait until the Output is ROUTED
|
|
595
|
+
class OutputRouted
|
|
596
|
+
|
|
597
|
+
# @param [Hash] options
|
|
598
|
+
# @option options [required, Client] :client
|
|
599
|
+
# @option options [Integer] :max_attempts (40)
|
|
600
|
+
# @option options [Integer] :delay (3)
|
|
601
|
+
# @option options [Proc] :before_attempt
|
|
602
|
+
# @option options [Proc] :before_wait
|
|
603
|
+
def initialize(options)
|
|
604
|
+
@client = options.fetch(:client)
|
|
605
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
606
|
+
max_attempts: 40,
|
|
607
|
+
delay: 3,
|
|
608
|
+
poller: Aws::Waiters::Poller.new(
|
|
609
|
+
operation_name: :get_router_output,
|
|
610
|
+
acceptors: [
|
|
611
|
+
{
|
|
612
|
+
"matcher" => "path",
|
|
613
|
+
"argument" => "router_output.routed_state",
|
|
614
|
+
"state" => "success",
|
|
615
|
+
"expected" => "ROUTED"
|
|
616
|
+
},
|
|
617
|
+
{
|
|
618
|
+
"matcher" => "path",
|
|
619
|
+
"argument" => "router_output.routed_state",
|
|
620
|
+
"state" => "retry",
|
|
621
|
+
"expected" => "ROUTING"
|
|
622
|
+
},
|
|
623
|
+
{
|
|
624
|
+
"matcher" => "error",
|
|
625
|
+
"state" => "retry",
|
|
626
|
+
"expected" => "InternalServerErrorException"
|
|
627
|
+
},
|
|
628
|
+
{
|
|
629
|
+
"matcher" => "error",
|
|
630
|
+
"state" => "retry",
|
|
631
|
+
"expected" => "ServiceUnavailableException"
|
|
632
|
+
}
|
|
633
|
+
]
|
|
634
|
+
)
|
|
635
|
+
}.merge(options))
|
|
636
|
+
end
|
|
637
|
+
|
|
638
|
+
# @option (see Client#get_router_output)
|
|
639
|
+
# @return (see Client#get_router_output)
|
|
640
|
+
def wait(params = {})
|
|
641
|
+
@waiter.wait(client: @client, params: params)
|
|
642
|
+
end
|
|
643
|
+
|
|
644
|
+
# @api private
|
|
645
|
+
attr_reader :waiter
|
|
646
|
+
|
|
647
|
+
end
|
|
648
|
+
|
|
649
|
+
# Wait until the Output is STANDBY
|
|
650
|
+
class OutputStandby
|
|
651
|
+
|
|
652
|
+
# @param [Hash] options
|
|
653
|
+
# @option options [required, Client] :client
|
|
654
|
+
# @option options [Integer] :max_attempts (40)
|
|
655
|
+
# @option options [Integer] :delay (3)
|
|
656
|
+
# @option options [Proc] :before_attempt
|
|
657
|
+
# @option options [Proc] :before_wait
|
|
658
|
+
def initialize(options)
|
|
659
|
+
@client = options.fetch(:client)
|
|
660
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
661
|
+
max_attempts: 40,
|
|
662
|
+
delay: 3,
|
|
663
|
+
poller: Aws::Waiters::Poller.new(
|
|
664
|
+
operation_name: :get_router_output,
|
|
665
|
+
acceptors: [
|
|
666
|
+
{
|
|
667
|
+
"matcher" => "path",
|
|
668
|
+
"argument" => "router_output.state",
|
|
669
|
+
"state" => "success",
|
|
670
|
+
"expected" => "STANDBY"
|
|
671
|
+
},
|
|
672
|
+
{
|
|
673
|
+
"matcher" => "path",
|
|
674
|
+
"argument" => "router_output.state",
|
|
675
|
+
"state" => "retry",
|
|
676
|
+
"expected" => "STOPPING"
|
|
677
|
+
},
|
|
678
|
+
{
|
|
679
|
+
"matcher" => "error",
|
|
680
|
+
"state" => "retry",
|
|
681
|
+
"expected" => "InternalServerErrorException"
|
|
682
|
+
},
|
|
683
|
+
{
|
|
684
|
+
"matcher" => "error",
|
|
685
|
+
"state" => "retry",
|
|
686
|
+
"expected" => "ServiceUnavailableException"
|
|
687
|
+
},
|
|
688
|
+
{
|
|
689
|
+
"matcher" => "path",
|
|
690
|
+
"argument" => "router_output.state",
|
|
691
|
+
"state" => "failure",
|
|
692
|
+
"expected" => "ERROR"
|
|
693
|
+
}
|
|
694
|
+
]
|
|
695
|
+
)
|
|
696
|
+
}.merge(options))
|
|
697
|
+
end
|
|
698
|
+
|
|
699
|
+
# @option (see Client#get_router_output)
|
|
700
|
+
# @return (see Client#get_router_output)
|
|
701
|
+
def wait(params = {})
|
|
702
|
+
@waiter.wait(client: @client, params: params)
|
|
703
|
+
end
|
|
704
|
+
|
|
705
|
+
# @api private
|
|
706
|
+
attr_reader :waiter
|
|
707
|
+
|
|
708
|
+
end
|
|
271
709
|
end
|
|
272
710
|
end
|
data/lib/aws-sdk-mediaconnect.rb
CHANGED