aws-sdk-medialive 1.130.0 → 1.132.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-medialive/client.rb +2148 -31
- data/lib/aws-sdk-medialive/client_api.rb +1116 -0
- data/lib/aws-sdk-medialive/endpoints.rb +334 -368
- data/lib/aws-sdk-medialive/plugins/endpoints.rb +54 -1
- data/lib/aws-sdk-medialive/types.rb +2985 -23
- data/lib/aws-sdk-medialive/waiters.rb +397 -17
- data/lib/aws-sdk-medialive.rb +1 -1
- data/sig/client.rbs +766 -8
- data/sig/types.rbs +774 -5
- data/sig/waiters.rbs +75 -0
- metadata +4 -4
|
@@ -67,23 +67,30 @@ module Aws::MediaLive
|
|
|
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
|
-
# | channel_created
|
|
73
|
-
# | channel_deleted
|
|
74
|
-
# |
|
|
75
|
-
# |
|
|
76
|
-
# |
|
|
77
|
-
# |
|
|
78
|
-
# |
|
|
79
|
-
# |
|
|
80
|
-
# |
|
|
81
|
-
# |
|
|
82
|
-
# |
|
|
83
|
-
# |
|
|
84
|
-
# |
|
|
85
|
-
# |
|
|
86
|
-
# |
|
|
70
|
+
# | waiter_name | params | :delay | :max_attempts |
|
|
71
|
+
# | ---------------------------------- | ----------------------------------------- | -------- | ------------- |
|
|
72
|
+
# | channel_created | {Client#describe_channel} | 3 | 5 |
|
|
73
|
+
# | channel_deleted | {Client#describe_channel} | 5 | 84 |
|
|
74
|
+
# | channel_placement_group_assigned | {Client#describe_channel_placement_group} | 3 | 5 |
|
|
75
|
+
# | channel_placement_group_deleted | {Client#describe_channel_placement_group} | 5 | 20 |
|
|
76
|
+
# | channel_placement_group_unassigned | {Client#describe_channel_placement_group} | 5 | 20 |
|
|
77
|
+
# | channel_running | {Client#describe_channel} | 5 | 120 |
|
|
78
|
+
# | channel_stopped | {Client#describe_channel} | 5 | 60 |
|
|
79
|
+
# | cluster_created | {Client#describe_cluster} | 3 | 5 |
|
|
80
|
+
# | cluster_deleted | {Client#describe_cluster} | 5 | 20 |
|
|
81
|
+
# | input_attached | {Client#describe_input} | 5 | 20 |
|
|
82
|
+
# | input_deleted | {Client#describe_input} | 5 | 20 |
|
|
83
|
+
# | input_detached | {Client#describe_input} | 5 | 84 |
|
|
84
|
+
# | multiplex_created | {Client#describe_multiplex} | 3 | 5 |
|
|
85
|
+
# | multiplex_deleted | {Client#describe_multiplex} | 5 | 20 |
|
|
86
|
+
# | multiplex_running | {Client#describe_multiplex} | 5 | 120 |
|
|
87
|
+
# | multiplex_stopped | {Client#describe_multiplex} | 5 | 28 |
|
|
88
|
+
# | node_deregistered | {Client#describe_node} | 5 | 20 |
|
|
89
|
+
# | node_registered | {Client#describe_node} | 3 | 5 |
|
|
90
|
+
# | signal_map_created | {Client#get_signal_map} | 5 | 60 |
|
|
91
|
+
# | signal_map_monitor_deleted | {Client#get_signal_map} | 5 | 120 |
|
|
92
|
+
# | signal_map_monitor_deployed | {Client#get_signal_map} | 5 | 120 |
|
|
93
|
+
# | signal_map_updated | {Client#get_signal_map} | 5 | 60 |
|
|
87
94
|
#
|
|
88
95
|
module Waiters
|
|
89
96
|
|
|
@@ -193,6 +200,156 @@ module Aws::MediaLive
|
|
|
193
200
|
|
|
194
201
|
end
|
|
195
202
|
|
|
203
|
+
# Wait until the channel placement group has been assigned
|
|
204
|
+
class ChannelPlacementGroupAssigned
|
|
205
|
+
|
|
206
|
+
# @param [Hash] options
|
|
207
|
+
# @option options [required, Client] :client
|
|
208
|
+
# @option options [Integer] :max_attempts (5)
|
|
209
|
+
# @option options [Integer] :delay (3)
|
|
210
|
+
# @option options [Proc] :before_attempt
|
|
211
|
+
# @option options [Proc] :before_wait
|
|
212
|
+
def initialize(options)
|
|
213
|
+
@client = options.fetch(:client)
|
|
214
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
215
|
+
max_attempts: 5,
|
|
216
|
+
delay: 3,
|
|
217
|
+
poller: Aws::Waiters::Poller.new(
|
|
218
|
+
operation_name: :describe_channel_placement_group,
|
|
219
|
+
acceptors: [
|
|
220
|
+
{
|
|
221
|
+
"state" => "success",
|
|
222
|
+
"matcher" => "path",
|
|
223
|
+
"argument" => "state",
|
|
224
|
+
"expected" => "ASSIGNED"
|
|
225
|
+
},
|
|
226
|
+
{
|
|
227
|
+
"state" => "retry",
|
|
228
|
+
"matcher" => "path",
|
|
229
|
+
"argument" => "state",
|
|
230
|
+
"expected" => "ASSIGNING"
|
|
231
|
+
},
|
|
232
|
+
{
|
|
233
|
+
"state" => "retry",
|
|
234
|
+
"matcher" => "status",
|
|
235
|
+
"expected" => 500
|
|
236
|
+
}
|
|
237
|
+
]
|
|
238
|
+
)
|
|
239
|
+
}.merge(options))
|
|
240
|
+
end
|
|
241
|
+
|
|
242
|
+
# @option (see Client#describe_channel_placement_group)
|
|
243
|
+
# @return (see Client#describe_channel_placement_group)
|
|
244
|
+
def wait(params = {})
|
|
245
|
+
@waiter.wait(client: @client, params: params)
|
|
246
|
+
end
|
|
247
|
+
|
|
248
|
+
# @api private
|
|
249
|
+
attr_reader :waiter
|
|
250
|
+
|
|
251
|
+
end
|
|
252
|
+
|
|
253
|
+
# Wait until the channel placement group has been deleted
|
|
254
|
+
class ChannelPlacementGroupDeleted
|
|
255
|
+
|
|
256
|
+
# @param [Hash] options
|
|
257
|
+
# @option options [required, Client] :client
|
|
258
|
+
# @option options [Integer] :max_attempts (20)
|
|
259
|
+
# @option options [Integer] :delay (5)
|
|
260
|
+
# @option options [Proc] :before_attempt
|
|
261
|
+
# @option options [Proc] :before_wait
|
|
262
|
+
def initialize(options)
|
|
263
|
+
@client = options.fetch(:client)
|
|
264
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
265
|
+
max_attempts: 20,
|
|
266
|
+
delay: 5,
|
|
267
|
+
poller: Aws::Waiters::Poller.new(
|
|
268
|
+
operation_name: :describe_channel_placement_group,
|
|
269
|
+
acceptors: [
|
|
270
|
+
{
|
|
271
|
+
"state" => "success",
|
|
272
|
+
"matcher" => "path",
|
|
273
|
+
"argument" => "state",
|
|
274
|
+
"expected" => "DELETED"
|
|
275
|
+
},
|
|
276
|
+
{
|
|
277
|
+
"state" => "retry",
|
|
278
|
+
"matcher" => "path",
|
|
279
|
+
"argument" => "state",
|
|
280
|
+
"expected" => "DELETING"
|
|
281
|
+
},
|
|
282
|
+
{
|
|
283
|
+
"state" => "retry",
|
|
284
|
+
"matcher" => "status",
|
|
285
|
+
"expected" => 500
|
|
286
|
+
}
|
|
287
|
+
]
|
|
288
|
+
)
|
|
289
|
+
}.merge(options))
|
|
290
|
+
end
|
|
291
|
+
|
|
292
|
+
# @option (see Client#describe_channel_placement_group)
|
|
293
|
+
# @return (see Client#describe_channel_placement_group)
|
|
294
|
+
def wait(params = {})
|
|
295
|
+
@waiter.wait(client: @client, params: params)
|
|
296
|
+
end
|
|
297
|
+
|
|
298
|
+
# @api private
|
|
299
|
+
attr_reader :waiter
|
|
300
|
+
|
|
301
|
+
end
|
|
302
|
+
|
|
303
|
+
# Wait until the channel placement group has been unassigned
|
|
304
|
+
class ChannelPlacementGroupUnassigned
|
|
305
|
+
|
|
306
|
+
# @param [Hash] options
|
|
307
|
+
# @option options [required, Client] :client
|
|
308
|
+
# @option options [Integer] :max_attempts (20)
|
|
309
|
+
# @option options [Integer] :delay (5)
|
|
310
|
+
# @option options [Proc] :before_attempt
|
|
311
|
+
# @option options [Proc] :before_wait
|
|
312
|
+
def initialize(options)
|
|
313
|
+
@client = options.fetch(:client)
|
|
314
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
315
|
+
max_attempts: 20,
|
|
316
|
+
delay: 5,
|
|
317
|
+
poller: Aws::Waiters::Poller.new(
|
|
318
|
+
operation_name: :describe_channel_placement_group,
|
|
319
|
+
acceptors: [
|
|
320
|
+
{
|
|
321
|
+
"state" => "success",
|
|
322
|
+
"matcher" => "path",
|
|
323
|
+
"argument" => "state",
|
|
324
|
+
"expected" => "UNASSIGNED"
|
|
325
|
+
},
|
|
326
|
+
{
|
|
327
|
+
"state" => "retry",
|
|
328
|
+
"matcher" => "path",
|
|
329
|
+
"argument" => "state",
|
|
330
|
+
"expected" => "UNASSIGNING"
|
|
331
|
+
},
|
|
332
|
+
{
|
|
333
|
+
"state" => "retry",
|
|
334
|
+
"matcher" => "status",
|
|
335
|
+
"expected" => 500
|
|
336
|
+
}
|
|
337
|
+
]
|
|
338
|
+
)
|
|
339
|
+
}.merge(options))
|
|
340
|
+
end
|
|
341
|
+
|
|
342
|
+
# @option (see Client#describe_channel_placement_group)
|
|
343
|
+
# @return (see Client#describe_channel_placement_group)
|
|
344
|
+
def wait(params = {})
|
|
345
|
+
@waiter.wait(client: @client, params: params)
|
|
346
|
+
end
|
|
347
|
+
|
|
348
|
+
# @api private
|
|
349
|
+
attr_reader :waiter
|
|
350
|
+
|
|
351
|
+
end
|
|
352
|
+
|
|
196
353
|
# Wait until a channel is running
|
|
197
354
|
class ChannelRunning
|
|
198
355
|
|
|
@@ -293,6 +450,112 @@ module Aws::MediaLive
|
|
|
293
450
|
|
|
294
451
|
end
|
|
295
452
|
|
|
453
|
+
# Wait until a cluster has been created
|
|
454
|
+
class ClusterCreated
|
|
455
|
+
|
|
456
|
+
# @param [Hash] options
|
|
457
|
+
# @option options [required, Client] :client
|
|
458
|
+
# @option options [Integer] :max_attempts (5)
|
|
459
|
+
# @option options [Integer] :delay (3)
|
|
460
|
+
# @option options [Proc] :before_attempt
|
|
461
|
+
# @option options [Proc] :before_wait
|
|
462
|
+
def initialize(options)
|
|
463
|
+
@client = options.fetch(:client)
|
|
464
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
465
|
+
max_attempts: 5,
|
|
466
|
+
delay: 3,
|
|
467
|
+
poller: Aws::Waiters::Poller.new(
|
|
468
|
+
operation_name: :describe_cluster,
|
|
469
|
+
acceptors: [
|
|
470
|
+
{
|
|
471
|
+
"state" => "success",
|
|
472
|
+
"matcher" => "path",
|
|
473
|
+
"argument" => "state",
|
|
474
|
+
"expected" => "ACTIVE"
|
|
475
|
+
},
|
|
476
|
+
{
|
|
477
|
+
"state" => "retry",
|
|
478
|
+
"matcher" => "path",
|
|
479
|
+
"argument" => "state",
|
|
480
|
+
"expected" => "CREATING"
|
|
481
|
+
},
|
|
482
|
+
{
|
|
483
|
+
"state" => "retry",
|
|
484
|
+
"matcher" => "status",
|
|
485
|
+
"expected" => 500
|
|
486
|
+
},
|
|
487
|
+
{
|
|
488
|
+
"state" => "failure",
|
|
489
|
+
"matcher" => "path",
|
|
490
|
+
"argument" => "state",
|
|
491
|
+
"expected" => "CREATE_FAILED"
|
|
492
|
+
}
|
|
493
|
+
]
|
|
494
|
+
)
|
|
495
|
+
}.merge(options))
|
|
496
|
+
end
|
|
497
|
+
|
|
498
|
+
# @option (see Client#describe_cluster)
|
|
499
|
+
# @return (see Client#describe_cluster)
|
|
500
|
+
def wait(params = {})
|
|
501
|
+
@waiter.wait(client: @client, params: params)
|
|
502
|
+
end
|
|
503
|
+
|
|
504
|
+
# @api private
|
|
505
|
+
attr_reader :waiter
|
|
506
|
+
|
|
507
|
+
end
|
|
508
|
+
|
|
509
|
+
# Wait until a cluster has been deleted
|
|
510
|
+
class ClusterDeleted
|
|
511
|
+
|
|
512
|
+
# @param [Hash] options
|
|
513
|
+
# @option options [required, Client] :client
|
|
514
|
+
# @option options [Integer] :max_attempts (20)
|
|
515
|
+
# @option options [Integer] :delay (5)
|
|
516
|
+
# @option options [Proc] :before_attempt
|
|
517
|
+
# @option options [Proc] :before_wait
|
|
518
|
+
def initialize(options)
|
|
519
|
+
@client = options.fetch(:client)
|
|
520
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
521
|
+
max_attempts: 20,
|
|
522
|
+
delay: 5,
|
|
523
|
+
poller: Aws::Waiters::Poller.new(
|
|
524
|
+
operation_name: :describe_cluster,
|
|
525
|
+
acceptors: [
|
|
526
|
+
{
|
|
527
|
+
"state" => "success",
|
|
528
|
+
"matcher" => "path",
|
|
529
|
+
"argument" => "state",
|
|
530
|
+
"expected" => "DELETED"
|
|
531
|
+
},
|
|
532
|
+
{
|
|
533
|
+
"state" => "retry",
|
|
534
|
+
"matcher" => "path",
|
|
535
|
+
"argument" => "state",
|
|
536
|
+
"expected" => "DELETING"
|
|
537
|
+
},
|
|
538
|
+
{
|
|
539
|
+
"state" => "retry",
|
|
540
|
+
"matcher" => "status",
|
|
541
|
+
"expected" => 500
|
|
542
|
+
}
|
|
543
|
+
]
|
|
544
|
+
)
|
|
545
|
+
}.merge(options))
|
|
546
|
+
end
|
|
547
|
+
|
|
548
|
+
# @option (see Client#describe_cluster)
|
|
549
|
+
# @return (see Client#describe_cluster)
|
|
550
|
+
def wait(params = {})
|
|
551
|
+
@waiter.wait(client: @client, params: params)
|
|
552
|
+
end
|
|
553
|
+
|
|
554
|
+
# @api private
|
|
555
|
+
attr_reader :waiter
|
|
556
|
+
|
|
557
|
+
end
|
|
558
|
+
|
|
296
559
|
# Wait until an input has been attached
|
|
297
560
|
class InputAttached
|
|
298
561
|
|
|
@@ -655,6 +918,123 @@ module Aws::MediaLive
|
|
|
655
918
|
|
|
656
919
|
end
|
|
657
920
|
|
|
921
|
+
# Wait until a node has been deregistered
|
|
922
|
+
class NodeDeregistered
|
|
923
|
+
|
|
924
|
+
# @param [Hash] options
|
|
925
|
+
# @option options [required, Client] :client
|
|
926
|
+
# @option options [Integer] :max_attempts (20)
|
|
927
|
+
# @option options [Integer] :delay (5)
|
|
928
|
+
# @option options [Proc] :before_attempt
|
|
929
|
+
# @option options [Proc] :before_wait
|
|
930
|
+
def initialize(options)
|
|
931
|
+
@client = options.fetch(:client)
|
|
932
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
933
|
+
max_attempts: 20,
|
|
934
|
+
delay: 5,
|
|
935
|
+
poller: Aws::Waiters::Poller.new(
|
|
936
|
+
operation_name: :describe_node,
|
|
937
|
+
acceptors: [
|
|
938
|
+
{
|
|
939
|
+
"state" => "success",
|
|
940
|
+
"matcher" => "path",
|
|
941
|
+
"argument" => "state",
|
|
942
|
+
"expected" => "DEREGISTERED"
|
|
943
|
+
},
|
|
944
|
+
{
|
|
945
|
+
"state" => "retry",
|
|
946
|
+
"matcher" => "path",
|
|
947
|
+
"argument" => "state",
|
|
948
|
+
"expected" => "DEREGISTERING"
|
|
949
|
+
},
|
|
950
|
+
{
|
|
951
|
+
"state" => "retry",
|
|
952
|
+
"matcher" => "path",
|
|
953
|
+
"argument" => "state",
|
|
954
|
+
"expected" => "DRAINING"
|
|
955
|
+
},
|
|
956
|
+
{
|
|
957
|
+
"state" => "retry",
|
|
958
|
+
"matcher" => "status",
|
|
959
|
+
"expected" => 500
|
|
960
|
+
}
|
|
961
|
+
]
|
|
962
|
+
)
|
|
963
|
+
}.merge(options))
|
|
964
|
+
end
|
|
965
|
+
|
|
966
|
+
# @option (see Client#describe_node)
|
|
967
|
+
# @return (see Client#describe_node)
|
|
968
|
+
def wait(params = {})
|
|
969
|
+
@waiter.wait(client: @client, params: params)
|
|
970
|
+
end
|
|
971
|
+
|
|
972
|
+
# @api private
|
|
973
|
+
attr_reader :waiter
|
|
974
|
+
|
|
975
|
+
end
|
|
976
|
+
|
|
977
|
+
# Wait until a node has been registered
|
|
978
|
+
class NodeRegistered
|
|
979
|
+
|
|
980
|
+
# @param [Hash] options
|
|
981
|
+
# @option options [required, Client] :client
|
|
982
|
+
# @option options [Integer] :max_attempts (5)
|
|
983
|
+
# @option options [Integer] :delay (3)
|
|
984
|
+
# @option options [Proc] :before_attempt
|
|
985
|
+
# @option options [Proc] :before_wait
|
|
986
|
+
def initialize(options)
|
|
987
|
+
@client = options.fetch(:client)
|
|
988
|
+
@waiter = Aws::Waiters::Waiter.new({
|
|
989
|
+
max_attempts: 5,
|
|
990
|
+
delay: 3,
|
|
991
|
+
poller: Aws::Waiters::Poller.new(
|
|
992
|
+
operation_name: :describe_node,
|
|
993
|
+
acceptors: [
|
|
994
|
+
{
|
|
995
|
+
"state" => "success",
|
|
996
|
+
"matcher" => "path",
|
|
997
|
+
"argument" => "state",
|
|
998
|
+
"expected" => "ACTIVE"
|
|
999
|
+
},
|
|
1000
|
+
{
|
|
1001
|
+
"state" => "retry",
|
|
1002
|
+
"matcher" => "path",
|
|
1003
|
+
"argument" => "state",
|
|
1004
|
+
"expected" => "REGISTERING"
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
"state" => "retry",
|
|
1008
|
+
"matcher" => "status",
|
|
1009
|
+
"expected" => 404
|
|
1010
|
+
},
|
|
1011
|
+
{
|
|
1012
|
+
"state" => "failure",
|
|
1013
|
+
"matcher" => "path",
|
|
1014
|
+
"argument" => "state",
|
|
1015
|
+
"expected" => "REGISTRATION_FAILED"
|
|
1016
|
+
},
|
|
1017
|
+
{
|
|
1018
|
+
"state" => "retry",
|
|
1019
|
+
"matcher" => "status",
|
|
1020
|
+
"expected" => 500
|
|
1021
|
+
}
|
|
1022
|
+
]
|
|
1023
|
+
)
|
|
1024
|
+
}.merge(options))
|
|
1025
|
+
end
|
|
1026
|
+
|
|
1027
|
+
# @option (see Client#describe_node)
|
|
1028
|
+
# @return (see Client#describe_node)
|
|
1029
|
+
def wait(params = {})
|
|
1030
|
+
@waiter.wait(client: @client, params: params)
|
|
1031
|
+
end
|
|
1032
|
+
|
|
1033
|
+
# @api private
|
|
1034
|
+
attr_reader :waiter
|
|
1035
|
+
|
|
1036
|
+
end
|
|
1037
|
+
|
|
658
1038
|
# Wait until a signal map has been created
|
|
659
1039
|
class SignalMapCreated
|
|
660
1040
|
|