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