api_op_DescribeRepositories.go

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

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