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