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