Source file src/github.com/aws/aws-sdk-go-v2/service/ecr/api_op_CreateRepository.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  // Creates a repository. For more information, see Amazon ECR repositories (https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html)
    20  // in the Amazon Elastic Container Registry User Guide.
    21  func (c *Client) CreateRepository(ctx context.Context, params *CreateRepositoryInput, optFns ...func(*Options)) (*CreateRepositoryOutput, error) {
    22  	if params == nil {
    23  		params = &CreateRepositoryInput{}
    24  	}
    25  
    26  	result, metadata, err := c.invokeOperation(ctx, "CreateRepository", params, optFns, c.addOperationCreateRepositoryMiddlewares)
    27  	if err != nil {
    28  		return nil, err
    29  	}
    30  
    31  	out := result.(*CreateRepositoryOutput)
    32  	out.ResultMetadata = metadata
    33  	return out, nil
    34  }
    35  
    36  type CreateRepositoryInput struct {
    37  
    38  	// The name to use for the repository. The repository name may be specified on its
    39  	// own (such as nginx-web-app ) or it can be prepended with a namespace to group
    40  	// the repository into a category (such as project-a/nginx-web-app ). The
    41  	// repository name must start with a letter and can only contain lowercase letters,
    42  	// numbers, hyphens, underscores, and forward slashes.
    43  	//
    44  	// This member is required.
    45  	RepositoryName *string
    46  
    47  	// The encryption configuration for the repository. This determines how the
    48  	// contents of your repository are encrypted at rest.
    49  	EncryptionConfiguration *types.EncryptionConfiguration
    50  
    51  	// The image scanning configuration for the repository. This determines whether
    52  	// images are scanned for known vulnerabilities after being pushed to the
    53  	// repository.
    54  	ImageScanningConfiguration *types.ImageScanningConfiguration
    55  
    56  	// The tag mutability setting for the repository. If this parameter is omitted,
    57  	// the default setting of MUTABLE will be used which will allow image tags to be
    58  	// overwritten. If IMMUTABLE is specified, all image tags within the repository
    59  	// will be immutable which will prevent them from being overwritten.
    60  	ImageTagMutability types.ImageTagMutability
    61  
    62  	// The Amazon Web Services account ID associated with the registry to create the
    63  	// repository. If you do not specify a registry, the default registry is assumed.
    64  	RegistryId *string
    65  
    66  	// The metadata that you apply to the repository to help you categorize and
    67  	// organize them. Each tag consists of a key and an optional value, both of which
    68  	// you define. Tag keys can have a maximum character length of 128 characters, and
    69  	// tag values can have a maximum length of 256 characters.
    70  	Tags []types.Tag
    71  
    72  	noSmithyDocumentSerde
    73  }
    74  
    75  type CreateRepositoryOutput struct {
    76  
    77  	// The repository that was created.
    78  	Repository *types.Repository
    79  
    80  	// Metadata pertaining to the operation's result.
    81  	ResultMetadata middleware.Metadata
    82  
    83  	noSmithyDocumentSerde
    84  }
    85  
    86  func (c *Client) addOperationCreateRepositoryMiddlewares(stack *middleware.Stack, options Options) (err error) {
    87  	err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateRepository{}, middleware.After)
    88  	if err != nil {
    89  		return err
    90  	}
    91  	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateRepository{}, middleware.After)
    92  	if err != nil {
    93  		return err
    94  	}
    95  	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
    96  		return err
    97  	}
    98  	if err = addSetLoggerMiddleware(stack, options); err != nil {
    99  		return err
   100  	}
   101  	if err = awsmiddleware.AddClientRequestIDMiddleware(stack); err != nil {
   102  		return err
   103  	}
   104  	if err = smithyhttp.AddComputeContentLengthMiddleware(stack); err != nil {
   105  		return err
   106  	}
   107  	if err = addResolveEndpointMiddleware(stack, options); err != nil {
   108  		return err
   109  	}
   110  	if err = v4.AddComputePayloadSHA256Middleware(stack); err != nil {
   111  		return err
   112  	}
   113  	if err = addRetryMiddlewares(stack, options); err != nil {
   114  		return err
   115  	}
   116  	if err = addHTTPSignerV4Middleware(stack, options); err != nil {
   117  		return err
   118  	}
   119  	if err = awsmiddleware.AddRawResponseToMetadata(stack); err != nil {
   120  		return err
   121  	}
   122  	if err = awsmiddleware.AddRecordResponseTiming(stack); err != nil {
   123  		return err
   124  	}
   125  	if err = addClientUserAgent(stack, options); err != nil {
   126  		return err
   127  	}
   128  	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
   129  		return err
   130  	}
   131  	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
   132  		return err
   133  	}
   134  	if err = addCreateRepositoryResolveEndpointMiddleware(stack, options); err != nil {
   135  		return err
   136  	}
   137  	if err = addOpCreateRepositoryValidationMiddleware(stack); err != nil {
   138  		return err
   139  	}
   140  	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateRepository(options.Region), middleware.Before); err != nil {
   141  		return err
   142  	}
   143  	if err = awsmiddleware.AddRecursionDetection(stack); err != nil {
   144  		return err
   145  	}
   146  	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
   147  		return err
   148  	}
   149  	if err = addResponseErrorMiddleware(stack); err != nil {
   150  		return err
   151  	}
   152  	if err = addRequestResponseLogging(stack, options); err != nil {
   153  		return err
   154  	}
   155  	if err = addendpointDisableHTTPSMiddleware(stack, options); err != nil {
   156  		return err
   157  	}
   158  	return nil
   159  }
   160  
   161  func newServiceMetadataMiddleware_opCreateRepository(region string) *awsmiddleware.RegisterServiceMetadata {
   162  	return &awsmiddleware.RegisterServiceMetadata{
   163  		Region:        region,
   164  		ServiceID:     ServiceID,
   165  		SigningName:   "ecr",
   166  		OperationName: "CreateRepository",
   167  	}
   168  }
   169  
   170  type opCreateRepositoryResolveEndpointMiddleware struct {
   171  	EndpointResolver EndpointResolverV2
   172  	BuiltInResolver  builtInParameterResolver
   173  }
   174  
   175  func (*opCreateRepositoryResolveEndpointMiddleware) ID() string {
   176  	return "ResolveEndpointV2"
   177  }
   178  
   179  func (m *opCreateRepositoryResolveEndpointMiddleware) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
   180  	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
   181  ) {
   182  	if awsmiddleware.GetRequiresLegacyEndpoints(ctx) {
   183  		return next.HandleSerialize(ctx, in)
   184  	}
   185  
   186  	req, ok := in.Request.(*smithyhttp.Request)
   187  	if !ok {
   188  		return out, metadata, fmt.Errorf("unknown transport type %T", in.Request)
   189  	}
   190  
   191  	if m.EndpointResolver == nil {
   192  		return out, metadata, fmt.Errorf("expected endpoint resolver to not be nil")
   193  	}
   194  
   195  	params := EndpointParameters{}
   196  
   197  	m.BuiltInResolver.ResolveBuiltIns(&params)
   198  
   199  	var resolvedEndpoint smithyendpoints.Endpoint
   200  	resolvedEndpoint, err = m.EndpointResolver.ResolveEndpoint(ctx, params)
   201  	if err != nil {
   202  		return out, metadata, fmt.Errorf("failed to resolve service endpoint, %w", err)
   203  	}
   204  
   205  	req.URL = &resolvedEndpoint.URI
   206  
   207  	for k := range resolvedEndpoint.Headers {
   208  		req.Header.Set(
   209  			k,
   210  			resolvedEndpoint.Headers.Get(k),
   211  		)
   212  	}
   213  
   214  	authSchemes, err := internalauth.GetAuthenticationSchemes(&resolvedEndpoint.Properties)
   215  	if err != nil {
   216  		var nfe *internalauth.NoAuthenticationSchemesFoundError
   217  		if errors.As(err, &nfe) {
   218  			// if no auth scheme is found, default to sigv4
   219  			signingName := "ecr"
   220  			signingRegion := m.BuiltInResolver.(*builtInResolver).Region
   221  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   222  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   223  
   224  		}
   225  		var ue *internalauth.UnSupportedAuthenticationSchemeSpecifiedError
   226  		if errors.As(err, &ue) {
   227  			return out, metadata, fmt.Errorf(
   228  				"This operation requests signer version(s) %v but the client only supports %v",
   229  				ue.UnsupportedSchemes,
   230  				internalauth.SupportedSchemes,
   231  			)
   232  		}
   233  	}
   234  
   235  	for _, authScheme := range authSchemes {
   236  		switch authScheme.(type) {
   237  		case *internalauth.AuthenticationSchemeV4:
   238  			v4Scheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4)
   239  			var signingName, signingRegion string
   240  			if v4Scheme.SigningName == nil {
   241  				signingName = "ecr"
   242  			} else {
   243  				signingName = *v4Scheme.SigningName
   244  			}
   245  			if v4Scheme.SigningRegion == nil {
   246  				signingRegion = m.BuiltInResolver.(*builtInResolver).Region
   247  			} else {
   248  				signingRegion = *v4Scheme.SigningRegion
   249  			}
   250  			if v4Scheme.DisableDoubleEncoding != nil {
   251  				// The signer sets an equivalent value at client initialization time.
   252  				// Setting this context value will cause the signer to extract it
   253  				// and override the value set at client initialization time.
   254  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4Scheme.DisableDoubleEncoding)
   255  			}
   256  			ctx = awsmiddleware.SetSigningName(ctx, signingName)
   257  			ctx = awsmiddleware.SetSigningRegion(ctx, signingRegion)
   258  			break
   259  		case *internalauth.AuthenticationSchemeV4A:
   260  			v4aScheme, _ := authScheme.(*internalauth.AuthenticationSchemeV4A)
   261  			if v4aScheme.SigningName == nil {
   262  				v4aScheme.SigningName = aws.String("ecr")
   263  			}
   264  			if v4aScheme.DisableDoubleEncoding != nil {
   265  				// The signer sets an equivalent value at client initialization time.
   266  				// Setting this context value will cause the signer to extract it
   267  				// and override the value set at client initialization time.
   268  				ctx = internalauth.SetDisableDoubleEncoding(ctx, *v4aScheme.DisableDoubleEncoding)
   269  			}
   270  			ctx = awsmiddleware.SetSigningName(ctx, *v4aScheme.SigningName)
   271  			ctx = awsmiddleware.SetSigningRegion(ctx, v4aScheme.SigningRegionSet[0])
   272  			break
   273  		case *internalauth.AuthenticationSchemeNone:
   274  			break
   275  		}
   276  	}
   277  
   278  	return next.HandleSerialize(ctx, in)
   279  }
   280  
   281  func addCreateRepositoryResolveEndpointMiddleware(stack *middleware.Stack, options Options) error {
   282  	return stack.Serialize.Insert(&opCreateRepositoryResolveEndpointMiddleware{
   283  		EndpointResolver: options.EndpointResolverV2,
   284  		BuiltInResolver: &builtInResolver{
   285  			Region:       options.Region,
   286  			UseDualStack: options.EndpointOptions.UseDualStackEndpoint,
   287  			UseFIPS:      options.EndpointOptions.UseFIPSEndpoint,
   288  			Endpoint:     options.BaseEndpoint,
   289  		},
   290  	}, "ResolveEndpoint", middleware.After)
   291  }
   292  

View as plain text