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