package fastly import ( "encoding/json" "fmt" "io" "net/http" "net/url" "os" "runtime" "strings" "github.com/ajg/form" "github.com/hashicorp/go-cleanhttp" "github.com/mitchellh/mapstructure" ) // APIKeyEnvVar is the name of the environment variable where the Fastly API // key should be read from. const APIKeyEnvVar = "FASTLY_API_KEY" // APIKeyHeader is the name of the header that contains the Fastly API key. const APIKeyHeader = "Fastly-Key" // DefaultEndpoint is the default endpoint for Fastly. Since Fastly does not // support an on-premise solution, this is likely to always be the default. const DefaultEndpoint = "https://api.fastly.com" // ProjectURL is the url for this library. var ProjectURL = "github.com/sethvargo/go-fastly" // ProjectVersion is the version of this library. var ProjectVersion = "0.1" // UserAgent is the user agent for this particular client. var UserAgent = fmt.Sprintf("FastlyGo/%s (+%s; %s)", ProjectVersion, ProjectURL, runtime.Version()) // Client is the main entrypoint to the Fastly golang API library. type Client struct { // Address is the address of Fastly's API endpoint. Address string // HTTPClient is the HTTP client to use. If one is not provided, a default // client will be used. HTTPClient *http.Client // apiKey is the Fastly API key to authenticate requests. apiKey string // url is the parsed URL from Address url *url.URL } // DefaultClient instantiates a new Fastly API client. This function requires // the environment variable `FASTLY_API_KEY` is set and contains a valid API key // to authenticate with Fastly. func DefaultClient() *Client { client, err := NewClient(os.Getenv(APIKeyEnvVar)) if err != nil { panic(err) } return client } // NewClient creates a new API client with the given key. Because Fastly allows // some requests without an API key, this function will not error if the API // token is not supplied. Attempts to make a request that requires an API key // will return a 403 response. func NewClient(key string) (*Client, error) { client := &Client{apiKey: key} return client.init() } func (c *Client) init() (*Client, error) { if len(c.Address) == 0 { c.Address = DefaultEndpoint } u, err := url.Parse(c.Address) if err != nil { return nil, err } c.url = u if c.HTTPClient == nil { c.HTTPClient = cleanhttp.DefaultClient() } return c, nil } // Get issues an HTTP GET request. func (c *Client) Get(p string, ro *RequestOptions) (*http.Response, error) { return c.Request("GET", p, ro) } // Head issues an HTTP HEAD request. func (c *Client) Head(p string, ro *RequestOptions) (*http.Response, error) { return c.Request("HEAD", p, ro) } // Post issues an HTTP POST request. func (c *Client) Post(p string, ro *RequestOptions) (*http.Response, error) { return c.Request("POST", p, ro) } // PostForm issues an HTTP POST request with the given interface form-encoded. func (c *Client) PostForm(p string, i interface{}, ro *RequestOptions) (*http.Response, error) { return c.RequestForm("POST", p, i, ro) } // Put issues an HTTP PUT request. func (c *Client) Put(p string, ro *RequestOptions) (*http.Response, error) { return c.Request("PUT", p, ro) } // PutForm issues an HTTP PUT request with the given interface form-encoded. func (c *Client) PutForm(p string, i interface{}, ro *RequestOptions) (*http.Response, error) { return c.RequestForm("PUT", p, i, ro) } // Delete issues an HTTP DELETE request. func (c *Client) Delete(p string, ro *RequestOptions) (*http.Response, error) { return c.Request("DELETE", p, ro) } // Request makes an HTTP request against the HTTPClient using the given verb, // Path, and request options. func (c *Client) Request(verb, p string, ro *RequestOptions) (*http.Response, error) { req, err := c.RawRequest(verb, p, ro) if err != nil { return nil, err } resp, err := checkResp(c.HTTPClient.Do(req)) if err != nil { return resp, err } return resp, nil } // RequestForm makes an HTTP request with the given interface being encoded as // form data. func (c *Client) RequestForm(verb, p string, i interface{}, ro *RequestOptions) (*http.Response, error) { values, err := form.EncodeToValues(i) if err != nil { return nil, err } if ro == nil { ro = new(RequestOptions) } if ro.Headers == nil { ro.Headers = make(map[string]string) } ro.Headers["Content-Type"] = "application/x-www-form-urlencoded" // There is a super-jank implementation in the form library where fields with // a "dot" are replaced with "/.". That is then URL encoded and Fastly just // dies. We fix that here. body := strings.Replace(values.Encode(), "%5C.", ".", -1) ro.Body = strings.NewReader(body) ro.BodyLength = int64(len(body)) return c.Request(verb, p, ro) } // checkResp wraps an HTTP request from the default client and verifies that the // request was successful. A non-200 request returns an error formatted to // included any validation problems or otherwise. func checkResp(resp *http.Response, err error) (*http.Response, error) { // If the err is already there, there was an error higher up the chain, so // just return that. if err != nil { return resp, err } switch resp.StatusCode { case 200, 201, 202, 204, 205, 206: return resp, nil default: return resp, NewHTTPError(resp) } } // decodeJSON is used to decode an HTTP response body into an interface as JSON. func decodeJSON(out interface{}, body io.ReadCloser) error { defer body.Close() var parsed interface{} dec := json.NewDecoder(body) if err := dec.Decode(&parsed); err != nil { return err } decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{ DecodeHook: mapstructure.ComposeDecodeHookFunc( mapToHTTPHeaderHookFunc(), stringToTimeHookFunc(), ), WeaklyTypedInput: true, Result: out, }) if err != nil { return err } return decoder.Decode(parsed) }