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