e2tShutdownManager := managers.NewE2TShutdownManager(logger, config, rnibDataService, e2tInstancesManager, e2tAssociationManager, ranConnectStatusChangeManager)
e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
rmrReceiver := rmrreceiver.NewRmrReceiver(logger, rmrMessenger, notificationManager)
go rmrReceiver.ListenAndHandle()
go e2tKeepAliveWorker.Execute()
- httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
+ httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
rootController := controllers.NewRootController(rnibDataService)
nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
e2tController := controllers.NewE2TController(logger, httpMsgHandlerProvider)
# The Jenkins job requires a tag to build the Docker image.
# Global-JJB script assumes this file is in the repo root.
---
-tag: 5.2.14
+tag: 5.2.15
nodebValidator := managers.NewNodebValidator()
updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
- handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, nil, config, rnibDataService, e2tInstancesManager, nil, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
+ handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, nil, config, rnibDataService, e2tInstancesManager, nil, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
controller := NewE2TController(log, handlerProvider)
return controller, readerMock
}
}
type saveNodebParams struct {
- nodebInfo *entities.NodebInfo
- nbIdentity *entities.NbIdentity
- err error
+ err error
+}
+
+type addNbIdentityParams struct {
+ err error
}
type removeServedCellsParams struct {
type controllerAddEnbTestContext struct {
getNodebInfoResult *getNodebInfoResult
saveNodebParams *saveNodebParams
+ addNbIdentityParams *addNbIdentityParams
requestBody map[string]interface{}
expectedStatusCode int
expectedJsonResponse string
func getUpdateEnbRequest(propToOmit string) map[string]interface{} {
ret := map[string]interface{}{
- "enb": buildEnb(propToOmit),
+ "enb": buildEnb(propToOmit),
}
if len(propToOmit) != 0 {
return ret
}
-
func getAddEnbRequest(propToOmit string) map[string]interface{} {
ret := map[string]interface{}{
"ranName": RanName,
e2tInstancesManager := &mocks.E2TInstancesManagerMock{}
httpClientMock := &mocks.HttpClientMock{}
rmClient := clients.NewRoutingManagerClient(log, config, httpClientMock)
- ranListManager := &mocks.RanListManagerMock{}
+ ranListManager := managers.NewRanListManager(log, rnibDataService)
ranAlarmService := &mocks.RanAlarmServiceMock{}
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(log, rnibDataService, ranListManager, ranAlarmService)
nodebValidator := managers.NewNodebValidator()
updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
- handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
+ handlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(log, rmrSender, config, rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
controller := NewNodebController(log, handlerProvider)
return controller, readerMock, writerMock, rmrMessengerMock, e2tInstancesManager
}
assert.Equal(t, context.expectedJsonResponse, string(bodyBytes))
}
-func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock,updateEnbRequest *models.UpdateEnbRequest) {
+func activateControllerUpdateEnbMocks(context *controllerUpdateEnbTestContext, readerMock *mocks.RnibReaderMock, writerMock *mocks.RnibWriterMock, updateEnbRequest *models.UpdateEnbRequest) {
if context.getNodebInfoResult != nil {
readerMock.On("GetNodeb", RanName).Return(context.getNodebInfoResult.nodebInfo, context.getNodebInfoResult.rnibError)
}
ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,
}
- //nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId}
writerMock.On("SaveNodeb", &nodebInfo).Return(context.saveNodebParams.err)
- // TODO: add writerMock.On("AddNbIdentity")
+ }
+
+ if context.addNbIdentityParams != nil {
+ nbIdentity := entities.NbIdentity{InventoryName: addEnbRequest.RanName, GlobalNbId: addEnbRequest.GlobalNbId, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
+ writerMock.On("AddNbIdentity", entities.Node_ENB, &nbIdentity).Return(context.addNbIdentityParams.err)
}
}
func TestControllerUpdateEnbEmptyEnbType(t *testing.T) {
context := controllerUpdateEnbTestContext{
- getNodebInfoResult: nil,
- requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
+ getNodebInfoResult: nil,
+ requestBody: getUpdateEnbRequest(EnbRequiredFields[0]),
expectedStatusCode: http.StatusBadRequest,
expectedJsonResponse: ValidationFailureJson,
}
func TestControllerUpdateEnbEmptyServedCells(t *testing.T) {
context := controllerUpdateEnbTestContext{
- getNodebInfoResult: nil,
- requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
+ getNodebInfoResult: nil,
+ requestBody: getUpdateEnbRequest(EnbRequiredFields[1]),
expectedStatusCode: http.StatusBadRequest,
expectedJsonResponse: ValidationFailureJson,
}
func TestControllerUpdateEnbMissingEnb(t *testing.T) {
context := controllerUpdateEnbTestContext{
- getNodebInfoResult: nil,
- requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
+ getNodebInfoResult: nil,
+ requestBody: getUpdateEnbRequest(UpdateEnbRequestRequiredFields[0]),
expectedStatusCode: http.StatusBadRequest,
expectedJsonResponse: ValidationFailureJson,
}
nodebInfo: nil,
rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusNotFound,
expectedJsonResponse: ResourceNotFoundJson,
}
nodebInfo: nil,
rnibError: common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")),
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusInternalServerError,
expectedJsonResponse: RnibErrorJson,
}
},
rnibError: nil,
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusBadRequest,
expectedJsonResponse: ValidationFailureJson,
}
},
rnibError: nil,
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusInternalServerError,
expectedJsonResponse: RnibErrorJson,
}
oldServedCells := generateServedCells("whatever1", "whatever2")
context := controllerUpdateEnbTestContext{
removeServedCellsParams: &removeServedCellsParams{
- err: nil,
+ err: nil,
servedCellInfo: oldServedCells,
},
updateEnbCellsParams: &updateEnbCellsParams{
},
rnibError: nil,
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusInternalServerError,
expectedJsonResponse: RnibErrorJson,
}
oldServedCells := generateServedCells("whatever1", "whatever2")
context := controllerUpdateEnbTestContext{
removeServedCellsParams: &removeServedCellsParams{
- err: nil,
+ err: nil,
servedCellInfo: oldServedCells,
},
updateEnbCellsParams: &updateEnbCellsParams{
},
rnibError: nil,
},
- requestBody: getUpdateEnbRequest(""),
+ requestBody: getUpdateEnbRequest(""),
expectedStatusCode: http.StatusOK,
expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"CONNECTED\",\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]},\"associatedE2tInstanceAddress\":\"10.0.2.15:38000\"}",
}
controllerAddEnbTestExecuter(t, &context)
}
+func TestControllerAddEnbAddNbIdentityFailure(t *testing.T) {
+ context := controllerAddEnbTestContext{
+ saveNodebParams: &saveNodebParams{
+ err: nil,
+ },
+ addNbIdentityParams: &addNbIdentityParams{
+ err: common.NewInternalError(errors.New("#writer.addNbIdentity - Internal Error")),
+ },
+ getNodebInfoResult: &getNodebInfoResult{
+ nodebInfo: nil,
+ rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
+ },
+ requestBody: getAddEnbRequest(""),
+ expectedStatusCode: http.StatusInternalServerError,
+ expectedJsonResponse: RnibErrorJson,
+ }
+
+ controllerAddEnbTestExecuter(t, &context)
+}
+
func TestControllerAddEnbMissingRequiredRequestProps(t *testing.T) {
for _, v := range AddEnbRequestRequiredFields {
saveNodebParams: &saveNodebParams{
err: nil,
},
+ addNbIdentityParams: &addNbIdentityParams{
+ err: nil,
+ },
getNodebInfoResult: &getNodebInfoResult{
nodebInfo: nil,
rnibError: common.NewResourceNotFoundError("#reader.GetNodeb - Not found Error"),
},
- requestBody: map[string]interface{}{
- "ranName": RanName,
- "globalNbId": map[string]interface{}{
- "plmnId": "whatever",
- "nbId": "whatever2",
- },
- "enb": map[string]interface{}{
- "enbType": 1,
- "servedCells": []interface{}{
- buildServedCell(""),
- },
- },
- },
+ requestBody: getAddEnbRequest(""),
expectedStatusCode: http.StatusCreated,
expectedJsonResponse: "{\"ranName\":\"test\",\"connectionStatus\":\"DISCONNECTED\",\"globalNbId\":{\"plmnId\":\"whatever\",\"nbId\":\"whatever2\"},\"nodeType\":\"ENB\",\"enb\":{\"enbType\":\"MACRO_ENB\",\"servedCells\":[{\"pci\":1,\"cellId\":\"whatever\",\"tac\":\"whatever3\",\"broadcastPlmns\":[\"whatever\"],\"choiceEutraMode\":{\"fdd\":{}},\"eutraMode\":\"FDD\"}]}}",
}
logger *logger.Logger
nodebValidator *managers.NodebValidator
rNibDataService services.RNibDataService
+ ranListManager managers.RanListManager
}
-func NewAddEnbRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService, nodebValidator *managers.NodebValidator) *AddEnbRequestHandler {
+func NewAddEnbRequestHandler(logger *logger.Logger, rNibDataService services.RNibDataService, nodebValidator *managers.NodebValidator, ranListManager managers.RanListManager) *AddEnbRequestHandler {
return &AddEnbRequestHandler{
logger: logger,
nodebValidator: nodebValidator,
rNibDataService: rNibDataService,
+ ranListManager: ranListManager,
}
}
return nil, e2managererrors.NewRnibDbError()
}
- _ = h.createNbIdentity(addEnbRequest) // TODO: add call to ranListManager
+ nbIdentity := h.createNbIdentity(addEnbRequest)
+ err = h.ranListManager.AddNbIdentity(entities.Node_ENB, nbIdentity)
+
+ if err != nil {
+ return nil, e2managererrors.NewRnibDbError()
+ }
return models.NewNodebResponse(nodebInfo), nil
}
rNibDataService services.RNibDataService
e2tAssociationManager *managers.E2TAssociationManager
ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager
+ ranListManager managers.RanListManager
}
-func NewE2SetupRequestNotificationHandler(logger *logger.Logger, config *configuration.Configuration, e2tInstancesManager managers.IE2TInstancesManager, rmrSender *rmrsender.RmrSender, rNibDataService services.RNibDataService, e2tAssociationManager *managers.E2TAssociationManager, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager) *E2SetupRequestNotificationHandler {
+func NewE2SetupRequestNotificationHandler(logger *logger.Logger, config *configuration.Configuration, e2tInstancesManager managers.IE2TInstancesManager, rmrSender *rmrsender.RmrSender, rNibDataService services.RNibDataService, e2tAssociationManager *managers.E2TAssociationManager, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, ranListManager managers.RanListManager) *E2SetupRequestNotificationHandler {
return &E2SetupRequestNotificationHandler{
logger: logger,
config: config,
rNibDataService: rNibDataService,
e2tAssociationManager: e2tAssociationManager,
ranConnectStatusChangeManager: ranConnectStatusChangeManager,
+ ranListManager: ranListManager,
}
}
return nil, err
}
- _ = h.buildNbIdentity(ranName, setupRequest) // TODO: add call to ranListManager
+ nbIdentity := h.buildNbIdentity(ranName, setupRequest)
+
+ err = h.ranListManager.AddNbIdentity(entities.Node_GNB, nbIdentity)
+
+ if err != nil {
+ return nil, err
+ }
return nodebInfo, nil
}
}
-func TestE2SetupRequestNotificationHandler_HandleNewRanError(t *testing.T) {
+func TestE2SetupRequestNotificationHandler_HandleNewRanSaveNodebFailure(t *testing.T) {
xml := readXmlFile(t, GnbSetupRequestXmlPath)
handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
nodebInfo := getExpectedNodebForNewRan(notificationRequest.Payload)
writerMock.On("SaveNodeb", nodebInfo).Return(common.NewInternalError(errors.New("error")))
- //nbIdentity := &entities.NbIdentity{InventoryName: nodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
- // TODO: add writerMock.On("AddNbIdentity")
handler.Handle(notificationRequest)
readerMock.AssertExpectations(t)
e2tInstancesManagerMock.AssertExpectations(t)
}
+func TestE2SetupRequestNotificationHandler_HandleNewRanAddNbIdentityFailure(t *testing.T) {
+ xml := readXmlFile(t, GnbSetupRequestXmlPath)
+ handler, readerMock, writerMock, _, e2tInstancesManagerMock, _ := initMocks(t)
+ readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
+ e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
+ var gnb *entities.NodebInfo
+ readerMock.On("GetNodeb", nodebRanName).Return(gnb, common.NewResourceNotFoundError("Not found"))
+ notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
+ nodebInfo := getExpectedNodebForNewRan(notificationRequest.Payload)
+ writerMock.On("SaveNodeb", nodebInfo).Return(nil)
+ nbIdentity := &entities.NbIdentity{InventoryName: nodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
+ writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(common.NewInternalError(errors.New("error")))
+ handler.Handle(notificationRequest)
+ readerMock.AssertExpectations(t)
+ writerMock.AssertExpectations(t)
+ e2tInstancesManagerMock.AssertExpectations(t)
+}
+
func testE2SetupRequestNotificationHandler_HandleNewRanSuccess(t *testing.T, xmlPath string) {
xml := readXmlFile(t, xmlPath)
handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock := initMocks(t)
notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xml...)}
nodebInfo := getExpectedNodebForNewRan(notificationRequest.Payload)
writerMock.On("SaveNodeb", nodebInfo).Return(nil)
- //nbIdentity := &entities.NbIdentity{InventoryName: nodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
- // TODO: add writerMock.On("AddNbIdentity")
+ nbIdentity := &entities.NbIdentity{InventoryName: nodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
+ writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
updatedNodebInfo := *nodebInfo
updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, nodebRanName+"_CONNECTED").Return(nil)
notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append([]byte(e2SetupMsgPrefix), xmlGnb...)}
nodebInfo := getExpectedNodebForNewRan(notificationRequest.Payload)
writerMock.On("SaveNodeb", nodebInfo).Return(nil)
+ nbIdentity := &entities.NbIdentity{InventoryName: nodebRanName, GlobalNbId: nodebInfo.GlobalNbId}
+ writerMock.On("AddNbIdentity", entities.Node_GNB, nbIdentity).Return(nil)
updatedNodebInfo := *nodebInfo
updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", &updatedNodebInfo, nodebRanName+"_CONNECTED").Return(nil)
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
- handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
+ handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
readerMock.On("GetGeneralConfiguration").Return(&entities.GeneralConfiguration{EnableRic: true}, nil)
e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceFullAddress).Return(&entities.E2TInstance{}, nil)
var gnb *entities.NodebInfo
readerMock.On("GetNodeb", mock.Anything).Return(gnb, common.NewResourceNotFoundError("Not found"))
writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(nil)
+ writerMock.On("AddNbIdentity", entities.Node_GNB, mock.Anything).Return(nil)
writerMock.On("UpdateNodebInfoOnConnectionStatusInversion", mock.Anything, mock.Anything).Return(nil)
routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(nil)
writerMock.On("UpdateNodebInfo", mock.Anything).Return(nil)
ranAlarmService := services.NewRanAlarmService(logger, config)
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock, ranConnectStatusChangeManager)
- handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
+ handler := NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManagerMock, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
return handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
}
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService,ranListManager, ranAlarmService)
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager,routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager,routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
notificationManager := NewNotificationManager(logger, rmrNotificationHandlerProvider )
return logger, readerMock, notificationManager
}
nbIds, err := m.rnibDataService.GetListNodebIds()
if err != nil {
- m.logger.Errorf("#ranListManagerInstance.InitRanList - Failed fetching RAN list from DB. error: %s", err)
+ m.logger.Errorf("#ranListManagerInstance.InitNbIdentityMap - Failed fetching RAN list from DB. error: %s", err)
return err
}
m.nbIdentityMap[v.InventoryName] = v
}
- m.logger.Infof("#ranListManagerInstance.InitRanList - Successfully initiated nodeb identity map")
+ m.logger.Infof("#ranListManagerInstance.InitNbIdentityMap - Successfully initiated nodeb identity map")
+ m.logger.Debugf("#ranListManagerInstance.InitNbIdentityMap - nodeb Identity map: %s", m.nbIdentityMap)
return nil
}
}
m.logger.Infof("#ranListManagerInstance.AddNbIdentity - RAN name: %s - Successfully added nodeb identity", nbIdentity.InventoryName)
+ m.logger.Debugf("#ranListManagerInstance.AddNbIdentity - nodeb Identity map: %s", m.nbIdentityMap)
return nil
}
--- /dev/null
+//
+// 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/configuration"
+ "e2mgr/logger"
+ "e2mgr/mocks"
+ "e2mgr/services"
+ "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/pkg/errors"
+ "github.com/stretchr/testify/assert"
+ "testing"
+)
+
+func initRanListManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, RanListManager) {
+ logger, err := logger.InitLogger(logger.DebugLevel)
+ if err != nil {
+ t.Fatalf("#... - failed to initialize logger, error: %s", err)
+ }
+
+ config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3,
+ RnibWriter: configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE"}}
+
+ readerMock := &mocks.RnibReaderMock{}
+ writerMock := &mocks.RnibWriterMock{}
+ rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+ ranListManager := NewRanListManager(logger, rnibDataService)
+ return readerMock, writerMock, ranListManager
+}
+
+func TestRanListManagerInstance_InitNbIdentityMapSuccess(t *testing.T) {
+ readerMock, _, ranListManager := initRanListManagerTest(t)
+ readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{{InventoryName: RanName, GlobalNbId: &entities.GlobalNbId{NbId: "asd", PlmnId: "efg"}, ConnectionStatus: entities.ConnectionStatus_CONNECTED}}, nil)
+ err := ranListManager.InitNbIdentityMap()
+ assert.Nil(t, err)
+}
+
+func TestRanListManagerInstance_InitNbIdentityMapFailure(t *testing.T) {
+ readerMock, _, ranListManager := initRanListManagerTest(t)
+ readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, common.NewInternalError(errors.New("#reader.GetListNodebIds - Internal Error")))
+ err := ranListManager.InitNbIdentityMap()
+ assert.NotNil(t, err)
+}
\ No newline at end of file
ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager
}
-func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager) *IncomingRequestHandlerProvider {
+func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager, ranListManager managers.RanListManager) *IncomingRequestHandlerProvider {
return &IncomingRequestHandlerProvider{
- requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager),
+ requestMap: initRequestHandlerMap(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager),
logger: logger,
ranConnectStatusChangeManager: ranConnectStatusChangeManager,
}
}
-func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
+func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, rmClient clients.IRoutingManagerClient, ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, nodebValidator *managers.NodebValidator, updateEnbManager managers.IUpdateNodebManager, ranListManager managers.RanListManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
return map[IncomingRequest]httpmsghandlers.RequestHandler{
ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager),
GetE2TInstancesRequest: httpmsghandlers.NewGetE2TInstancesRequestHandler(logger, e2tInstancesManager),
UpdateGnbRequest: httpmsghandlers.NewUpdateGnbRequestHandler(logger, rNibDataService),
UpdateEnbRequest: httpmsghandlers.NewUpdateNodebRequestHandler(logger, rNibDataService, updateEnbManager),
- AddEnbRequest: httpmsghandlers.NewAddEnbRequestHandler(logger, rNibDataService, nodebValidator),
+ AddEnbRequest: httpmsghandlers.NewAddEnbRequestHandler(logger, rNibDataService, nodebValidator, ranListManager),
DeleteEnbRequest: httpmsghandlers.NewDeleteEnbRequestHandler(logger, rNibDataService),
}
}
nodebValidator := managers.NewNodebValidator()
updateEnbManager := managers.NewUpdateEnbManager(log, rnibDataService, nodebValidator)
- return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager)
+ return NewIncomingRequestHandlerProvider(log, rmrSender, configuration.ParseConfiguration(), rnibDataService, e2tInstancesManager, rmClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, ranListManager)
}
func TestNewIncomingRequestHandlerProvider(t *testing.T) {
func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration,
rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, e2tInstancesManager managers.IE2TInstancesManager,
routingManagerClient clients.IRoutingManagerClient, e2tAssociationManager *managers.E2TAssociationManager,
- ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager) {
+ ranConnectStatusChangeManager managers.IRanConnectStatusChangeManager, ranListManager managers.RanListManager) {
// Init converters
x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger)
x2ResetRequestNotificationHandler := rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender)
e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, e2tInstancesManager, routingManagerClient)
e2TKeepAliveResponseHandler := rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager)
- e2SetupRequestNotificationHandler := rmrmsghandlers.NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManager, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
+ e2SetupRequestNotificationHandler := rmrmsghandlers.NewE2SetupRequestNotificationHandler(logger, config, e2tInstancesManager, rmrSender, rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
provider.Register(rmrCgo.RIC_X2_SETUP_RESP, x2SetupResponseHandler)
provider.Register(rmrCgo.RIC_X2_SETUP_FAILURE, x2SetupFailureResponseHandler)
* Verify support for known providers.
*/
-func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, managers.IE2TInstancesManager, clients.IRoutingManagerClient, *managers.E2TAssociationManager, managers.IRanConnectStatusChangeManager) {
+func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, managers.IE2TInstancesManager, clients.IRoutingManagerClient, *managers.E2TAssociationManager, managers.IRanConnectStatusChangeManager, managers.RanListManager) {
logger := initLog(t)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, RnibWriter: configuration.RnibWriterConfig{StateChangeMessageChannel: "RAN_CONNECTION_STATUS_CHANGE", RanManipulationMessageChannel: "RAN_MANIPULATION"}}
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
- return logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager
+ return logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager
}
func TestGetNotificationHandlerSuccess(t *testing.T) {
- logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
+ logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager := initTestCase(t)
ranDisconnectionManager := managers.NewRanDisconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, e2tAssociationManager, ranConnectStatusChangeManager)
ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender)
for _, tc := range testCases {
provider := NewNotificationHandlerProvider()
- provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+ provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
handler, err := provider.GetNotificationHandler(tc.msgType)
if err != nil {
}
for _, tc := range testCases {
- logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager := initTestCase(t)
+ logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager := initTestCase(t)
provider := NewNotificationHandlerProvider()
- provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+ provider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
_, err := provider.GetNotificationHandler(tc.msgType)
if err == nil {
ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
return NewRmrReceiver(logger, rmrMessenger, notificationManager)
}