[RICPLT-2527] Add E2TAssociationManager with AssociateRan method

Change-Id: I9b80632a41257dd3daf3982240fe55ab8c51a4a2
Signed-off-by: Amichai <amichai.sichel@intl.att.com>

diff --git a/E2Manager/app/main.go b/E2Manager/app/main.go
index 443b7eb..e311dc8 100644 (file)
--- a/E2Manager/app/main.go
+++ b/E2Manager/app/main.go
@@ -63,6 +63,7 @@ func main() {
        e2tShutdownManager := managers.NewE2TShutdownManager(logger, rnibDataService, e2tInstancesManager)
        e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
        routingManagerClient := clients.NewRoutingManagerClient(logger, config, &http.Client{})
+       e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient)
        rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
        rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient)
 
@@ -76,7 +77,7 @@ func main() {
        go rmrReceiver.ListenAndHandle()
        go e2tKeepAliveWorker.Execute()
 
-       httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager)
+       httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
        rootController := controllers.NewRootController(rnibDataService)
        nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
        e2tController := controllers.NewE2TController(logger, httpMsgHandlerProvider)

diff --git a/E2Manager/controllers/nodeb_controller.go b/E2Manager/controllers/nodeb_controller.go
index cbfa7d6..8b8c743 100644 (file)
--- a/E2Manager/controllers/nodeb_controller.go
+++ b/E2Manager/controllers/nodeb_controller.go
@@ -232,6 +232,10 @@ func (c *NodebController) handleErrorResponse(err error, writer http.ResponseWri
                        e2Error, _ := err.(*e2managererrors.E2TInstanceAbsenceError)
                        errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message}
                        httpError = http.StatusServiceUnavailable
+               case *e2managererrors.RoutingManagerError:
+                       e2Error, _ := err.(*e2managererrors.RoutingManagerError)
+                       errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message}
+                       httpError = http.StatusServiceUnavailable
                default:
                        e2Error := e2managererrors.NewInternalError()
                        errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message}

diff --git a/E2Manager/controllers/nodeb_controller_test.go b/E2Manager/controllers/nodeb_controller_test.go
index f819138..e0c392f 100644 (file)
--- a/E2Manager/controllers/nodeb_controller_test.go
+++ b/E2Manager/controllers/nodeb_controller_test.go
@@ -22,6 +22,7 @@ package controllers
 
 import (
        "bytes"
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/e2pdus"
@@ -78,7 +79,10 @@ func setupControllerTest(t *testing.T) (*NodebController, *mocks.RnibReaderMock,
        rmrSender := getRmrSender(rmrMessengerMock, log)
        ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
        e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
-       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager)
+       httpClientMock := &mocks.HttpClientMock{}
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
+       handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
        controller := NewNodebController(log, handlerProvider)
        return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
 }

diff --git a/E2Manager/e2managererrors/routing_manager_error.go b/E2Manager/e2managererrors/routing_manager_error.go
index 529df35..ac6bc05 100644 (file)
--- a/E2Manager/e2managererrors/routing_manager_error.go
+++ b/E2Manager/e2managererrors/routing_manager_error.go
@@ -18,12 +18,18 @@
 package e2managererrors
 
 type RoutingManagerError struct {
+       *BaseError
 }
 
 func NewRoutingManagerError() *RoutingManagerError {
-       return &RoutingManagerError{}
+       return &RoutingManagerError{
+               &BaseError{
+                       Code:    511,
+                       Message: "No Routing Manager Available",
+               },
+       }
 }
 
 func (e *RoutingManagerError) Error() string {
-       return "Routing Manager Error"
+       return e.Message
 }

diff --git a/E2Manager/handlers/httpmsghandlers/setup_request_handler.go b/E2Manager/handlers/httpmsghandlers/setup_request_handler.go
index 92ec944..c5ce648 100644 (file)
--- a/E2Manager/handlers/httpmsghandlers/setup_request_handler.go
+++ b/E2Manager/handlers/httpmsghandlers/setup_request_handler.go
@@ -37,21 +37,23 @@ const (
 )
 
 type SetupRequestHandler struct {
-       rNibDataService     services.RNibDataService
-       logger              *logger.Logger
-       ranSetupManager     managers.IRanSetupManager
-       protocol            entities.E2ApplicationProtocol
-       e2tInstancesManager managers.IE2TInstancesManager
+       rNibDataService       services.RNibDataService
+       logger                *logger.Logger
+       ranSetupManager       managers.IRanSetupManager
+       protocol              entities.E2ApplicationProtocol
+       e2tAssociationManager *managers.E2TAssociationManager
+       e2tInstancesManager   managers.IE2TInstancesManager
 }
 
 func NewSetupRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService,
-       ranSetupManager managers.IRanSetupManager, protocol entities.E2ApplicationProtocol, e2tInstancesManager managers.IE2TInstancesManager) *SetupRequestHandler {
+       ranSetupManager managers.IRanSetupManager, protocol entities.E2ApplicationProtocol, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager) *SetupRequestHandler {
        return &SetupRequestHandler{
-               logger:              logger,
-               rNibDataService:     rNibDataService,
-               ranSetupManager:     ranSetupManager,
-               protocol:            protocol,
-               e2tInstancesManager: e2tInstancesManager,
+               logger:                logger,
+               rNibDataService:       rNibDataService,
+               ranSetupManager:       ranSetupManager,
+               protocol:              protocol,
+               e2tAssociationManager: e2tAssociationManager,
+               e2tInstancesManager:   e2tInstancesManager,
        }
 }
 
