terraform/vendor/github.com/henrikhodne/go-librato/librato/client.go

283 lines
6.7 KiB
Go

package librato
import (
"bytes"
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"reflect"
"github.com/google/go-querystring/query"
)
const (
libraryVersion = "0.1"
defaultBaseURL = "https://metrics-api.librato.com/v1/"
userAgent = "go-librato/" + libraryVersion
defaultMediaType = "application/json"
)
// A Client manages communication with the Librato API.
type Client struct {
// HTTP client used to communicate with the API
client *http.Client
// Headers to attach to every request made with the client. Headers will be
// used to provide Librato API authentication details and other necessary
// headers.
Headers map[string]string
// Email and Token contains the authentication details needed to authenticate
// against the Librato API.
Email, Token string
// Base URL for API requests. Defaults to the public Librato API, but can be
// set to an alternate endpoint if necessary. BaseURL should always be
// terminated by a slash.
BaseURL *url.URL
// User agent used when communicating with the Librato API.
UserAgent string
// Services used to manipulate API entities.
Spaces *SpacesService
}
// NewClient returns a new Librato API client bound to the public Librato API.
func NewClient(email, token string) *Client {
bu, err := url.Parse(defaultBaseURL)
if err != nil {
panic("Default Librato API base URL couldn't be parsed")
}
return NewClientWithBaseURL(bu, email, token)
}
// NewClientWithBaseURL returned a new Librato API client with a custom base URL.
func NewClientWithBaseURL(baseURL *url.URL, email, token string) *Client {
headers := map[string]string{
"Content-Type": defaultMediaType,
"Accept": defaultMediaType,
}
c := &Client{
client: http.DefaultClient,
Headers: headers,
Email: email,
Token: token,
BaseURL: baseURL,
UserAgent: userAgent,
}
c.Spaces = &SpacesService{client: c}
return c
}
// NewRequest creates an API request. A relative URL can be provided in urlStr,
// in which case it is resolved relative to the BaseURL of the Client.
// Relative URLs should always be specified without a preceding slash. If
// specified, the value pointed to by body is JSON encoded and included as the
// request body. If specified, the map provided by headers will be used to
// update request headers.
func (c *Client) NewRequest(method, urlStr string, body interface{}) (*http.Request, error) {
rel, err := url.Parse(urlStr)
if err != nil {
return nil, err
}
u := c.BaseURL.ResolveReference(rel)
var buf io.ReadWriter
if body != nil {
buf = new(bytes.Buffer)
err := json.NewEncoder(buf).Encode(body)
if err != nil {
return nil, err
}
}
req, err := http.NewRequest(method, u.String(), buf)
if err != nil {
return nil, err
}
req.SetBasicAuth(c.Email, c.Token)
if c.UserAgent != "" {
req.Header.Set("User-Agent", c.UserAgent)
}
for k, v := range c.Headers {
req.Header.Set(k, v)
}
return req, nil
}
// Do sends an API request and returns the API response. The API response is
// JSON decoded and stored in the value pointed to by v, or returned as an
// error if an API error has occurred. If v implements the io.Writer
// interface, the raw response body will be written to v, without attempting to
// first decode it.
func (c *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
resp, err := c.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
err = CheckResponse(resp)
if err != nil {
return resp, err
}
if v != nil {
if w, ok := v.(io.Writer); ok {
_, err = io.Copy(w, resp.Body)
} else {
err = json.NewDecoder(resp.Body).Decode(v)
}
}
return resp, err
}
// ErrorResponse reports an error caused by an API request.
// ErrorResponse implements the Error interface.
type ErrorResponse struct {
// HTTP response that caused this error
Response *http.Response
// Error messages produces by Librato API.
Errors ErrorResponseMessages `json:"errors"`
}
func (er *ErrorResponse) Error() string {
buf := new(bytes.Buffer)
if er.Errors.Params != nil && len(er.Errors.Params) > 0 {
buf.WriteString(" Parameter errors:")
for param, errs := range er.Errors.Params {
fmt.Fprintf(buf, " %s:", param)
for _, err := range errs {
fmt.Fprintf(buf, " %s,", err)
}
}
buf.WriteString(".")
}
if er.Errors.Request != nil && len(er.Errors.Request) > 0 {
buf.WriteString(" Request errors:")
for _, err := range er.Errors.Request {
fmt.Fprintf(buf, " %s,", err)
}
buf.WriteString(".")
}
if er.Errors.System != nil && len(er.Errors.System) > 0 {
buf.WriteString(" System errors:")
for _, err := range er.Errors.System {
fmt.Fprintf(buf, " %s,", err)
}
buf.WriteString(".")
}
return fmt.Sprintf(
"%v %v: %d %v",
er.Response.Request.Method,
er.Response.Request.URL,
er.Response.StatusCode,
buf.String(),
)
}
// ErrorResponseMessages contains error messages returned from the Librato API.
type ErrorResponseMessages struct {
Params map[string][]string `json:"params,omitempty"`
Request []string `json:"request,omitempty"`
System []string `json:"system,omitempty"`
}
// CheckResponse checks the API response for errors; and returns them if
// present. A Response is considered an error if it has a status code outside
// the 2XX range.
func CheckResponse(r *http.Response) error {
if c := r.StatusCode; 200 <= c && c <= 299 {
return nil
}
errorResponse := &ErrorResponse{Response: r}
data, err := ioutil.ReadAll(r.Body)
if err == nil && data != nil {
json.Unmarshal(data, errorResponse)
}
return errorResponse
}
func urlWithOptions(s string, opt interface{}) (string, error) {
rv := reflect.ValueOf(opt)
if rv.Kind() == reflect.Ptr && rv.IsNil() {
return s, nil
}
u, err := url.Parse(s)
if err != nil {
return s, err
}
qs, err := query.Values(opt)
if err != nil {
return "", err
}
u.RawQuery = qs.Encode()
return u.String(), nil
}
// Bool is a helper routine that allocates a new bool value
// to store v and returns a pointer to it.
func Bool(v bool) *bool {
p := new(bool)
*p = v
return p
}
// Int is a helper routine that allocates a new int32 value
// to store v and returns a pointer to it, but unlike Int32
// its argument value is an int.
func Int(v int) *int {
p := new(int)
*p = v
return p
}
// Uint is a helper routine that allocates a new uint value
// to store v and returns a pointer to it.
func Uint(v uint) *uint {
p := new(uint)
*p = v
return p
}
// String is a helper routine that allocates a new string value
// to store v and returns a pointer to it.
func String(v string) *string {
p := new(string)
*p = v
return p
}
// Float is a helper routine that allocates a new float64 value
// to store v and returns a pointer to it.
func Float(v float64) *float64 {
p := new(float64)
*p = v
return p
}