CLOUDP-60178: Implement logs API, Atlas (#79)

Author: andreaangiolillo

mongodbatlas/logs.go

@@ -0,0 +1,67 @@
+package mongodbatlas
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+)
+
+const logsPath = "groups/%s/clusters/%s/logs/%s"
+
+// LogsService is an interface for interfacing with the Logs
+// endpoints of the MongoDB Atlas API.
+// See more: https://docs.atlas.mongodb.com/reference/api/logs/
+type LogsService interface {
+	Get(context.Context, string, string, string, io.Writer, *DateRangetOptions) (*Response, error)
+}
+
+// LogsServiceOp handles communication with the Logs related methods of the
+// MongoDB Atlas API
+type LogsServiceOp struct {
+	Client GZipRequestDoer
+}
+
+// DateRangetOptions specifies an optional date range query.
+type DateRangetOptions struct {
+	StartDate string `url:"startDate,omitempty"`
+	EndDate   string `url:"endDate,omitempty"`
+}
+
+// Get gets a compressed (.gz) log file that contains a range of log messages for a particular host.
+// Note: The input parameter out (io.Writer) is not closed by this function.
+// See more: https://docs.atlas.mongodb.com/reference/api/logs/
+func (s *LogsServiceOp) Get(ctx context.Context, groupID string, hostName string, logName string, out io.Writer, opts *DateRangetOptions) (*Response, error) {
+	if groupID == "" {
+		return nil, NewArgError("groupID", "must be set")
+	}
+
+	if hostName == "" {
+		return nil, NewArgError("hostName", "must be set")
+	}
+
+	if logName == "" {
+		return nil, NewArgError("logName", "must be set")
+	}
+
+	basePath := fmt.Sprintf(logsPath, groupID, hostName, logName)
+
+	// Add query params
+	path, err := setListOptions(basePath, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := s.Client.NewGZipRequest(ctx, http.MethodGet, path)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.Client.Do(ctx, req, out)
+	if err != nil {
+		return nil, err
+	}
+
+	return resp, nil
+
+}

mongodbatlas/logs_test.go

@@ -0,0 +1,29 @@
+package mongodbatlas
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"testing"
+)
+
+func TestLogs_Get(t *testing.T) {
+	setup()
+	defer teardown()
+
+	groupID := "1"
+	cluster := "test-username"
+	log := "log"
+
+	mux.HandleFunc(fmt.Sprintf("/groups/%s/clusters/%s/logs/%s", groupID, cluster, log), func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, http.MethodGet)
+		fmt.Fprint(w, "test")
+	})
+
+	buf := new(bytes.Buffer)
+	_, err := client.Logs.Get(ctx, groupID, cluster, log, buf, nil)
+
+	if buf.String() != "test" {
+		t.Fatalf("Logs.Get returned error: %v", err)
+	}
+}

mongodbatlas/mongodbatlas.go

@@ -22,14 +22,29 @@ const (
 	defaultBaseURL = "https://cloud.mongodb.com/api/atlas/v1.0/"
 	userAgent      = "go-mongodbatlas" + libraryVersion
 	mediaType      = "application/json"
+	gzipMediaType  = "application/gzip"
 )
 
