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