blib/lib/Paws/EMRContainers.pm untested

filter: Statementstmt 0.0% 0 / 118 Branchbran 0.0% 0 / 12 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 24 Podpod 0.0% 0 / 23 totaltotal 0.0% 0 / 177 CC 7 SCAR 16.1
CC
7
Cov
0%
ListAllJobRuns
12.0
ListAllManagedEndpoints
12.0
ListAllVirtualClusters
12.0
CRAP 5.0
1 package Paws::EMRContainers;
2 use Moose;
3 sub service { 'emr-containers' }
4 sub signing_name { 'emr-containers' }
5 sub version { '2020-10-01' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub CancelJobRun {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::EMRContainers::CancelJobRun', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub CreateManagedEndpoint {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::EMRContainers::CreateManagedEndpoint', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateVirtualCluster {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::EMRContainers::CreateVirtualCluster', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub DeleteManagedEndpoint {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::EMRContainers::DeleteManagedEndpoint', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub DeleteVirtualCluster {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::EMRContainers::DeleteVirtualCluster', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub DescribeJobRun {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::EMRContainers::DescribeJobRun', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DescribeManagedEndpoint {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::EMRContainers::DescribeManagedEndpoint', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub DescribeVirtualCluster {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::EMRContainers::DescribeVirtualCluster', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub ListJobRuns {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::EMRContainers::ListJobRuns', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub ListManagedEndpoints {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::EMRContainers::ListManagedEndpoints', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub ListTagsForResource {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::EMRContainers::ListTagsForResource', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub ListVirtualClusters {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::EMRContainers::ListVirtualClusters', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub StartJobRun {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::EMRContainers::StartJobRun', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub TagResource {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::EMRContainers::TagResource', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub UntagResource {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::EMRContainers::UntagResource', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92
93 sub ListAllJobRuns {
94 my $self = shift;
95  
96 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
97 my $result = $self->ListJobRuns(@_);
98 my $next_result = $result;
99  
100 if (not defined $callback) {
101 while ($next_result->nextToken) {
102 $next_result = $self->ListJobRuns(@_, nextToken => $next_result->nextToken);
103 push @{ $result->jobRuns }, @{ $next_result->jobRuns };
104 }
105 return $result;
106 } else {
107 while ($result->nextToken) {
108 $callback->($_ => 'jobRuns') foreach (@{ $result->jobRuns });
109 $result = $self->ListJobRuns(@_, nextToken => $result->nextToken);
110 }
111 $callback->($_ => 'jobRuns') foreach (@{ $result->jobRuns });
112 }
113  
114 return undef
115 }
116 sub ListAllManagedEndpoints {
117 my $self = shift;
118  
119 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
120 my $result = $self->ListManagedEndpoints(@_);
121 my $next_result = $result;
122  
123 if (not defined $callback) {
124 while ($next_result->nextToken) {
125 $next_result = $self->ListManagedEndpoints(@_, nextToken => $next_result->nextToken);
126 push @{ $result->endpoints }, @{ $next_result->endpoints };
127 }
128 return $result;
129 } else {
130 while ($result->nextToken) {
131 $callback->($_ => 'endpoints') foreach (@{ $result->endpoints });
132 $result = $self->ListManagedEndpoints(@_, nextToken => $result->nextToken);
133 }
134 $callback->($_ => 'endpoints') foreach (@{ $result->endpoints });
135 }
136  
137 return undef
138 }
139 sub ListAllVirtualClusters {
140 my $self = shift;
141  
142 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
143 my $result = $self->ListVirtualClusters(@_);
144 my $next_result = $result;
145  
146 if (not defined $callback) {
147 while ($next_result->nextToken) {
148 $next_result = $self->ListVirtualClusters(@_, nextToken => $next_result->nextToken);
149 push @{ $result->virtualClusters }, @{ $next_result->virtualClusters };
150 }
151 return $result;
152 } else {
153 while ($result->nextToken) {
154 $callback->($_ => 'virtualClusters') foreach (@{ $result->virtualClusters });
155 $result = $self->ListVirtualClusters(@_, nextToken => $result->nextToken);
156 }
157 $callback->($_ => 'virtualClusters') foreach (@{ $result->virtualClusters });
158 }
159  
160 return undef
161 }
162  
163  
164 sub operations { qw/CancelJobRun CreateManagedEndpoint CreateVirtualCluster DeleteManagedEndpoint DeleteVirtualCluster DescribeJobRun DescribeManagedEndpoint DescribeVirtualCluster ListJobRuns ListManagedEndpoints ListTagsForResource ListVirtualClusters StartJobRun TagResource UntagResource / }
165  
166 1;
167  
168 ### main pod documentation begin ###
169  
170 =head1 NAME
171  
172 Paws::EMRContainers - Perl Interface to AWS Amazon EMR Containers
173  
174 =head1 SYNOPSIS
175  
176 use Paws;
177  
178 my $obj = Paws->service('EMRContainers');
179 my $res = $obj->Method(
180 Arg1 => $val1,
181 Arg2 => [ 'V1', 'V2' ],
182 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
183 # of the arguments type
184 Arg3 => { Att1 => 'Val1' },
185 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
186 # the constructor of the arguments type
187 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
188 );
189  
190 =head1 DESCRIPTION
191  
192 Amazon EMR on EKS provides a deployment option for Amazon EMR that
193 allows you to run open-source big data frameworks on Amazon Elastic
194 Kubernetes Service (Amazon EKS). With this deployment option, you can
195 focus on running analytics workloads while Amazon EMR on EKS builds,
196 configures, and manages containers for open-source applications. For
197 more information about Amazon EMR on EKS concepts and tasks, see What
198 is Amazon EMR on EKS
199 (https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/emr-eks.html).
200  
201 I<Amazon EMR containers> is the API name for Amazon EMR on EKS. The
202 C<emr-containers> prefix is used in the following scenarios:
203  
204 =over
205  
206 =item *
207  
208 It is the prefix in the CLI commands for Amazon EMR on EKS. For
209 example, C<aws emr-containers start-job-run>.
210  
211 =item *
212  
213 It is the prefix before IAM policy actions for Amazon EMR on EKS. For
214 example, C<"Action": [ "emr-containers:StartJobRun"]>. For more
215 information, see Policy actions for Amazon EMR on EKS
216 (https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-actions).
217  
218 =item *
219  
220 It is the prefix used in Amazon EMR on EKS service endpoints. For
221 example, C<emr-containers.us-east-2.amazonaws.com>. For more
222 information, see Amazon EMR on EKS Service Endpoints
223 (https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/service-quotas.html#service-endpoints).
224  
225 =back
226  
227  
228 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/emr-containers-2020-10-01>
229  
230  
231 =head1 METHODS
232  
233 =head2 CancelJobRun
234  
235 =over
236  
237 =item Id => Str
238  
239 =item VirtualClusterId => Str
240  
241  
242 =back
243  
244 Each argument is described in detail in: L<Paws::EMRContainers::CancelJobRun>
245  
246 Returns: a L<Paws::EMRContainers::CancelJobRunResponse> instance
247  
248 Cancels a job run. A job run is a unit of work, such as a Spark jar,
249 PySpark script, or SparkSQL query, that you submit to Amazon EMR on
250 EKS.
251  
252  
253 =head2 CreateManagedEndpoint
254  
255 =over
256  
257 =item CertificateArn => Str
258  
259 =item ClientToken => Str
260  
261 =item ExecutionRoleArn => Str
262  
263 =item Name => Str
264  
265 =item ReleaseLabel => Str
266  
267 =item Type => Str
268  
269 =item VirtualClusterId => Str
270  
271 =item [ConfigurationOverrides => L<Paws::EMRContainers::ConfigurationOverrides>]
272  
273 =item [Tags => L<Paws::EMRContainers::TagMap>]
274  
275  
276 =back
277  
278 Each argument is described in detail in: L<Paws::EMRContainers::CreateManagedEndpoint>
279  
280 Returns: a L<Paws::EMRContainers::CreateManagedEndpointResponse> instance
281  
282 Creates a managed endpoint. A managed endpoint is a gateway that
283 connects EMR Studio to Amazon EMR on EKS so that EMR Studio can
284 communicate with your virtual cluster.
285  
286  
287 =head2 CreateVirtualCluster
288  
289 =over
290  
291 =item ClientToken => Str
292  
293 =item ContainerProvider => L<Paws::EMRContainers::ContainerProvider>
294  
295 =item Name => Str
296  
297 =item [Tags => L<Paws::EMRContainers::TagMap>]
298  
299  
300 =back
301  
302 Each argument is described in detail in: L<Paws::EMRContainers::CreateVirtualCluster>
303  
304 Returns: a L<Paws::EMRContainers::CreateVirtualClusterResponse> instance
305  
306 Creates a virtual cluster. Virtual cluster is a managed entity on
307 Amazon EMR on EKS. You can create, describe, list and delete virtual
308 clusters. They do not consume any additional resource in your system. A
309 single virtual cluster maps to a single Kubernetes namespace. Given
310 this relationship, you can model virtual clusters the same way you
311 model Kubernetes namespaces to meet your requirements.
312  
313  
314 =head2 DeleteManagedEndpoint
315  
316 =over
317  
318 =item Id => Str
319  
320 =item VirtualClusterId => Str
321  
322  
323 =back
324  
325 Each argument is described in detail in: L<Paws::EMRContainers::DeleteManagedEndpoint>
326  
327 Returns: a L<Paws::EMRContainers::DeleteManagedEndpointResponse> instance
328  
329 Deletes a managed endpoint. A managed endpoint is a gateway that
330 connects EMR Studio to Amazon EMR on EKS so that EMR Studio can
331 communicate with your virtual cluster.
332  
333  
334 =head2 DeleteVirtualCluster
335  
336 =over
337  
338 =item Id => Str
339  
340  
341 =back
342  
343 Each argument is described in detail in: L<Paws::EMRContainers::DeleteVirtualCluster>
344  
345 Returns: a L<Paws::EMRContainers::DeleteVirtualClusterResponse> instance
346  
347 Deletes a virtual cluster. Virtual cluster is a managed entity on
348 Amazon EMR on EKS. You can create, describe, list and delete virtual
349 clusters. They do not consume any additional resource in your system. A
350 single virtual cluster maps to a single Kubernetes namespace. Given
351 this relationship, you can model virtual clusters the same way you
352 model Kubernetes namespaces to meet your requirements.
353  
354  
355 =head2 DescribeJobRun
356  
357 =over
358  
359 =item Id => Str
360  
361 =item VirtualClusterId => Str
362  
363  
364 =back
365  
366 Each argument is described in detail in: L<Paws::EMRContainers::DescribeJobRun>
367  
368 Returns: a L<Paws::EMRContainers::DescribeJobRunResponse> instance
369  
370 Displays detailed information about a job run. A job run is a unit of
371 work, such as a Spark jar, PySpark script, or SparkSQL query, that you
372 submit to Amazon EMR on EKS.
373  
374  
375 =head2 DescribeManagedEndpoint
376  
377 =over
378  
379 =item Id => Str
380  
381 =item VirtualClusterId => Str
382  
383  
384 =back
385  
386 Each argument is described in detail in: L<Paws::EMRContainers::DescribeManagedEndpoint>
387  
388 Returns: a L<Paws::EMRContainers::DescribeManagedEndpointResponse> instance
389  
390 Displays detailed information about a managed endpoint. A managed
391 endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so
392 that EMR Studio can communicate with your virtual cluster.
393  
394  
395 =head2 DescribeVirtualCluster
396  
397 =over
398  
399 =item Id => Str
400  
401  
402 =back
403  
404 Each argument is described in detail in: L<Paws::EMRContainers::DescribeVirtualCluster>
405  
406 Returns: a L<Paws::EMRContainers::DescribeVirtualClusterResponse> instance
407  
408 Displays detailed information about a specified virtual cluster.
409 Virtual cluster is a managed entity on Amazon EMR on EKS. You can
410 create, describe, list and delete virtual clusters. They do not consume
411 any additional resource in your system. A single virtual cluster maps
412 to a single Kubernetes namespace. Given this relationship, you can
413 model virtual clusters the same way you model Kubernetes namespaces to
414 meet your requirements.
415  
416  
417 =head2 ListJobRuns
418  
419 =over
420  
421 =item VirtualClusterId => Str
422  
423 =item [CreatedAfter => Str]
424  
425 =item [CreatedBefore => Str]
426  
427 =item [MaxResults => Int]
428  
429 =item [Name => Str]
430  
431 =item [NextToken => Str]
432  
433 =item [States => ArrayRef[Str|Undef]]
434  
435  
436 =back
437  
438 Each argument is described in detail in: L<Paws::EMRContainers::ListJobRuns>
439  
440 Returns: a L<Paws::EMRContainers::ListJobRunsResponse> instance
441  
442 Lists job runs based on a set of parameters. A job run is a unit of
443 work, such as a Spark jar, PySpark script, or SparkSQL query, that you
444 submit to Amazon EMR on EKS.
445  
446  
447 =head2 ListManagedEndpoints
448  
449 =over
450  
451 =item VirtualClusterId => Str
452  
453 =item [CreatedAfter => Str]
454  
455 =item [CreatedBefore => Str]
456  
457 =item [MaxResults => Int]
458  
459 =item [NextToken => Str]
460  
461 =item [States => ArrayRef[Str|Undef]]
462  
463 =item [Types => ArrayRef[Str|Undef]]
464  
465  
466 =back
467  
468 Each argument is described in detail in: L<Paws::EMRContainers::ListManagedEndpoints>
469  
470 Returns: a L<Paws::EMRContainers::ListManagedEndpointsResponse> instance
471  
472 Lists managed endpoints based on a set of parameters. A managed
473 endpoint is a gateway that connects EMR Studio to Amazon EMR on EKS so
474 that EMR Studio can communicate with your virtual cluster.
475  
476  
477 =head2 ListTagsForResource
478  
479 =over
480  
481 =item ResourceArn => Str
482  
483  
484 =back
485  
486 Each argument is described in detail in: L<Paws::EMRContainers::ListTagsForResource>
487  
488 Returns: a L<Paws::EMRContainers::ListTagsForResourceResponse> instance
489  
490 Lists the tags assigned to the resources.
491  
492  
493 =head2 ListVirtualClusters
494  
495 =over
496  
497 =item [ContainerProviderId => Str]
498  
499 =item [ContainerProviderType => Str]
500  
501 =item [CreatedAfter => Str]
502  
503 =item [CreatedBefore => Str]
504  
505 =item [MaxResults => Int]
506  
507 =item [NextToken => Str]
508  
509 =item [States => ArrayRef[Str|Undef]]
510  
511  
512 =back
513  
514 Each argument is described in detail in: L<Paws::EMRContainers::ListVirtualClusters>
515  
516 Returns: a L<Paws::EMRContainers::ListVirtualClustersResponse> instance
517  
518 Lists information about the specified virtual cluster. Virtual cluster
519 is a managed entity on Amazon EMR on EKS. You can create, describe,
520 list and delete virtual clusters. They do not consume any additional
521 resource in your system. A single virtual cluster maps to a single
522 Kubernetes namespace. Given this relationship, you can model virtual
523 clusters the same way you model Kubernetes namespaces to meet your
524 requirements.
525  
526  
527 =head2 StartJobRun
528  
529 =over
530  
531 =item ClientToken => Str
532  
533 =item ExecutionRoleArn => Str
534  
535 =item JobDriver => L<Paws::EMRContainers::JobDriver>
536  
537 =item ReleaseLabel => Str
538  
539 =item VirtualClusterId => Str
540  
541 =item [ConfigurationOverrides => L<Paws::EMRContainers::ConfigurationOverrides>]
542  
543 =item [Name => Str]
544  
545 =item [Tags => L<Paws::EMRContainers::TagMap>]
546  
547  
548 =back
549  
550 Each argument is described in detail in: L<Paws::EMRContainers::StartJobRun>
551  
552 Returns: a L<Paws::EMRContainers::StartJobRunResponse> instance
553  
554 Starts a job run. A job run is a unit of work, such as a Spark jar,
555 PySpark script, or SparkSQL query, that you submit to Amazon EMR on
556 EKS.
557  
558  
559 =head2 TagResource
560  
561 =over
562  
563 =item ResourceArn => Str
564  
565 =item Tags => L<Paws::EMRContainers::TagMap>
566  
567  
568 =back
569  
570 Each argument is described in detail in: L<Paws::EMRContainers::TagResource>
571  
572 Returns: a L<Paws::EMRContainers::TagResourceResponse> instance
573  
574 Assigns tags to resources. A tag is a label that you assign to an AWS
575 resource. Each tag consists of a key and an optional value, both of
576 which you define. Tags enable you to categorize your AWS resources by
577 attributes such as purpose, owner, or environment. When you have many
578 resources of the same type, you can quickly identify a specific
579 resource based on the tags you've assigned to it. For example, you can
580 define a set of tags for your Amazon EMR on EKS clusters to help you
581 track each cluster's owner and stack level. We recommend that you
582 devise a consistent set of tag keys for each resource type. You can
583 then search and filter the resources based on the tags that you add.
584  
585  
586 =head2 UntagResource
587  
588 =over
589  
590 =item ResourceArn => Str
591  
592 =item TagKeys => ArrayRef[Str|Undef]
593  
594  
595 =back
596  
597 Each argument is described in detail in: L<Paws::EMRContainers::UntagResource>
598  
599 Returns: a L<Paws::EMRContainers::UntagResourceResponse> instance
600  
601 Removes tags from resources.
602  
603  
604  
605  
606 =head1 PAGINATORS
607  
608 Paginator methods are helpers that repetively call methods that return partial results
609  
610 =head2 ListAllJobRuns(sub { },VirtualClusterId => Str, [CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, Name => Str, NextToken => Str, States => ArrayRef[Str|Undef]])
611  
612 =head2 ListAllJobRuns(VirtualClusterId => Str, [CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, Name => Str, NextToken => Str, States => ArrayRef[Str|Undef]])
613  
614  
615 If passed a sub as first parameter, it will call the sub for each element found in :
616  
617 - jobRuns, passing the object as the first parameter, and the string 'jobRuns' as the second parameter
618  
619 If not, it will return a a L<Paws::EMRContainers::ListJobRunsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
620  
621  
622 =head2 ListAllManagedEndpoints(sub { },VirtualClusterId => Str, [CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef], Types => ArrayRef[Str|Undef]])
623  
624 =head2 ListAllManagedEndpoints(VirtualClusterId => Str, [CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef], Types => ArrayRef[Str|Undef]])
625  
626  
627 If passed a sub as first parameter, it will call the sub for each element found in :
628  
629 - endpoints, passing the object as the first parameter, and the string 'endpoints' as the second parameter
630  
631 If not, it will return a a L<Paws::EMRContainers::ListManagedEndpointsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
632  
633  
634 =head2 ListAllVirtualClusters(sub { },[ContainerProviderId => Str, ContainerProviderType => Str, CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
635  
636 =head2 ListAllVirtualClusters([ContainerProviderId => Str, ContainerProviderType => Str, CreatedAfter => Str, CreatedBefore => Str, MaxResults => Int, NextToken => Str, States => ArrayRef[Str|Undef]])
637  
638  
639 If passed a sub as first parameter, it will call the sub for each element found in :
640  
641 - virtualClusters, passing the object as the first parameter, and the string 'virtualClusters' as the second parameter
642  
643 If not, it will return a a L<Paws::EMRContainers::ListVirtualClustersResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
644  
645  
646  
647  
648  
649 =head1 SEE ALSO
650  
651 This service class forms part of L<Paws>
652  
653 =head1 BUGS and CONTRIBUTIONS
654  
655 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
656  
657 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
658  
659 =cut
660