Vendor main dependencies.

vendor/github.com/edeckers/auroradnsclient/requests/requestor.go

@@ -0,0 +1,123 @@
+package requests
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"github.com/Sirupsen/logrus"
+	request_errors "github.com/edeckers/auroradnsclient/requests/errors"
+	"github.com/edeckers/auroradnsclient/tokens"
+	"io/ioutil"
+	"net/http"
+	"net/http/httputil"
+	"time"
+)
+
+// AuroraRequestor performs actual requests to API
+type AuroraRequestor struct {
+	endpoint string
+	userID   string
+	key      string
+}
+
+// NewAuroraRequestor instantiates a new requestor
+func NewAuroraRequestor(endpoint string, userID string, key string) (*AuroraRequestor, error) {
+	if endpoint == "" {
+		return nil, fmt.Errorf("Aurora endpoint missing")
+	}
+
+	if userID == "" || key == "" {
+		return nil, fmt.Errorf("Aurora credentials missing")
+	}
+
+	return &AuroraRequestor{endpoint: endpoint, userID: userID, key: key}, nil
+}
+
+func (requestor *AuroraRequestor) buildRequest(relativeURL string, method string, body []byte) (*http.Request, error) {
+	url := fmt.Sprintf("%s/%s", requestor.endpoint, relativeURL)
+
+	request, err := http.NewRequest(method, url, bytes.NewReader(body))
+	if err != nil {
+		logrus.Errorf("Failed to build request: %s", err)
+
+		return request, err
+	}
+
+	timestamp := time.Now().UTC()
+	fmtTime := timestamp.Format("20060102T150405Z")
+
+	token := tokens.NewToken(requestor.userID, requestor.key, method, fmt.Sprintf("/%s", relativeURL), timestamp)
+
+	request.Header.Set("X-AuroraDNS-Date", fmtTime)
+	request.Header.Set("Authorization", fmt.Sprintf("AuroraDNSv1 %s", token))
+
+	request.Header.Set("Content-Type", "application/json")
+
+	rawRequest, err := httputil.DumpRequestOut(request, true)
+	if err != nil {
+		logrus.Errorf("Failed to dump request: %s", err)
+	}
+
+	logrus.Debugf("Built request:\n%s", rawRequest)
+
+	return request, err
+}
+
+func (requestor *AuroraRequestor) testInvalidResponse(resp *http.Response, response []byte) ([]byte, error) {
+	if resp.StatusCode < 400 {
+		return response, nil
+	}
+
+	logrus.Errorf("Received invalid status code %d:\n%s", resp.StatusCode, response)
+
+	content := errors.New(string(response))
+
+	statusCodeErrorMap := map[int]error{
+		400: request_errors.BadRequest(content),
+		401: request_errors.Unauthorized(content),
+		403: request_errors.Forbidden(content),
+		404: request_errors.NotFound(content),
+		500: request_errors.ServerError(content),
+	}
+
+	mappedError := statusCodeErrorMap[resp.StatusCode]
+
+	if mappedError == nil {
+		return nil, request_errors.InvalidStatusCodeError(content)
+	}
+
+	return nil, mappedError
+}
+
+// Request builds and executues a request to the API
+func (requestor *AuroraRequestor) Request(relativeURL string, method string, body []byte) ([]byte, error) {
+	req, err := requestor.buildRequest(relativeURL, method, body)
+
+	client := http.Client{Timeout: 30 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		logrus.Errorf("Failed request: %s", err)
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+
+	rawResponse, err := httputil.DumpResponse(resp, true)
+	logrus.Debugf("Received raw response:\n%s", rawResponse)
+	if err != nil {
+		logrus.Errorf("Failed to dump response: %s", err)
+	}
+
+	response, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		logrus.Errorf("Failed to read response: %s", response)
+		return nil, err
+	}
+
+	response, err = requestor.testInvalidResponse(resp, response)
+	if err != nil {
+		return nil, err
+	}
+
+	return response, nil
+}