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