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

View as plain text