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