Source file src/github.com/aws/aws-sdk-go-v2/service/ecr/api_op_BatchDeleteImage.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  	"github.com/aws/aws-sdk-go-v2/service/ecr/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  // Deletes a list of specified images within a repository. Images are specified
    20  // with either an imageTag or imageDigest . You can remove a tag from an image by
    21  // specifying the image's tag in your request. When you remove the last tag from an
    22  // image, the image is deleted from your repository. You can completely delete an
    23  // image (and all of its tags) by specifying the image's digest in your request.
    24  func (c *Client) BatchDeleteImage(ctx context.Context, params *BatchDeleteImageInput, optFns ...func(*Options)) (*BatchDeleteImageOutput, error) {
    25  	if params == nil {
    26  		params = &BatchDeleteImageInput{}
    27  	}
    28  
    29  	result, metadata, err := c.invokeOperation(ctx, "BatchDeleteImage", params, optFns, c.addOperationBatchDeleteImageMiddlewares)
    30  	if err != nil {
    31  		return nil, err
    32  	}
    33  
    34  	out := result.(*BatchDeleteImageOutput)
    35  	out.ResultMetadata = metadata
    36  	return out, nil
    37  }
    38  
    39  // Deletes specified images within a specified repository. Images are specified
    40  // with either the imageTag or imageDigest .
    41  type BatchDeleteImageInput struct {
    42  
    43  	// A list of image ID references that correspond to images to delete. The format
    44  	// of the imageIds reference is imageTag=tag or imageDigest=digest .
    45  	//
    46  	// This member is required.
    47  	ImageIds []types.ImageIdentifier
    48  
    49  	// The repository that contains the image to delete.
    50  	//
    51  	// This member is required.
    52  	RepositoryName *string
    53  
    54  	// The Amazon Web Services account ID associated with the registry that contains
    55  	// the image to delete. If you do not specify a registry, the default registry is
    56  	// assumed.
    57  	RegistryId *string
    58  
    59  	noSmithyDocumentSerde
    60  }
    61  
    62  type BatchDeleteImageOutput struct {
    63  
    64  	// Any failures associated with the call.
    65  	Failures []types.ImageFailure
    66  
    67  	// The image IDs of the deleted images.
    68  	ImageIds []types.ImageIdentifier
    69  
    70  	// Metadata pertaining to the operation's result.
    71  	ResultMetadata middleware.Metadata
    72  
    73  	noSmithyDocumentSerde
    74  }
    75  
    76  func (c *Client) addOperationBatchDeleteImageMiddlewares(stack *middleware.Stack, options Options) (err error) {
    77  	err = stack.Serialize.Add(&awsAwsjson11_serializeOpBatchDeleteImage{}, middleware.After)
    78  	if err != nil {
    79  		return err
    80  	}
    81  	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpBatchDeleteImage{}, middleware.After)
    82  	if err != nil {
    83  		return err
    84  	}
    85  	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
    86  		return err
    87  	}
    88  	if err = addSetLoggerMiddleware(stack, options); err != nil {
    89  		return err
    90  	}
    91  	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
    92  		return err
    93  	}
    94  	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
    95  		return err
    96  	}
    97  	if err = addResolveEndpointMiddleware(stack, options); err != nil {
    98  		return err
    99  	}
   100  	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
   101  		return err
   102  	}
   103  	if err = addRetryMiddlewares(stack, options); err != nil {
   104  		return err
   105  	}
   106  	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
   107  		return err
   108  	}
   109  	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
   110  		return err
   111  	}
   112  	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
   113  		return err
   114  	}
   115  	if err = addClientUserAgent(stack, options); err != nil {
   116  		return err
   117  	}
   118  	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
   119  		return err
   120  	}
   121  	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
   122  		return err
   123  	}
   124  	if err = addBatchDeleteImageResolveEndpointMiddleware(stack, options); err != nil {
   125  		return err
   126  	}
   127  	if err = addOpBatchDeleteImageValidationMiddleware(stack); err != nil {
   128  		return err
   129  	}
   130  	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opBatchDeleteImage(options.Region), middleware.Before); err != nil {
   131  		return err
   132  	}
   133  	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
   134  		return err
   135  	}
   136  	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
   137  		return err
   138  	}
   139  	if err = addResponseErrorMiddleware(stack); err != nil {
   140  		return err
   141  	}
   142  	if err = addRequestResponseLogging(stack, options); err != nil {
   143  		return err
   144  	}
   145  	if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil {
   146  		return err
   147  	}
   148  	return nil
   149  }
   150  
   151  func newServiceMetadataMiddleware_opBatchDeleteImage(region string) *awsmiddleware.RegisterServiceMetadata {
   152  	return &awsmiddleware.RegisterServiceMetadata{
   153  		Region:        region,
   154  		ServiceID:     ServiceID,
   155  		SigningName:   "ecr",
   156  		OperationName: "BatchDeleteImage",
   157  	}
   158  }
   159  
   160  type opBatchDeleteImageResolveEndpointMiddleware struct {
   161  	EndpointResolver EndpointResolverV2
   162  	BuiltInResolver  builtInParameterResolver
   163  }
   164  
   165  func (*opBatchDeleteImageResolveEndpointMiddleware) ID() string {
   166  	return "ResolveEndpointV2"
   167  }
   168  
   169  func (m *opBatchDeleteImageResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   170  	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   171  ) {
   172  	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
   173  		return next.HandleSerialize(ctx, in)
   174  	}
   175  
   176  	req, ok := in.Request.(*smithyhttp.Request)
   177  	if !ok {
   178  		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   179  	}
   180  
   181  	if m.EndpointResolver == nil {
   182  		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
   183  	}
   184  
   185  	params := EndpointParameters{}
   186  
   187  	m.BuiltInResolver.ResolveBuiltIns(&params)
   188  
   189  	var resolvedEndpoint smithyendpoints.Endpoint
   190  	resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params)
   191  	if err != nil {
   192  		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
   193  	}
   194  
   195  	req.URL = &resolvedEndpoint.URI
   196  
   197  	for k := range resolvedEndpoint.Headers {
   198  		req.Header.Set(
   199  			k,
   200  			resolvedEndpoint.Headers.Get(k),
   201  		)
   202  	}
   203  
   204  	authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties)
   205  	if err != nil {
   206  		var nfe *internalauth.NoAuthenticationSchemesFoundError
   207  		if errors.As(err, &nfe) {
   208  			// if no auth scheme is found, default to sigv4
   209  			signingName := "ecr"
   210  			signingRegion := m.BuiltInResolver.(*builtInResolver).Region
   211  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   212  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   213  
   214  		}
   215  		var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError
   216  		if errors.As(err, &ue) {
   217  			return out, metadata, fmt.Errorf(
   218  				"This operation requests signer version(s) %v but the client only supports %v",
   219  				ue.UnsupportedSchemes,
   220  				internalauth.SupportedSchemes,
   221  			)
   222  		}
   223  	}
   224  
   225  	for _, authScheme := range authSchemes {
   226  		switch authScheme.(type) {
   227  		case *internalauth.AuthenticationSchemeV4:
   228  			v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4)
   229  			var signingName, signingRegion string
   230  			if v4Scheme.SigningName == nil {
   231  				signingName = "ecr"
   232  			} else {
   233  				signingName = *v4Scheme.SigningName
   234  			}
   235  			if v4Scheme.SigningRegion == nil {
   236  				signingRegion = m.BuiltInResolver.(*builtInResolver).Region
   237  			} else {
   238  				signingRegion = *v4Scheme.SigningRegion
   239  			}
   240  			if v4Scheme.DisableDoubleEncoding != nil {
   241  				// The signer sets an equivalent value at client initialization time.
   242  				// Setting this context value will cause the signer to extract it
   243  				// and override the value set at client initialization time.
   244  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding)
   245  			}
   246  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   247  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   248  			break
   249  		case *internalauth.AuthenticationSchemeV4A:
   250  			v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A)
   251  			if v4aScheme.SigningName == nil {
   252  				v4aScheme.SigningName = aws.String("ecr")
   253  			}
   254  			if v4aScheme.DisableDoubleEncoding != nil {
   255  				// The signer sets an equivalent value at client initialization time.
   256  				// Setting this context value will cause the signer to extract it
   257  				// and override the value set at client initialization time.
   258  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding)
   259  			}
   260  			ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName)
   261  			ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0])
   262  			break
   263  		case *internalauth.AuthenticationSchemeNone:
   264  			break
   265  		}
   266  	}
   267  
   268  	return next.HandleSerialize(ctx, in)
   269  }
   270  
   271  func addBatchDeleteImageResolveEndpointMiddleware(stack *middleware.Stack, options Options) error {
   272  	return stack.Serialize.Insert(&opBatchDeleteImageResolveEndpointMiddleware{
   273  		EndpointResolver: options.EndpointResolverV2,
   274  		BuiltInResolver: &builtInResolver{
   275  			Region:       options.Region,
   276  			UseDualStack: options.EndpointOptions.UseDualStackEndpoint,
   277  			UseFIPS:      options.EndpointOptions.UseFIPSEndpoint,
   278  			Endpoint:     options.BaseEndpoint,
   279  		},
   280  	}, "ResolveEndpoint", middleware.After)
   281  }
   282  

View as plain text