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