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