Vendor main dependencies.

vendor/github.com/timewasted/linode/linode.go

@@ -0,0 +1,197 @@
+package linode
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+const (
+	// ApiEndpoint is the base URL for the Linode API endpoint.
+	ApiEndpoint = "https://api.linode.com/"
+)
+
+// The following are keys related to working with the Linode API.
+const (
+	apiAction       = "api_action"
+	apiKey          = "api_key"
+	apiRequestArray = "api_requestArray"
+)
+
+var (
+	// client is an HTTP client which will be used for making API calls.
+	client = &http.Client{
+		Transport: &http.Transport{},
+	}
+)
+
+type (
+	// Action represents an action to be performed.
+	Action struct {
+		parameters Parameters
+		result     interface{}
+	}
+	// Linode represents the interface to the Linode API.
+	Linode struct {
+		apiEndpoint string
+		apiKey      string
+		actions     []Action
+	}
+	// ResponseError represents an error returned by an API call.
+	ResponseError struct {
+		Code    int    `json:"ERRORCODE"`
+		Message string `json:"ERRORMESSAGE"`
+	}
+	// Response represents the response to an API call.  Data is defined as
+	// an interface, because each API call will return a different response.
+	// It is the user's responsibility to turn it into something useful.
+	Response struct {
+		Action  string          `json:"ACTION"`
+		RawData json.RawMessage `json:"DATA"`
+		Errors  []ResponseError `json:"ERRORARRAY"`
+		Data    interface{}     `json:"-"`
+	}
+)
+
+// New returns a pointer to a new Linode object.
+func New(apiKey string) *Linode {
+	return &Linode{
+		apiEndpoint: ApiEndpoint,
+		apiKey:      apiKey,
+		actions:     []Action{},
+	}
+}
+
+// SetEndpoint sets the endpoint that all API requests will be sent to.  This
+// should only be used for testing/debugging purposes!
+func (l *Linode) SetEndpoint(endpoint string) {
+	l.apiEndpoint = endpoint
+}
+
+// Request performs a single API operation and returns the full response.
+func (l *Linode) Request(action string, params Parameters, result interface{}) (*Response, error) {
+	// Initialize the request.
+	req, err := http.NewRequest("GET", l.apiEndpoint, nil)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	params.Set(apiAction, action)
+	params.Set(apiKey, l.apiKey)
+	req.URL.RawQuery = params.Encode()
+
+	// Make the request.
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, NewError(fmt.Errorf("Expected status code %d, received %d", http.StatusOK, resp.StatusCode))
+	}
+
+	// Decode the response.
+	var response *Response
+	decoder := json.NewDecoder(resp.Body)
+	if err = decoder.Decode(&response); err != nil {
+		return nil, NewError(err)
+	}
+
+	// Decode the raw data into action-specific data.
+	if result != nil {
+		if err = json.Unmarshal(response.RawData, &result); err != nil {
+			return nil, NewError(err)
+		}
+		response.Data = result
+	}
+
+	// If we have errors in the response, return both the response as well
+	// as an API error.
+	if len(response.Errors) != 0 {
+		return response, NewApiError(response.Errors[0].Code, response.Errors[0].Message)
+	}
+	return response, nil
+}
+
+// Batch adds a new action to the batch request to be performed.
+func (l *Linode) Batch(action string, params Parameters, result interface{}) {
+	params.Set(apiAction, action)
+	l.actions = append(l.actions, Action{
+		parameters: params,
+		result:     result,
+	})
+}
+
+// Process performs all batch actions that have been added.
+func (l *Linode) Process() ([]*Response, error) {
+	// Quickly handle the case where we have zero or one actions to perform.
+	count := len(l.actions)
+	if count == 0 {
+		return nil, NewError(errors.New("linode: request must contain at least one action"))
+	}
+	defer l.Reset()
+	if count == 1 {
+		resp, err := l.Request(l.actions[0].parameters.Get(apiAction), l.actions[0].parameters, l.actions[0].result)
+		if resp == nil {
+			return nil, err
+		}
+		return []*Response{resp}, err
+	}
+
+	// Prepare the parameters.
+	params := make([]Parameters, 0, len(l.actions))
+	for _, action := range l.actions {
+		params = append(params, action.parameters)
+	}
+	jsonParams, err := json.Marshal(params)
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	// Initialize the request.
+	req, err := http.NewRequest("GET", l.apiEndpoint, nil)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	query := Parameters{
+		apiKey:          l.apiKey,
+		apiAction:       "batch",
+		apiRequestArray: string(jsonParams),
+	}
+	req.URL.RawQuery = query.Encode()
+
+	// Do the request.
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	defer resp.Body.Close()
+
+	// Decode the response.
+	var response []*Response
+	decoder := json.NewDecoder(resp.Body)
+	if err = decoder.Decode(&response); err != nil {
+		return nil, NewError(err)
+	}
+
+	// Decode the raw data into action-specific data.
+	// FIXME: This whole block needs error handling, and I think since this
+	// is handling multiple actions, it should probably handle errors on a
+	// per-action basis.
+	for index, action := range response {
+		if l.actions[index].result == nil {
+			continue
+		}
+		if err = json.Unmarshal(action.RawData, &l.actions[index].result); err != nil {
+			continue
+		}
+		response[index].Data = l.actions[index].result
+	}
+
+	return response, nil
+}
+
+// Reset clears the list of actions to be performed.
+func (l *Linode) Reset() {
+	l.actions = []Action{}
+}