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" "crypto/tls" "errors" "fmt" "io" "io/ioutil" "log" "net/http" "strings" "time" "github.com/Azure/go-autorest/logger" ) const ( // DefaultPollingDelay is a reasonable delay between polling requests. DefaultPollingDelay = 30 * 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 ( // 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:"-"` } // IsHTTPStatus returns true if the returned HTTP status code matches the provided status code. // If there was no response (i.e. the underlying http.Response is nil) the return value is false. func (r Response) IsHTTPStatus(statusCode int) bool { if r.Response == nil { return false } return r.Response.StatusCode == statusCode } // HasHTTPStatus returns true if the returned HTTP status code matches one of the provided status codes. // If there was no response (i.e. the underlying http.Response is nil) or not status codes are provided // the return value is false. func (r Response) HasHTTPStatus(statusCodes ...int) bool { return ResponseHasStatusCode(r.Response, statusCodes...) } // 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. // Setting this to zero will use the provided context to control the duration. PollingDuration time.Duration // RetryAttempts sets the total number of times the client will attempt to make an HTTP request. // Set the value to 1 to disable retries. DO NOT set the value to less than 1. 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 // SendDecorators can be used to override the default chain of SendDecorators. // This can be used to specify things like a custom retry SendDecorator. // Set this to an empty slice to use no SendDecorators. SendDecorators []SendDecorator } // NewClientWithUserAgent returns an instance of a Client with the UserAgent set to the passed // string. func NewClientWithUserAgent(ua string) Client { return newClient(ua, tls.RenegotiateNever) } // ClientOptions contains various Client configuration options. type ClientOptions struct { // UserAgent is an optional user-agent string to append to the default user agent. UserAgent string // Renegotiation is an optional setting to control client-side TLS renegotiation. Renegotiation tls.RenegotiationSupport } // NewClientWithOptions returns an instance of a Client with the specified values. func NewClientWithOptions(options ClientOptions) Client { return newClient(options.UserAgent, options.Renegotiation) } func newClient(ua string, renegotiation tls.RenegotiationSupport) Client { c := Client{ PollingDelay: DefaultPollingDelay, PollingDuration: DefaultPollingDuration, RetryAttempts: DefaultRetryAttempts, RetryDuration: DefaultRetryDuration, UserAgent: UserAgent(), } c.Sender = c.sender(renegotiation) 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") } logger.Instance.WriteRequest(r, logger.Filter{ Header: func(k string, v []string) (bool, []string) { // remove the auth token from the log if strings.EqualFold(k, "Authorization") || strings.EqualFold(k, "Ocp-Apim-Subscription-Key") { v = []string{"**REDACTED**"} } return true, v }, }) resp, err := SendWithSender(c.sender(tls.RenegotiateNever), r) if resp == nil && err == nil { err = errors.New("autorest: received nil response and error") } logger.Instance.WriteResponse(resp, logger.Filter{}) Respond(resp, c.ByInspecting()) return resp, err } // sender returns the Sender to which to send requests. func (c Client) sender(renengotiation tls.RenegotiationSupport) Sender { if c.Sender == nil { return sender(renengotiation) } 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 } // Send sends the provided http.Request using the client's Sender or the default sender. // It returns the http.Response and possible error. It also accepts a, possibly empty, // default set of SendDecorators used when sending the request. // SendDecorators have the following precedence: // 1. In a request's context via WithSendDecorators() // 2. Specified on the client in SendDecorators // 3. The default values specified in this method func (c Client) Send(req *http.Request, decorators ...SendDecorator) (*http.Response, error) { if c.SendDecorators != nil { decorators = c.SendDecorators } inCtx := req.Context().Value(ctxSendDecorators{}) if sd, ok := inCtx.([]SendDecorator); ok { decorators = sd } return SendWithSender(c, req, decorators...) }