INTMDB-263: Added Private_link_endpoint_adl resource to go-client (#271)

Author: abner-dou

mongodbatlas/data_lakes.go

@@ -20,7 +20,10 @@ import (
 	"net/http"
 )
 
-const dataLakesBasePath = "api/atlas/v1.0/groups"
+const (
+	dataLakesBasePath                = "api/atlas/v1.0/groups"
+	privateLinkEndpointsDataLakePath = "api/atlas/v1.0/groups/%s/privateNetworkSettings/endpointIds"
+)
 
 // DataLakeService is an interface for interfacing with the Data Lake endpoints of the MongoDB Atlas API.
 //
@@ -31,12 +34,18 @@ type DataLakeService interface {
 	Create(context.Context, string, *DataLakeCreateRequest) (*DataLake, *Response, error)
 	Update(context.Context, string, string, *DataLakeUpdateRequest) (*DataLake, *Response, error)
 	Delete(context.Context, string, string) (*Response, error)
+	CreatePrivateLinkEndpoint(context.Context, string, *PrivateLinkEndpointDataLake) (*PrivateLinkEndpointDataLakeResponse, *Response, error)
+	GetPrivateLinkEndpoint(context.Context, string, string) (*PrivateLinkEndpointDataLake, *Response, error)
+	ListPrivateLinkEndpoint(context.Context, string) (*PrivateLinkEndpointDataLakeResponse, *Response, error)
+	DeletePrivateLinkEndpoint(context.Context, string, string) (*Response, error)
 }
 
 // DataLakeServiceOp handles communication with the DataLakeService related methods of the
 // MongoDB Atlas API.
 type DataLakeServiceOp service
 
+var _ DataLakeService = &DataLakeServiceOp{}
+
 // AwsCloudProviderConfig is the data lake configuration for AWS.
 type AwsCloudProviderConfig struct {
 	ExternalID        string `json:"externalId,omitempty"`
@@ -126,6 +135,21 @@ type DataLakeCreateRequest struct {
 	CloudProviderConfig *CloudProviderConfig `json:"cloudProviderConfig,omitempty"`
 }
 
+// PrivateLinkEndpointDataLakeResponse represents MongoDB Private Endpoint Connection to DataLake.
+type PrivateLinkEndpointDataLakeResponse struct {
+	Links      []*Link                        `json:"links,omitempty"`
+	Results    []*PrivateLinkEndpointDataLake `json:"results"`
+	TotalCount int                            `json:"totalCount"`
+}
+
+// PrivateLinkEndpointDataLake represents the private link result for data lake.
+type PrivateLinkEndpointDataLake struct {
+	Comment    string `json:"comment,omitempty"`
+	EndpointID string `json:"endpointId,omitempty"`
+	Provider   string `json:"provider,omitempty"`
+	Type       string `json:"type,omitempty"`
+}
+
 // List gets all data lakes for the specified group.
 //
 // See more: https://docs.mongodb.com/datalake/reference/api/dataLakes-get-all-tenants
@@ -256,3 +280,104 @@ func (s *DataLakeServiceOp) Delete(ctx context.Context, groupID, name string) (*
 
 	return resp, err
 }
+
+// CreatePrivateLinkEndpoint creates one private link endpoint in Data Lake Atlas project.
+//
+// See more: https://docs.mongodb.com/datalake/reference/api/dataLakes-private-link-create-one/#std-label-api-pvt-link-create-one
+func (s *DataLakeServiceOp) CreatePrivateLinkEndpoint(ctx context.Context, groupID string, createRequest *PrivateLinkEndpointDataLake) (*PrivateLinkEndpointDataLakeResponse, *Response, error) {
+	if groupID == "" {
+		return nil, nil, NewArgError("groupID", "must be set")
+	}
+	if createRequest == nil {
+		return nil, nil, NewArgError("createRequest", "must be set")
+	}
+
+	path := fmt.Sprintf(privateLinkEndpointsDataLakePath, groupID)
+
+	req, err := s.Client.NewRequest(ctx, http.MethodPost, path, createRequest)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	root := new(PrivateLinkEndpointDataLakeResponse)
+	resp, err := s.Client.Do(ctx, req, root)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return root, resp, err
+}
+
+// DeletePrivateLinkEndpoint deletes the Data Lake private link endpoint with a given endpoint id.
+//
+// See more: https://docs.mongodb.com/datalake/reference/api/dataLakes-private-link-delete-one/#std-label-api-pvt-link-delete-one
+func (s *DataLakeServiceOp) DeletePrivateLinkEndpoint(ctx context.Context, groupID, endpointID string) (*Response, error) {
+	if groupID == "" {
+		return nil, NewArgError("groupId", "must be set")
+	}
+	if endpointID == "" {
+		return nil, NewArgError("endpointID", "must be set")
+	}
+
+	path := fmt.Sprintf("%s/%s", fmt.Sprintf(privateLinkEndpointsDataLakePath, groupID), endpointID)
+
+	req, err := s.Client.NewRequest(ctx, http.MethodDelete, path, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.Client.Do(ctx, req, nil)
+
+	return resp, err
+}
+
+// ListPrivateLinkEndpoint gets all private link endpoints for data lake for the specified group.
+//
+// See more: https://docs.atlas.mongodb.com/reference/api/online-archive-private-link-get-all/#std-label-api-online-archive-pvt-link-get-all
+func (s *DataLakeServiceOp) ListPrivateLinkEndpoint(ctx context.Context, groupID string) (*PrivateLinkEndpointDataLakeResponse, *Response, error) {
+	if groupID == "" {
+		return nil, nil, NewArgError("groupID", "must be set")
+	}
+
+	path := fmt.Sprintf(privateLinkEndpointsDataLakePath, groupID)
+
+	req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var root = new(PrivateLinkEndpointDataLakeResponse)
+	resp, err := s.Client.Do(ctx, req, root)
+	if err != nil {
+		return root, resp, err
+	}
+
+	return root, resp, nil
+}
+
+// GetPrivateLinkEndpoint gets the data lake private link endpoint associated with a specific group and endpointID.
+//
+// See more: https://docs.mongodb.com/datalake/reference/api/dataLakes-private-link-get-one/#std-label-api-pvt-link-get-one
+func (s *DataLakeServiceOp) GetPrivateLinkEndpoint(ctx context.Context, groupID, endpointID string) (*PrivateLinkEndpointDataLake, *Response, error) {
+	if groupID == "" {
+		return nil, nil, NewArgError("groupID", "must be set")
+	}
+	if endpointID == "" {
+		return nil, nil, NewArgError("endpointID", "must be set")
+	}
+
+	path := fmt.Sprintf("%s/%s", fmt.Sprintf(privateLinkEndpointsDataLakePath, groupID), endpointID)
+
+	req, err := s.Client.NewRequest(ctx, http.MethodGet, path, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	root := new(PrivateLinkEndpointDataLake)
+	resp, err := s.Client.Do(ctx, req, root)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return root, resp, err
+}

mongodbatlas/data_lakes_test.go

@@ -18,6 +18,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"reflect"
 	"testing"
 
 	"github.com/go-test/deep"
@@ -437,3 +438,185 @@ func TestDataLake_Delete(t *testing.T) {
 		t.Fatalf("DataLakes.Delete returned error: %v", err)
 	}
 }
+
+func TestDataLake_CreatePrivateLinkEndpoint(t *testing.T) {
+	client, mux, teardown := setup()
+	defer teardown()
+
+	groupID := "6c7498dg87d9e6526801572b"
+
+	path := fmt.Sprintf("/api/atlas/v1.0/groups/%s/privateNetworkSettings/endpointIds", groupID)
+
+	createRequest := &PrivateLinkEndpointDataLake{
+		EndpointID: "vpce-jjg5e24qp93513h03",
+		Type:       "DATA_LAKE",
+		Provider:   "AWS",
+		Comment:    "Private endpoint for Application Server A",
+	}
+
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		expected := map[string]interface{}{
+			"endpointId": "vpce-jjg5e24qp93513h03",
+			"type":       "DATA_LAKE",
+			"provider":   "AWS",
+			"comment":    "Private endpoint for Application Server A",
+		}
+
+		var v map[string]interface{}
+		err := json.NewDecoder(r.Body).Decode(&v)
+		if err != nil {
+			t.Fatalf("decode json: %v", err)
+		}
+
+		if diff := deep.Equal(v, expected); diff != nil {
+			t.Errorf("Request body\n got=%#v\nwant=%#v \n\ndiff=%#v", v, expected, diff)
+		}
+
+		fmt.Fprint(w, `{
+  "links" : [ {
+    "href" : "https://cloud.mongodb.com/api/atlas/v1.0/groups/6c7498dg87d9e6526801572b/privateNetworkSettings/endpointIds?pretty=true&pageNum=1&itemsPerPage=100",
+    "rel" : "self"
+  } ],
+  "results" : [ {
+    "comment" : "Private endpoint for Application Server A",
+    "endpointId" : "vpce-jjg5e24qp93513h03",
+    "provider" : "AWS",
+    "type" : "DATA_LAKE"
+  } ],
+  "totalCount" : 1
+}`)
+	})
+
+	privateEndpointConnection, _, err := client.DataLakes.CreatePrivateLinkEndpoint(ctx, groupID, createRequest)
+	if err != nil {
+		t.Errorf("DataLakes.CreatePrivateLinkEndpoint returned error: %v", err)
+		return
+	}
+
+	expected := &PrivateLinkEndpointDataLakeResponse{
+		Results: []*PrivateLinkEndpointDataLake{
+			{
+				EndpointID: "vpce-jjg5e24qp93513h03",
+				Type:       "DATA_LAKE",
+				Provider:   "AWS",
+				Comment:    "Private endpoint for Application Server A",
+			},
+		},
+		Links: []*Link{
+			{
+				Href: "https://cloud.mongodb.com/api/atlas/v1.0/groups/6c7498dg87d9e6526801572b/privateNetworkSettings/endpointIds?pretty=true&pageNum=1&itemsPerPage=100",
+				Rel:  "self",
+			},
+		},
+		TotalCount: 1,
+	}
+
+	if !reflect.DeepEqual(privateEndpointConnection, expected) {
+		t.Errorf("DataLakes.CreatePrivateLinkEndpoint\n got=%#v\nwant=%#v", privateEndpointConnection, expected)
+	}
+}
+
+func TestDataLake_GetPrivateLinkEndpoint(t *testing.T) {
+	client, mux, teardown := setup()
+	defer teardown()
+
+	groupID := "6c7498dg87d9e6526801572b"
+	path := fmt.Sprintf("/api/atlas/v1.0/groups/%s/privateNetworkSettings/endpointIds/1", groupID)
+
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, http.MethodGet)
+		fmt.Fprint(w, `{
+   "comment" : "Private endpoint for Application Server A",
+   "endpointId" : "vpce-jjg5e24qp93513h03",
+   "provider" : "AWS",
+   "type" : "DATA_LAKE"
+}`)
+	})
+
+	privateLinkEndpointADL, _, err := client.DataLakes.GetPrivateLinkEndpoint(ctx, groupID, "1")
+	if err != nil {
+		t.Fatalf("DataLakes.GetPrivateLinkEndpoint returned error: %v", err)
+	}
+
+	expected := PrivateLinkEndpointDataLake{
+		Comment:    "Private endpoint for Application Server A",
+		EndpointID: "vpce-jjg5e24qp93513h03",
+		Provider:   "AWS",
+		Type:       "DATA_LAKE",
+	}
+
+	if diff := deep.Equal(privateLinkEndpointADL, &expected); diff != nil {
+		t.Error(diff)
+	}
+}
+
+func TestDataLake_ListPrivateLinkEndpoint(t *testing.T) {
+	client, mux, teardown := setup()
+	defer teardown()
+
+	groupID := "6c7498dg87d9e6526801572b"
+
+	path := fmt.Sprintf("/api/atlas/v1.0/groups/%s/privateNetworkSettings/endpointIds", groupID)
+
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, http.MethodGet)
+		fmt.Fprint(w, `{
+  "links" : [ {
+    "href" : "https://cloud.mongodb.com/api/atlas/v1.0/groups/6c7498dg87d9e6526801572b/privateNetworkSettings/endpointIds?pretty=true&pageNum=1&itemsPerPage=100",
+     "rel" : "self"
+  } ],
+  "results" : [ {
+    "comment" : "Private endpoint for Application Server A",
+    "endpointId" : "vpce-jjg5e24qp93513h03",
+     "provider" : "AWS",
+     "type" : "DATA_LAKE"
+   } ],
+   "totalCount" : 1
+ }`)
+	})
+
+	privateLinkEndpoints, _, err := client.DataLakes.ListPrivateLinkEndpoint(ctx, groupID)
+	if err != nil {
+		t.Fatalf("DataLakes.ListPrivateLinkEndpoint returned error: %v", err)
+	}
+
+	expected := &PrivateLinkEndpointDataLakeResponse{
+		Results: []*PrivateLinkEndpointDataLake{
+			{
+				EndpointID: "vpce-jjg5e24qp93513h03",
+				Type:       "DATA_LAKE",
+				Provider:   "AWS",
+				Comment:    "Private endpoint for Application Server A",
+			},
+		},
+		Links: []*Link{
+			{
+				Href: "https://cloud.mongodb.com/api/atlas/v1.0/groups/6c7498dg87d9e6526801572b/privateNetworkSettings/endpointIds?pretty=true&pageNum=1&itemsPerPage=100",
+				Rel:  "self",
+			},
+		},
+		TotalCount: 1,
+	}
+
+	if !reflect.DeepEqual(privateLinkEndpoints, expected) {
+		t.Errorf("DataLakes.ListPrivateLinkEndpoint\n got=%#v\nwant=%#v", privateLinkEndpoints, expected)
+	}
+}
+
+func TestDataLake_DeletePrivateLinkEndpoint(t *testing.T) {
+	client, mux, teardown := setup()
+	defer teardown()
+
+	groupID := "6c7498dg87d9e6526801572b"
+
+	path := fmt.Sprintf("/api/atlas/v1.0/groups/%s/privateNetworkSettings/endpointIds/1", groupID)
+
+	mux.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, http.MethodDelete)
+	})
+
+	_, err := client.DataLakes.DeletePrivateLinkEndpoint(ctx, groupID, "1")
+	if err != nil {
+		t.Errorf("DataLakes.DeletePrivateLinkEndpoint returned error: %v", err)
+	}
+}