api_op_GetAuthorizationToken.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  // Retrieves an authorization token. An authorization token represents your IAM
    20  // authentication credentials. You can use it to access any Amazon ECR registry
    21  // that your IAM principal has access to. The authorization token is valid for 12
    22  // hours. This API requires the ecr-public:GetAuthorizationToken and
    23  // sts:GetServiceBearerToken permissions.
    24  func (c *Client) GetAuthorizationToken(ctx context.Context, params *GetAuthorizationTokenInput, optFns ...func(*Options)) (*GetAuthorizationTokenOutput, error) {
    25  	if params == nil {
    26  		params = &GetAuthorizationTokenInput{}
    27  	}
    28  
    29  	result, metadata, err := c.invokeOperation(ctx, "GetAuthorizationToken", params, optFns, c.addOperationGetAuthorizationTokenMiddlewares)
    30  	if err != nil {
    31  		return nil, err
    32  	}
    33  
    34  	out := result.(*GetAuthorizationTokenOutput)
    35  	out.ResultMetadata = metadata
    36  	return out, nil
    37  }
    38  
    39  type GetAuthorizationTokenInput struct {
    40  	noSmithyDocumentSerde
    41  }
    42  
    43  type GetAuthorizationTokenOutput struct {
    44  
    45  	// An authorization token data object that corresponds to a public registry.
    46  	AuthorizationData *types.AuthorizationData
    47  
    48  	// Metadata pertaining to the operation's result.
    49  	ResultMetadata middleware.Metadata
    50  
    51  	noSmithyDocumentSerde
    52  }
    53  
    54  func (c *Client) addOperationGetAuthorizationTokenMiddlewares(stack *middleware.Stack, options Options) (err error) {
    55  	err = stack.Serialize.Add(&awsAwsjson11_serializeOpGetAuthorizationToken{}, middleware.After)
    56  	if err != nil {
    57  		return err
    58  	}
    59  	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpGetAuthorizationToken{}, middleware.After)
    60  	if err != nil {
    61  		return err
    62  	}
    63  	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
    64  		return err
    65  	}
    66  	if err = addSetLoggerMiddleware(stack, options); err != nil {
    67  		return err
    68  	}
    69  	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
    70  		return err
    71  	}
    72  	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
    73  		return err
    74  	}
    75  	if err = addResolveEndpointMiddleware(stack, options); err != nil {
    76  		return err
    77  	}
    78  	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
    79  		return err
    80  	}
    81  	if err = addRetryMiddlewares(stack, options); err != nil {
    82  		return err
    83  	}
    84  	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
    85  		return err
    86  	}
    87  	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
    88  		return err
    89  	}
    90  	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
    91  		return err
    92  	}
    93  	if err = addClientUserAgent(stack, options); err != nil {
    94  		return err
    95  	}
    96  	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
    97  		return err
    98  	}
    99  	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
   100  		return err
   101  	}
   102  	if err = addGetAuthorizationTokenResolveEndpointMiddleware(stack, options); err != nil {
   103  		return err
   104  	}
   105  	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opGetAuthorizationToken(options.Region), middleware.Before); err != nil {
   106  		return err
   107  	}
   108  	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
   109  		return err
   110  	}
   111  	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
   112  		return err
   113  	}
   114  	if err = addResponseErrorMiddleware(stack); err != nil {
   115  		return err
   116  	}
   117  	if err = addRequestResponseLogging(stack, options); err != nil {
   118  		return err
   119  	}
   120  	if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil {
   121  		return err
   122  	}
   123  	return nil
   124  }
   125  
   126  func newServiceMetadataMiddleware_opGetAuthorizationToken(region string) *awsmiddleware.RegisterServiceMetadata {
   127  	return &awsmiddleware.RegisterServiceMetadata{
   128  		Region:        region,
   129  		ServiceID:     ServiceID,
   130  		SigningName:   "ecr-public",
   131  		OperationName: "GetAuthorizationToken",
   132  	}
   133  }
   134  
   135  type opGetAuthorizationTokenResolveEndpointMiddleware struct {
   136  	EndpointResolver EndpointResolverV2
   137  	BuiltInResolver  builtInParameterResolver
   138  }
   139  
   140  func (*opGetAuthorizationTokenResolveEndpointMiddleware) ID() string {
   141  	return "ResolveEndpointV2"
   142  }
   143  
   144  func (m *opGetAuthorizationTokenResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   145  	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   146  ) {
   147  	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
   148  		return next.HandleSerialize(ctx, in)
   149  	}
   150  
   151  	req, ok := in.Request.(*smithyhttp.Request)
   152  	if !ok {
   153  		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   154  	}
   155  
   156  	if m.EndpointResolver == nil {
   157  		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
   158  	}
   159  
   160  	params := EndpointParameters{}
   161  
   162  	m.BuiltInResolver.ResolveBuiltIns(&params)
   163  
   164  	var resolvedEndpoint smithyendpoints.Endpoint
   165  	resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params)
   166  	if err != nil {
   167  		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
   168  	}
   169  
   170  	req.URL = &resolvedEndpoint.URI
   171  
   172  	for k := range resolvedEndpoint.Headers {
   173  		req.Header.Set(
   174  			k,
   175  			resolvedEndpoint.Headers.Get(k),
   176  		)
   177  	}
   178  
   179  	authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties)
   180  	if err != nil {
   181  		var nfe *internalauth.NoAuthenticationSchemesFoundError
   182  		if errors.As(err, &nfe) {
   183  			// if no auth scheme is found, default to sigv4
   184  			signingName := "ecr-public"
   185  			signingRegion := m.BuiltInResolver.(*builtInResolver).Region
   186  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   187  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   188  
   189  		}
   190  		var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError
   191  		if errors.As(err, &ue) {
   192  			return out, metadata, fmt.Errorf(
   193  				"This operation requests signer version(s) %v but the client only supports %v",
   194  				ue.UnsupportedSchemes,
   195  				internalauth.SupportedSchemes,
   196  			)
   197  		}
   198  	}
   199  
   200  	for _, authScheme := range authSchemes {
   201  		switch authScheme.(type) {
   202  		case *internalauth.AuthenticationSchemeV4:
   203  			v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4)
   204  			var signingName, signingRegion string
   205  			if v4Scheme.SigningName == nil {
   206  				signingName = "ecr-public"
   207  			} else {
   208  				signingName = *v4Scheme.SigningName
   209  			}
   210  			if v4Scheme.SigningRegion == nil {
   211  				signingRegion = m.BuiltInResolver.(*builtInResolver).Region
   212  			} else {
   213  				signingRegion = *v4Scheme.SigningRegion
   214  			}
   215  			if v4Scheme.DisableDoubleEncoding != nil {
   216  				// The signer sets an equivalent value at client initialization time.
   217  				// Setting this context value will cause the signer to extract it
   218  				// and override the value set at client initialization time.
   219  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding)
   220  			}
   221  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   222  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   223  			break
   224  		case *internalauth.AuthenticationSchemeV4A:
   225  			v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A)
   226  			if v4aScheme.SigningName == nil {
   227  				v4aScheme.SigningName = aws.String("ecr-public")
   228  			}
   229  			if v4aScheme.DisableDoubleEncoding != nil {
   230  				// The signer sets an equivalent value at client initialization time.
   231  				// Setting this context value will cause the signer to extract it
   232  				// and override the value set at client initialization time.
   233  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding)
   234  			}
   235  			ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName)
   236  			ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0])
   237  			break
   238  		case *internalauth.AuthenticationSchemeNone:
   239  			break
   240  		}
   241  	}
   242  
   243  	return next.HandleSerialize(ctx, in)
   244  }
   245  
   246  func addGetAuthorizationTokenResolveEndpointMiddleware(stack *middleware.Stack, options Options) error {
   247  	return stack.Serialize.Insert(&opGetAuthorizationTokenResolveEndpointMiddleware{
   248  		EndpointResolver: options.EndpointResolverV2,
   249  		BuiltInResolver: &builtInResolver{
   250  			Region:       options.Region,
   251  			UseDualStack: options.EndpointOptions.UseDualStackEndpoint,
   252  			UseFIPS:      options.EndpointOptions.UseFIPSEndpoint,
   253  			Endpoint:     options.BaseEndpoint,
   254  		},
   255  	}, "ResolveEndpoint", middleware.After)
   256  }
   257
View as plain text