Debian Codegraph @

autorest/preparer.go

raw
1 package autorest
2
3 // Copyright 2017 Microsoft Corporation
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16
17 import (
18 "bytes"
19 "context"
20 "encoding/json"
21 "encoding/xml"
22 "fmt"
23 "io"
24 "io/ioutil"
25 "mime/multipart"
26 "net/http"
27 "net/url"
28 "strings"
29 )
30
31 const (
32 mimeTypeJSON = "application/json"
33 mimeTypeOctetStream = "application/octet-stream"
34 mimeTypeFormPost = "application/x-www-form-urlencoded"
35
36 headerAuthorization = "Authorization"
37 headerAuxAuthorization = "x-ms-authorization-auxiliary"
38 headerContentType = "Content-Type"
39 headerUserAgent = "User-Agent"
40 )
41
42 // used as a key type in context.WithValue()
43 type ctxPrepareDecorators struct{}
44
45 // WithPrepareDecorators adds the specified PrepareDecorators to the provided context.
46 // If no PrepareDecorators are provided the context is unchanged.
47 func WithPrepareDecorators(ctx context.Context, prepareDecorator []PrepareDecorator) context.Context {
48 if len(prepareDecorator) == 0 {
49 return ctx
50 }
51 return context.WithValue(ctx, ctxPrepareDecorators{}, prepareDecorator)
52 }
53
54 // GetPrepareDecorators returns the PrepareDecorators in the provided context or the provided default PrepareDecorators.
55 func GetPrepareDecorators(ctx context.Context, defaultPrepareDecorators ...PrepareDecorator) []PrepareDecorator {
56 inCtx := ctx.Value(ctxPrepareDecorators{})
57 if pd, ok := inCtx.([]PrepareDecorator); ok {
58 return pd
59 }
60 return defaultPrepareDecorators
61 }
62
63 // Preparer is the interface that wraps the Prepare method.
64 //
65 // Prepare accepts and possibly modifies an http.Request (e.g., adding Headers). Implementations
66 // must ensure to not share or hold per-invocation state since Preparers may be shared and re-used.
67 type Preparer interface {
68 Prepare(*http.Request) (*http.Request, error)
69 }
70
71 // PreparerFunc is a method that implements the Preparer interface.
72 type PreparerFunc func(*http.Request) (*http.Request, error)
73
74 // Prepare implements the Preparer interface on PreparerFunc.
75 func (pf PreparerFunc) Prepare(r *http.Request) (*http.Request, error) {
76 return pf(r)
77 }
78
79 // PrepareDecorator takes and possibly decorates, by wrapping, a Preparer. Decorators may affect the
80 // http.Request and pass it along or, first, pass the http.Request along then affect the result.
81 type PrepareDecorator func(Preparer) Preparer
82
83 // CreatePreparer creates, decorates, and returns a Preparer.
84 // Without decorators, the returned Preparer returns the passed http.Request unmodified.
85 // Preparers are safe to share and re-use.
86 func CreatePreparer(decorators ...PrepareDecorator) Preparer {
87 return DecoratePreparer(
88 Preparer(PreparerFunc(func(r *http.Request) (*http.Request, error) { return r, nil })),
89 decorators...)
90 }
91
92 // DecoratePreparer accepts a Preparer and a, possibly empty, set of PrepareDecorators, which it
93 // applies to the Preparer. Decorators are applied in the order received, but their affect upon the
94 // request depends on whether they are a pre-decorator (change the http.Request and then pass it
95 // along) or a post-decorator (pass the http.Request along and alter it on return).
96 func DecoratePreparer(p Preparer, decorators ...PrepareDecorator) Preparer {
97 for _, decorate := range decorators {
98 p = decorate(p)
99 }
100 return p
101 }
102
103 // Prepare accepts an http.Request and a, possibly empty, set of PrepareDecorators.
104 // It creates a Preparer from the decorators which it then applies to the passed http.Request.
105 func Prepare(r *http.Request, decorators ...PrepareDecorator) (*http.Request, error) {
106 if r == nil {
107 return nil, NewError("autorest", "Prepare", "Invoked without an http.Request")
108 }
109 return CreatePreparer(decorators...).Prepare(r)
110 }
111
112 // WithNothing returns a "do nothing" PrepareDecorator that makes no changes to the passed
113 // http.Request.
114 func WithNothing() PrepareDecorator {
115 return func(p Preparer) Preparer {
116 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
117 return p.Prepare(r)
118 })
119 }
120 }
121
122 // WithHeader returns a PrepareDecorator that sets the specified HTTP header of the http.Request to
123 // the passed value. It canonicalizes the passed header name (via http.CanonicalHeaderKey) before
124 // adding the header.
125 func WithHeader(header string, value string) PrepareDecorator {
126 return func(p Preparer) Preparer {
127 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
128 r, err := p.Prepare(r)
129 if err == nil {
130 setHeader(r, http.CanonicalHeaderKey(header), value)
131 }
132 return r, err
133 })
134 }
135 }
136
137 // WithHeaders returns a PrepareDecorator that sets the specified HTTP headers of the http.Request to
138 // the passed value. It canonicalizes the passed headers name (via http.CanonicalHeaderKey) before
139 // adding them.
140 func WithHeaders(headers map[string]interface{}) PrepareDecorator {
141 h := ensureValueStrings(headers)
142 return func(p Preparer) Preparer {
143 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
144 r, err := p.Prepare(r)
145 if err == nil {
146 if r.Header == nil {
147 r.Header = make(http.Header)
148 }
149
150 for name, value := range h {
151 r.Header.Set(http.CanonicalHeaderKey(name), value)
152 }
153 }
154 return r, err
155 })
156 }
157 }
158
159 // WithBearerAuthorization returns a PrepareDecorator that adds an HTTP Authorization header whose
160 // value is "Bearer " followed by the supplied token.
161 func WithBearerAuthorization(token string) PrepareDecorator {
162 return WithHeader(headerAuthorization, fmt.Sprintf("Bearer %s", token))
163 }
164
165 // AsContentType returns a PrepareDecorator that adds an HTTP Content-Type header whose value
166 // is the passed contentType.
167 func AsContentType(contentType string) PrepareDecorator {
168 return WithHeader(headerContentType, contentType)
169 }
170
171 // WithUserAgent returns a PrepareDecorator that adds an HTTP User-Agent header whose value is the
172 // passed string.
173 func WithUserAgent(ua string) PrepareDecorator {
174 return WithHeader(headerUserAgent, ua)
175 }
176
177 // AsFormURLEncoded returns a PrepareDecorator that adds an HTTP Content-Type header whose value is
178 // "application/x-www-form-urlencoded".
179 func AsFormURLEncoded() PrepareDecorator {
180 return AsContentType(mimeTypeFormPost)
181 }
182
183 // AsJSON returns a PrepareDecorator that adds an HTTP Content-Type header whose value is
184 // "application/json".
185 func AsJSON() PrepareDecorator {
186 return AsContentType(mimeTypeJSON)
187 }
188
189 // AsOctetStream returns a PrepareDecorator that adds the "application/octet-stream" Content-Type header.
190 func AsOctetStream() PrepareDecorator {
191 return AsContentType(mimeTypeOctetStream)
192 }
193
194 // WithMethod returns a PrepareDecorator that sets the HTTP method of the passed request. The
195 // decorator does not validate that the passed method string is a known HTTP method.
196 func WithMethod(method string) PrepareDecorator {
197 return func(p Preparer) Preparer {
198 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
199 r.Method = method
200 return p.Prepare(r)
201 })
202 }
203 }
204
205 // AsDelete returns a PrepareDecorator that sets the HTTP method to DELETE.
206 func AsDelete() PrepareDecorator { return WithMethod("DELETE") }
207
208 // AsGet returns a PrepareDecorator that sets the HTTP method to GET.
209 func AsGet() PrepareDecorator { return WithMethod("GET") }
210
211 // AsHead returns a PrepareDecorator that sets the HTTP method to HEAD.
212 func AsHead() PrepareDecorator { return WithMethod("HEAD") }
213
214 // AsMerge returns a PrepareDecorator that sets the HTTP method to MERGE.
215 func AsMerge() PrepareDecorator { return WithMethod("MERGE") }
216
217 // AsOptions returns a PrepareDecorator that sets the HTTP method to OPTIONS.
218 func AsOptions() PrepareDecorator { return WithMethod("OPTIONS") }
219
220 // AsPatch returns a PrepareDecorator that sets the HTTP method to PATCH.
221 func AsPatch() PrepareDecorator { return WithMethod("PATCH") }
222
223 // AsPost returns a PrepareDecorator that sets the HTTP method to POST.
224 func AsPost() PrepareDecorator { return WithMethod("POST") }
225
226 // AsPut returns a PrepareDecorator that sets the HTTP method to PUT.
227 func AsPut() PrepareDecorator { return WithMethod("PUT") }
228
229 // WithBaseURL returns a PrepareDecorator that populates the http.Request with a url.URL constructed
230 // from the supplied baseUrl. Query parameters will be encoded as required.
231 func WithBaseURL(baseURL string) PrepareDecorator {
232 return func(p Preparer) Preparer {
233 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
234 r, err := p.Prepare(r)
235 if err == nil {
236 var u *url.URL
237 if u, err = url.Parse(baseURL); err != nil {
238 return r, err
239 }
240 if u.Scheme == "" {
241 return r, fmt.Errorf("autorest: No scheme detected in URL %s", baseURL)
242 }
243 if u.RawQuery != "" {
244 // handle unencoded semicolons (ideally the server would send them already encoded)
245 u.RawQuery = strings.Replace(u.RawQuery, ";", "%3B", -1)
246 q, err := url.ParseQuery(u.RawQuery)
247 if err != nil {
248 return r, err
249 }
250 u.RawQuery = q.Encode()
251 }
252 r.URL = u
253 }
254 return r, err
255 })
256 }
257 }
258
259 // WithBytes returns a PrepareDecorator that takes a list of bytes
260 // which passes the bytes directly to the body
261 func WithBytes(input *[]byte) PrepareDecorator {
262 return func(p Preparer) Preparer {
263 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
264 r, err := p.Prepare(r)
265 if err == nil {
266 if input == nil {
267 return r, fmt.Errorf("Input Bytes was nil")
268 }
269
270 r.ContentLength = int64(len(*input))
271 r.Body = ioutil.NopCloser(bytes.NewReader(*input))
272 }
273 return r, err
274 })
275 }
276 }
277
278 // WithCustomBaseURL returns a PrepareDecorator that replaces brace-enclosed keys within the
279 // request base URL (i.e., http.Request.URL) with the corresponding values from the passed map.
280 func WithCustomBaseURL(baseURL string, urlParameters map[string]interface{}) PrepareDecorator {
281 parameters := ensureValueStrings(urlParameters)
282 for key, value := range parameters {
283 baseURL = strings.Replace(baseURL, "{"+key+"}", value, -1)
284 }
285 return WithBaseURL(baseURL)
286 }
287
288 // WithFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) into the
289 // http.Request body.
290 func WithFormData(v url.Values) PrepareDecorator {
291 return func(p Preparer) Preparer {
292 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
293 r, err := p.Prepare(r)
294 if err == nil {
295 s := v.Encode()
296
297 setHeader(r, http.CanonicalHeaderKey(headerContentType), mimeTypeFormPost)
298 r.ContentLength = int64(len(s))
299 r.Body = ioutil.NopCloser(strings.NewReader(s))
300 }
301 return r, err
302 })
303 }
304 }
305
306 // WithMultiPartFormData returns a PrepareDecoratore that "URL encodes" (e.g., bar=baz&foo=quux) form parameters
307 // into the http.Request body.
308 func WithMultiPartFormData(formDataParameters map[string]interface{}) PrepareDecorator {
309 return func(p Preparer) Preparer {
310 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
311 r, err := p.Prepare(r)
312 if err == nil {
313 var body bytes.Buffer
314 writer := multipart.NewWriter(&body)
315 for key, value := range formDataParameters {
316 if rc, ok := value.(io.ReadCloser); ok {
317 var fd io.Writer
318 if fd, err = writer.CreateFormFile(key, key); err != nil {
319 return r, err
320 }
321 if _, err = io.Copy(fd, rc); err != nil {
322 return r, err
323 }
324 } else {
325 if err = writer.WriteField(key, ensureValueString(value)); err != nil {
326 return r, err
327 }
328 }
329 }
330 if err = writer.Close(); err != nil {
331 return r, err
332 }
333 setHeader(r, http.CanonicalHeaderKey(headerContentType), writer.FormDataContentType())
334 r.Body = ioutil.NopCloser(bytes.NewReader(body.Bytes()))
335 r.ContentLength = int64(body.Len())
336 return r, err
337 }
338 return r, err
339 })
340 }
341 }
342
343 // WithFile returns a PrepareDecorator that sends file in request body.
344 func WithFile(f io.ReadCloser) PrepareDecorator {
345 return func(p Preparer) Preparer {
346 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
347 r, err := p.Prepare(r)
348 if err == nil {
349 b, err := ioutil.ReadAll(f)
350 if err != nil {
351 return r, err
352 }
353 r.Body = ioutil.NopCloser(bytes.NewReader(b))
354 r.ContentLength = int64(len(b))
355 }
356 return r, err
357 })
358 }
359 }
360
361 // WithBool returns a PrepareDecorator that encodes the passed bool into the body of the request
362 // and sets the Content-Length header.
363 func WithBool(v bool) PrepareDecorator {
364 return WithString(fmt.Sprintf("%v", v))
365 }
366
367 // WithFloat32 returns a PrepareDecorator that encodes the passed float32 into the body of the
368 // request and sets the Content-Length header.
369 func WithFloat32(v float32) PrepareDecorator {
370 return WithString(fmt.Sprintf("%v", v))
371 }
372
373 // WithFloat64 returns a PrepareDecorator that encodes the passed float64 into the body of the
374 // request and sets the Content-Length header.
375 func WithFloat64(v float64) PrepareDecorator {
376 return WithString(fmt.Sprintf("%v", v))
377 }
378
379 // WithInt32 returns a PrepareDecorator that encodes the passed int32 into the body of the request
380 // and sets the Content-Length header.
381 func WithInt32(v int32) PrepareDecorator {
382 return WithString(fmt.Sprintf("%v", v))
383 }
384
385 // WithInt64 returns a PrepareDecorator that encodes the passed int64 into the body of the request
386 // and sets the Content-Length header.
387 func WithInt64(v int64) PrepareDecorator {
388 return WithString(fmt.Sprintf("%v", v))
389 }
390
391 // WithString returns a PrepareDecorator that encodes the passed string into the body of the request
392 // and sets the Content-Length header.
393 func WithString(v string) PrepareDecorator {
394 return func(p Preparer) Preparer {
395 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
396 r, err := p.Prepare(r)
397 if err == nil {
398 r.ContentLength = int64(len(v))
399 r.Body = ioutil.NopCloser(strings.NewReader(v))
400 }
401 return r, err
402 })
403 }
404 }
405
406 // WithJSON returns a PrepareDecorator that encodes the data passed as JSON into the body of the
407 // request and sets the Content-Length header.
408 func WithJSON(v interface{}) PrepareDecorator {
409 return func(p Preparer) Preparer {
410 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
411 r, err := p.Prepare(r)
412 if err == nil {
413 b, err := json.Marshal(v)
414 if err == nil {
415 r.ContentLength = int64(len(b))
416 r.Body = ioutil.NopCloser(bytes.NewReader(b))
417 }
418 }
419 return r, err
420 })
421 }
422 }
423
424 // WithXML returns a PrepareDecorator that encodes the data passed as XML into the body of the
425 // request and sets the Content-Length header.
426 func WithXML(v interface{}) PrepareDecorator {
427 return func(p Preparer) Preparer {
428 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
429 r, err := p.Prepare(r)
430 if err == nil {
431 b, err := xml.Marshal(v)
432 if err == nil {
433 // we have to tack on an XML header
434 withHeader := xml.Header + string(b)
435 bytesWithHeader := []byte(withHeader)
436
437 r.ContentLength = int64(len(bytesWithHeader))
438 setHeader(r, headerContentLength, fmt.Sprintf("%d", len(bytesWithHeader)))
439 r.Body = ioutil.NopCloser(bytes.NewReader(bytesWithHeader))
440 }
441 }
442 return r, err
443 })
444 }
445 }
446
447 // WithPath returns a PrepareDecorator that adds the supplied path to the request URL. If the path
448 // is absolute (that is, it begins with a "/"), it replaces the existing path.
449 func WithPath(path string) PrepareDecorator {
450 return func(p Preparer) Preparer {
451 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
452 r, err := p.Prepare(r)
453 if err == nil {
454 if r.URL == nil {
455 return r, NewError("autorest", "WithPath", "Invoked with a nil URL")
456 }
457 if r.URL, err = parseURL(r.URL, path); err != nil {
458 return r, err
459 }
460 }
461 return r, err
462 })
463 }
464 }
465
466 // WithEscapedPathParameters returns a PrepareDecorator that replaces brace-enclosed keys within the
467 // request path (i.e., http.Request.URL.Path) with the corresponding values from the passed map. The
468 // values will be escaped (aka URL encoded) before insertion into the path.
469 func WithEscapedPathParameters(path string, pathParameters map[string]interface{}) PrepareDecorator {
470 parameters := escapeValueStrings(ensureValueStrings(pathParameters))
471 return func(p Preparer) Preparer {
472 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
473 r, err := p.Prepare(r)
474 if err == nil {
475 if r.URL == nil {
476 return r, NewError("autorest", "WithEscapedPathParameters", "Invoked with a nil URL")
477 }
478 for key, value := range parameters {
479 path = strings.Replace(path, "{"+key+"}", value, -1)
480 }
481 if r.URL, err = parseURL(r.URL, path); err != nil {
482 return r, err
483 }
484 }
485 return r, err
486 })
487 }
488 }
489
490 // WithPathParameters returns a PrepareDecorator that replaces brace-enclosed keys within the
491 // request path (i.e., http.Request.URL.Path) with the corresponding values from the passed map.
492 func WithPathParameters(path string, pathParameters map[string]interface{}) PrepareDecorator {
493 parameters := ensureValueStrings(pathParameters)
494 return func(p Preparer) Preparer {
495 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
496 r, err := p.Prepare(r)
497 if err == nil {
498 if r.URL == nil {
499 return r, NewError("autorest", "WithPathParameters", "Invoked with a nil URL")
500 }
501 for key, value := range parameters {
502 path = strings.Replace(path, "{"+key+"}", value, -1)
503 }
504
505 if r.URL, err = parseURL(r.URL, path); err != nil {
506 return r, err
507 }
508 }
509 return r, err
510 })
511 }
512 }
513
514 func parseURL(u *url.URL, path string) (*url.URL, error) {
515 p := strings.TrimRight(u.String(), "/")
516 if !strings.HasPrefix(path, "/") {
517 path = "/" + path
518 }
519 return url.Parse(p + path)
520 }
521
522 // WithQueryParameters returns a PrepareDecorators that encodes and applies the query parameters
523 // given in the supplied map (i.e., key=value).
524 func WithQueryParameters(queryParameters map[string]interface{}) PrepareDecorator {
525 parameters := MapToValues(queryParameters)
526 return func(p Preparer) Preparer {
527 return PreparerFunc(func(r *http.Request) (*http.Request, error) {
528 r, err := p.Prepare(r)
529 if err == nil {
530 if r.URL == nil {
531 return r, NewError("autorest", "WithQueryParameters", "Invoked with a nil URL")
532 }
533 v := r.URL.Query()
534 for key, value := range parameters {
535 for i := range value {
536 d, err := url.QueryUnescape(value[i])
537 if err != nil {
538 return r, err
539 }
540 value[i] = d
541 }
542 v[key] = value
543 }
544 r.URL.RawQuery = v.Encode()
545 }
546 return r, err
547 })
548 }
549 }