From: Irina Date: Sun, 22 Dec 2019 09:14:46 +0000 (+0200) Subject: RICPLT-2727 - E2 Initialized (Routing Manager) X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F92%2F2092%2F1;p=ric-plt%2Fe2mgr.git RICPLT-2727 - E2 Initialized (Routing Manager) Change-Id: If962ee9f750633bf4cc26999c94f47526e6ad0f4 Signed-off-by: Irina --- diff --git a/Automation/Tests/Resource/Keywords.robot b/Automation/Tests/Resource/Keywords.robot index 92f2e83..241d006 100755 --- a/Automation/Tests/Resource/Keywords.robot +++ b/Automation/Tests/Resource/Keywords.robot @@ -57,6 +57,7 @@ Remove log files Remove File ${EXECDIR}/${e2t_log_filename} Remove File ${EXECDIR}/${rsm_log_filename} Remove File ${EXECDIR}/${e2e_simu_log_filename} + Remove File ${EXECDIR}/${rm_sim_log_filename} Remove File ${EXECDIR}/${e2adapter_log_filename} Save logs @@ -66,6 +67,7 @@ Save logs Run ${Save_e2t_log} Run ${Save_rsm_log} Run ${Save_e2e_simu_log} + Run ${Save_rm_sim_log} Run ${Save_e2adapter_log} @@ -94,24 +96,28 @@ Prepare Enviorment ${gnb_log_filename} Evaluate "gnb.${SUITE NAME}.log".replace(" ","-") ${rsm_log_filename} Evaluate "rsm.${SUITE NAME}.log".replace(" ","-") ${e2e_simu_log_filename} Evaluate "e2e_simu.${SUITE NAME}.log".replace(" ","-") + ${rm_sim_log_filename} Evaluate "rm_sim.${SUITE NAME}.log".replace(" ","-") ${e2adapter_log_filename} Evaluate "e2adapter.${SUITE NAME}.log".replace(" ","-") ${Save_sim_log} Evaluate 'docker logs --since ${starting_timestamp} gnbe2_simu > ${gnb_log_filename}' ${Save_e2mgr_log} Evaluate 'docker logs --since ${starting_timestamp} e2mgr > ${e2mgr_log_filename}' ${Save_e2t_log} Evaluate 'docker logs --since ${starting_timestamp} e2 > ${e2t_log_filename}' ${Save_rsm_log} Evaluate 'docker logs --since ${starting_timestamp} rsm > ${rsm_log_filename}' ${Save_e2e_simu_log} Evaluate 'docker logs --since ${starting_timestamp} e2e_simu > ${e2e_simu_log_filename}' + ${Save_rm_sim_log} Evaluate 'docker logs --since ${starting_timestamp} rm_sim > ${rm_sim_log_filename}' ${Save_e2adapter_log} Evaluate 'docker logs --since ${starting_timestamp} e2adapter > ${e2adapter_log_filename}' Set Suite Variable ${e2t_log_filename} Set Suite Variable ${e2mgr_log_filename} Set Suite Variable ${gnb_log_filename} Set Suite Variable ${rsm_log_filename} - Set Suite Variable ${e2e_simu_log_filename} + Set Suite Variable ${e2e_simu_log_filename} + Set Suite Variable ${rm_sim_log_filename} Set Suite Variable ${e2adapter_log_filename} Set Suite Variable ${Save_sim_log} Set Suite Variable ${Save_e2mgr_log} Set Suite Variable ${Save_e2t_log} Set Suite Variable ${Save_rsm_log} Set Suite Variable ${Save_e2e_simu_log} + Set Suite Variable ${Save_rm_sim_log} Set Suite Variable ${Save_e2adapter_log} ${flush} cleanup_db.flush diff --git a/Automation/Tests/Resource/resource.robot b/Automation/Tests/Resource/resource.robot index cdecf81..581b489 100755 --- a/Automation/Tests/Resource/resource.robot +++ b/Automation/Tests/Resource/resource.robot @@ -21,8 +21,8 @@ Documentation Resource file *** Variables *** -${docker_number} 7 -${docker_number-1} 6 +${docker_number} 8 +${docker_number-1} 7 ${ip_gnb_simu} 10.0.2.15 ${ip_e2adapter} 10.0.2.15 ${url} http://localhost:3800 @@ -56,7 +56,6 @@ ${dbass_start} docker run -d --name dbass -p 6379:6379 --env DBAAS_SERVICE_HOS ${dbass_remove} docker rm dbass ${dbass_stop} docker stop dbass ${restart_simu} docker restart gnbe2_simu -${start_e2} docker start e2 ${stop_docker_e2} docker stop e2 ${restart_docker_sim} docker restart gnbe2_simu ${Run_Config} docker exec gnbe2_simu pkill gnbe2_simu -INT diff --git a/E2Manager/app/main.go b/E2Manager/app/main.go index 1ca5291..a54b8b2 100644 --- a/E2Manager/app/main.go +++ b/E2Manager/app/main.go @@ -18,6 +18,7 @@ package main import ( + "e2mgr/clients" "e2mgr/configuration" "e2mgr/controllers" "e2mgr/httpserver" @@ -34,6 +35,7 @@ import ( "fmt" "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader" "gerrit.o-ran-sc.org/r/ric-plt/sdlgo" + "net/http" "os" "strconv" ) @@ -57,8 +59,9 @@ func main() { e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger) e2tShutdownManager := managers.NewE2TShutdownManager(logger, rnibDataService, e2tInstancesManager) e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config) + routingManagerClient := clients.NewRoutingManagerClient(logger, config, &http.Client{}) rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider() - rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager) + rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient) notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider) rmrReceiver := rmrreceiver.NewRmrReceiver(logger, rmrMessenger, notificationManager) diff --git a/E2Manager/clients/routing_manager_client.go b/E2Manager/clients/routing_manager_client.go index 80ba071..c584f5b 100644 --- a/E2Manager/clients/routing_manager_client.go +++ b/E2Manager/clients/routing_manager_client.go @@ -26,12 +26,13 @@ import ( "e2mgr/logger" "e2mgr/models" "encoding/json" - "fmt" "net/http" ) const ( - AddE2TInstanceApiSuffix = "e2t" + AddE2TInstanceApiSuffix = "e2t" + AssociateRanToE2TInstanceApiSuffix = "associate-ran-to-e2t" + DissociateRanE2TInstanceApiSuffix = "dissociate-ran" ) type RoutingManagerClient struct { @@ -42,6 +43,8 @@ type RoutingManagerClient struct { type IRoutingManagerClient interface { AddE2TInstance(e2tAddress string) error + AssociateRanToE2TInstance(e2tAddress string, ranName string) error + DissociateRanE2TInstance(e2tAddress string, ranName string) error } func NewRoutingManagerClient(logger *logger.Logger, config *configuration.Configuration, httpClient HttpClient) *RoutingManagerClient { @@ -53,32 +56,53 @@ func NewRoutingManagerClient(logger *logger.Logger, config *configuration.Config } func (c *RoutingManagerClient) AddE2TInstance(e2tAddress string) error { + data := models.NewRoutingManagerE2TData(e2tAddress) + url := c.config.RoutingManager.BaseUrl + AddE2TInstanceApiSuffix + + return c.PostMessage(data, url) +} + +func (c *RoutingManagerClient) AssociateRanToE2TInstance(e2tAddress string, ranName string) error { + + data := models.NewRoutingManagerE2TData(e2tAddress, ranName) + url := c.config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix + + return c.PostMessage(data, url) +} + +func (c *RoutingManagerClient) DissociateRanE2TInstance(e2tAddress string, ranName string) error { + data := models.NewRoutingManagerE2TData(e2tAddress, ranName) + url := c.config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix + + return c.PostMessage(data, url) +} + +func (c *RoutingManagerClient) PostMessage(data *models.RoutingManagerE2TData, url string) error { marshaled, err := json.Marshal(data) if err != nil { - return e2managererrors.NewRoutingManagerError(err) + return e2managererrors.NewRoutingManagerError() } body := bytes.NewBuffer(marshaled) - c.logger.Infof("[E2M -> Routing Manager] #RoutingManagerClient.AddE2TInstance - request body: %+v", body) + c.logger.Infof("[E2M -> Routing Manager] #RoutingManagerClient.PostMessage - url: %s, request body: %+v", url, body) - url := c.config.RoutingManager.BaseUrl + AddE2TInstanceApiSuffix resp, err := c.httpClient.Post(url, "application/json", body) if err != nil { - c.logger.Errorf("#RoutingManagerClient.AddE2TInstance - failed sending request. error: %s", err) - return e2managererrors.NewRoutingManagerError(err) + c.logger.Errorf("#RoutingManagerClient.PostMessage - failed sending request. error: %s", err) + return e2managererrors.NewRoutingManagerError() } defer resp.Body.Close() - if resp.StatusCode == http.StatusCreated { - c.logger.Infof("[Routing Manager -> E2M] #RoutingManagerClient.AddE2TInstance - success. http status code: %d", resp.StatusCode) + if resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusMultipleChoices { + c.logger.Infof("[Routing Manager -> E2M] #RoutingManagerClient.PostMessage - success. http status code: %d", resp.StatusCode) return nil } - c.logger.Errorf("[Routing Manager -> E2M] #RoutingManagerClient.AddE2TInstance - failure. http status code: %d", resp.StatusCode) - return e2managererrors.NewRoutingManagerError(fmt.Errorf("invalid data")) -} + c.logger.Errorf("[Routing Manager -> E2M] #RoutingManagerClient.PostMessage - failure. http status code: %d", resp.StatusCode) + return e2managererrors.NewRoutingManagerError() +} \ No newline at end of file diff --git a/E2Manager/clients/routing_manager_client_test.go b/E2Manager/clients/routing_manager_client_test.go index 8ac2b3e..2d02cfd 100644 --- a/E2Manager/clients/routing_manager_client_test.go +++ b/E2Manager/clients/routing_manager_client_test.go @@ -17,6 +17,7 @@ // This source code is part of the near-RT RIC (RAN Intelligent Controller) // platform project (RICP). + package clients import ( @@ -34,8 +35,8 @@ import ( ) const E2TAddress = "10.0.2.15:38000" +const RanName = "test1" -// TODO: add response Body and dont check for nil in prod code. itll always be populated func initRoutingManagerClientTest(t *testing.T) (*RoutingManagerClient, *mocks.HttpClientMock, *configuration.Configuration) { logger := initLog(t) @@ -84,6 +85,82 @@ func TestAddE2TInstanceFailure(t *testing.T) { assert.NotNil(t, err) } +func TestAssociateRanToE2TInstance_Success(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix + respBody := ioutil.NopCloser(bytes.NewBufferString("")) + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil) + err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName) + assert.Nil(t, err) +} + +func TestAssociateRanToE2TInstance_RoutingManagerError(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error")) + err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName) + assert.NotNil(t, err) +} + +func TestAssociateRanToE2TInstance_RoutingManager_400(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix + respBody := ioutil.NopCloser(bytes.NewBufferString("")) + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body:respBody}, nil) + err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName) + assert.NotNil(t, err) +} + +func TestDissociateRanE2TInstance_Success(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix + respBody := ioutil.NopCloser(bytes.NewBufferString("")) + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil) + err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName) + assert.Nil(t, err) +} + +func TestDissociateRanE2TInstance_RoutingManagerError(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error")) + err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName) + assert.NotNil(t, err) +} + +func TestDissociateRanE2TInstance_RoutingManager_400(t *testing.T) { + rmClient, httpClientMock, config := initRoutingManagerClientTest(t) + + data := models.NewRoutingManagerE2TData(E2TAddress,RanName) + marshaled, _ := json.Marshal(data) + body := bytes.NewBuffer(marshaled) + url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix + respBody := ioutil.NopCloser(bytes.NewBufferString("")) + httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body:respBody}, nil) + err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName) + assert.NotNil(t, err) +} + // TODO: extract to test_utils func initLog(t *testing.T) *logger.Logger { log, err := logger.InitLogger(logger.InfoLevel) diff --git a/E2Manager/e2managererrors/routing_manager_error.go b/E2Manager/e2managererrors/routing_manager_error.go index d6e291a..529df35 100644 --- a/E2Manager/e2managererrors/routing_manager_error.go +++ b/E2Manager/e2managererrors/routing_manager_error.go @@ -17,21 +17,13 @@ package e2managererrors -import "fmt" - type RoutingManagerError struct { - *BaseError } -func NewRoutingManagerError(err error) *RoutingManagerError { - return &RoutingManagerError{ - &BaseError{ - Code: 511, - Message: fmt.Sprintf("Routing manager error: %s", err), - }, - } +func NewRoutingManagerError() *RoutingManagerError { + return &RoutingManagerError{} } func (e *RoutingManagerError) Error() string { - return e.Message + return "Routing Manager Error" } diff --git a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler.go b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler.go index 55cd6b5..e25ace1 100644 --- a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler.go +++ b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler.go @@ -18,12 +18,14 @@ package rmrmsghandlers import ( + "e2mgr/clients" "e2mgr/logger" "e2mgr/managers" "e2mgr/models" "e2mgr/services" "encoding/json" "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common" + "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities" ) type E2TermInitNotificationHandler struct { @@ -31,20 +33,22 @@ type E2TermInitNotificationHandler struct { rnibDataService services.RNibDataService ranReconnectionManager *managers.RanReconnectionManager e2tInstancesManager managers.IE2TInstancesManager + routingManagerClient clients.IRoutingManagerClient } -func NewE2TermInitNotificationHandler(logger *logger.Logger, ranReconnectionManager *managers.RanReconnectionManager, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager) E2TermInitNotificationHandler { +func NewE2TermInitNotificationHandler(logger *logger.Logger, ranReconnectionManager *managers.RanReconnectionManager, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, routingManagerClient clients.IRoutingManagerClient) E2TermInitNotificationHandler { return E2TermInitNotificationHandler{ logger: logger, rnibDataService: rnibDataService, ranReconnectionManager: ranReconnectionManager, e2tInstancesManager: e2tInstancesManager, + routingManagerClient: routingManagerClient, } } func (h E2TermInitNotificationHandler) Handle(request *models.NotificationRequest) { unmarshalledPayload := models.E2TermInitPayload{} - err := json.Unmarshal(request.Payload, &unmarshalledPayload) + err := json.Unmarshal(request.Payload, &unmarshalledPayload) if err != nil { h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Error unmarshaling E2 Term Init payload: %s", err) @@ -70,7 +74,7 @@ func (h E2TermInitNotificationHandler) Handle(request *models.NotificationReques return } - _ = h.e2tInstancesManager.AddE2TInstance(e2tAddress) + h.HandleNewE2TInstance(e2tAddress) return } @@ -79,16 +83,45 @@ func (h E2TermInitNotificationHandler) Handle(request *models.NotificationReques return } + if e2tInstance.State == entities.ToBeDeleted{ + h.logger.Infof("#E2TermInitNotificationHandler.Handle - E2T Address: %s - E2T instance status is: %s, ignore", e2tInstance.Address, e2tInstance.State) + return + } + + if e2tInstance.State == entities.RoutingManagerFailure { + err := h.e2tInstancesManager.ActivateE2TInstance(e2tInstance) + if err != nil { + return + } + } + + h.HandleExistingE2TInstance(e2tInstance) + + h.logger.Infof("#E2TermInitNotificationHandler.Handle - Completed handling of E2_TERM_INIT") +} + +func (h E2TermInitNotificationHandler) HandleExistingE2TInstance(e2tInstance *entities.E2TInstance) { + for _, ranName := range e2tInstance.AssociatedRanList { if err := h.ranReconnectionManager.ReconnectRan(ranName); err != nil { - h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Ran name: %s - connection attempt failure, error: %s", ranName, err) + h.logger.Errorf("#E2TermInitNotificationHandler.HandleExistingE2TInstance - Ran name: %s - connection attempt failure, error: %s", ranName, err) _, ok := err.(*common.ResourceNotFoundError) if !ok { break } } } - - h.logger.Infof("#E2TermInitNotificationHandler.Handle - Completed handling of E2_TERM_INIT") } + +func (h E2TermInitNotificationHandler) HandleNewE2TInstance(e2tAddress string) { + + err := h.routingManagerClient.AddE2TInstance(e2tAddress) + + if err != nil{ + h.logger.Errorf("#E2TermInitNotificationHandler.HandleNewE2TInstance - e2t address: %s - routing manager failure", e2tAddress) + return + } + + _ = h.e2tInstancesManager.AddE2TInstance(e2tAddress) +} \ No newline at end of file diff --git a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go index 1e52ea5..84ab950 100644 --- a/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go +++ b/E2Manager/handlers/rmrmsghandlers/e2_term_init_notification_handler_test.go @@ -37,7 +37,7 @@ import ( const e2tInstanceAddress = "10.0.2.15" const e2tInitPayload = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}" -func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) { +func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) { logger := initLog(t) config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3} @@ -49,13 +49,17 @@ func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotifica writerMock := &mocks.RnibWriterMock{} + routingManagerClientMock := &mocks.RoutingManagerClientMock{} + rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService) e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{} + ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManagerMock) - handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManagerMock) - return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock + handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock) + + return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock } func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock) { @@ -69,18 +73,19 @@ func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger. readerMock := &mocks.RnibReaderMock{} writerMock := &mocks.RnibWriterMock{} + routingManagerClientMock := &mocks.RoutingManagerClientMock{} rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService) e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger) ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager) - handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager) + handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClientMock) return logger, handler, readerMock, writerMock, rmrMessengerMock } func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) { - _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")} handler.Handle(notificationRequest) e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance") @@ -88,7 +93,7 @@ func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) { } func TestE2TermInitEmptyE2TAddress(t *testing.T) { - _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")} handler.Handle(notificationRequest) e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance") @@ -96,7 +101,7 @@ func TestE2TermInitEmptyE2TAddress(t *testing.T) { } func TestE2TermInitGetE2TInstanceFailure(t *testing.T) { - _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var e2tInstance *entities.E2TInstance e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error"))) notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} @@ -115,18 +120,35 @@ func TestE2TermInitGetE2TInstanceDbFailure(t *testing.T) { } func TestE2TermInitNewE2TInstance(t *testing.T) { - _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, _, _, e2tInstancesManagerMock, routingManagerClient := initRanLostConnectionTest(t) var e2tInstance *entities.E2TInstance e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found")) e2tInstance = entities.NewE2TInstance(e2tInstanceAddress) e2tInstancesManagerMock.On("AddE2TInstance", e2tInstanceAddress).Return(nil) + routingManagerClient.On("AddE2TInstance", e2tInstanceAddress).Return(nil) notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} handler.Handle(notificationRequest) + routingManagerClient.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress) e2tInstancesManagerMock.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress) } +func TestE2TermInitNewE2TInstance_RoutingManagerError(t *testing.T) { + _, handler, _, _, _, e2tInstancesManagerMock, routingManagerClient := initRanLostConnectionTest(t) + var e2tInstance *entities.E2TInstance + e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found")) + e2tInstance = entities.NewE2TInstance(e2tInstanceAddress) + e2tInstancesManagerMock.On("AddE2TInstance", e2tInstanceAddress).Return(nil) + routingManagerClient.On("AddE2TInstance", e2tInstanceAddress).Return(fmt.Errorf("error")) + notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} + + handler.Handle(notificationRequest) + + routingManagerClient.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress) + e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance", e2tInstanceAddress) +} + func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) { - _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) e2tInstance := entities.NewE2TInstance(e2tInstanceAddress) e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil) notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} @@ -135,13 +157,13 @@ func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) { } func TestE2TermInitHandlerSuccessOneRan(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error - var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} + var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr) - var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1} + var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1} writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) payload := e2pdus.PackedX2setupRequest @@ -162,7 +184,7 @@ func TestE2TermInitHandlerSuccessOneRan(t *testing.T) { } func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} @@ -188,8 +210,101 @@ func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) { rmrMessengerMock.AssertNotCalled(t, "SendMsg") } +func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) { + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) + var rnibErr error + + var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} + readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr) + + var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1} + writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) + + payload := e2pdus.PackedX2setupRequest + xaction := []byte(RanName) + msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction) + + rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil) + + e2tInstance := entities.NewE2TInstance(e2tInstanceAddress) + e2tInstance.State = entities.ToBeDeleted + e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName) + + e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil) + notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} + + handler.Handle(notificationRequest) + + writerMock.AssertNotCalled(t, "UpdateNodebInfo") + rmrMessengerMock.AssertNotCalled(t, "SendMsg") +} + +func TestE2TermInitHandlerSuccessOneRan_RoutingManagerFailure(t *testing.T) { + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) + var rnibErr error + + var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} + readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr) + + var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1} + writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) + + payload := e2pdus.PackedX2setupRequest + xaction := []byte(RanName) + msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction) + + rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil) + + e2tInstance := entities.NewE2TInstance(e2tInstanceAddress) + e2tInstance.State = entities.RoutingManagerFailure + e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName) + + e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil) + e2tInstancesManagerMock.On("ActivateE2TInstance", e2tInstance).Return(nil) + writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) + + notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} + + handler.Handle(notificationRequest) + + writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1) + rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1) +} + +func TestE2TermInitHandlerSuccessOneRan_RoutingManagerFailure_Error(t *testing.T) { + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) + var rnibErr error + + var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} + readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr) + + var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1} + writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) + + payload := e2pdus.PackedX2setupRequest + xaction := []byte(RanName) + msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction) + + rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil) + + e2tInstance := entities.NewE2TInstance(e2tInstanceAddress) + e2tInstance.State = entities.RoutingManagerFailure + e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName) + + e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil) + e2tInstancesManagerMock.On("ActivateE2TInstance", e2tInstance).Return(fmt.Errorf(" Error ")) + writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr) + + notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)} + + handler.Handle(notificationRequest) + + writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0) + rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0) +} + func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} @@ -217,7 +332,7 @@ func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) { } func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} @@ -246,7 +361,7 @@ func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) { } func TestE2TermInitHandlerSuccessThreeRansFirstRmrFailure(t *testing.T) { - log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}} @@ -288,7 +403,7 @@ func TestE2TermInitHandlerSuccessThreeRansFirstRmrFailure(t *testing.T) { } func TestE2TermInitHandlerSuccessThreeRansSecondNotFoundFailure(t *testing.T) { - log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}} @@ -336,7 +451,7 @@ func TestE2TermInitHandlerSuccessThreeRansSecondNotFoundFailure(t *testing.T) { } func TestE2TermInitHandlerSuccessThreeRansSecondRnibInternalErrorFailure(t *testing.T) { - log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}} @@ -384,7 +499,7 @@ func TestE2TermInitHandlerSuccessThreeRansSecondRnibInternalErrorFailure(t *test } func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) { - _, handler, _, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, _, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) e2tInstance := entities.NewE2TInstance(e2tInstanceAddress) e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil) @@ -397,7 +512,7 @@ func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) { } func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var nodebInfo *entities.NodebInfo readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error"))) @@ -413,7 +528,7 @@ func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) { } func TestE2TermInitHandlerSuccessTwoRansSecondIsDisconnected(t *testing.T) { - _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t) + _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t) var rnibErr error var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST} diff --git a/E2Manager/managers/e2t_instances_manager.go b/E2Manager/managers/e2t_instances_manager.go index 2e36d61..1873473 100644 --- a/E2Manager/managers/e2t_instances_manager.go +++ b/E2Manager/managers/e2t_instances_manager.go @@ -43,6 +43,7 @@ type IE2TInstancesManager interface { SelectE2TInstance() (string, error) AssociateRan(ranName string, e2tAddress string) error DissociateRan(ranName string, e2tAddress string) error + ActivateE2TInstance(e2tInstance *entities.E2TInstance) error ResetKeepAliveTimestamp(e2tAddress string) error } @@ -298,6 +299,26 @@ func (m *E2TInstancesManager) AssociateRan(ranName string, e2tAddress string) er return nil } +func (h E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error{ + + if e2tInstance == nil { + h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - e2tInstance empty") + return e2managererrors.NewInternalError() + } + + h.logger.Infof("#E2TInstancesManager.ActivateE2TInstance - E2T Address: %s - activate E2T instance", e2tInstance.Address) + + e2tInstance.State = entities.Active + e2tInstance.KeepAliveTimestamp = time.Now().UnixNano() + + err := h.rnibDataService.SaveE2TInstance(e2tInstance) + if err != nil { + h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tInstance.Address, err) + return err + } + return nil +} + func (m *E2TInstancesManager) ResetKeepAliveTimestamp(e2tAddress string) error { m.mux.Lock() diff --git a/E2Manager/managers/e2t_instances_manager_test.go b/E2Manager/managers/e2t_instances_manager_test.go index f836bda..fb564e5 100644 --- a/E2Manager/managers/e2t_instances_manager_test.go +++ b/E2Manager/managers/e2t_instances_manager_test.go @@ -292,6 +292,43 @@ func TestSelectE2TInstancesSuccess(t *testing.T) { rnibWriterMock.AssertExpectations(t) } +func TestActivateE2TInstanceSuccess(t *testing.T) { + _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t) + + e2tInstance1 := entities.NewE2TInstance(E2TAddress) + e2tInstance1.State = entities.RoutingManagerFailure + e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"} + + rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil) + + err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1) + assert.Nil(t, err) + assert.Equal(t, entities.Active, e2tInstance1.State) + rnibWriterMock.AssertExpectations(t) +} + +func TestActivateE2TInstance_RnibError(t *testing.T) { + _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t) + + e2tInstance1 := entities.NewE2TInstance(E2TAddress) + e2tInstance1.State = entities.RoutingManagerFailure + e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"} + + rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error"))) + + err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1) + assert.NotNil(t, err) +} + +func TestActivateE2TInstance_NoInstance(t *testing.T) { + _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t) + + err := e2tInstancesManager.ActivateE2TInstance(nil) + + assert.NotNil(t, err) + rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance") +} + func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) { rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t) diff --git a/E2Manager/managers/notificationmanager/notification_manager_test.go b/E2Manager/managers/notificationmanager/notification_manager_test.go index 9dbd1d9..5bce096 100644 --- a/E2Manager/managers/notificationmanager/notification_manager_test.go +++ b/E2Manager/managers/notificationmanager/notification_manager_test.go @@ -1,6 +1,7 @@ package notificationmanager import ( + "e2mgr/clients" "e2mgr/configuration" "e2mgr/logger" "e2mgr/managers" @@ -21,16 +22,16 @@ func initNotificationManagerTest(t *testing.T) (*logger.Logger, *mocks.RnibReade config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3} readerMock := &mocks.RnibReaderMock{} - writerMock := &mocks.RnibWriterMock{} - + httpClient := &mocks.HttpClientMock{} rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger) rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService) e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger) + routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient) rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider() - rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager) + rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager,routingManagerClient) notificationManager := NewNotificationManager(logger, rmrNotificationHandlerProvider ) return logger, readerMock, notificationManager } diff --git a/E2Manager/mocks/e2t_instances_manager_mock.go b/E2Manager/mocks/e2t_instances_manager_mock.go index 0bbe764..235c76a 100644 --- a/E2Manager/mocks/e2t_instances_manager_mock.go +++ b/E2Manager/mocks/e2t_instances_manager_mock.go @@ -73,4 +73,10 @@ func (m *E2TInstancesManagerMock) ResetKeepAliveTimestamp(e2tAddress string) err args := m.Called(e2tAddress) return args.Error(0) +} + +func (m *E2TInstancesManagerMock) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error { + args := m.Called(e2tInstance) + return args.Error(0) + } \ No newline at end of file diff --git a/E2Manager/mocks/routing_manager_client_mock.go b/E2Manager/mocks/routing_manager_client_mock.go new file mode 100644 index 0000000..24edd55 --- /dev/null +++ b/E2Manager/mocks/routing_manager_client_mock.go @@ -0,0 +1,46 @@ +// +// Copyright 2019 AT&T Intellectual Property +// Copyright 2019 Nokia +// +// 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. + +// This source code is part of the near-RT RIC (RAN Intelligent Controller) +// platform project (RICP). + +package mocks + +import ( + "github.com/stretchr/testify/mock" +) + +type RoutingManagerClientMock struct { + mock.Mock +} + +func (m *RoutingManagerClientMock) AddE2TInstance(e2tAddress string) error { + + args := m.Called(e2tAddress) + return args.Error(0) +} + +func (m *RoutingManagerClientMock) AssociateRanToE2TInstance(e2tAddress string, ranName string) error { + + args := m.Called(e2tAddress, ranName) + return args.Error(0) +} + +func (m *RoutingManagerClientMock) DissociateRanE2TInstance(e2tAddress string, ranName string) error { + + args := m.Called(e2tAddress, ranName) + return args.Error(0) +} \ No newline at end of file diff --git a/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider.go b/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider.go index 99a3c32..ab88a3b 100644 --- a/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider.go +++ b/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider.go @@ -18,6 +18,7 @@ package rmrmsghandlerprovider import ( + "e2mgr/clients" "e2mgr/configuration" "e2mgr/converters" "e2mgr/handlers/rmrmsghandlers" @@ -54,7 +55,7 @@ func (provider *NotificationHandlerProvider) Register(msgType int, handler rmrms provider.notificationHandlers[msgType] = handler } -func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager) { +func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, routingManagerClient clients.IRoutingManagerClient) { // Init converters x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger) @@ -83,7 +84,7 @@ func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config endcConfigurationUpdateHandler := rmrmsghandlers.NewEndcConfigurationUpdateHandler(logger, rmrSender) x2ResetResponseHandler := rmrmsghandlers.NewX2ResetResponseHandler(logger, rnibDataService, ranStatusChangeManager, x2ResetResponseExtractor) x2ResetRequestNotificationHandler := rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender) - e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager) + e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClient) e2TKeepAliveResponseHandler := rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager) provider.Register(rmrCgo.RIC_X2_SETUP_RESP, x2SetupResponseHandler) diff --git a/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider_test.go b/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider_test.go index 1874e71..f303b72 100644 --- a/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider_test.go +++ b/E2Manager/providers/rmrmsghandlerprovider/notification_handler_provider_test.go @@ -18,6 +18,7 @@ package rmrmsghandlerprovider import ( + "e2mgr/clients" "e2mgr/configuration" "e2mgr/converters" "e2mgr/handlers/rmrmsghandlers" @@ -38,40 +39,26 @@ import ( * Verify support for known providers. */ -func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, *managers.RanSetupManager, managers.IE2TInstancesManager) { +func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, *managers.RanSetupManager, managers.IE2TInstancesManager, clients.IRoutingManagerClient) { logger := initLog(t) config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3} readerMock := &mocks.RnibReaderMock{} writerMock := &mocks.RnibWriterMock{} + httpClient := &mocks.HttpClientMock{} rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger) rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService) e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger) + routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient) - //ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager) - //ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender) - // - //x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger) - //x2SetupResponseManager := managers.NewX2SetupResponseManager(x2SetupResponseConverter) - // - //x2SetupFailureResponseConverter := converters.NewX2SetupFailureResponseConverter(logger) - //x2SetupFailureResponseManager := managers.NewX2SetupFailureResponseManager(x2SetupFailureResponseConverter) - // - //endcSetupResponseConverter := converters.NewEndcSetupResponseConverter(logger) - //endcSetupResponseManager := managers.NewEndcSetupResponseManager(endcSetupResponseConverter) - // - // - //endcSetupFailureResponseConverter := converters.NewEndcSetupFailureResponseConverter(logger) - //endcSetupFailureResponseManager := managers.NewEndcSetupFailureResponseManager(endcSetupFailureResponseConverter) - - return logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager + return logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient } func TestGetNotificationHandlerSuccess(t *testing.T) { - logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager := initTestCase(t) + logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient := initTestCase(t) ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager) ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender) @@ -102,7 +89,7 @@ func TestGetNotificationHandlerSuccess(t *testing.T) { {rmrCgo.RIC_ENB_LOAD_INFORMATION, rmrmsghandlers.NewEnbLoadInformationNotificationHandler(logger, rnibDataService, converters.NewEnbLoadInformationExtractor(logger))}, {rmrCgo.RIC_ENB_CONF_UPDATE, rmrmsghandlers.NewX2EnbConfigurationUpdateHandler(logger, rmrSender)}, {rmrCgo.RIC_ENDC_CONF_UPDATE, rmrmsghandlers.NewEndcConfigurationUpdateHandler(logger, rmrSender)}, - {rmrCgo.RIC_E2_TERM_INIT, rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager)}, + {rmrCgo.RIC_E2_TERM_INIT, rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClient)}, {rmrCgo.E2_TERM_KEEP_ALIVE_RESP, rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager)}, {rmrCgo.RIC_X2_RESET_RESP, rmrmsghandlers.NewX2ResetResponseHandler(logger, rnibDataService, ranStatusChangeManager, converters.NewX2ResetResponseExtractor(logger))}, {rmrCgo.RIC_X2_RESET, rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender)}, @@ -111,7 +98,7 @@ func TestGetNotificationHandlerSuccess(t *testing.T) { for _, tc := range testCases { provider := NewNotificationHandlerProvider() - provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager) + provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient) t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) { handler, err := provider.GetNotificationHandler(tc.msgType) if err != nil { @@ -140,9 +127,9 @@ func TestGetNotificationHandlerFailure(t *testing.T) { } for _, tc := range testCases { - logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager := initTestCase(t) + logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient := initTestCase(t) provider := NewNotificationHandlerProvider() - provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager) + provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient) t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) { _, err := provider.GetNotificationHandler(tc.msgType) if err == nil { diff --git a/E2Manager/resources/configuration.yaml b/E2Manager/resources/configuration.yaml index 4d43e40..f10d275 100644 --- a/E2Manager/resources/configuration.yaml +++ b/E2Manager/resources/configuration.yaml @@ -6,7 +6,7 @@ rmr: port: 3801 maxMsgSize: 65536 routingManager: - baseUrl: http://iltlv740.intl.att.com:8080/ric/v1/handles/ + baseUrl: http://10.0.2.15:12020/ric/v1/handles/v1/ notificationResponseBuffer: 100 bigRedButtonTimeoutSec: 5 maxConnectionAttempts: 3 diff --git a/E2Manager/services/rmrreceiver/rmr_receiver_test.go b/E2Manager/services/rmrreceiver/rmr_receiver_test.go index 7a04e51..fddddc7 100644 --- a/E2Manager/services/rmrreceiver/rmr_receiver_test.go +++ b/E2Manager/services/rmrreceiver/rmr_receiver_test.go @@ -18,6 +18,7 @@ package rmrreceiver import ( + "e2mgr/clients" "e2mgr/configuration" "e2mgr/logger" "e2mgr/managers" @@ -59,17 +60,17 @@ func initRmrReceiver(logger *logger.Logger) *RmrReceiver { config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3} readerMock := &mocks.RnibReaderMock{} - writerMock := &mocks.RnibWriterMock{} - + httpClient := &mocks.HttpClientMock{} rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock) rmrMessenger := initRmrMessenger(logger) rmrSender := rmrsender.NewRmrSender(logger, rmrMessenger) ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService) e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger) + routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient) rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider() - rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager) + rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient) notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider) return NewRmrReceiver(logger, rmrMessenger, notificationManager) }