From fd6dfb58c5403c904fc0f2080f4fe649dad461dd Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 1 Apr 2020 19:11:50 +0100 Subject: [PATCH 1/5] CLOUDP-57849:List events, Atlas --- Makefile | 1 + e2e/atlas_events_test.go | 103 ++++++++++++++++++ internal/cli/atlas.go | 1 + internal/cli/atlas_events.go | 32 ++++++ internal/cli/atlas_events_list.go | 114 ++++++++++++++++++++ internal/cli/atlas_events_list_test.go | 59 +++++++++++ internal/description/description.go | 2 + internal/fixtures/events.go | 39 +++++++ internal/flags/flags.go | 5 +- internal/mocks/mock_events.go | 140 +++++++++++++++++++++++++ internal/store/events.go | 58 ++++++++++ internal/usage/usage.go | 3 + 12 files changed, 556 insertions(+), 1 deletion(-) create mode 100644 e2e/atlas_events_test.go create mode 100644 internal/cli/atlas_events.go create mode 100644 internal/cli/atlas_events_list.go create mode 100644 internal/cli/atlas_events_list_test.go create mode 100644 internal/fixtures/events.go create mode 100644 internal/mocks/mock_events.go create mode 100644 internal/store/events.go diff --git a/Makefile b/Makefile index 6a8f33a69d..677cc3792a 100644 --- a/Makefile +++ b/Makefile @@ -64,6 +64,7 @@ gen-mocks: ## Generate mocks mockgen -source=internal/store/checkpoints.go -destination=internal/mocks/mock_checkpoints.go -package=mocks mockgen -source=internal/store/alerts.go -destination=internal/mocks/mock_alerts.go -package=mocks mockgen -source=internal/store/global_alerts.go -destination=internal/mocks/mock_global_alerts.go -package=mocks + mockgen -source=internal/store/events.go -destination=internal/mocks/mock_events.go -package=mocks .PHONY: build build: ## Generate a binary in ./bin diff --git a/e2e/atlas_events_test.go b/e2e/atlas_events_test.go new file mode 100644 index 0000000000..7cb2484a24 --- /dev/null +++ b/e2e/atlas_events_test.go @@ -0,0 +1,103 @@ +// Copyright 2020 MongoDB Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +build e2e + +package e2e_test + +import ( + "encoding/json" + "os" + "os/exec" + "path/filepath" + "testing" + + "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" +) + +func TestAtlasEvents(t *testing.T) { + cliPath, err := filepath.Abs("../bin/mongocli") + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + _, err = os.Stat(cliPath) + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + atlasEntity := "atlas" + eventsEntity := "events" + + t.Run("ListProjectEvent", func(t *testing.T) { + + cmd := exec.Command(cliPath, + atlasEntity, + eventsEntity, + "list", + "--projectId=5e429f2e06822c6eac4d59c9", + "--source=project", + ) + + cmd.Env = os.Environ() + resp, err := cmd.CombinedOutput() + + if err != nil { + t.Fatalf("unexpected error: %v, resp: %v", err, string(resp)) + } + + events := mongodbatlas.EventResponse{} + err = json.Unmarshal(resp, &events) + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if len(events.Results) == 0 { + t.Errorf("got=%#v\nwant>0\n", len(events.Results)) + } + + }) + + t.Run("ListOrganizationEvent", func(t *testing.T) { + + cmd := exec.Command(cliPath, + atlasEntity, + eventsEntity, + "list", + "--projectId=5e429e7706822c6eac4d5970", + "--source=organization", + "--minDate=2020-04-01", + ) + + cmd.Env = os.Environ() + resp, err := cmd.CombinedOutput() + + if err != nil { + t.Fatalf("unexpected error: %v, resp: %v", err, string(resp)) + } + + events := mongodbatlas.EventResponse{} + err = json.Unmarshal(resp, &events) + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if len(events.Results) == 0 { + t.Errorf("got=%#v\nwant>0\n", len(events.Results)) + } + + }) + +} diff --git a/internal/cli/atlas.go b/internal/cli/atlas.go index 68679f9e5b..cddcf865ad 100644 --- a/internal/cli/atlas.go +++ b/internal/cli/atlas.go @@ -29,6 +29,7 @@ func AtlasBuilder() *cobra.Command { cmd.AddCommand(AtlasWhitelistBuilder()) cmd.AddCommand(AtlasAlertsBuilder()) cmd.AddCommand(AtlasBackupsBuilder()) + cmd.AddCommand(AtlasEventsBuilder()) return cmd } diff --git a/internal/cli/atlas_events.go b/internal/cli/atlas_events.go new file mode 100644 index 0000000000..86ae8c33cc --- /dev/null +++ b/internal/cli/atlas_events.go @@ -0,0 +1,32 @@ +// Copyright 2020 MongoDB Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package cli + +import ( + "github.com/mongodb/mongocli/internal/description" + "github.com/spf13/cobra" +) + +func AtlasEventsBuilder() *cobra.Command { + cmd := &cobra.Command{ + Use: "events", + Aliases: []string{"event"}, + Short: description.Events, + } + + cmd.AddCommand(AtlasEventsListBuilder()) + + return cmd +} diff --git a/internal/cli/atlas_events_list.go b/internal/cli/atlas_events_list.go new file mode 100644 index 0000000000..3a0fcf4f46 --- /dev/null +++ b/internal/cli/atlas_events_list.go @@ -0,0 +1,114 @@ +// Copyright 2020 MongoDB Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +package cli + +import ( + "errors" + "strings" + + atlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" + "github.com/mongodb/mongocli/internal/description" + "github.com/mongodb/mongocli/internal/flags" + "github.com/mongodb/mongocli/internal/json" + "github.com/mongodb/mongocli/internal/store" + "github.com/mongodb/mongocli/internal/usage" + "github.com/spf13/cobra" +) + +type atlasEventsListOpts struct { + *globalOpts + pageNum int + itemsPerPage int + source string + eventType string + minDate string + maxDate string + store store.EventsStore +} + +func (opts *atlasEventsListOpts) init() error { + if opts.ProjectID() == "" { + return errMissingProjectID + } + + var err error + opts.store, err = store.New() + return err +} + +func (opts *atlasEventsListOpts) Run() error { + listOpts := opts.newEventListOptions() + + var result *atlas.EventResponse + var err error + + source := strings.ToLower(opts.source) + switch source { + case "organization": + result, err = opts.store.OrganizationEvents(opts.projectID, listOpts) + case "project": + result, err = opts.store.ProjectEvents(opts.projectID, &listOpts.ListOptions) + default: + return errors.New("--source must be project or organization") + } + + if err != nil { + return err + } + + return json.PrettyPrint(result) +} + +func (opts *atlasEventsListOpts) newEventListOptions() *atlas.EventListOptions { + + return &atlas.EventListOptions{ + ListOptions: atlas.ListOptions{ + PageNum: opts.pageNum, + ItemsPerPage: opts.itemsPerPage, + }, + EventType: opts.eventType, + MinDate: opts.minDate, + MaxDate: opts.maxDate, + } +} + +// mongocli atlas event(s) list [--projectId projectId] [--source source][--type type] [--page N] [--limit N] +func AtlasEventsListBuilder() *cobra.Command { + opts := &atlasEventsListOpts{ + globalOpts: newGlobalOpts(), + } + cmd := &cobra.Command{ + Use: "list", + Short: description.ListEvents, + Aliases: []string{"ls"}, + Args: cobra.NoArgs, + PreRunE: func(cmd *cobra.Command, args []string) error { + return opts.init() + }, + RunE: func(cmd *cobra.Command, args []string) error { + return opts.Run() + }, + } + + cmd.Flags().IntVar(&opts.pageNum, flags.Page, 0, usage.Page) + cmd.Flags().IntVar(&opts.itemsPerPage, flags.Limit, 0, usage.Limit) + cmd.Flags().StringVar(&opts.source, flags.Source, "organization", usage.Source) + cmd.Flags().StringVar(&opts.eventType, flags.Type, "", usage.Event) + cmd.Flags().StringVar(&opts.maxDate, flags.MaxDate, "", usage.MaxDate) + cmd.Flags().StringVar(&opts.minDate, flags.MinDate, "", usage.MaxDate) + + cmd.Flags().StringVar(&opts.projectID, flags.ProjectID, "", usage.ProjectID) + + return cmd +} diff --git a/internal/cli/atlas_events_list_test.go b/internal/cli/atlas_events_list_test.go new file mode 100644 index 0000000000..759c09f1fa --- /dev/null +++ b/internal/cli/atlas_events_list_test.go @@ -0,0 +1,59 @@ +package cli + +import ( + "testing" + + "github.com/golang/mock/gomock" + "github.com/mongodb/mongocli/internal/fixtures" + "github.com/mongodb/mongocli/internal/mocks" +) + +func TestAtlasOrganizationEventsList_Run(t *testing.T) { + ctrl := gomock.NewController(t) + mockStore := mocks.NewMockEventsStore(ctrl) + + defer ctrl.Finish() + + expected := fixtures.Events() + + listOpts := &atlasEventsListOpts{ + globalOpts: newGlobalOpts(), + source: "organization", + store: mockStore, + } + + mockStore. + EXPECT().OrganizationEvents(listOpts.projectID, listOpts.newEventListOptions()). + Return(expected, nil). + Times(1) + + err := listOpts.Run() + if err != nil { + t.Fatalf("Run() unexpected error: %v", err) + } +} + +func TestAtlasProjectEventsList_Run(t *testing.T) { + ctrl := gomock.NewController(t) + mockStore := mocks.NewMockEventsStore(ctrl) + + defer ctrl.Finish() + + expected := fixtures.Events() + + listOpts := &atlasEventsListOpts{ + globalOpts: newGlobalOpts(), + source: "project", + store: mockStore, + } + + mockStore. + EXPECT().ProjectEvents(listOpts.projectID, &listOpts.newEventListOptions().ListOptions). + Return(expected, nil). + Times(1) + + err := listOpts.Run() + if err != nil { + t.Fatalf("Run() unexpected error: %v", err) + } +} diff --git a/internal/description/description.go b/internal/description/description.go index b9c749d551..af92b6cf14 100644 --- a/internal/description/description.go +++ b/internal/description/description.go @@ -51,6 +51,7 @@ A user’s roles apply to all the clusters in the project.` CreateDBUser = "Create a database user for a project." DeleteDBUser = "Delete a database user for a project." ListDBUsers = "List Atlas database users for a project." + ListEvents = "List events for an organization or project" UpdateDBUser = "Update a MongoDB dbuser in Atlas." Whitelist = "Manage the IP whitelist for a project." CreateWhitelist = "Create an IP whitelist for a project." @@ -85,4 +86,5 @@ A user’s roles apply to all the clusters in the project.` ListServer = "List all available servers running an automation agent for the given project." Security = "Manage clusters security configuration." EnableSecurity = "Enable authentication mechanisms for the project." + Events = "Manage events for your project." ) diff --git a/internal/fixtures/events.go b/internal/fixtures/events.go new file mode 100644 index 0000000000..f0dc959c09 --- /dev/null +++ b/internal/fixtures/events.go @@ -0,0 +1,39 @@ +package fixtures + +import atlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" + +func Event() *atlas.Event { + return &atlas.Event{ + Created: "2018-06-19T15:06:15Z", + EventTypeName: "JOINED_ORG", + ID: "5b48f4d2d7e33a1c0c60597e", + IsGlobalAdmin: false, + Links: []*atlas.Link{ + { + Rel: "http://mms.mongodb.com/org", + Href: "https://cloud.mongodb.com/api/atlas/v1.0/orgs/5b478b3afc4625789ce616a3", + }, + { + Rel: "http://mms.mongodb.com/org", + Href: "https://cloud.mongodb.com/api/atlas/v1.0/users/6b610e1087d9d66b272f0c86", + }, + { + Rel: "http://mms.mongodb.com/org", + Href: "https://cloud.mongodb.com/api/atlas/v1.0/orgs/5b478b3afc4625789ce616a3/events/5b48f4d2d7e33a1c0c60597e", + }, + }, + OrgID: "5b478b3afc4625789ce616a3", + RemoteAddress: "198.51.100.64", + TargetUsername: "j.doe@example.com", + UserID: "6b610e1087d9d66b272f0c86", + Username: "j.doe@example.com", + } +} + +func Events() *atlas.EventResponse { + return &atlas.EventResponse{ + Links: []*atlas.Link{}, + Results: []*atlas.Event{Event()}, + TotalCount: 1, + } +} diff --git a/internal/flags/flags.go b/internal/flags/flags.go index 847308623a..55c0e55a82 100644 --- a/internal/flags/flags.go +++ b/internal/flags/flags.go @@ -86,5 +86,8 @@ const ( PointInTimeUTCMillis = "pointInTimeUTCMillis" // PointInTimeUTCMillis flag Expires = "expires" // Expires flag MaxDownloads = "maxDownloads" // MaxDownloads flag - ExpirationHours = "expirationHours" // ExpirationHours + ExpirationHours = "expirationHours" // ExpirationHours flag + Source = "source" // Source flag + MaxDate = "maxDate" // MaxDate flag + MinDate = "minDate" // MinDate flag ) diff --git a/internal/mocks/mock_events.go b/internal/mocks/mock_events.go new file mode 100644 index 0000000000..549945d962 --- /dev/null +++ b/internal/mocks/mock_events.go @@ -0,0 +1,140 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: internal/store/events.go + +// Package mocks is a generated GoMock package. +package mocks + +import ( + gomock "github.com/golang/mock/gomock" + mongodbatlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" + reflect "reflect" +) + +// MockOrganizationEventLister is a mock of OrganizationEventLister interface +type MockOrganizationEventLister struct { + ctrl *gomock.Controller + recorder *MockOrganizationEventListerMockRecorder +} + +// MockOrganizationEventListerMockRecorder is the mock recorder for MockOrganizationEventLister +type MockOrganizationEventListerMockRecorder struct { + mock *MockOrganizationEventLister +} + +// NewMockOrganizationEventLister creates a new mock instance +func NewMockOrganizationEventLister(ctrl *gomock.Controller) *MockOrganizationEventLister { + mock := &MockOrganizationEventLister{ctrl: ctrl} + mock.recorder = &MockOrganizationEventListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockOrganizationEventLister) EXPECT() *MockOrganizationEventListerMockRecorder { + return m.recorder +} + +// OrganizationEvents mocks base method +func (m *MockOrganizationEventLister) OrganizationEvents(arg0 string, arg1 *mongodbatlas.EventListOptions) (*mongodbatlas.EventResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationEvents", arg0, arg1) + ret0, _ := ret[0].(*mongodbatlas.EventResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OrganizationEvents indicates an expected call of OrganizationEvents +func (mr *MockOrganizationEventListerMockRecorder) OrganizationEvents(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationEvents", reflect.TypeOf((*MockOrganizationEventLister)(nil).OrganizationEvents), arg0, arg1) +} + +// MockProjectEventLister is a mock of ProjectEventLister interface +type MockProjectEventLister struct { + ctrl *gomock.Controller + recorder *MockProjectEventListerMockRecorder +} + +// MockProjectEventListerMockRecorder is the mock recorder for MockProjectEventLister +type MockProjectEventListerMockRecorder struct { + mock *MockProjectEventLister +} + +// NewMockProjectEventLister creates a new mock instance +func NewMockProjectEventLister(ctrl *gomock.Controller) *MockProjectEventLister { + mock := &MockProjectEventLister{ctrl: ctrl} + mock.recorder = &MockProjectEventListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockProjectEventLister) EXPECT() *MockProjectEventListerMockRecorder { + return m.recorder +} + +// ProjectEvents mocks base method +func (m *MockProjectEventLister) ProjectEvents(arg0 string, arg1 *mongodbatlas.ListOptions) (*mongodbatlas.EventResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProjectEvents", arg0, arg1) + ret0, _ := ret[0].(*mongodbatlas.EventResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectEvents indicates an expected call of ProjectEvents +func (mr *MockProjectEventListerMockRecorder) ProjectEvents(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectEvents", reflect.TypeOf((*MockProjectEventLister)(nil).ProjectEvents), arg0, arg1) +} + +// MockEventsStore is a mock of EventsStore interface +type MockEventsStore struct { + ctrl *gomock.Controller + recorder *MockEventsStoreMockRecorder +} + +// MockEventsStoreMockRecorder is the mock recorder for MockEventsStore +type MockEventsStoreMockRecorder struct { + mock *MockEventsStore +} + +// NewMockEventsStore creates a new mock instance +func NewMockEventsStore(ctrl *gomock.Controller) *MockEventsStore { + mock := &MockEventsStore{ctrl: ctrl} + mock.recorder = &MockEventsStoreMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockEventsStore) EXPECT() *MockEventsStoreMockRecorder { + return m.recorder +} + +// OrganizationEvents mocks base method +func (m *MockEventsStore) OrganizationEvents(arg0 string, arg1 *mongodbatlas.EventListOptions) (*mongodbatlas.EventResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationEvents", arg0, arg1) + ret0, _ := ret[0].(*mongodbatlas.EventResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OrganizationEvents indicates an expected call of OrganizationEvents +func (mr *MockEventsStoreMockRecorder) OrganizationEvents(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationEvents", reflect.TypeOf((*MockEventsStore)(nil).OrganizationEvents), arg0, arg1) +} + +// ProjectEvents mocks base method +func (m *MockEventsStore) ProjectEvents(arg0 string, arg1 *mongodbatlas.ListOptions) (*mongodbatlas.EventResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ProjectEvents", arg0, arg1) + ret0, _ := ret[0].(*mongodbatlas.EventResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectEvents indicates an expected call of ProjectEvents +func (mr *MockEventsStoreMockRecorder) ProjectEvents(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectEvents", reflect.TypeOf((*MockEventsStore)(nil).ProjectEvents), arg0, arg1) +} diff --git a/internal/store/events.go b/internal/store/events.go new file mode 100644 index 0000000000..1f0d8ed781 --- /dev/null +++ b/internal/store/events.go @@ -0,0 +1,58 @@ +// Copyright 2020 MongoDB Inc +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package store + +import ( + "context" + "fmt" + + atlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" + "github.com/mongodb/mongocli/internal/config" +) + +type OrganizationEventLister interface { + OrganizationEvents(string, *atlas.EventListOptions) (*atlas.EventResponse, error) +} + +type ProjectEventLister interface { + ProjectEvents(string, *atlas.ListOptions) (*atlas.EventResponse, error) +} + +type EventsStore interface { + OrganizationEventLister + ProjectEventLister +} + +// ProjectEvents encapsulate the logic to manage different cloud providers +func (s *Store) ProjectEvents(projectID string, opts *atlas.ListOptions) (*atlas.EventResponse, error) { + switch s.service { + case config.CloudService: + result, _, err := s.client.(*atlas.Client).Events.ListProjectEvents(context.Background(), projectID, opts) + return result, err + default: + return nil, fmt.Errorf("unsupported service: %s", s.service) + } +} + +// OrganizationEvents encapsulate the logic to manage different cloud providers +func (s *Store) OrganizationEvents(projectID string, opts *atlas.EventListOptions) (*atlas.EventResponse, error) { + switch s.service { + case config.CloudService: + result, _, err := s.client.(*atlas.Client).Events.ListOrganizationEvents(context.Background(), projectID, opts) + return result, err + default: + return nil, fmt.Errorf("unsupported service: %s", s.service) + } +} diff --git a/internal/usage/usage.go b/internal/usage/usage.go index 20ec41806e..77b363dbb9 100644 --- a/internal/usage/usage.go +++ b/internal/usage/usage.go @@ -25,6 +25,7 @@ const ( MDBVersion = "MongoDB version of the cluster to deploy." AuthDB = "Authentication database name." Page = "Page number." + Source = "The source where listing events." Status = "Alert's status." Until = "Acknowledged until a date." Limit = "Number of items per page." @@ -36,6 +37,8 @@ const ( Email = "User’s email address." FirstName = "User’s first name." LastName = "User’s last name." + MaxDate = "Returns events whose created date is less than or equal to it." + MinDate = "Returns events whose created date is greater than or equal to it." Filename = "Filename to use" WhitelistIps = "IP addresses to add to the new user’s whitelist." Event = "Type of event that will trigger an alert." From 84b2dd8468b807a8423f8d82b5d6f03b8bd47991 Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Wed, 1 Apr 2020 19:18:19 +0100 Subject: [PATCH 2/5] added missing comment --- internal/cli/atlas_events_list.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/cli/atlas_events_list.go b/internal/cli/atlas_events_list.go index 3a0fcf4f46..d5f7037932 100644 --- a/internal/cli/atlas_events_list.go +++ b/internal/cli/atlas_events_list.go @@ -83,7 +83,7 @@ func (opts *atlasEventsListOpts) newEventListOptions() *atlas.EventListOptions { } } -// mongocli atlas event(s) list [--projectId projectId] [--source source][--type type] [--page N] [--limit N] +// mongocli atlas event(s) list [--projectId projectId] [--source source][--type type] [--page N] [--limit N] [--mindate minDate] [--maxDate maxDate] func AtlasEventsListBuilder() *cobra.Command { opts := &atlasEventsListOpts{ globalOpts: newGlobalOpts(), From 3921968fc4bf50ad9a04908b0e0e5565b5d9d7cc Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Thu, 2 Apr 2020 10:06:39 +0100 Subject: [PATCH 3/5] CLOUDP-57850: List events, C/OM --- internal/cli/cloud_manager.go | 1 + internal/cli/ops_manager.go | 1 + internal/store/events.go | 7 +++++++ 3 files changed, 9 insertions(+) diff --git a/internal/cli/cloud_manager.go b/internal/cli/cloud_manager.go index e12d16a37e..ce4791577e 100644 --- a/internal/cli/cloud_manager.go +++ b/internal/cli/cloud_manager.go @@ -33,6 +33,7 @@ func CloudManagerBuilder() *cobra.Command { cmd.AddCommand(OpsManagerAutomationBuilder()) cmd.AddCommand(OpsManagerSecurityBuilder()) cmd.AddCommand(OpsManagerDBUsersBuilder()) + cmd.AddCommand(AtlasEventsBuilder()) return cmd } diff --git a/internal/cli/ops_manager.go b/internal/cli/ops_manager.go index 52b896fab4..8c0e153121 100644 --- a/internal/cli/ops_manager.go +++ b/internal/cli/ops_manager.go @@ -34,6 +34,7 @@ func OpsManagerBuilder() *cobra.Command { cmd.AddCommand(OpsManagerSecurityBuilder()) cmd.AddCommand(OpsManagerDBUsersBuilder()) cmd.AddCommand(OpsManagerOwnerBuilder()) + cmd.AddCommand(AtlasEventsBuilder()) return cmd } diff --git a/internal/store/events.go b/internal/store/events.go index 1f0d8ed781..98eb486e03 100644 --- a/internal/store/events.go +++ b/internal/store/events.go @@ -19,6 +19,7 @@ import ( "fmt" atlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" + om "github.com/mongodb/go-client-mongodb-ops-manager/opsmngr" "github.com/mongodb/mongocli/internal/config" ) @@ -41,6 +42,9 @@ func (s *Store) ProjectEvents(projectID string, opts *atlas.ListOptions) (*atlas case config.CloudService: result, _, err := s.client.(*atlas.Client).Events.ListProjectEvents(context.Background(), projectID, opts) return result, err + case config.OpsManagerService, config.CloudManagerService: + result, _, err := s.client.(*om.Client).Events.ListProjectEvents(context.Background(), projectID, opts) + return result, err default: return nil, fmt.Errorf("unsupported service: %s", s.service) } @@ -52,6 +56,9 @@ func (s *Store) OrganizationEvents(projectID string, opts *atlas.EventListOption case config.CloudService: result, _, err := s.client.(*atlas.Client).Events.ListOrganizationEvents(context.Background(), projectID, opts) return result, err + case config.OpsManagerService, config.CloudManagerService: + result, _, err := s.client.(*om.Client).Events.ListOrganizationEvents(context.Background(), projectID, opts) + return result, err default: return nil, fmt.Errorf("unsupported service: %s", s.service) } From a27d7e1e9b23fda792bba89597af33f7819e31c4 Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Thu, 2 Apr 2020 16:59:05 +0100 Subject: [PATCH 4/5] Refactoring --- internal/store/events.go | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/internal/store/events.go b/internal/store/events.go index 0df7de0d26..6d41b33f34 100644 --- a/internal/store/events.go +++ b/internal/store/events.go @@ -19,10 +19,7 @@ import ( "fmt" atlas "github.com/mongodb/go-client-mongodb-atlas/mongodbatlas" -<<<<<<< HEAD om "github.com/mongodb/go-client-mongodb-ops-manager/opsmngr" -======= ->>>>>>> origin/master "github.com/mongodb/mongocli/internal/config" ) @@ -54,13 +51,13 @@ func (s *Store) ProjectEvents(projectID string, opts *atlas.ListOptions) (*atlas } // OrganizationEvents encapsulate the logic to manage different cloud providers -func (s *Store) OrganizationEvents(projectID string, opts *atlas.EventListOptions) (*atlas.EventResponse, error) { +func (s *Store) OrganizationEvents(orgID string, opts *atlas.EventListOptions) (*atlas.EventResponse, error) { switch s.service { case config.CloudService: - result, _, err := s.client.(*atlas.Client).Events.ListOrganizationEvents(context.Background(), projectID, opts) + result, _, err := s.client.(*atlas.Client).Events.ListOrganizationEvents(context.Background(), orgID, opts) return result, err case config.OpsManagerService, config.CloudManagerService: - result, _, err := s.client.(*om.Client).Events.ListOrganizationEvents(context.Background(), projectID, opts) + result, _, err := s.client.(*om.Client).Events.ListOrganizationEvents(context.Background(), orgID, opts) return result, err default: return nil, fmt.Errorf("unsupported service: %s", s.service) From 1fe0c6ba0072978a816644b16664289eacfff226 Mon Sep 17 00:00:00 2001 From: andreaangiolillo Date: Thu, 2 Apr 2020 17:00:39 +0100 Subject: [PATCH 5/5] Refactoring --- internal/cli/atlas_events_list.go | 2 +- internal/usage/usage.go | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/internal/cli/atlas_events_list.go b/internal/cli/atlas_events_list.go index 5184ea3ac7..67d4f3d91c 100644 --- a/internal/cli/atlas_events_list.go +++ b/internal/cli/atlas_events_list.go @@ -98,7 +98,7 @@ func AtlasEventsListBuilder() *cobra.Command { cmd.Flags().StringVar(&opts.eventType, flags.Type, "", usage.Event) cmd.Flags().StringVar(&opts.maxDate, flags.MaxDate, "", usage.MaxDate) - cmd.Flags().StringVar(&opts.minDate, flags.MinDate, "", usage.MaxDate) + cmd.Flags().StringVar(&opts.minDate, flags.MinDate, "", usage.MinDate) cmd.Flags().StringVar(&opts.projectID, flags.ProjectID, "", usage.ProjectID) cmd.Flags().StringVar(&opts.orgID, flags.OrgID, "", usage.OrgID) diff --git a/internal/usage/usage.go b/internal/usage/usage.go index 77b363dbb9..43d35cc18a 100644 --- a/internal/usage/usage.go +++ b/internal/usage/usage.go @@ -25,7 +25,6 @@ const ( MDBVersion = "MongoDB version of the cluster to deploy." AuthDB = "Authentication database name." Page = "Page number." - Source = "The source where listing events." Status = "Alert's status." Until = "Acknowledged until a date." Limit = "Number of items per page."