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