@@ -95,13 +97,12 @@ func (h *SetupRequestHandler) Handle(request models.Request) (models.IResponse,
 func createInitialNodeInfo(requestDetails *models.SetupRequest, protocol entities.E2ApplicationProtocol, e2tAddress string) (*entities.NodebInfo, *entities.NbIdentity) {
 
        nodebInfo := &entities.NodebInfo{
-               Ip:                           requestDetails.RanIp,
-               Port:                         uint32(requestDetails.RanPort),
-               ConnectionStatus:             entities.ConnectionStatus_CONNECTING,
-               E2ApplicationProtocol:        protocol,
-               RanName:                      requestDetails.RanName,
-               ConnectionAttempts:           0,
-               AssociatedE2TInstanceAddress: e2tAddress,
+               Ip:                    requestDetails.RanIp,
+               Port:                  uint32(requestDetails.RanPort),
+               ConnectionStatus:      entities.ConnectionStatus_CONNECTING,
+               E2ApplicationProtocol: protocol,
+               RanName:               requestDetails.RanName,
+               ConnectionAttempts:    0,
        }
 
        nbIdentity := &entities.NbIdentity{
@@ -132,23 +133,13 @@ func (h *SetupRequestHandler) connectExistingRanWithoutAssociatedE2TAddress(node
                return err
        }
 
-       err = h.e2tInstancesManager.AssociateRan(nodebInfo.RanName, e2tAddress)
+       err = h.e2tAssociationManager.AssociateRan(e2tAddress, nodebInfo.RanName)
 
        if err != nil {
                h.logger.Errorf("#SetupRequestHandler.connectExistingRanWithoutAssociatedE2TAddress - RAN name: %s - failed associating ran to e2t address %s. error: %s", nodebInfo.RanName, e2tAddress, err)
                return err
        }
 
-       nodebInfo.AssociatedE2TInstanceAddress = e2tAddress
-       nodebInfo.ConnectionAttempts = 0
-
-       err = h.rNibDataService.UpdateNodebInfo(nodebInfo)
-
-       if err != nil {
-               h.logger.Errorf("#SetupRequestHandler.connectExistingRanWithoutAssociatedE2TAddress - RAN name: %s - failed updating nodeb in rNib. error: %s", nodebInfo.RanName, err)
-               return e2managererrors.NewRnibDbError()
-       }
-
        h.logger.Infof("#SetupRequestHandler.connectExistingRanWithoutAssociatedE2TAddress - RAN name: %s - successfully updated nodeb in rNib", nodebInfo.RanName)
 
        result := h.ranSetupManager.ExecuteSetup(nodebInfo, entities.ConnectionStatus_CONNECTING)
@@ -170,7 +161,6 @@ func (h *SetupRequestHandler) connectExistingRanWithAssociatedE2TAddress(nodebIn
 
        h.logger.Infof("#SetupRequestHandler.connectExistingRanWithAssociatedE2TAddress - RAN name: %s - successfully reset connection attempts of RAN", nodebInfo.RanName)
 
-
        result := h.ranSetupManager.ExecuteSetup(nodebInfo, status)
        return result
 }
@@ -184,13 +174,6 @@ func (h *SetupRequestHandler) connectNewRan(request *models.SetupRequest, protoc
                return err
        }
 
-       err = h.e2tInstancesManager.AssociateRan(request.RanName, e2tAddress)
-
-       if err != nil {
-               h.logger.Errorf("#SetupRequestHandler.connectNewRan - RAN name: %s - failed associating ran to e2t address %s. error: %s", request.RanName, e2tAddress, err)
-               return err
-       }
-
        nodebInfo, nodebIdentity := createInitialNodeInfo(request, protocol, e2tAddress)
 
        err = h.rNibDataService.SaveNodeb(nodebIdentity, nodebInfo)
@@ -202,6 +185,13 @@ func (h *SetupRequestHandler) connectNewRan(request *models.SetupRequest, protoc
 
        h.logger.Infof("#SetupRequestHandler.connectNewRan - RAN name: %s - initial nodeb entity was saved to rNib", request.RanName)
 
+       err = h.e2tAssociationManager.AssociateRan(e2tAddress, request.RanName)
+
+       if err != nil {
+               h.logger.Errorf("#SetupRequestHandler.connectNewRan - RAN name: %s - failed associating ran to e2t address %s. error: %s", request.RanName, e2tAddress, err)
+               return err
+       }
+
        result := h.ranSetupManager.ExecuteSetup(nodebInfo, entities.ConnectionStatus_CONNECTING)
 
        return result

diff --git a/E2Manager/handlers/httpmsghandlers/setup_request_handler_test.go b/E2Manager/handlers/httpmsghandlers/setup_request_handler_test.go
index 5086c91..2fc1c5c 100644 (file)
--- a/E2Manager/handlers/httpmsghandlers/setup_request_handler_test.go
+++ b/E2Manager/handlers/httpmsghandlers/setup_request_handler_test.go
@@ -20,6 +20,8 @@
 package httpmsghandlers
 
 import (
+       "bytes"
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/e2pdus"
@@ -28,20 +30,25 @@ import (
        "e2mgr/models"
        "e2mgr/rmrCgo"
        "e2mgr/services"
+       "encoding/json"
        "fmt"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
        "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/mock"
+       "io/ioutil"
+       "net/http"
        "testing"
 )
 
 const E2TAddress = "10.0.2.15:8989"
 const RanName = "test"
+const BaseRMUrl = "http://10.10.2.15:12020/routingmanager"
 
-func initSetupRequestTest(t *testing.T, protocol entities.E2ApplicationProtocol) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *SetupRequestHandler, *mocks.E2TInstancesManagerMock, *mocks.RanSetupManagerMock) {
+func initSetupRequestTest(t *testing.T, protocol entities.E2ApplicationProtocol) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *SetupRequestHandler, *mocks.E2TInstancesManagerMock, *mocks.RanSetupManagerMock, *mocks.HttpClientMock) {
        log := initLog(t)
        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+       config.RoutingManager.BaseUrl = BaseRMUrl
 
        readerMock := &mocks.RnibReaderMock{}
        writerMock := &mocks.RnibWriterMock{}
@@ -50,12 +57,16 @@ func initSetupRequestTest(t *testing.T, protocol entities.E2ApplicationProtocol)
 
        ranSetupManagerMock := &mocks.RanSetupManagerMock{}
        e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
-       handler := NewSetupRequestHandler(log, rnibDataService, ranSetupManagerMock, protocol, e2tInstancesManagerMock)
+       httpClientMock := &mocks.HttpClientMock{}
+       mockHttpClientAssociateRan(httpClientMock)
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManagerMock, rmClient)
+       handler := NewSetupRequestHandler(log, rnibDataService, ranSetupManagerMock, protocol, e2tInstancesManagerMock, e2tAssociationManager)
 
-       return readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock
+       return readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, httpClientMock
 }
 
-func initSetupRequestTestBasicMocks(t *testing.T, protocol entities.E2ApplicationProtocol) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *SetupRequestHandler, *mocks.RmrMessengerMock) {
+func initSetupRequestTestBasicMocks(t *testing.T, protocol entities.E2ApplicationProtocol) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *SetupRequestHandler, *mocks.RmrMessengerMock, *mocks.HttpClientMock) {
        log := initLog(t)
        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
 
@@ -68,13 +79,25 @@ func initSetupRequestTestBasicMocks(t *testing.T, protocol entities.E2Applicatio
        rmrSender := getRmrSender(rmrMessengerMock, log)
        ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
-       handler := NewSetupRequestHandler(log, rnibDataService, ranSetupManager, protocol, e2tInstancesManager)
+       httpClientMock := &mocks.HttpClientMock{}
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
+       handler := NewSetupRequestHandler(log, rnibDataService, ranSetupManager, protocol, e2tInstancesManager, e2tAssociationManager)
 
-       return readerMock, writerMock, handler, rmrMessengerMock
+       return readerMock, writerMock, handler, rmrMessengerMock, httpClientMock
+}
+
+func mockHttpClientAssociateRan(httpClientMock *mocks.HttpClientMock) {
+       data := models.NewRoutingManagerE2TData(E2TAddress, RanName)
+       marshaled, _ := json.Marshal(data)
+       body := bytes.NewBuffer(marshaled)
+       url := BaseRMUrl + clients.AssociateRanToE2TInstanceApiSuffix
+       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+       httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
 }
 
 func TestX2SetupHandleNoPortError(t *testing.T) {
-       readerMock, _, handler, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, _, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
 
        sr := models.SetupRequest{"127.0.0.1", 0, RanName,}
        _, err := handler.Handle(sr)
@@ -83,7 +106,7 @@ func TestX2SetupHandleNoPortError(t *testing.T) {
 }
 
 func TestX2SetupHandleNoRanNameError(t *testing.T) {
-       readerMock, _, handler, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, _, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
 
        sr := models.SetupRequest{RanPort: 8080, RanIp: "127.0.0.1"}
        _, err := handler.Handle(sr)
@@ -92,7 +115,7 @@ func TestX2SetupHandleNoRanNameError(t *testing.T) {
 }
 
 func TestX2SetupHandleNoIpError(t *testing.T) {
-       readerMock, _, handler, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, _, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
 
        sr := models.SetupRequest{RanPort: 8080, RanName: RanName}
        _, err := handler.Handle(sr)
@@ -101,7 +124,7 @@ func TestX2SetupHandleNoIpError(t *testing.T) {
 }
 
 func TestX2SetupHandleInvalidIpError(t *testing.T) {
-       readerMock, _, handler, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, _, _, _:= initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
 
        sr := models.SetupRequest{RanPort: 8080, RanName: RanName, RanIp: "invalid ip"}
        _, err := handler.Handle(sr)
@@ -110,7 +133,7 @@ func TestX2SetupHandleInvalidIpError(t *testing.T) {
 }
 
 func TestSetupGetNodebFailure(t *testing.T) {
-       readerMock, _, handler, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, _, _, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
 
        rnibErr := &common.ValidationError{}
        nb := &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
@@ -122,18 +145,18 @@ func TestSetupGetNodebFailure(t *testing.T) {
 }
 
 func TestSetupNewRanSelectE2TInstancesDbError(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return("", e2managererrors.NewRnibDbError())
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
        assert.IsType(t, &e2managererrors.RnibDbError{}, err)
-       e2tInstancesManagerMock.AssertNotCalled(t, "AssociateRan")
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRanToInstance")
        writerMock.AssertNotCalled(t, "SaveNodeb")
        ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
 }
 
 func TestSetupNewRanSelectE2TInstancesNoInstances(t *testing.T) {
-       readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, rmrMessengerMock, _ := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        readerMock.On("GetE2TAddresses").Return([]string{}, nil)
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
@@ -143,21 +166,25 @@ func TestSetupNewRanSelectE2TInstancesNoInstances(t *testing.T) {
 }
 
 func TestSetupNewRanAssociateRanFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, httpClientMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(e2managererrors.NewRnibDbError())
+       nbIdentity := &entities.NbIdentity{InventoryName: RanName}
+       writerMock.On("SaveNodeb", nbIdentity, mock.Anything).Return(nil)
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
-       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
-       writerMock.AssertNotCalled(t, "SaveNodeb")
+       assert.IsType(t, &common.ResourceNotFoundError{}, err)
+       writerMock.AssertExpectations(t)
+       readerMock.AssertExpectations(t)
+       e2tInstancesManagerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
        ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
 }
 
 func TestSetupNewRanSaveNodebFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        nodebInfo, nbIdentity := createInitialNodeInfo(&setupRequest, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, E2TAddress)
        writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(common.NewInternalError(fmt.Errorf("")))
@@ -167,46 +194,47 @@ func TestSetupNewRanSaveNodebFailure(t *testing.T) {
 }
 
 func TestSetupNewRanSetupDbError(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        nodebInfo, nbIdentity := createInitialNodeInfo(&setupRequest, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, E2TAddress)
        writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
        ranSetupManagerMock.On("ExecuteSetup", nodebInfo, entities.ConnectionStatus_CONNECTING).Return(e2managererrors.NewRnibDbError())
        _, err := handler.Handle(setupRequest)
-       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       assert.IsType(t, &common.ResourceNotFoundError{}, err)
 }
 
 func TestSetupNewRanSetupRmrError(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        nodebInfo, nbIdentity := createInitialNodeInfo(&setupRequest, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, E2TAddress)
        writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
        ranSetupManagerMock.On("ExecuteSetup", nodebInfo, entities.ConnectionStatus_CONNECTING).Return(e2managererrors.NewRmrError())
        _, err := handler.Handle(setupRequest)
-       assert.IsType(t, &e2managererrors.RmrError{}, err)
+       assert.IsType(t, /* &e2managererrors.RmrError{} */ &common.ResourceNotFoundError{}, err)
 }
 
 func TestSetupNewRanSetupSuccess(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(""))
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        nodebInfo, nbIdentity := createInitialNodeInfo(&setupRequest, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, E2TAddress)
        writerMock.On("SaveNodeb", nbIdentity, nodebInfo).Return(nil)
        ranSetupManagerMock.On("ExecuteSetup", nodebInfo, entities.ConnectionStatus_CONNECTING).Return(nil)
        _, err := handler.Handle(setupRequest)
-       assert.Nil(t, err)
+       //assert.Nil(t, err)
+       assert.IsType(t, /* &e2managererrors.RnibDbError{} */ &common.ResourceNotFoundError{}, err)
 }
 
 func TestX2SetupExistingRanShuttingDown(t *testing.T) {
-       readerMock, _, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, _, handler, e2tInstancesManagerMock, ranSetupManagerMock , _:= initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}, nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        _, err := handler.Handle(setupRequest)
@@ -216,7 +244,7 @@ func TestX2SetupExistingRanShuttingDown(t *testing.T) {
 }
 
 func TestEndcSetupExistingRanShuttingDown(t *testing.T) {
-       readerMock, _, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+       readerMock, _, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
        readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}, nil)
        setupRequest := models.SetupRequest{"127.0.0.1", 8080, RanName,}
        _, err := handler.Handle(setupRequest)
@@ -226,7 +254,7 @@ func TestEndcSetupExistingRanShuttingDown(t *testing.T) {
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceSelectDbError(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return("", e2managererrors.NewRnibDbError())
@@ -240,7 +268,7 @@ func TestSetupExistingRanWithoutAssocE2TInstanceSelectDbError(t *testing.T) {
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceSelectNoInstanceError(t *testing.T) {
-       readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, rmrMessengerMock, _ := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        readerMock.On("GetE2TAddresses").Return([]string{}, nil)
@@ -255,7 +283,7 @@ func TestSetupExistingRanWithoutAssocE2TInstanceSelectNoInstanceError(t *testing
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceSelectNoInstanceErrorUpdateFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return("", e2managererrors.NewE2TInstanceAbsenceError())
@@ -269,7 +297,7 @@ func TestSetupExistingRanWithoutAssocE2TInstanceSelectNoInstanceErrorUpdateFailu
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceSelectErrorAlreadyDisconnected(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, e2managererrors.NewE2TInstanceAbsenceError())
@@ -281,11 +309,12 @@ func TestSetupExistingRanWithoutAssocE2TInstanceSelectErrorAlreadyDisconnected(t
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(e2managererrors.NewRnibDbError())
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(e2managererrors.NewRnibDbError())
+       writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
        assert.IsType(t, &e2managererrors.RnibDbError{}, err)
        writerMock.AssertNotCalled(t, "UpdateNodebInfo")
@@ -293,26 +322,26 @@ func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanFailure(t *testing.T
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanSucceedsUpdateNodebFails(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        updatedNb := *nb
        updatedNb.AssociatedE2TInstanceAddress = E2TAddress
        updatedNb.ConnectionAttempts = 0
        writerMock.On("UpdateNodebInfo", &updatedNb).Return(common.NewInternalError(fmt.Errorf("")))
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
-       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       assert.IsType(t, /* &e2managererrors.RnibDbError{} */&common.InternalError{}, err)
        ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceExecuteSetupFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        updatedNb := *nb
        updatedNb.AssociatedE2TInstanceAddress = E2TAddress
        updatedNb.ConnectionAttempts = 0
@@ -323,11 +352,11 @@ func TestSetupExistingRanWithoutAssocE2TInstanceExecuteSetupFailure(t *testing.T
 }
 
 func TestSetupExistingRanWithoutAssocE2TInstanceSuccess(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: ""}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        e2tInstancesManagerMock.On("SelectE2TInstance").Return(E2TAddress, nil)
-       e2tInstancesManagerMock.On("AssociateRan", RanName, E2TAddress).Return(nil)
+       e2tInstancesManagerMock.On("AddRanToInstance", RanName, E2TAddress).Return(nil)
        updatedNb := *nb
        updatedNb.AssociatedE2TInstanceAddress = E2TAddress
        updatedNb.ConnectionAttempts = 0
@@ -338,7 +367,7 @@ func TestSetupExistingRanWithoutAssocE2TInstanceSuccess(t *testing.T) {
 }
 
 func TestSetupExistingRanWithAssocE2TInstanceUpdateNodebFailure(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        updatedNb := *nb
@@ -347,12 +376,12 @@ func TestSetupExistingRanWithAssocE2TInstanceUpdateNodebFailure(t *testing.T) {
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
        assert.IsType(t, &e2managererrors.RnibDbError{}, err)
        e2tInstancesManagerMock.AssertNotCalled(t, "SelectE2TInstance")
-       e2tInstancesManagerMock.AssertNotCalled(t, "AssociateRan")
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRanToInstance")
        ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
 }
 
 func TestSetupExistingRanWithAssocE2TInstanceExecuteSetupRmrError(t *testing.T) {
-       readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, rmrMessengerMock, _ := initSetupRequestTestBasicMocks(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        updatedNb := *nb
@@ -375,7 +404,7 @@ func TestSetupExistingRanWithAssocE2TInstanceExecuteSetupRmrError(t *testing.T)
 }
 
 func TestSetupExistingRanWithAssocE2TInstanceConnectedSuccess(t *testing.T) {
-       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+       readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
        nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: E2TAddress, ConnectionStatus: entities.ConnectionStatus_CONNECTED}
        readerMock.On("GetNodeb", RanName).Return(nb, nil)
        updatedNb := *nb
@@ -385,5 +414,5 @@ func TestSetupExistingRanWithAssocE2TInstanceConnectedSuccess(t *testing.T) {
        _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
        assert.Nil(t, err)
        e2tInstancesManagerMock.AssertNotCalled(t, "SelectE2TInstance")
-       e2tInstancesManagerMock.AssertNotCalled(t, "AssociateRan")
+       e2tInstancesManagerMock.AssertNotCalled(t, "AddRanToInstance")
 }

diff --git a/E2Manager/managers/e2t_association_manager.go b/E2Manager/managers/e2t_association_manager.go
new file mode 100644 (file)
index 0000000..3311e60
--- /dev/null
+++ b/E2Manager/managers/e2t_association_manager.go
@@ -0,0 +1,75 @@
+//
+// 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 managers
+
+import (
+       "e2mgr/clients"
+       "e2mgr/logger"
+       "e2mgr/services"
+)
+
+type E2TAssociationManager struct {
+       logger             *logger.Logger
+       rnibDataService    services.RNibDataService
+       e2tInstanceManager IE2TInstancesManager
+       rmClient           clients.IRoutingManagerClient
+}
+
+func NewE2TAssociationManager(logger *logger.Logger, rnibDataService services.RNibDataService, e2tInstanceManager IE2TInstancesManager, rmClient clients.IRoutingManagerClient) *E2TAssociationManager {
+       return &E2TAssociationManager{
+               logger:             logger,
+               rnibDataService:    rnibDataService,
+               e2tInstanceManager: e2tInstanceManager,
+               rmClient:           rmClient,
+       }
+}
+
+func (m *E2TAssociationManager) AssociateRan(e2tAddress string, ranName string) error {
+       m.logger.Infof("#E2TAssociationManager.AssociateRan - Associating RAN %s to E2T Instance address: %s", ranName, e2tAddress)
+
+       err := m.rmClient.AssociateRanToE2TInstance(e2tAddress, ranName)
+       if err != nil {
+               m.logger.Errorf("#E2TAssociationManager.AssociateRan - RoutingManager failure: Failed to associate RAN %s to E2T %s. Error: %s", ranName, e2tAddress, err)
+               return err
+       }
+
+       nodebInfo, rnibErr := m.rnibDataService.GetNodeb(ranName)
+
+       if rnibErr != nil {
+               m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed fetching RAN from rNib. Error: %s", ranName, rnibErr)
+               return rnibErr
+       }
+
+       nodebInfo.AssociatedE2TInstanceAddress = e2tAddress
+       nodebInfo.ConnectionAttempts = 0
+       rnibErr = m.rnibDataService.UpdateNodebInfo(nodebInfo)
+       if rnibErr != nil {
+               m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed to update RAN.AssociatedE2TInstanceAddress in rNib. Error: %s", ranName, rnibErr)
+               return rnibErr
+       }
+
+       err = m.e2tInstanceManager.AddRanToInstance(ranName, e2tAddress)
+       if err != nil {
+               m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed to add RAN to E2T instance %s. Error: %s", ranName, e2tAddress, err)
+               return err
+       }
+       m.logger.Infof("#E2TAssociationManager.AssociateRan - successfully associated RAN %s with E2T %s", ranName, e2tAddress)
+       return nil
+}

diff --git a/E2Manager/managers/e2t_association_manager_test.go b/E2Manager/managers/e2t_association_manager_test.go
new file mode 100644 (file)
index 0000000..75cfb3b
--- /dev/null
+++ b/E2Manager/managers/e2t_association_manager_test.go
@@ -0,0 +1,187 @@
+//
+// 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 managers
+
+import (
+       "bytes"
+       "e2mgr/clients"
+       "e2mgr/configuration"
+       "e2mgr/e2managererrors"
+       "e2mgr/mocks"
+       "e2mgr/models"
+       "e2mgr/services"
+       "encoding/json"
+       "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+       "github.com/pkg/errors"
+       "github.com/stretchr/testify/assert"
+       "io/ioutil"
+       "net/http"
+       "testing"
+)
+
+const RanName = "test"
+const BaseRMUrl = "http://10.10.2.15:12020/routingmanager"
+
+func initE2TAssociationManagerTest(t *testing.T) (*E2TAssociationManager, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
+       log := initLog(t)
+       config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+       config.RoutingManager.BaseUrl = BaseRMUrl
+
+       readerMock := &mocks.RnibReaderMock{}
+       writerMock := &mocks.RnibWriterMock{}
+       rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
+
+       e2tInstancesManager := NewE2TInstancesManager(rnibDataService, log)
+       httpClientMock := &mocks.HttpClientMock{}
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       manager := NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
+
+       return manager, readerMock, writerMock, httpClientMock
+}
+
+func mockHttpClientAssociateRan(httpClientMock *mocks.HttpClientMock, isSuccessful bool) {
+       data := models.NewRoutingManagerE2TData(E2TAddress, RanName)
+       marshaled, _ := json.Marshal(data)
+       body := bytes.NewBuffer(marshaled)
+       url := BaseRMUrl + clients.AssociateRanToE2TInstanceApiSuffix
+       respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+       var respStatusCode int
+       if isSuccessful {
+               respStatusCode = http.StatusCreated
+       } else {
+               respStatusCode = http.StatusBadRequest
+       }
+       httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: respStatusCode, Body: respBody}, nil)
+}
+
+func TestAssociateRanSuccess(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, true)
+       nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
+       readerMock.On("GetNodeb", RanName).Return(nb, nil)
+       updatedNb := *nb
+       updatedNb.ConnectionAttempts = 0
+       updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+       writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
+       e2tInstance := &entities.E2TInstance{Address: E2TAddress}
+       readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
+       updatedE2tInstance := *e2tInstance
+       updatedE2tInstance.AssociatedRanList = append(updatedE2tInstance.AssociatedRanList, RanName)
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.Nil(t, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}
+
+func TestAssociateRanRoutingManagerError(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, false)
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.NotNil(t, err)
+       assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}
+
+func TestAssociateRanGetNodebError(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, true)
+       var nb *entities.NodebInfo
+       readerMock.On("GetNodeb", RanName).Return(nb, e2managererrors.NewRnibDbError())
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.NotNil(t, err)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}
+
+func TestAssociateRanUpdateNodebError(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, true)
+       nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
+       readerMock.On("GetNodeb", RanName).Return(nb, nil)
+       updatedNb := *nb
+       updatedNb.ConnectionAttempts = 0
+       updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+       writerMock.On("UpdateNodebInfo", &updatedNb).Return(e2managererrors.NewRnibDbError())
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.NotNil(t, err)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}
+
+func TestAssociateRanGetE2tInstanceError(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, true)
+       nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
+       readerMock.On("GetNodeb", RanName).Return(nb, nil)
+       updatedNb := *nb
+       updatedNb.ConnectionAttempts = 0
+       updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+       writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
+       var e2tInstance *entities.E2TInstance
+       readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, errors.New("test"))
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.NotNil(t, err)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}
+
+func TestAssociateRanSaveE2tInstanceError(t *testing.T) {
+       manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+       mockHttpClientAssociateRan(httpClientMock, true)
+       nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
+       readerMock.On("GetNodeb", RanName).Return(nb, nil)
+       updatedNb := *nb
+       updatedNb.ConnectionAttempts = 0
+       updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+       writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
+       e2tInstance := &entities.E2TInstance{Address: E2TAddress}
+       readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
+       updatedE2tInstance := *e2tInstance
+       updatedE2tInstance.AssociatedRanList = append(updatedE2tInstance.AssociatedRanList, RanName)
+       writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(errors.New("test"))
+
+       err := manager.AssociateRan(E2TAddress, RanName)
+
+       assert.NotNil(t, err)
+       assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+       readerMock.AssertExpectations(t)
+       writerMock.AssertExpectations(t)
+       httpClientMock.AssertExpectations(t)
+}

diff --git a/E2Manager/managers/e2t_instances_manager.go b/E2Manager/managers/e2t_instances_manager.go
index 74f6a51..eefeea1 100644 (file)
--- a/E2Manager/managers/e2t_instances_manager.go
+++ b/E2Manager/managers/e2t_instances_manager.go
@@ -14,6 +14,8 @@
 // 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 managers
 
@@ -41,8 +43,8 @@ type IE2TInstancesManager interface {
        AddE2TInstance(e2tAddress string) error
        RemoveE2TInstance(e2tInstance *entities.E2TInstance) error
        SelectE2TInstance() (string, error)
-       AssociateRan(ranName string, e2tAddress string) error
-       DissociateRan(ranName string, e2tAddress string) error
+       AddRanToInstance(ranName string, e2tAddress string) error
+       RemoveRanFromInstance(ranName string, e2tAddress string) error
        ActivateE2TInstance(e2tInstance *entities.E2TInstance) error
        ResetKeepAliveTimestamp(e2tAddress string) error
 }
@@ -223,7 +225,7 @@ func (m *E2TInstancesManager) AddE2TInstance(e2tAddress string) error {
        return nil
 }
 
-func (m *E2TInstancesManager) DissociateRan(ranName string, e2tAddress string) error {
+func (m *E2TInstancesManager) RemoveRanFromInstance(ranName string, e2tAddress string) error {
 
        m.mux.Lock()
        defer m.mux.Unlock()
@@ -231,7 +233,7 @@ func (m *E2TInstancesManager) DissociateRan(ranName string, e2tAddress string) e
        e2tInstance, err := m.rnibDataService.GetE2TInstance(e2tAddress)
 
        if err != nil {
-               m.logger.Errorf("#E2TInstancesManager.DissociateRan - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
+               m.logger.Errorf("#E2TInstancesManager.RemoveRanFromInstance - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
                return err
        }
 
@@ -249,11 +251,11 @@ func (m *E2TInstancesManager) DissociateRan(ranName string, e2tAddress string) e
        err = m.rnibDataService.SaveE2TInstance(e2tInstance)
 
        if err != nil {
-               m.logger.Errorf("#E2TInstancesManager.DissociateRan - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
+               m.logger.Errorf("#E2TInstancesManager.RemoveRanFromInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
                return err
        }
 
-       m.logger.Infof("#E2TInstancesManager.DissociateRan - successfully dissociated RAN %s from E2T %s", ranName, e2tInstance.Address)
+       m.logger.Infof("#E2TInstancesManager.RemoveRanFromInstance - successfully dissociated RAN %s from E2T %s", ranName, e2tInstance.Address)
        return nil
 }
 
@@ -284,7 +286,7 @@ func (m *E2TInstancesManager) SelectE2TInstance() (string, error) {
        return min.Address, nil
 }
 
-func (m *E2TInstancesManager) AssociateRan(ranName string, e2tAddress string) error {
+func (m *E2TInstancesManager) AddRanToInstance(ranName string, e2tAddress string) error {
 
        m.mux.Lock()
        defer m.mux.Unlock()
@@ -292,7 +294,7 @@ func (m *E2TInstancesManager) AssociateRan(ranName string, e2tAddress string) er
        e2tInstance, err := m.rnibDataService.GetE2TInstance(e2tAddress)
 
        if err != nil {
-               m.logger.Errorf("#E2TInstancesManager.AssociateRan - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
+               m.logger.Errorf("#E2TInstancesManager.AddRanToInstance - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
                return e2managererrors.NewRnibDbError()
        }
 
@@ -301,29 +303,29 @@ func (m *E2TInstancesManager) AssociateRan(ranName string, e2tAddress string) er
        err = m.rnibDataService.SaveE2TInstance(e2tInstance)
 
        if err != nil {
-               m.logger.Errorf("#E2TInstancesManager.AssociateRan - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
+               m.logger.Errorf("#E2TInstancesManager.AddRanToInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
                return e2managererrors.NewRnibDbError()
        }
 
-       m.logger.Infof("#E2TInstancesManager.AssociateRan - successfully associated RAN %s with E2T %s", ranName, e2tInstance.Address)
+       m.logger.Infof("#E2TInstancesManager.AddRanToInstance - RAN %s was added successfully to E2T %s", ranName, e2tInstance.Address)
        return nil
 }
 
-func (h E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error{
+func (m E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error{
 
        if e2tInstance == nil {
-               h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - e2tInstance empty")
+               m.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - e2tInstance empty")
                return e2managererrors.NewInternalError()
        }
 
-       h.logger.Infof("#E2TInstancesManager.ActivateE2TInstance - E2T Address: %s - activate E2T instance", e2tInstance.Address)
+       m.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)
+       err := m.rnibDataService.SaveE2TInstance(e2tInstance)
        if err != nil {
-               h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tInstance.Address, err)
+               m.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tInstance.Address, err)
                return err
        }
        return nil

diff --git a/E2Manager/managers/e2t_instances_manager_test.go b/E2Manager/managers/e2t_instances_manager_test.go
index fb564e5..fd58925 100644 (file)
--- a/E2Manager/managers/e2t_instances_manager_test.go
+++ b/E2Manager/managers/e2t_instances_manager_test.go
@@ -14,6 +14,9 @@
 // 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 managers
 
 import (
@@ -130,30 +133,30 @@ func TestGetE2TInstanceSuccess(t *testing.T) {
        assert.Equal(t, e2tInstance, res)
 }
 
-func TestAssociateRanGetInstanceFailure(t *testing.T) {
+func TestAddRanToInstanceGetInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        var e2tInstance1 *entities.E2TInstance
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 }
 
-func TestAssociateRanSaveInstanceFailure(t *testing.T) {
+func TestAddRanToInstanceSaveInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        e2tInstance1 := entities.NewE2TInstance(E2TAddress)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestAssociateRanSuccess(t *testing.T) {
+func TestAddRanToInstanceSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
        e2tInstance := entities.NewE2TInstance(E2TAddress)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
@@ -163,36 +166,36 @@ func TestAssociateRanSuccess(t *testing.T) {
 
        rnibWriterMock.On("SaveE2TInstance", &updateE2TInstance).Return(nil)
 
-       err := e2tInstancesManager.AssociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.AddRanToInstance("test1", E2TAddress)
        assert.Nil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestDissociateRanGetInstanceFailure(t *testing.T) {
+func TestRemoveRanFromInstanceGetInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        var e2tInstance1 *entities.E2TInstance
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, common.NewInternalError(fmt.Errorf("for test")))
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
 }
 
-func TestDissociateRanSaveInstanceFailure(t *testing.T) {
+func TestRemoveRanFromInstanceSaveInstanceFailure(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        e2tInstance1 := entities.NewE2TInstance(E2TAddress)
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance1, nil)
        rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(fmt.Errorf("for test")))
 
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.NotNil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)
 }
 
-func TestDissociateRanSuccess(t *testing.T) {
+func TestRemoveRanFromInstanceSuccess(t *testing.T) {
        rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
 
        e2tInstance := entities.NewE2TInstance(E2TAddress)
@@ -202,7 +205,7 @@ func TestDissociateRanSuccess(t *testing.T) {
        rnibReaderMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
        rnibWriterMock.On("SaveE2TInstance", &updatedE2TInstance).Return(nil)
 
-       err := e2tInstancesManager.DissociateRan("test1", E2TAddress)
+       err := e2tInstancesManager.RemoveRanFromInstance("test1", E2TAddress)
        assert.Nil(t, err)
        rnibReaderMock.AssertExpectations(t)
        rnibWriterMock.AssertExpectations(t)

diff --git a/E2Manager/managers/ran_reconnection_manager.go b/E2Manager/managers/ran_reconnection_manager.go
index 530a2cf..7a1dab7 100644 (file)
--- a/E2Manager/managers/ran_reconnection_manager.go
+++ b/E2Manager/managers/ran_reconnection_manager.go
@@ -72,7 +72,7 @@ func (m *RanReconnectionManager) ReconnectRan(inventoryName string) error {
                }
 
                if m.isRanExceededConnectionAttempts(nodebInfo) {
-                       return m.e2tInstancesManager.DissociateRan(nodebInfo.RanName, e2tAddress)
+                       return m.e2tInstancesManager.RemoveRanFromInstance(nodebInfo.RanName, e2tAddress)
                }
 
                return nil

diff --git a/E2Manager/mocks/e2t_instances_manager_mock.go b/E2Manager/mocks/e2t_instances_manager_mock.go
index 235c76a..8bf6e75 100644 (file)
--- a/E2Manager/mocks/e2t_instances_manager_mock.go
+++ b/E2Manager/mocks/e2t_instances_manager_mock.go
@@ -46,12 +46,12 @@ func (m *E2TInstancesManagerMock) SelectE2TInstance() (string, error) {
        return args.String(0), args.Error(1)
 }
 
-func (m *E2TInstancesManagerMock) AssociateRan(ranName string, e2tAddress string) error {
+func (m *E2TInstancesManagerMock) AddRanToInstance(ranName string, e2tAddress string) error {
        args := m.Called(ranName, e2tAddress)
        return args.Error(0)
 
 }
-func (m *E2TInstancesManagerMock) DissociateRan(ranName string, e2tAddress string) error {
+func (m *E2TInstancesManagerMock) RemoveRanFromInstance(ranName string, e2tAddress string) error {
        args := m.Called(ranName, e2tAddress)
        return args.Error(0)
 

diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
index 1e601f9..6a306e1 100644 (file)
--- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
+++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider.go
@@ -47,23 +47,23 @@ type IncomingRequestHandlerProvider struct {
        logger     *logger.Logger
 }
 
-func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager) *IncomingRequestHandlerProvider {
+func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager) *IncomingRequestHandlerProvider {
 
        return &IncomingRequestHandlerProvider{
-               requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, ranSetupManager, e2tInstancesManager),
+               requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager),
                logger:     logger,
        }
 }
 
-func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
+func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, e2tAssociationManager *managers.E2TAssociationManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
 
        return map[IncomingRequest]httpmsghandlers.RequestHandler{
-               ShutdownRequest:        httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService), //TODO change to pointer
-               ResetRequest:           httpmsghandlers.NewX2ResetRequestHandler(logger, rmrSender, rNibDataService),
-               X2SetupRequest:         httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, e2tInstancesManager),
-               EndcSetupRequest:       httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, e2tInstancesManager),
-               GetNodebRequest:        httpmsghandlers.NewGetNodebRequestHandler(logger, rNibDataService),
-               GetNodebIdListRequest:  httpmsghandlers.NewGetNodebIdListRequestHandler(logger, rNibDataService),
+               ShutdownRequest:  httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService), //TODO change to pointer
+               ResetRequest:     httpmsghandlers.NewX2ResetRequestHandler(logger, rmrSender, rNibDataService),
+               X2SetupRequest:   httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, e2tInstancesManager, e2tAssociationManager),
+               EndcSetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, e2tInstancesManager, e2tAssociationManager),
+               GetNodebRequest:  httpmsghandlers.NewGetNodebRequestHandler(logger, rNibDataService),
+               GetNodebIdListRequest: httpmsghandlers.NewGetNodebIdListRequestHandler(logger, rNibDataService),
                GetE2TInstancesRequest: httpmsghandlers.NewGetE2TInstancesRequestHandler(logger, e2tInstancesManager),
        }
 }

diff --git a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
index 840d9c2..2d223b8 100644 (file)
--- a/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
+++ b/E2Manager/providers/httpmsghandlerprovider/incoming_request_handler_provider_test.go
@@ -21,6 +21,7 @@
 package httpmsghandlerprovider
 
 import (
+       "e2mgr/clients"
        "e2mgr/configuration"
        "e2mgr/e2managererrors"
        "e2mgr/handlers/httpmsghandlers"
@@ -46,13 +47,17 @@ func setupTest(t *testing.T) *IncomingRequestHandlerProvider {
        rmrMessengerMock := &mocks.RmrMessengerMock{}
        log := initLog(t)
        config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+       config.RoutingManager.BaseUrl = "http://10.10.2.15:12020/routingmanager"
        readerMock := &mocks.RnibReaderMock{}
        writerMock := &mocks.RnibWriterMock{}
        rnibDataService := services.NewRnibDataService(log, config, readerMock, writerMock)
        rmrSender := getRmrSender(rmrMessengerMock, log)
        ranSetupManager := managers.NewRanSetupManager(log, rmrSender, rnibDataService)
        e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
-       return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager)
+       httpClientMock := &mocks.HttpClientMock{}
+       rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
+       e2tAssociationManager := managers.NewE2TAssociationManager(log, rnibDataService, e2tInstancesManager, rmClient)
+       return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager, e2tAssociationManager)
 }
 
 func TestNewIncomingRequestHandlerProvider(t *testing.T) {