api_op_InitiateLayerUpload.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  	smithyendpoints "github.com/aws/smithy-go/endpoints"
    14  	"github.com/aws/smithy-go/middleware"
    15  	smithyhttp "github.com/aws/smithy-go/transport/http"
    16  )
    17  
    18  // Notifies Amazon ECR that you intend to upload an image layer. When an image is
    19  // pushed, the InitiateLayerUpload API is called once per image layer that has not
    20  // already been uploaded. Whether or not an image layer has been uploaded is
    21  // determined by the BatchCheckLayerAvailability API action. This operation is used
    22  // by the Amazon ECR proxy and is not generally used by customers for pulling and
    23  // pushing images. In most cases, you should use the docker CLI to pull, tag, and
    24  // push images.
    25  func (c *Client) InitiateLayerUpload(ctx context.Context, params *InitiateLayerUploadInput, optFns ...func(*Options)) (*InitiateLayerUploadOutput, error) {
    26  	if params == nil {
    27  		params = &InitiateLayerUploadInput{}
    28  	}
    29  
    30  	result, metadata, err := c.invokeOperation(ctx, "InitiateLayerUpload", params, optFns, c.addOperationInitiateLayerUploadMiddlewares)
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  
    35  	out := result.(*InitiateLayerUploadOutput)
    36  	out.ResultMetadata = metadata
    37  	return out, nil
    38  }
    39  
    40  type InitiateLayerUploadInput struct {
    41  
    42  	// The name of the repository to which you intend to upload layers.
    43  	//
    44  	// This member is required.
    45  	RepositoryName *string
    46  
    47  	// The Amazon Web Services account ID associated with the registry to which you
    48  	// intend to upload layers. If you do not specify a registry, the default registry
    49  	// is assumed.
    50  	RegistryId *string
    51  
    52  	noSmithyDocumentSerde
    53  }
    54  
    55  type InitiateLayerUploadOutput struct {
    56  
    57  	// The size, in bytes, that Amazon ECR expects future layer part uploads to be.
    58  	PartSize *int64
    59  
    60  	// The upload ID for the layer upload. This parameter is passed to further
    61  	// UploadLayerPart and CompleteLayerUpload operations.
    62  	UploadId *string
    63  
    64  	// Metadata pertaining to the operation's result.
    65  	ResultMetadata middleware.Metadata
    66  
    67  	noSmithyDocumentSerde
    68  }
    69  
    70  func (c *Client) addOperationInitiateLayerUploadMiddlewares(stack *middleware.Stack, options Options) (err error) {
    71  	err = stack.Serialize.Add(&awsAwsjson11_serializeOpInitiateLayerUpload{}, middleware.After)
    72  	if err != nil {
    73  		return err
    74  	}
    75  	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpInitiateLayerUpload{}, middleware.After)
    76  	if err != nil {
    77  		return err
    78  	}
    79  	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
    80  		return err
    81  	}
    82  	if err = addSetLoggerMiddleware(stack, options); err != nil {
    83  		return err
    84  	}
    85  	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
    86  		return err
    87  	}
    88  	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
    89  		return err
    90  	}
    91  	if err = addResolveEndpointMiddleware(stack, options); err != nil {
    92  		return err
    93  	}
    94  	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
    95  		return err
    96  	}
    97  	if err = addRetryMiddlewares(stack, options); err != nil {
    98  		return err
    99  	}
   100  	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
   101  		return err
   102  	}
   103  	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
   104  		return err
   105  	}
   106  	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
   107  		return err
   108  	}
   109  	if err = addClientUserAgent(stack, options); err != nil {
   110  		return err
   111  	}
   112  	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
   113  		return err
   114  	}
   115  	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
   116  		return err
   117  	}
   118  	if err = addInitiateLayerUploadResolveEndpointMiddleware(stack, options); err != nil {
   119  		return err
   120  	}
   121  	if err = addOpInitiateLayerUploadValidationMiddleware(stack); err != nil {
   122  		return err
   123  	}
   124  	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opInitiateLayerUpload(options.Region), middleware.Before); err != nil {
   125  		return err
   126  	}
   127  	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
   128  		return err
   129  	}
   130  	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
   131  		return err
   132  	}
   133  	if err = addResponseErrorMiddleware(stack); err != nil {
   134  		return err
   135  	}
   136  	if err = addRequestResponseLogging(stack, options); err != nil {
   137  		return err
   138  	}
   139  	if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil {
   140  		return err
   141  	}
   142  	return nil
   143  }
   144  
   145  func newServiceMetadataMiddleware_opInitiateLayerUpload(region string) *awsmiddleware.RegisterServiceMetadata {
   146  	return &awsmiddleware.RegisterServiceMetadata{
   147  		Region:        region,
   148  		ServiceID:     ServiceID,
   149  		SigningName:   "ecr",
   150  		OperationName: "InitiateLayerUpload",
   151  	}
   152  }
   153  
   154  type opInitiateLayerUploadResolveEndpointMiddleware struct {
   155  	EndpointResolver EndpointResolverV2
   156  	BuiltInResolver  builtInParameterResolver
   157  }
   158  
   159  func (*opInitiateLayerUploadResolveEndpointMiddleware) ID() string {
   160  	return "ResolveEndpointV2"
   161  }
   162  
   163  func (m *opInitiateLayerUploadResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   164  	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   165  ) {
   166  	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
   167  		return next.HandleSerialize(ctx, in)
   168  	}
   169  
   170  	req, ok := in.Request.(*smithyhttp.Request)
   171  	if !ok {
   172  		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   173  	}
   174  
   175  	if m.EndpointResolver == nil {
   176  		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
   177  	}
   178  
   179  	params := EndpointParameters{}
   180  
   181  	m.BuiltInResolver.ResolveBuiltIns(&params)
   182  
   183  	var resolvedEndpoint smithyendpoints.Endpoint
   184  	resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params)
   185  	if err != nil {
   186  		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
   187  	}
   188  
   189  	req.URL = &resolvedEndpoint.URI
   190  
   191  	for k := range resolvedEndpoint.Headers {
   192  		req.Header.Set(
   193  			k,
   194  			resolvedEndpoint.Headers.Get(k),
   195  		)
   196  	}
   197  
   198  	authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties)
   199  	if err != nil {
   200  		var nfe *internalauth.NoAuthenticationSchemesFoundError
   201  		if errors.As(err, &nfe) {
   202  			// if no auth scheme is found, default to sigv4
   203  			signingName := "ecr"
   204  			signingRegion := m.BuiltInResolver.(*builtInResolver).Region
   205  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   206  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   207  
   208  		}
   209  		var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError
   210  		if errors.As(err, &ue) {
   211  			return out, metadata, fmt.Errorf(
   212  				"This operation requests signer version(s) %v but the client only supports %v",
   213  				ue.UnsupportedSchemes,
   214  				internalauth.SupportedSchemes,
   215  			)
   216  		}
   217  	}
   218  
   219  	for _, authScheme := range authSchemes {
   220  		switch authScheme.(type) {
   221  		case *internalauth.AuthenticationSchemeV4:
   222  			v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4)
   223  			var signingName, signingRegion string
   224  			if v4Scheme.SigningName == nil {
   225  				signingName = "ecr"
   226  			} else {
   227  				signingName = *v4Scheme.SigningName
   228  			}
   229  			if v4Scheme.SigningRegion == nil {
   230  				signingRegion = m.BuiltInResolver.(*builtInResolver).Region
   231  			} else {
   232  				signingRegion = *v4Scheme.SigningRegion
   233  			}
   234  			if v4Scheme.DisableDoubleEncoding != nil {
   235  				// The signer sets an equivalent value at client initialization time.
   236  				// Setting this context value will cause the signer to extract it
   237  				// and override the value set at client initialization time.
   238  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding)
   239  			}
   240  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   241  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   242  			break
   243  		case *internalauth.AuthenticationSchemeV4A:
   244  			v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A)
   245  			if v4aScheme.SigningName == nil {
   246  				v4aScheme.SigningName = aws.String("ecr")
   247  			}
   248  			if v4aScheme.DisableDoubleEncoding != nil {
   249  				// The signer sets an equivalent value at client initialization time.
   250  				// Setting this context value will cause the signer to extract it
   251  				// and override the value set at client initialization time.
   252  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding)
   253  			}
   254  			ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName)
   255  			ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0])
   256  			break
   257  		case *internalauth.AuthenticationSchemeNone:
   258  			break
   259  		}
   260  	}
   261  
   262  	return next.HandleSerialize(ctx, in)
   263  }
   264  
   265  func addInitiateLayerUploadResolveEndpointMiddleware(stack *middleware.Stack, options Options) error {
   266  	return stack.Serialize.Insert(&opInitiateLayerUploadResolveEndpointMiddleware{
   267  		EndpointResolver: options.EndpointResolverV2,
   268  		BuiltInResolver: &builtInResolver{
   269  			Region:       options.Region,
   270  			UseDualStack: options.EndpointOptions.UseDualStackEndpoint,
   271  			UseFIPS:      options.EndpointOptions.UseFIPSEndpoint,
   272  			Endpoint:     options.BaseEndpoint,
   273  		},
   274  	}, "ResolveEndpoint", middleware.After)
   275  }
   276
View as plain text