File Coverage

blib/lib/Paws/ECR.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::ECR;
2 1     1   28654 use Moose;
  1         3  
  1         8  
3             sub service { 'ecr' }
4             sub version { '2015-09-21' }
5             sub target_prefix { 'AmazonEC2ContainerRegistry_V20150921' }
6             sub json_version { "1.1" }
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::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub BatchCheckLayerAvailability {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::ECR::BatchCheckLayerAvailability', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub BatchDeleteImage {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::ECR::BatchDeleteImage', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub BatchGetImage {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::ECR::BatchGetImage', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub CompleteLayerUpload {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::ECR::CompleteLayerUpload', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub CreateRepository {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::ECR::CreateRepository', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub DeleteRepository {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::ECR::DeleteRepository', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub DeleteRepositoryPolicy {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::ECR::DeleteRepositoryPolicy', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub DescribeImages {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::ECR::DescribeImages', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub DescribeRepositories {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::ECR::DescribeRepositories', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub GetAuthorizationToken {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::ECR::GetAuthorizationToken', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub GetDownloadUrlForLayer {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::ECR::GetDownloadUrlForLayer', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub GetRepositoryPolicy {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::ECR::GetRepositoryPolicy', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub InitiateLayerUpload {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::ECR::InitiateLayerUpload', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub ListImages {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::ECR::ListImages', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub PutImage {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::ECR::PutImage', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92             sub SetRepositoryPolicy {
93             my $self = shift;
94             my $call_object = $self->new_with_coercions('Paws::ECR::SetRepositoryPolicy', @_);
95             return $self->caller->do_call($self, $call_object);
96             }
97             sub UploadLayerPart {
98             my $self = shift;
99             my $call_object = $self->new_with_coercions('Paws::ECR::UploadLayerPart', @_);
100             return $self->caller->do_call($self, $call_object);
101             }
102            
103             sub DescribeAllImages {
104             my $self = shift;
105              
106             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
107             my $result = $self->DescribeImages(@_);
108             my $next_result = $result;
109              
110             if (not defined $callback) {
111             while ($next_result->nextToken) {
112             $next_result = $self->DescribeImages(@_, nextToken => $next_result->nextToken);
113             push @{ $result->imageDetails }, @{ $next_result->imageDetails };
114             }
115             return $result;
116             } else {
117             while ($result->nextToken) {
118             $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
119             $result = $self->DescribeImages(@_, nextToken => $result->nextToken);
120             }
121             $callback->($_ => 'imageDetails') foreach (@{ $result->imageDetails });
122             }
123              
124             return undef
125             }
126             sub DescribeAllRepositories {
127             my $self = shift;
128              
129             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
130             my $result = $self->DescribeRepositories(@_);
131             my $next_result = $result;
132              
133             if (not defined $callback) {
134             while ($next_result->nextToken) {
135             $next_result = $self->DescribeRepositories(@_, nextToken => $next_result->nextToken);
136             push @{ $result->repositories }, @{ $next_result->repositories };
137             }
138             return $result;
139             } else {
140             while ($result->nextToken) {
141             $callback->($_ => 'repositories') foreach (@{ $result->repositories });
142             $result = $self->DescribeRepositories(@_, nextToken => $result->nextToken);
143             }
144             $callback->($_ => 'repositories') foreach (@{ $result->repositories });
145             }
146              
147             return undef
148             }
149             sub ListAllImages {
150             my $self = shift;
151              
152             my $callback = shift @_ if (ref($_[0]) eq 'CODE');
153             my $result = $self->ListImages(@_);
154             my $next_result = $result;
155              
156             if (not defined $callback) {
157             while ($next_result->nextToken) {
158             $next_result = $self->ListImages(@_, nextToken => $next_result->nextToken);
159             push @{ $result->imageIds }, @{ $next_result->imageIds };
160             }
161             return $result;
162             } else {
163             while ($result->nextToken) {
164             $callback->($_ => 'imageIds') foreach (@{ $result->imageIds });
165             $result = $self->ListImages(@_, nextToken => $result->nextToken);
166             }
167             $callback->($_ => 'imageIds') foreach (@{ $result->imageIds });
168             }
169              
170             return undef
171             }
172              
173              
174             sub operations { qw/BatchCheckLayerAvailability BatchDeleteImage BatchGetImage CompleteLayerUpload CreateRepository DeleteRepository DeleteRepositoryPolicy DescribeImages DescribeRepositories GetAuthorizationToken GetDownloadUrlForLayer GetRepositoryPolicy InitiateLayerUpload ListImages PutImage SetRepositoryPolicy UploadLayerPart / }
175              
176             1;
177              
178             ### main pod documentation begin ###
179              
180             =head1 NAME
181              
182             Paws::ECR - Perl Interface to AWS Amazon EC2 Container Registry
183              
184             =head1 SYNOPSIS
185              
186             use Paws;
187              
188             my $obj = Paws->service('ECR');
189             my $res = $obj->Method(
190             Arg1 => $val1,
191             Arg2 => [ 'V1', 'V2' ],
192             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
193             # of the arguments type
194             Arg3 => { Att1 => 'Val1' },
195             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
196             # the constructor of the arguments type
197             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
198             );
199              
200             =head1 DESCRIPTION
201              
202             Amazon EC2 Container Registry (Amazon ECR) is a managed AWS Docker
203             registry service. Customers can use the familiar Docker CLI to push,
204             pull, and manage images. Amazon ECR provides a secure, scalable, and
205             reliable registry. Amazon ECR supports private Docker repositories with
206             resource-based permissions using AWS IAM so that specific users or
207             Amazon EC2 instances can access repositories and images. Developers can
208             use the Docker CLI to author and manage images.
209              
210             =head1 METHODS
211              
212             =head2 BatchCheckLayerAvailability(LayerDigests => ArrayRef[Str|Undef], RepositoryName => Str, [RegistryId => Str])
213              
214             Each argument is described in detail in: L<Paws::ECR::BatchCheckLayerAvailability>
215              
216             Returns: a L<Paws::ECR::BatchCheckLayerAvailabilityResponse> instance
217              
218             Check the availability of multiple image layers in a specified registry
219             and repository.
220              
221             This operation is used by the Amazon ECR proxy, and it is not intended
222             for general use by customers for pulling and pushing images. In most
223             cases, you should use the C<docker> CLI to pull, tag, and push images.
224              
225              
226             =head2 BatchDeleteImage(ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], RepositoryName => Str, [RegistryId => Str])
227              
228             Each argument is described in detail in: L<Paws::ECR::BatchDeleteImage>
229              
230             Returns: a L<Paws::ECR::BatchDeleteImageResponse> instance
231              
232             Deletes a list of specified images within a specified repository.
233             Images are specified with either C<imageTag> or C<imageDigest>.
234              
235             You can remove a tag from an image by specifying the image's tag in
236             your request. When you remove the last tag from an image, the image is
237             deleted from your repository.
238              
239             You can completely delete an image (and all of its tags) by specifying
240             the image's digest in your request.
241              
242              
243             =head2 BatchGetImage(ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], RepositoryName => Str, [AcceptedMediaTypes => ArrayRef[Str|Undef], RegistryId => Str])
244              
245             Each argument is described in detail in: L<Paws::ECR::BatchGetImage>
246              
247             Returns: a L<Paws::ECR::BatchGetImageResponse> instance
248              
249             Gets detailed information for specified images within a specified
250             repository. Images are specified with either C<imageTag> or
251             C<imageDigest>.
252              
253              
254             =head2 CompleteLayerUpload(LayerDigests => ArrayRef[Str|Undef], RepositoryName => Str, UploadId => Str, [RegistryId => Str])
255              
256             Each argument is described in detail in: L<Paws::ECR::CompleteLayerUpload>
257              
258             Returns: a L<Paws::ECR::CompleteLayerUploadResponse> instance
259              
260             Inform Amazon ECR that the image layer upload for a specified registry,
261             repository name, and upload ID, has completed. You can optionally
262             provide a C<sha256> digest of the image layer for data validation
263             purposes.
264              
265             This operation is used by the Amazon ECR proxy, and it is not intended
266             for general use by customers for pulling and pushing images. In most
267             cases, you should use the C<docker> CLI to pull, tag, and push images.
268              
269              
270             =head2 CreateRepository(RepositoryName => Str)
271              
272             Each argument is described in detail in: L<Paws::ECR::CreateRepository>
273              
274             Returns: a L<Paws::ECR::CreateRepositoryResponse> instance
275              
276             Creates an image repository.
277              
278              
279             =head2 DeleteRepository(RepositoryName => Str, [Force => Bool, RegistryId => Str])
280              
281             Each argument is described in detail in: L<Paws::ECR::DeleteRepository>
282              
283             Returns: a L<Paws::ECR::DeleteRepositoryResponse> instance
284              
285             Deletes an existing image repository. If a repository contains images,
286             you must use the C<force> option to delete it.
287              
288              
289             =head2 DeleteRepositoryPolicy(RepositoryName => Str, [RegistryId => Str])
290              
291             Each argument is described in detail in: L<Paws::ECR::DeleteRepositoryPolicy>
292              
293             Returns: a L<Paws::ECR::DeleteRepositoryPolicyResponse> instance
294              
295             Deletes the repository policy from a specified repository.
296              
297              
298             =head2 DescribeImages(RepositoryName => Str, [Filter => L<Paws::ECR::DescribeImagesFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
299              
300             Each argument is described in detail in: L<Paws::ECR::DescribeImages>
301              
302             Returns: a L<Paws::ECR::DescribeImagesResponse> instance
303              
304             Returns metadata about the images in a repository, including image
305             size, image tags, and creation date.
306              
307             Beginning with Docker version 1.9, the Docker client compresses image
308             layers before pushing them to a V2 Docker registry. The output of the
309             C<docker images> command shows the uncompressed image size, so it may
310             return a larger image size than the image sizes returned by
311             DescribeImages.
312              
313              
314             =head2 DescribeRepositories([MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
315              
316             Each argument is described in detail in: L<Paws::ECR::DescribeRepositories>
317              
318             Returns: a L<Paws::ECR::DescribeRepositoriesResponse> instance
319              
320             Describes image repositories in a registry.
321              
322              
323             =head2 GetAuthorizationToken([RegistryIds => ArrayRef[Str|Undef]])
324              
325             Each argument is described in detail in: L<Paws::ECR::GetAuthorizationToken>
326              
327             Returns: a L<Paws::ECR::GetAuthorizationTokenResponse> instance
328              
329             Retrieves a token that is valid for a specified registry for 12 hours.
330             This command allows you to use the C<docker> CLI to push and pull
331             images with Amazon ECR. If you do not specify a registry, the default
332             registry is assumed.
333              
334             The C<authorizationToken> returned for each registry specified is a
335             base64 encoded string that can be decoded and used in a C<docker login>
336             command to authenticate to a registry. The AWS CLI offers an C<aws ecr
337             get-login> command that simplifies the login process.
338              
339              
340             =head2 GetDownloadUrlForLayer(LayerDigest => Str, RepositoryName => Str, [RegistryId => Str])
341              
342             Each argument is described in detail in: L<Paws::ECR::GetDownloadUrlForLayer>
343              
344             Returns: a L<Paws::ECR::GetDownloadUrlForLayerResponse> instance
345              
346             Retrieves the pre-signed Amazon S3 download URL corresponding to an
347             image layer. You can only get URLs for image layers that are referenced
348             in an image.
349              
350             This operation is used by the Amazon ECR proxy, and it is not intended
351             for general use by customers for pulling and pushing images. In most
352             cases, you should use the C<docker> CLI to pull, tag, and push images.
353              
354              
355             =head2 GetRepositoryPolicy(RepositoryName => Str, [RegistryId => Str])
356              
357             Each argument is described in detail in: L<Paws::ECR::GetRepositoryPolicy>
358              
359             Returns: a L<Paws::ECR::GetRepositoryPolicyResponse> instance
360              
361             Retrieves the repository policy for a specified repository.
362              
363              
364             =head2 InitiateLayerUpload(RepositoryName => Str, [RegistryId => Str])
365              
366             Each argument is described in detail in: L<Paws::ECR::InitiateLayerUpload>
367              
368             Returns: a L<Paws::ECR::InitiateLayerUploadResponse> instance
369              
370             Notify Amazon ECR that you intend to upload an image layer.
371              
372             This operation is used by the Amazon ECR proxy, and it is not intended
373             for general use by customers for pulling and pushing images. In most
374             cases, you should use the C<docker> CLI to pull, tag, and push images.
375              
376              
377             =head2 ListImages(RepositoryName => Str, [Filter => L<Paws::ECR::ListImagesFilter>, MaxResults => Int, NextToken => Str, RegistryId => Str])
378              
379             Each argument is described in detail in: L<Paws::ECR::ListImages>
380              
381             Returns: a L<Paws::ECR::ListImagesResponse> instance
382              
383             Lists all the image IDs for a given repository.
384              
385             You can filter images based on whether or not they are tagged by
386             setting the C<tagStatus> parameter to C<TAGGED> or C<UNTAGGED>. For
387             example, you can filter your results to return only C<UNTAGGED> images
388             and then pipe that result to a BatchDeleteImage operation to delete
389             them. Or, you can filter your results to return only C<TAGGED> images
390             to list all of the tags in your repository.
391              
392              
393             =head2 PutImage(ImageManifest => Str, RepositoryName => Str, [ImageTag => Str, RegistryId => Str])
394              
395             Each argument is described in detail in: L<Paws::ECR::PutImage>
396              
397             Returns: a L<Paws::ECR::PutImageResponse> instance
398              
399             Creates or updates the image manifest and tags associated with an
400             image.
401              
402             This operation is used by the Amazon ECR proxy, and it is not intended
403             for general use by customers for pulling and pushing images. In most
404             cases, you should use the C<docker> CLI to pull, tag, and push images.
405              
406              
407             =head2 SetRepositoryPolicy(PolicyText => Str, RepositoryName => Str, [Force => Bool, RegistryId => Str])
408              
409             Each argument is described in detail in: L<Paws::ECR::SetRepositoryPolicy>
410              
411             Returns: a L<Paws::ECR::SetRepositoryPolicyResponse> instance
412              
413             Applies a repository policy on a specified repository to control access
414             permissions.
415              
416              
417             =head2 UploadLayerPart(LayerPartBlob => Str, PartFirstByte => Int, PartLastByte => Int, RepositoryName => Str, UploadId => Str, [RegistryId => Str])
418              
419             Each argument is described in detail in: L<Paws::ECR::UploadLayerPart>
420              
421             Returns: a L<Paws::ECR::UploadLayerPartResponse> instance
422              
423             Uploads an image layer part to Amazon ECR.
424              
425             This operation is used by the Amazon ECR proxy, and it is not intended
426             for general use by customers for pulling and pushing images. In most
427             cases, you should use the C<docker> CLI to pull, tag, and push images.
428              
429              
430              
431              
432             =head1 PAGINATORS
433              
434             Paginator methods are helpers that repetively call methods that return partial results
435              
436             =head2 DescribeAllImages(sub { },RepositoryName => Str, [Filter => L<Paws::ECR::DescribeImagesFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
437              
438             =head2 DescribeAllImages(RepositoryName => Str, [Filter => L<Paws::ECR::DescribeImagesFilter>, ImageIds => ArrayRef[L<Paws::ECR::ImageIdentifier>], MaxResults => Int, NextToken => Str, RegistryId => Str])
439              
440              
441             If passed a sub as first parameter, it will call the sub for each element found in :
442              
443             - imageDetails, passing the object as the first parameter, and the string 'imageDetails' as the second parameter
444              
445             If not, it will return a a L<Paws::ECR::DescribeImagesResponse> 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.
446              
447              
448             =head2 DescribeAllRepositories(sub { },[MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
449              
450             =head2 DescribeAllRepositories([MaxResults => Int, NextToken => Str, RegistryId => Str, RepositoryNames => ArrayRef[Str|Undef]])
451              
452              
453             If passed a sub as first parameter, it will call the sub for each element found in :
454              
455             - repositories, passing the object as the first parameter, and the string 'repositories' as the second parameter
456              
457             If not, it will return a a L<Paws::ECR::DescribeRepositoriesResponse> 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.
458              
459              
460             =head2 ListAllImages(sub { },RepositoryName => Str, [Filter => L<Paws::ECR::ListImagesFilter>, MaxResults => Int, NextToken => Str, RegistryId => Str])
461              
462             =head2 ListAllImages(RepositoryName => Str, [Filter => L<Paws::ECR::ListImagesFilter>, MaxResults => Int, NextToken => Str, RegistryId => Str])
463              
464              
465             If passed a sub as first parameter, it will call the sub for each element found in :
466              
467             - imageIds, passing the object as the first parameter, and the string 'imageIds' as the second parameter
468              
469             If not, it will return a a L<Paws::ECR::ListImagesResponse> 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.
470              
471              
472              
473              
474              
475             =head1 SEE ALSO
476              
477             This service class forms part of L<Paws>
478              
479             =head1 BUGS and CONTRIBUTIONS
480              
481             The source code is located here: https://github.com/pplu/aws-sdk-perl
482              
483             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
484              
485             =cut
486