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