api_op_DescribeImages.go

Documentation: github.com/aws/aws-sdk-go-v2/service/ecrpublic

     1  // Code generated by smithy-go-codegen DO NOT EDIT.
     2  
     3  package ecrpublic
     4  
     5  import (
     6  	"context"
     7  	"errors"
     8  	"fmt"
     9  	"github.com/aws/aws-sdk-go-v2/aws"
    10  	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
    11  	"github.com/aws/aws-sdk-go-v2/aws/signer/v4"
    12  	internalauth "github.com/aws/aws-sdk-go-v2/internal/auth"
    13  	"github.com/aws/aws-sdk-go-v2/service/ecrpublic/types"
    14  	smithyendpoints "github.com/aws/smithy-go/endpoints"
    15  	"github.com/aws/smithy-go/middleware"
    16  	smithyhttp "github.com/aws/smithy-go/transport/http"
    17  )
    18  
    19  // Returns metadata that's related to the images in a repository in a public
    20  // registry. Beginning with Docker version 1.9, the Docker client compresses image
    21  // layers before pushing them to a V2 Docker registry. The output of the docker
    22  // images command shows the uncompressed image size. Therefore, it might return a
    23  // larger image size than the image sizes that are returned by DescribeImages .
    24  func (c *Client) DescribeImages(ctx context.Context, params *DescribeImagesInput, optFns ...func(*Options)) (*DescribeImagesOutput, error) {
    25  	if params == nil {
    26  		params = &DescribeImagesInput{}
    27  	}
    28  
    29  	result, metadata, err := c.invokeOperation(ctx, "DescribeImages", params, optFns, c.addOperationDescribeImagesMiddlewares)
    30  	if err != nil {
    31  		return nil, err
    32  	}
    33  
    34  	out := result.(*DescribeImagesOutput)
    35  	out.ResultMetadata = metadata
    36  	return out, nil
    37  }
    38  
    39  type DescribeImagesInput struct {
    40  
    41  	// The repository that contains the images to describe.
    42  	//
    43  	// This member is required.
    44  	RepositoryName *string
    45  
    46  	// The list of image IDs for the requested repository.
    47  	ImageIds []types.ImageIdentifier
    48  
    49  	// The maximum number of repository results that's returned by DescribeImages in
    50  	// paginated output. When this parameter is used, DescribeImages only returns
    51  	// maxResults results in a single page along with a nextToken response element.
    52  	// You can see the remaining results of the initial request by sending another
    53  	// DescribeImages request with the returned nextToken value. This value can be
    54  	// between 1 and 1000. If this parameter isn't used, then DescribeImages returns
    55  	// up to 100 results and a nextToken value, if applicable. If you specify images
    56  	// with imageIds , you can't use this option.
    57  	MaxResults *int32
    58  
    59  	// The nextToken value that's returned from a previous paginated DescribeImages
    60  	// request where maxResults was used and the results exceeded the value of that
    61  	// parameter. Pagination continues from the end of the previous results that
    62  	// returned the nextToken value. If there are no more results to return, this
    63  	// value is null . If you specify images with imageIds , you can't use this option.
    64  	NextToken *string
    65  
    66  	// The Amazon Web Services account ID that's associated with the public registry
    67  	// that contains the repository where images are described. If you do not specify a
    68  	// registry, the default public registry is assumed.
    69  	RegistryId *string
    70  
    71  	noSmithyDocumentSerde
    72  }
    73  
    74  type DescribeImagesOutput struct {
    75  
    76  	// A list of ImageDetail objects that contain data about the image.
    77  	ImageDetails []types.ImageDetail
    78  
    79  	// The nextToken value to include in a future DescribeImages request. When the
    80  	// results of a DescribeImages request exceed maxResults , you can use this value
    81  	// to retrieve the next page of results. If there are no more results to return,
    82  	// this value is null .
    83  	NextToken *string
    84  
    85  	// Metadata pertaining to the operation's result.
    86  	ResultMetadata middleware.Metadata
    87  
    88  	noSmithyDocumentSerde
    89  }
    90  
    91  func (c *Client) addOperationDescribeImagesMiddlewares(stack *middleware.Stack, options Options) (err error) {
    92  	err = stack.Serialize.Add(&awsAwsjson11_serializeOpDescribeImages{}, middleware.After)
    93  	if err != nil {
    94  		return err
    95  	}
    96  	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpDescribeImages{}, middleware.After)
    97  	if err != nil {
    98  		return err
    99  	}
   100  	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
   101  		return err
   102  	}
   103  	if err = addSetLoggerMiddleware(stack, options); err != nil {
   104  		return err
   105  	}
   106  	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
   107  		return err
   108  	}
   109  	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
   110  		return err
   111  	}
   112  	if err = addResolveEndpointMiddleware(stack, options); err != nil {
   113  		return err
   114  	}
   115  	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
   116  		return err
   117  	}
   118  	if err = addRetryMiddlewares(stack, options); err != nil {
   119  		return err
   120  	}
   121  	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
   122  		return err
   123  	}
   124  	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
   125  		return err
   126  	}
   127  	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
   128  		return err
   129  	}
   130  	if err = addClientUserAgent(stack, options); err != nil {
   131  		return err
   132  	}
   133  	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
   134  		return err
   135  	}
   136  	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
   137  		return err
   138  	}
   139  	if err = addDescribeImagesResolveEndpointMiddleware(stack, options); err != nil {
   140  		return err
   141  	}
   142  	if err = addOpDescribeImagesValidationMiddleware(stack); err != nil {
   143  		return err
   144  	}
   145  	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opDescribeImages(options.Region), middleware.Before); err != nil {
   146  		return err
   147  	}
   148  	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
   149  		return err
   150  	}
   151  	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
   152  		return err
   153  	}
   154  	if err = addResponseErrorMiddleware(stack); err != nil {
   155  		return err
   156  	}
   157  	if err = addRequestResponseLogging(stack, options); err != nil {
   158  		return err
   159  	}
   160  	if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil {
   161  		return err
   162  	}
   163  	return nil
   164  }
   165  
   166  // DescribeImagesAPIClient is a client that implements the DescribeImages
   167  // operation.
   168  type DescribeImagesAPIClient interface {
   169  	DescribeImages(context.Context, *DescribeImagesInput, ...func(*Options)) (*DescribeImagesOutput, error)
   170  }
   171  
   172  var _ DescribeImagesAPIClient = (*Client)(nil)
   173  
   174  // DescribeImagesPaginatorOptions is the paginator options for DescribeImages
   175  type DescribeImagesPaginatorOptions struct {
   176  	// The maximum number of repository results that's returned by DescribeImages in
   177  	// paginated output. When this parameter is used, DescribeImages only returns
   178  	// maxResults results in a single page along with a nextToken response element.
   179  	// You can see the remaining results of the initial request by sending another
   180  	// DescribeImages request with the returned nextToken value. This value can be
   181  	// between 1 and 1000. If this parameter isn't used, then DescribeImages returns
   182  	// up to 100 results and a nextToken value, if applicable. If you specify images
   183  	// with imageIds , you can't use this option.
   184  	Limit int32
   185  
   186  	// Set to true if pagination should stop if the service returns a pagination token
   187  	// that matches the most recent token provided to the service.
   188  	StopOnDuplicateToken bool
   189  }
   190  
   191  // DescribeImagesPaginator is a paginator for DescribeImages
   192  type DescribeImagesPaginator struct {
   193  	options   DescribeImagesPaginatorOptions
   194  	client    DescribeImagesAPIClient
   195  	params    *DescribeImagesInput
   196  	nextToken *string
   197  	firstPage bool
   198  }
   199  
   200  // NewDescribeImagesPaginator returns a new DescribeImagesPaginator
   201  func NewDescribeImagesPaginator(client DescribeImagesAPIClient, params *DescribeImagesInput, optFns ...func(*DescribeImagesPaginatorOptions)) *DescribeImagesPaginator {
   202  	if params == nil {
   203  		params = &DescribeImagesInput{}
   204  	}
   205  
   206  	options := DescribeImagesPaginatorOptions{}
   207  	if params.MaxResults != nil {
   208  		options.Limit = *params.MaxResults
   209  	}
   210  
   211  	for _, fn := range optFns {
   212  		fn(&options)
   213  	}
   214  
   215  	return &DescribeImagesPaginator{
   216  		options:   options,
   217  		client:    client,
   218  		params:    params,
   219  		firstPage: true,
   220  		nextToken: params.NextToken,
   221  	}
   222  }
   223  
   224  // HasMorePages returns a boolean indicating whether more pages are available
   225  func (p *DescribeImagesPaginator) HasMorePages() bool {
   226  	return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
   227  }
   228  
   229  // NextPage retrieves the next DescribeImages page.
   230  func (p *DescribeImagesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*DescribeImagesOutput, error) {
   231  	if !p.HasMorePages() {
   232  		return nil, fmt.Errorf("no more pages available")
   233  	}
   234  
   235  	params := *p.params
   236  	params.NextToken = p.nextToken
   237  
   238  	var limit *int32
   239  	if p.options.Limit > 0 {
   240  		limit = &p.options.Limit
   241  	}
   242  	params.MaxResults = limit
   243  
   244  	result, err := p.client.DescribeImages(ctx, &params, optFns...)
   245  	if err != nil {
   246  		return nil, err
   247  	}
   248  	p.firstPage = false
   249  
   250  	prevToken := p.nextToken
   251  	p.nextToken = result.NextToken
   252  
   253  	if p.options.StopOnDuplicateToken &&
   254  		prevToken != nil &&
   255  		p.nextToken != nil &&
   256  		*prevToken == *p.nextToken {
   257  		p.nextToken = nil
   258  	}
   259  
   260  	return result, nil
   261  }
   262  
   263  func newServiceMetadataMiddleware_opDescribeImages(region string) *awsmiddleware.RegisterServiceMetadata {
   264  	return &awsmiddleware.RegisterServiceMetadata{
   265  		Region:        region,
   266  		ServiceID:     ServiceID,
   267  		SigningName:   "ecr-public",
   268  		OperationName: "DescribeImages",
   269  	}
   270  }
   271  
   272  type opDescribeImagesResolveEndpointMiddleware struct {
   273  	EndpointResolver EndpointResolverV2
   274  	BuiltInResolver  builtInParameterResolver
   275  }
   276  
   277  func (*opDescribeImagesResolveEndpointMiddleware) ID() string {
   278  	return "ResolveEndpointV2"
   279  }
   280  
   281  func (m *opDescribeImagesResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   282  	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   283  ) {
   284  	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
   285  		return next.HandleSerialize(ctx, in)
   286  	}
   287  
   288  	req, ok := in.Request.(*smithyhttp.Request)
   289  	if !ok {
   290  		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   291  	}
   292  
   293  	if m.EndpointResolver == nil {
   294  		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
   295  	}
   296  
   297  	params := EndpointParameters{}
   298  
   299  	m.BuiltInResolver.ResolveBuiltIns(&params)
   300  
   301  	var resolvedEndpoint smithyendpoints.Endpoint
   302  	resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params)
   303  	if err != nil {
   304  		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
   305  	}
   306  
   307  	req.URL = &resolvedEndpoint.URI
   308  
   309  	for k := range resolvedEndpoint.Headers {
   310  		req.Header.Set(
   311  			k,
   312  			resolvedEndpoint.Headers.Get(k),
   313  		)
   314  	}
   315  
   316  	authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties)
   317  	if err != nil {
   318  		var nfe *internalauth.NoAuthenticationSchemesFoundError
   319  		if errors.As(err, &nfe) {
   320  			// if no auth scheme is found, default to sigv4
   321  			signingName := "ecr-public"
   322  			signingRegion := m.BuiltInResolver.(*builtInResolver).Region
   323  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   324  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   325  
   326  		}
   327  		var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError
   328  		if errors.As(err, &ue) {
   329  			return out, metadata, fmt.Errorf(
   330  				"This operation requests signer version(s) %v but the client only supports %v",
   331  				ue.UnsupportedSchemes,
   332  				internalauth.SupportedSchemes,
   333  			)
   334  		}
   335  	}
   336  
   337  	for _, authScheme := range authSchemes {
   338  		switch authScheme.(type) {
   339  		case *internalauth.AuthenticationSchemeV4:
   340  			v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4)
   341  			var signingName, signingRegion string
   342  			if v4Scheme.SigningName == nil {
   343  				signingName = "ecr-public"
   344  			} else {
   345  				signingName = *v4Scheme.SigningName
   346  			}
   347  			if v4Scheme.SigningRegion == nil {
   348  				signingRegion = m.BuiltInResolver.(*builtInResolver).Region
   349  			} else {
   350  				signingRegion = *v4Scheme.SigningRegion
   351  			}
   352  			if v4Scheme.DisableDoubleEncoding != nil {
   353  				// The signer sets an equivalent value at client initialization time.
   354  				// Setting this context value will cause the signer to extract it
   355  				// and override the value set at client initialization time.
   356  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding)
   357  			}
   358  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   359  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   360  			break
   361  		case *internalauth.AuthenticationSchemeV4A:
   362  			v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A)
   363  			if v4aScheme.SigningName == nil {
   364  				v4aScheme.SigningName = aws.String("ecr-public")
   365  			}
   366  			if v4aScheme.DisableDoubleEncoding != nil {
   367  				// The signer sets an equivalent value at client initialization time.
   368  				// Setting this context value will cause the signer to extract it
   369  				// and override the value set at client initialization time.
   370  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding)
   371  			}
   372  			ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName)
   373  			ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0])
   374  			break
   375  		case *internalauth.AuthenticationSchemeNone:
   376  			break
   377  		}
   378  	}
   379  
   380  	return next.HandleSerialize(ctx, in)
   381  }
   382  
   383  func addDescribeImagesResolveEndpointMiddleware(stack *middleware.Stack, options Options) error {
   384  	return stack.Serialize.Insert(&opDescribeImagesResolveEndpointMiddleware{
   385  		EndpointResolver: options.EndpointResolverV2,
   386  		BuiltInResolver: &builtInResolver{
   387  			Region:       options.Region,
   388  			UseDualStack: options.EndpointOptions.UseDualStackEndpoint,
   389  			UseFIPS:      options.EndpointOptions.UseFIPSEndpoint,
   390  			Endpoint:     options.BaseEndpoint,
   391  		},
   392  	}, "ResolveEndpoint", middleware.After)
   393  }
   394
View as plain text