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