CLOUDP-60177: Implement Get Measurements of a Disk for a MongoDB Process, Atlas (#78)

Author: andreaangiolillo

mongodbatlas/mongodbatlas.go

@@ -68,6 +68,7 @@ type Client struct {
 	Processes                           ProcessesService
 	ProcessMeasurements                 ProcessMeasurementsService
 	ProcessDisks                        ProcessDisksService
+	ProcessDiskMeasurements             ProcessDiskMeasurementsService
 	ProcessDatabases                    ProcessDatabasesService
 
 	onRequestCompleted RequestCompletionCallback
@@ -190,6 +191,7 @@ func NewClient(httpClient *http.Client) *Client {
 	c.Processes = &ProcessesServiceOp{Client: c}
 	c.ProcessMeasurements = &ProcessMeasurementsServiceOp{Client: c}
 	c.ProcessDisks = &ProcessDisksServiceOp{Client: c}
+	c.ProcessDiskMeasurements = &ProcessDiskMeasurementsServiceOp{Client: c}
 	c.ProcessDatabases = &ProcessDatabasesServiceOp{Client: c}
 
 	return c

mongodbatlas/process_disk_measurements.go

@@ -0,0 +1,68 @@
+package mongodbatlas
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+const ProcessDiskMeasurementsPath = processesDisksPath + "/%s/measurements"
+
+// ProcessDiskMeasurementsService is an interface for interfacing with the Process Disk Measurements
+// endpoints of the MongoDB Atlas API.
+// See more: https://docs.atlas.mongodb.com/reference/api/process-disks-measurements/#get-measurements-of-a-disk-for-a-mongodb-process
+type ProcessDiskMeasurementsService interface {
+	List(context.Context, string, string, int, string, *ProcessMeasurementListOptions) (*ProcessDiskMeasurements, *Response, error)
+}
+
+// ProcessDiskMeasurementsServiceOp handles communication with the Process Disk Measurements related methods of the
+// MongoDB Atlas API
+type ProcessDiskMeasurementsServiceOp struct {
+	Client RequestDoer
+}
+
+// ProcessDiskMeasurements represents a MongoDB Process Disk Measurements.
+type ProcessDiskMeasurements struct {
+	*ProcessMeasurements
+	PartitionName string `json:"partitionName"`
+}
+
+var _ ProcessDiskMeasurementsService = &ProcessDiskMeasurementsServiceOp{}
+
+// Get gets measurements for a specific Atlas MongoDB disk.
+// See more: https://docs.atlas.mongodb.com/reference/api/process-disks-measurements/#get-measurements-of-a-disk-for-a-mongodb-process
+func (s *ProcessDiskMeasurementsServiceOp) List(ctx context.Context, groupID, hostName string, port int, diskName string, opts *ProcessMeasurementListOptions) (*ProcessDiskMeasurements, *Response, error) {
+
+	if groupID == "" {
+		return nil, nil, NewArgError("groupID", "must be set")
+	}
+
+	if hostName == "" {
+		return nil, nil, NewArgError("hostName", "must be set")
+	}
+
+	if diskName == "" {
+		return nil, nil, NewArgError("diskName", "must be set")
+	}
+
+	basePath := fmt.Sprintf(ProcessDiskMeasurementsPath, groupID, hostName, port, diskName)
+
+	//Add query params from listOptions
+	path, err := setListOptions(basePath, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	root := new(ProcessDiskMeasurements)
+	resp, err := s.Client.Do(ctx, req, root)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return root, resp, err
+}

mongodbatlas/process_disk_measurements_test.go

@@ -0,0 +1,102 @@
+package mongodbatlas
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/go-test/deep"
+)
+
+func TestDiskMeasurements_List(t *testing.T) {
+	setup()
+	defer teardown()
+
+	groups := "12345678"
+	host := "shard-00-00.mongodb.net"
+	port := 27017
+	disk := "disk"
+
+	mux.HandleFunc(fmt.Sprintf("/groups/%s/processes/%s:%d/disks/%s/measurements", groups, host, port, disk), func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, http.MethodGet)
+		fmt.Fprint(w, `{
+				  "end" : "2017-08-22T20:31:14Z",
+				  "granularity" : "PT1M",
+				  "groupId" : "12345678",
+				  "hostId" : "shard-00-00.mongodb.net:27017",
+				  "links" : [ {
+					"href" : "https://cloud.mongodb.com/api/atlas/v1.0/groups/12345678/processes/shard-00-00.mongodb.net:27017/measurements?granularity=PT1M&period=PT1M",
+					"rel" : "self"
+				  }, {
+					"href" : "https://cloud.mongodb.com/api/atlas/v1.0/groups/12345678/processes/shard-00-00.mongodb.net:27017",
+					"rel" : "http://mms.mongodb.com/host"
+				  } ],
+				  "measurements" : [ {
+					"dataPoints" : [ {
+					  "timestamp" : "2017-08-22T20:31:12Z",
+					  "value" : null
+					}, {
+					  "timestamp" : "2017-08-22T20:31:14Z",
+					  "value" : null
+					} ],
+					"name" : "DISK_PARTITION_IOPS_READ",
+					"units" : "SCALAR_PER_SECOND"
+				  }],
+                  "partitionName":"xvdb",
+				  "processId" : "shard-00-00.mongodb.net:27017",
+				  "start" : "2017-08-22T20:30:45Z"
+				}`)
+	})
+
+	opts := &ProcessMeasurementListOptions{
+		Granularity: "PT1M",
+		Period:      "PT1M",
+	}
+
+	measurements, _, err := client.ProcessDiskMeasurements.List(ctx, groups, host, port, disk, opts)
+	if err != nil {
+		t.Fatalf("Teams.Get returned error: %v", err)
+	}
+
+	expected := &ProcessDiskMeasurements{
+		ProcessMeasurements: &ProcessMeasurements{
+			End:         "2017-08-22T20:31:14Z",
+			Granularity: "PT1M",
+			GroupID:     "12345678",
+			HostID:      "shard-00-00.mongodb.net:27017",
+			Links: []*Link{
+				{
+					Rel:  "self",
+					Href: "https://cloud.mongodb.com/api/atlas/v1.0/groups/12345678/processes/shard-00-00.mongodb.net:27017/measurements?granularity=PT1M&period=PT1M",
+				},
+				{
+					Href: "https://cloud.mongodb.com/api/atlas/v1.0/groups/12345678/processes/shard-00-00.mongodb.net:27017",
+					Rel:  "http://mms.mongodb.com/host",
+				},
+			},
+			Measurements: []*Measurements{
+				{
+					DataPoints: []*DataPoints{
+						{
+							Timestamp: "2017-08-22T20:31:12Z",
+							Value:     nil,
+						},
+						{
+							Timestamp: "2017-08-22T20:31:14Z",
+							Value:     nil,
+						},
+					},
+					Name:  "DISK_PARTITION_IOPS_READ",
+					Units: "SCALAR_PER_SECOND",
+				},
+			},
+			ProcessID: "shard-00-00.mongodb.net:27017",
+			Start:     "2017-08-22T20:30:45Z",
+		},
+		PartitionName: "xvdb",
+	}
+
+	if diff := deep.Equal(measurements, expected); diff != nil {
+		t.Error(diff)
+	}
+}