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