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