package autorest // Copyright 2017 Microsoft Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import ( "bytes" "fmt" "io" "io/ioutil" "log" "net/http" "net/http/cookiejar" "runtime" "time" ) const ( // DefaultPollingDelay is a reasonable delay between polling requests. DefaultPollingDelay = 60 * time.Second // DefaultPollingDuration is a reasonable total polling duration. DefaultPollingDuration = 15 * time.Minute // DefaultRetryAttempts is number of attempts for retry status codes (5xx). DefaultRetryAttempts = 3 // DefaultRetryDuration is the duration to wait between retries. DefaultRetryDuration = 30 * time.Second ) var ( // defaultUserAgent builds a string containing the Go version, system archityecture and OS, // and the go-autorest version. defaultUserAgent = fmt.Sprintf("Go/%s (%s-%s) go-autorest/%s", runtime.Version(), runtime.GOARCH, runtime.GOOS, Version(), ) // StatusCodesForRetry are a defined group of status code for which the client will retry StatusCodesForRetry = []int{ http.StatusRequestTimeout, // 408 http.StatusTooManyRequests, // 429 http.StatusInternalServerError, // 500 http.StatusBadGateway, // 502 http.StatusServiceUnavailable, // 503 http.StatusGatewayTimeout, // 504 } ) const ( requestFormat = `HTTP Request Begin =================================================== %s ===================================================== HTTP Request End ` responseFormat = `HTTP Response Begin =================================================== %s ===================================================== HTTP Response End ` ) // Response serves as the base for all responses from generated clients. It provides access to the // last http.Response. type Response struct { *http.Response `json:"-"` } // LoggingInspector implements request and response inspectors that log the full request and // response to a supplied log. type LoggingInspector struct { Logger *log.Logger } // WithInspection returns a PrepareDecorator that emits the http.Request to the supplied logger. The // body is restored after being emitted. // // Note: Since it reads the entire Body, this decorator should not be used where body streaming is // important. It is best used to trace JSON or similar body values. func (li LoggingInspector) WithInspection() PrepareDecorator { return func(p Preparer) Preparer { return PreparerFunc(func(r *http.Request) (*http.Request, error) { var body, b bytes.Buffer defer r.Body.Close() r.Body = ioutil.NopCloser(io.TeeReader(r.Body, &body)) if err := r.Write(&b); err != nil { return nil, fmt.Errorf("Failed to write response: %v", err) } li.Logger.Printf(requestFormat, b.String()) r.Body = ioutil.NopCloser(&body) return p.Prepare(r) }) } } // ByInspecting returns a RespondDecorator that emits the http.Response to the supplied logger. The // body is restored after being emitted. // // Note: Since it reads the entire Body, this decorator should not be used where body streaming is // important. It is best used to trace JSON or similar body values. func (li LoggingInspector) ByInspecting() RespondDecorator { return func(r Responder) Responder { return ResponderFunc(func(resp *http.Response) error { var body, b bytes.Buffer defer resp.Body.Close() resp.Body = ioutil.NopCloser(io.TeeReader(resp.Body, &body)) if err := resp.Write(&b); err != nil { return fmt.Errorf("Failed to write response: %v", err) } li.Logger.Printf(responseFormat, b.String()) resp.Body = ioutil.NopCloser(&body) return r.Respond(resp) }) } } // Client is the base for autorest generated clients. It provides default, "do nothing" // implementations of an Authorizer, RequestInspector, and ResponseInspector. It also returns the // standard, undecorated http.Client as a default Sender. // // Generated clients should also use Error (see NewError and NewErrorWithError) for errors and // return responses that compose with Response. // // Most customization of generated clients is best achieved by supplying a custom Authorizer, custom // RequestInspector, and / or custom ResponseInspector. Users may log requests, implement circuit // breakers (see https://msdn.microsoft.com/en-us/library/dn589784.aspx) or otherwise influence // sending the request by providing a decorated Sender. type Client struct { Authorizer Authorizer Sender Sender RequestInspector PrepareDecorator ResponseInspector RespondDecorator // PollingDelay sets the polling frequency used in absence of a Retry-After HTTP header PollingDelay time.Duration // PollingDuration sets the maximum polling time after which an error is returned. PollingDuration time.Duration // RetryAttempts sets the default number of retry attempts for client. RetryAttempts int // RetryDuration sets the delay duration for retries. RetryDuration time.Duration // UserAgent, if not empty, will be set as the HTTP User-Agent header on all requests sent // through the Do method. UserAgent string Jar http.CookieJar // Set to true to skip attempted registration of resource providers (false by default). SkipResourceProviderRegistration bool } // NewClientWithUserAgent returns an instance of a Client with the UserAgent set to the passed // string. func NewClientWithUserAgent(ua string) Client { c := Client{ PollingDelay: DefaultPollingDelay, PollingDuration: DefaultPollingDuration, RetryAttempts: DefaultRetryAttempts, RetryDuration: DefaultRetryDuration, UserAgent: defaultUserAgent, } c.Sender = c.sender() c.AddToUserAgent(ua) return c } // AddToUserAgent adds an extension to the current user agent func (c *Client) AddToUserAgent(extension string) error { if extension != "" { c.UserAgent = fmt.Sprintf("%s %s", c.UserAgent, extension) return nil } return fmt.Errorf("Extension was empty, User Agent stayed as %s", c.UserAgent) } // Do implements the Sender interface by invoking the active Sender after applying authorization. // If Sender is not set, it uses a new instance of http.Client. In both cases it will, if UserAgent // is set, apply set the User-Agent header. func (c Client) Do(r *http.Request) (*http.Response, error) { if r.UserAgent() == "" { r, _ = Prepare(r, WithUserAgent(c.UserAgent)) } // NOTE: c.WithInspection() must be last in the list so that it can inspect all preceding operations r, err := Prepare(r, c.WithAuthorization(), c.WithInspection()) if err != nil { var resp *http.Response if detErr, ok := err.(DetailedError); ok { // if the authorization failed (e.g. invalid credentials) there will // be a response associated with the error, be sure to return it. resp = detErr.Response } return resp, NewErrorWithError(err, "autorest/Client", "Do", nil, "Preparing request failed") } resp, err := SendWithSender(c.sender(), r) Respond(resp, c.ByInspecting()) return resp, err } // sender returns the Sender to which to send requests. func (c Client) sender() Sender { if c.Sender == nil { j, _ := cookiejar.New(nil) return &http.Client{Jar: j} } return c.Sender } // WithAuthorization is a convenience method that returns the WithAuthorization PrepareDecorator // from the current Authorizer. If not Authorizer is set, it uses the NullAuthorizer. func (c Client) WithAuthorization() PrepareDecorator { return c.authorizer().WithAuthorization() } // authorizer returns the Authorizer to use. func (c Client) authorizer() Authorizer { if c.Authorizer == nil { return NullAuthorizer{} } return c.Authorizer } // WithInspection is a convenience method that passes the request to the supplied RequestInspector, // if present, or returns the WithNothing PrepareDecorator otherwise. func (c Client) WithInspection() PrepareDecorator { if c.RequestInspector == nil { return WithNothing() } return c.RequestInspector } // ByInspecting is a convenience method that passes the response to the supplied ResponseInspector, // if present, or returns the ByIgnoring RespondDecorator otherwise. func (c Client) ByInspecting() RespondDecorator { if c.ResponseInspector == nil { return ByIgnoring() } return c.ResponseInspector }