-type RequestDoer interface {
-	NewRequest(context.Context, string, string, interface{}) (*http.Request, error)
+type Doer interface {
 	Do(context.Context, *http.Request, interface{}) (*Response, error)
+}
+
+type Completer interface {
 	OnRequestCompleted(RequestCompletionCallback)
 }
 
+type RequestDoer interface {
+	Doer
+	Completer
+	NewRequest(context.Context, string, string, interface{}) (*http.Request, error)
+}
+
+type GZipRequestDoer interface {
+	Doer
+	Completer
+	NewGZipRequest(context.Context, string, string) (*http.Request, error)
+}
+
 // Client manages communication with MongoDBAtlas v1.0 API
 type Client struct {
 	client    *http.Client
@@ -71,6 +86,7 @@ type Client struct {
 	ProcessDiskMeasurements             ProcessDiskMeasurementsService
 	ProcessDatabases                    ProcessDatabasesService
 	Indexes                             IndexesService
+	Logs                                LogsService
 
 	onRequestCompleted RequestCompletionCallback
 }
@@ -195,6 +211,7 @@ func NewClient(httpClient *http.Client) *Client {
 	c.ProcessDiskMeasurements = &ProcessDiskMeasurementsServiceOp{Client: c}
 	c.ProcessDatabases = &ProcessDatabasesServiceOp{Client: c}
 	c.Indexes = &IndexesServiceOp{Client: c}
+	c.Logs = &LogsServiceOp{Client: c}
 
 	return c
 }
@@ -239,17 +256,13 @@ func SetUserAgent(ua string) ClientOpt {
 // 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 in as the request body.
 func (c *Client) NewRequest(ctx context.Context, method, urlStr string, body interface{}) (*http.Request, error) {
-	rel, err := url.Parse(urlStr)
+	u, err := c.BaseURL.Parse(urlStr)
 	if err != nil {
 		return nil, err
 	}
-
-	u := c.BaseURL.ResolveReference(rel)
-
-	buf := new(bytes.Buffer)
+	var buf io.Reader
 	if body != nil {
-		err = json.NewEncoder(buf).Encode(body)
-		if err != nil {
+		if buf, err = c.newEncodedBody(body); err != nil {
 			return nil, err
 		}
 	}
@@ -259,9 +272,44 @@ func (c *Client) NewRequest(ctx context.Context, method, urlStr string, body int
 		return nil, err
 	}
 
-	req.Header.Add("Content-Type", mediaType)
+	if body != nil {
+		req.Header.Set("Content-Type", mediaType)
+	}
 	req.Header.Add("Accept", mediaType)
-	req.Header.Add("User-Agent", c.UserAgent)
+	if c.UserAgent != "" {
+		req.Header.Set("User-Agent", c.UserAgent)
+	}
+	return req, nil
+}
+
+// newEncodedBody returns an ReadWriter object containing the body of the http request
+func (c *Client) newEncodedBody(body interface{}) (io.Reader, error) {
+	buf := &bytes.Buffer{}
+	enc := json.NewEncoder(buf)
+	enc.SetEscapeHTML(false)
+	err := enc.Encode(body)
+	return buf, err
+}
+
+// NewGZipRequest creates an API request that accepts gzip. A relative URL can be provided in urlStr, which will be resolved to the
+// BaseURL of the Client. Relative URLS should always be specified without a preceding slash.
+func (c *Client) NewGZipRequest(ctx context.Context, method, urlStr string) (*http.Request, error) {
+	rel, err := url.Parse(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	u := c.BaseURL.ResolveReference(rel)
+
+	req, err := http.NewRequest(method, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Accept", gzipMediaType)
+	if c.UserAgent != "" {
+		req.Header.Set("User-Agent", c.UserAgent)
+	}
 	return req, nil
 }
 
@@ -276,6 +324,14 @@ func (c *Client) OnRequestCompleted(rc RequestCompletionCallback) {
 func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) (*Response, error) {
 	resp, err := DoRequestWithClient(ctx, c.client, req)
 	if err != nil {
+		// If we got an error, and the context has been canceled,
+		// the context's error is probably more useful.
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+
 		return nil, err
 	}
 	if c.onRequestCompleted != nil {
@@ -288,7 +344,7 @@ func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) (*Res
 		}
 	}()
 
-	response := newResponse(resp)
+	response := &Response{Response: resp}
 
 	err = CheckResponse(resp)
 	if err != nil {
@@ -302,9 +358,12 @@ func (c *Client) Do(ctx context.Context, req *http.Request, v interface{}) (*Res
 				return nil, err
 			}
 		} else {
-			err = json.NewDecoder(resp.Body).Decode(v)
-			if err != nil {
-				return nil, err
+			decErr := json.NewDecoder(resp.Body).Decode(v)
+			if decErr == io.EOF {
+				decErr = nil // ignore EOF errors caused by empty response body
+			}
+			if decErr != nil {
+				err = decErr
 			}
 		}
 	}
@@ -338,13 +397,6 @@ func CheckResponse(r *http.Response) error {
 	return errorResponse
 }
 
-// newResponse creates a new Response for the provided http.Response
-func newResponse(r *http.Response) *Response {
-	response := Response{Response: r}
-
-	return &response
-}
-
 // DoRequestWithClient submits an HTTP request using the specified client.
 func DoRequestWithClient(
 	ctx context.Context,

mongodbatlas/mongodbatlas_test.go

@@ -2,6 +2,7 @@ package mongodbatlas
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -102,6 +103,23 @@ type testRequestBody struct {
 	TestData    string `json:"testUserData"`
 }
 
+// If a nil body is passed to mongodbatlas.NewRequest, make sure that nil is also
+// passed to http.NewRequest. In most cases, passing an io.Reader that returns
+// no content is fine, since there is no difference between an HTTP request
+// body that is an empty string versus one that is not set at all. However in
+// certain cases, intermediate systems may treat these differently resulting in
+// subtle errors.
+func TestNewRequest_emptyBody(t *testing.T) {
+	c := NewClient(nil)
+	req, err := c.NewRequest(ctx, http.MethodGet, ".", nil)
+	if err != nil {
+		t.Fatalf("NewRequest returned unexpected error: %v", err)
+	}
+	if req.Body != nil {
+		t.Fatalf("constructed request contains a non-nil Body")
+	}
+}
+
 func TestNewRequest_withUserData(t *testing.T) {
 	c := NewClient(nil)
 
@@ -153,6 +171,65 @@ func TestNewRequest_withCustomUserAgent(t *testing.T) {
 	}
 }
 
+func TestNewGZipRequest_emptyBody(t *testing.T) {
+	c := NewClient(nil)
+	req, err := c.NewGZipRequest(ctx, http.MethodGet, ".")
+	if err != nil {
+		t.Fatalf("NewRequest returned unexpected error: %v", err)
+	}
+	if req.Body != nil {
+		t.Fatalf("constructed request contains a non-nil Body")
+	}
+}
+
+func TestNewGZipRequest_withCustomUserAgent(t *testing.T) {
+	ua := "testing/0.0.1"
+	c, err := New(nil, SetUserAgent(ua))
+
+	if err != nil {
+		t.Fatalf("New() unexpected error: %v", err)
+	}
+
+	req, _ := c.NewGZipRequest(ctx, http.MethodGet, "/foo")
+
+	expected := fmt.Sprintf("%s %s", ua, userAgent)
+	if got := req.Header.Get("User-Agent"); got != expected {
+		t.Errorf("New() UserAgent = %s; expected %s", got, expected)
+	}
+}
+
+func TestNewGZipRequest_badURL(t *testing.T) {
+	c := NewClient(nil)
+	_, err := c.NewGZipRequest(ctx, http.MethodGet, ":/.")
+	testURLParseError(t, err)
+}
+
+func TestNewGZipRequest(t *testing.T) {
+	c := NewClient(nil)
+
+	requestPath := "foo"
+
+	inURL, outURL := requestPath, defaultBaseURL+requestPath
+	req, _ := c.NewGZipRequest(ctx, http.MethodGet, inURL)
+
+	// test relative URL was expanded
+	if req.URL.String() != outURL {
+		t.Errorf("NewGZipRequest(%v) URL = %v, expected %v", inURL, req.URL, outURL)
+	}
+
+	// test accept content type is correct
+	accept := req.Header.Get("Accept")
+	if gzipMediaType != accept {
+		t.Errorf("NewGZipRequest() Accept = %v, expected %v", accept, gzipMediaType)
+	}
+
+	// test default user-agent is attached to the request
+	userAgent := req.Header.Get("User-Agent")
+	if c.UserAgent != userAgent {
+		t.Errorf("NewGZipRequest() User-Agent = %v, expected %v", userAgent, c.UserAgent)
+	}
+}
+
 func TestDo(t *testing.T) {
 	setup()
 	defer teardown()
@@ -218,6 +295,23 @@ func TestDo_redirectLoop(t *testing.T) {
 	}
 }
 
+func TestDo_noContent(t *testing.T) {
+	setup()
+	defer teardown()
+
+	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	})
+
+	var body json.RawMessage
+
+	req, _ := client.NewRequest(ctx, http.MethodGet, ".", nil)
+	_, err := client.Do(context.Background(), req, &body)
+	if err != nil {
+		t.Fatalf("Do returned unexpected error: %v", err)
+	}
+}
+
 func TestCheckResponse(t *testing.T) {
 	res := &http.Response{
 		Request:    &http.Request{},