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