-/.idea/e2mgr.iml
-/.idea/encodings.xml
-/.idea/misc.xml
-/.idea/modules.xml
-/.idea/vcs.xml
-/.idea/workspace.xml
+/.idea/*
.vscode/launch.json
-/.idea/sonarIssues.xml
*.o
*.a
E2Manager/asn1codec/e2ap_engine/converter-example
E2Manager/asn1codec/tests/
E2Manager/cp.out
-/Automation/Tests/ConfigurationUpdate/__pycache__/verifylogs.cpython-36.pyc
-/Automation/Tests/Get-All-Nodes/__pycache__/getnodes.cpython-36.pyc
-/Automation/Tests/LoadInfomation/__pycache__/Loadinformation_adding_data_and_overwrite.robot
-/Automation/Tests/LoadInfomation/__pycache__/Loadinformation_verify_saving.robot
-/Automation/Tests/LoadInfomation/__pycache__/__init__.robot
-/Automation/Tests/LoadInfomation/__pycache__/config.py
-/Automation/Tests/LoadInfomation/__pycache__/loadscripts.py
-/Automation/Tests/Resource/__pycache__/config.cpython-36.pyc
-/Automation/Tests/Resource/__pycache__/scripts.cpython-36.pyc
+__pycache__/
+*.html
+*.log
+
controller.X2ResetHandler(writer, req)
assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
-
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
-
}
func TestHandleErrorResponse(t *testing.T) {
"e2mgr/models"
"e2mgr/rNibWriter"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/utils"
"encoding/json"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
internalErrorMessage = "Internal Server Error. Please try again later"
)
-var E2Sessions = make(sessions.E2Sessions)
-
var messageChannel chan *models.E2RequestMessage
var errorChannel chan error
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
func executeGetNodeb(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
func executeGetNodebIdList(logger *logger.Logger, writer *httptest.ResponseRecorder, rnibReaderProvider func() reader.RNibReader) {
req, _ := http.NewRequest("GET", "/nodeb-ids", nil)
- NewNodebController(logger, nil, rnibReaderProvider, nil ).GetNodebIdList(writer,req)
+ NewNodebController(logger, nil, rnibReaderProvider, nil).GetNodebIdList(writer, req)
}
func TestNodebController_GetNodebIdList_Success(t *testing.T) {
var rnibError error
nbList := []*entities.NbIdentity{
- {InventoryName:"test1", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId1",NbId: "nbId1"}},
- {InventoryName:"test2", GlobalNbId: &entities.GlobalNbId{PlmnId:"plmnId2",NbId: "nbId2"}},
- {InventoryName:"test3", GlobalNbId: &entities.GlobalNbId{PlmnId:"",NbId: ""}},
+ {InventoryName: "test1", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId1", NbId: "nbId1"}},
+ {InventoryName: "test2", GlobalNbId: &entities.GlobalNbId{PlmnId: "plmnId2", NbId: "nbId2"}},
+ {InventoryName: "test3", GlobalNbId: &entities.GlobalNbId{PlmnId: "", NbId: ""}},
}
rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
executeGetNodebIdList(logger, writer, rnibReaderProvider)
assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
bodyBytes, err := ioutil.ReadAll(writer.Body)
- assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{}}]",string(bodyBytes) )
+ assert.Equal(t, "[{\"inventoryName\":\"test1\",\"globalNbId\":{\"plmnId\":\"plmnId1\",\"nbId\":\"nbId1\"}},{\"inventoryName\":\"test2\",\"globalNbId\":{\"plmnId\":\"plmnId2\",\"nbId\":\"nbId2\"}},{\"inventoryName\":\"test3\",\"globalNbId\":{}}]", string(bodyBytes))
}
func TestNodebController_GetNodebIdList_EmptyList(t *testing.T) {
nbList := []*entities.NbIdentity{}
rnibReaderMock.On("GetListNodebIds").Return(nbList, rnibError)
-
rnibReaderProvider := func() reader.RNibReader {
return &rnibReaderMock
}
executeGetNodebIdList(logger, writer, rnibReaderProvider)
assert.Equal(t, writer.Result().StatusCode, http.StatusInternalServerError)
-}
\ No newline at end of file
+}
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
"e2mgr/logger"
"e2mgr/managers"
"e2mgr/models"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
}
}
-func (handler E2TermInitNotificationHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (handler E2TermInitNotificationHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
logger.Infof("#E2TermInitNotificationHandler.Handle - Handling E2_TERM_INIT")
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
rnibWriterProvider := func() rNibWriter.RNibWriter {
return writerMock
}
- ranSetupManager := managers.NewRanSetupManager(logger,rmrService, rnibWriterProvider)
+ ranSetupManager := managers.NewRanSetupManager(logger, rmrService, rnibWriterProvider)
ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
return logger, readerMock, writerMock, rmrMessengerMock, ranReconnectionManager
}
rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 2)
rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg0, fmt.Errorf("RMR Error"))
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
//test1 (before send +1, after failure +1), test2 (0) test3 (0)
writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg0, nil)
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
readerMock.AssertNumberOfCalls(t, "GetNodeb", 3)
//test1 (+1), test2 failure (0) test3 (+1)
rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg0, nil)
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
readerMock.AssertNumberOfCalls(t, "GetNodeb", 2)
//test1 (+1), test2 failure (0) test3 (0)
readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, rnibErr)
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
readerMock.On("GetListNodebIds").Return([]*entities.NbIdentity{}, common.NewInternalError(fmt.Errorf("internal error")))
handler := NewE2TermInitNotificationHandler(ranReconnectMgr, readerProvider)
- handler.Handle(log, nil, nil, nil)
+ handler.Handle(log, nil, nil)
writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
// TODO: extract to test_utils
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rNibWriter"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"time"
)
return float64(time.Since(startTime)) / float64(time.Millisecond)
}
-func (src EnbLoadInformationNotificationHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (src EnbLoadInformationNotificationHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
pdu, err := converters.UnpackX2apPdu(logger, e2pdus.MaxAsn1CodecAllocationBufferSize, request.Len, request.Payload, e2pdus.MaxAsn1CodecMessageBufferSize)
import (
"e2mgr/logger"
"e2mgr/models"
- "e2mgr/sessions"
"fmt"
"time"
)
return err
}
- loadInformationHandler.Handle(log, sessions.E2Sessions{}, notificationRequest, nil)
+ loadInformationHandler.Handle(log, notificationRequest, nil)
return nil
}
// var packedExampleByteSlice []byte
// _, err = fmt.Sscanf(FullUperPdu, "%x", &packedExampleByteSlice)
// notificationRequest := models.NewNotificationRequest(inventoryName, packedExampleByteSlice, time.Now(), " 881828026419")
-// loadInformationHandler.Handle(log, sessions.E2Sessions{}, notificationRequest, nil)
+// loadInformationHandler.Handle(log, notificationRequest, nil)
//
// writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 1)
//}
// var packedExampleByteSlice []byte
// _, err = fmt.Sscanf(GarbagePdu, "%x", &packedExampleByteSlice)
// notificationRequest := models.NewNotificationRequest(inventoryName, packedExampleByteSlice, time.Now(), " 881828026419")
-// loadInformationHandler.Handle(log, sessions.E2Sessions{}, notificationRequest, nil)
+// loadInformationHandler.Handle(log, notificationRequest, nil)
//
// writerMock.AssertNumberOfCalls(t, "SaveRanLoadInformation", 0)
//}
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"unsafe"
)
return EndcConfigurationUpdateHandler{}
}
-func (src EndcConfigurationUpdateHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest,
- messageChannel chan<- *models.NotificationResponse) {
+func (src EndcConfigurationUpdateHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
var payloadSize C.ulong
payloadSize = e2pdus.MaxAsn1PackedBufferSize
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"e2mgr/tests"
"github.com/stretchr/testify/assert"
"testing"
"time"
)
-func TestHandleSuccessEndcConfigUpdate(t *testing.T){
-/* log, err := logger.InitLogger(logger.InfoLevel)
- if err!=nil{
- t.Errorf("#endc_configuration_update_handler_test.TestHandleSuccessEndcConfigUpdate - failed to initialize logger, error: %s", err)
- }
- h := EndcConfigurationUpdateHandler{}
- E2Sessions := make(sessions.E2Sessions)
+func TestHandleSuccessEndcConfigUpdate(t *testing.T) {
+ /* log, err := logger.InitLogger(logger.InfoLevel)
+ if err!=nil{
+ t.Errorf("#endc_configuration_update_handler_test.TestHandleSuccessEndcConfigUpdate - failed to initialize logger, error: %s", err)
+ }
+ h := EndcConfigurationUpdateHandler{}
- payload := tests.GetPackedPayload(t)
- mBuf := rmrCgo.NewMBuf(10370, len(payload),"RanName", &payload, &tests.DummyXAction)
- notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now()}
- messageChannel := make(chan *models.NotificationResponse)
+ payload := tests.GetPackedPayload(t)
+ mBuf := rmrCgo.NewMBuf(10370, len(payload),"RanName", &payload, &tests.DummyXAction)
+ notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now()}
+ messageChannel := make(chan *models.NotificationResponse)
- go h.Handle(log, E2Sessions, ¬ificationRequest, messageChannel)
+ go h.Handle(log, ¬ificationRequest, messageChannel)
- response := <-messageChannel
+ response := <-messageChannel
- assert.NotEmpty(t, response)
- assert.EqualValues(t, 10371, response.MgsType)
- assert.True(t, len(response.Payload) > 0)*/
+ assert.NotEmpty(t, response)
+ assert.EqualValues(t, 10371, response.MgsType)
+ assert.True(t, len(response.Payload) > 0)*/
}
-func TestHandleFailureEndcConfigUpdate(t *testing.T){
+func TestHandleFailureEndcConfigUpdate(t *testing.T) {
log, err := logger.InitLogger(logger.InfoLevel)
- if err!=nil{
+ if err != nil {
t.Errorf("#endc_configuration_update_handler_test.TestHandleFailureEndcConfigUpdate - failed to initialize logger, error: %s", err)
}
h := EndcConfigurationUpdateHandler{}
- E2Sessions := make(sessions.E2Sessions)
- mBuf := rmrCgo.NewMBuf(tests.MessageType, 4,"RanName", &tests.DummyPayload, &tests.DummyXAction)
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, 4, "RanName", &tests.DummyPayload, &tests.DummyXAction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now()}
messageChannel := make(chan *models.NotificationResponse)
- go h.Handle(log, E2Sessions, ¬ificationRequest, messageChannel)
+ go h.Handle(log, ¬ificationRequest, messageChannel)
response := <-messageChannel
import (
"e2mgr/logger"
"e2mgr/models"
- "e2mgr/sessions"
"time"
)
type NotificationHandler interface {
- Handle(*logger.Logger, sessions.E2Sessions, *models.NotificationRequest, chan<- *models.NotificationResponse)
+ Handle(*logger.Logger, *models.NotificationRequest, chan<- *models.NotificationResponse)
}
//TODO: remove that
"e2mgr/logger"
"e2mgr/managers"
"e2mgr/models"
- "e2mgr/sessions"
)
type RanLostConnectionHandler struct {
ranReconnectionManager: ranReconnectionManager,
}
}
-func (handler RanLostConnectionHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (handler RanLostConnectionHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
ranName := request.RanName
"e2mgr/logger"
"e2mgr/mocks"
"e2mgr/models"
- "e2mgr/sessions"
"github.com/pkg/errors"
"testing"
)
ranReconnectionManagerMock := &mocks.RanReconnectionManagerMock{}
ranReconnectionManagerMock.On("ReconnectRan", ranName).Return(nil)
handler := NewRanLostConnectionHandler(ranReconnectionManagerMock)
- handler.Handle(logger, make(sessions.E2Sessions), ¬ificationRequest, nil)
+ handler.Handle(logger, ¬ificationRequest, nil)
ranReconnectionManagerMock.AssertCalled(t, "ReconnectRan", ranName)
}
ranReconnectionManagerMock := &mocks.RanReconnectionManagerMock{}
ranReconnectionManagerMock.On("ReconnectRan", ranName).Return(errors.New("error"))
handler := NewRanLostConnectionHandler(ranReconnectionManagerMock)
- handler.Handle(logger, make(sessions.E2Sessions), ¬ificationRequest, nil)
+ handler.Handle(logger, ¬ificationRequest, nil)
ranReconnectionManagerMock.AssertCalled(t, "ReconnectRan", ranName)
}
\ No newline at end of file
"e2mgr/managers"
"e2mgr/models"
"e2mgr/rNibWriter"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
}
}
-func (h SetupResponseNotificationHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (h SetupResponseNotificationHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
logger.Infof("#SetupResponseNotificationHandler - RAN name: %s - Received %s notification", request.RanName, h.notificationType)
inventoryName := request.RanName
testContext := NewSetupResponseTestContext(nil)
handler := NewSetupResponseNotificationHandler(testContext.rnibReaderProvider, testContext.rnibWriterProvider, &managers.X2SetupResponseManager{}, "X2 Setup Response")
testContext.readerMock.On("GetNodeb", RanName).Return(&entities.NodebInfo{}, common.NewInternalError(errors.New("Error")))
- handler.Handle(testContext.logger, nil, ¬ificationRequest, nil)
+ handler.Handle(testContext.logger, ¬ificationRequest, nil)
testContext.readerMock.AssertCalled(t, "GetNodeb", RanName)
testContext.writerMock.AssertNotCalled(t, "SaveNodeb")
}
handler := NewSetupResponseNotificationHandler(testContext.rnibReaderProvider, testContext.rnibWriterProvider, &managers.X2SetupResponseManager{}, "X2 Setup Response")
var rnibErr error
testContext.readerMock.On("GetNodeb", ranName).Return(&entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}, rnibErr)
- handler.Handle(testContext.logger, nil, ¬ificationRequest, nil)
+ handler.Handle(testContext.logger, ¬ificationRequest, nil)
testContext.readerMock.AssertCalled(t, "GetNodeb", ranName)
testContext.writerMock.AssertNotCalled(t, "SaveNodeb")
}
testContext.readerMock.On("GetNodeb", RanName).Return(nodebInfo, rnibErr)
testContext.writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(saveNodebMockReturnValue)
- handler.Handle(testContext.logger, nil, ¬ificationRequest, nil)
+ handler.Handle(testContext.logger, ¬ificationRequest, nil)
return testContext, nodebInfo
}
handler := NewSetupResponseNotificationHandler(testContext.rnibReaderProvider, testContext.rnibWriterProvider, &managers.X2SetupResponseManager{}, "X2 Setup Response")
var rnibErr error
testContext.readerMock.On("GetNodeb", ranName).Return(&entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, ConnectionAttempts: 1}, rnibErr)
- handler.Handle(testContext.logger, nil, ¬ificationRequest, nil)
+ handler.Handle(testContext.logger, ¬ificationRequest, nil)
testContext.readerMock.AssertCalled(t, "GetNodeb", ranName)
testContext.writerMock.AssertNotCalled(t, "SaveNodeb")
}
func TestSetupResponseSaveNodebFailure(t *testing.T) {
rnibErr := common.NewInternalError(errors.New("Error"))
- testContext, nodebInfo := executeHandleSuccessSetupResponse(t, X2SetupResponsePackedPdu, &managers.X2SetupResponseManager{},"X2 Setup Response", rnibErr)
+ testContext, nodebInfo := executeHandleSuccessSetupResponse(t, X2SetupResponsePackedPdu, &managers.X2SetupResponseManager{}, "X2 Setup Response", rnibErr)
testContext.readerMock.AssertCalled(t, "GetNodeb", RanName)
testContext.writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, nodebInfo)
-}
\ No newline at end of file
+}
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"unsafe"
}
}
-func (src X2ResetRequestNotificationHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (src X2ResetRequestNotificationHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
logger.Debugf("#X2ResetRequestNotificationHandler.Handle - Ran name: %s", request.RanName)
h := NewX2ResetRequestNotificationHandler(readerProvider)
xaction := []byte("RanName")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
- nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb := &entities.NodebInfo{RanName: mBuf.Meid, ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
var rnibErr error
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
messageChannel := make(chan *models.NotificationResponse)
- go h.Handle(log,nil, ¬ificationRequest, messageChannel)
+ go h.Handle(log, ¬ificationRequest, messageChannel)
result := <-messageChannel
assert.Equal(t, result.RanName, mBuf.Meid)
h := NewX2ResetRequestNotificationHandler(readerProvider)
xaction := []byte("RanName")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
- nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb := &entities.NodebInfo{RanName: mBuf.Meid, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
var rnibErr error
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,nil, ¬ificationRequest, nil)
+ h.Handle(log, ¬ificationRequest, nil)
}
func TestHandleX2ResetRequestNotifDisconnectStatus(t *testing.T) {
h := NewX2ResetRequestNotificationHandler(readerProvider)
xaction := []byte("RanName")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
- nb := &entities.NodebInfo{RanName:mBuf.Meid, ConnectionStatus:entities.ConnectionStatus_DISCONNECTED,}
+ nb := &entities.NodebInfo{RanName: mBuf.Meid, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
var rnibErr error
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,nil, ¬ificationRequest, nil)
+ h.Handle(log, ¬ificationRequest, nil)
}
-func TestHandleX2ResetRequestNotifGetNodebFailed(t *testing.T){
+func TestHandleX2ResetRequestNotifGetNodebFailed(t *testing.T) {
log := initLog(t)
var payload []byte
h := NewX2ResetRequestNotificationHandler(readerProvider)
xaction := []byte("RanName")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
var nb *entities.NodebInfo
- rnibErr := &common.ResourceNotFoundError{}
+ rnibErr := &common.ResourceNotFoundError{}
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,nil, ¬ificationRequest, nil)
-}
\ No newline at end of file
+ h.Handle(log, ¬ificationRequest, nil)
+}
"e2mgr/e2pdus"
"e2mgr/logger"
"e2mgr/models"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
}
}
-func (src X2ResetResponseHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions,
- request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
+func (src X2ResetResponseHandler) Handle(logger *logger.Logger, request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
logger.Infof("#x2ResetResponseHandler.Handle - received reset response. Payload: %x", request.Payload)
"e2mgr/mocks"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"e2mgr/tests"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
}
h := NewX2ResetResponseHandler(rnibReaderProvider)
- e2Sessions := make(sessions.E2Sessions)
- //xaction := []byte(fmt.Sprintf("%32s", "1234"))
xaction := []byte("RanName")
- e2Sessions[string(xaction)] = sessions.E2SessionDetails{SessionStart: time.Now()}
mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
var rnibErr error
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
+ h.Handle(log, ¬ificationRequest, messageChannel)
//TODO:Nothing to verify
}
}
h := NewX2ResetResponseHandler(rnibReaderProvider)
- e2Sessions := make(sessions.E2Sessions)
- //xaction = []byte(fmt.Sprintf("%32s", "1234"))
xaction := []byte("RanName")
- e2Sessions[string(xaction)] = sessions.E2SessionDetails{SessionStart: time.Now()}
mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
rnibErr := common.NewResourceNotFoundError("nodeb not found")
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
+ h.Handle(log, ¬ificationRequest, messageChannel)
//TODO:Nothing to verify
}
}
h := NewX2ResetResponseHandler(rnibReaderProvider)
- e2Sessions := make(sessions.E2Sessions)
- //xaction := []byte(fmt.Sprintf("%32s", "1234"))
xaction := []byte("RanName")
- e2Sessions[string(xaction)] = sessions.E2SessionDetails{SessionStart: time.Now()}
mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload),"RanName", &payload, &xaction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: string(xaction)}
var rnibErr error
readerMock.On("GetNodeb", mBuf.Meid).Return(nb, rnibErr)
- h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
+ h.Handle(log, ¬ificationRequest, messageChannel)
//TODO:Nothing to verify
}
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"unsafe"
)
return X2EnbConfigurationUpdateHandler{}
}
-func (src X2EnbConfigurationUpdateHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions, request *models.NotificationRequest,
+func (src X2EnbConfigurationUpdateHandler) Handle(logger *logger.Logger, request *models.NotificationRequest,
messageChannel chan<- *models.NotificationResponse) {
var payloadSize C.ulong
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"e2mgr/tests"
"github.com/stretchr/testify/assert"
"testing"
t.Errorf("#endc_configuration_update_handler_test.TestHandleSuccessEndcConfigUpdate - failed to initialize logger, error: %s", err)
}
h := X2EnbConfigurationUpdateHandler{}
- E2Sessions := make(sessions.E2Sessions)
payload := tests.GetPackedPayload(t)
mBuf := rmrCgo.NewMBuf(10370, len(payload),"RanName", &payload, &tests.DummyXAction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now()}
messageChannel := make(chan *models.NotificationResponse)
- go h.Handle(log, E2Sessions, ¬ificationRequest, messageChannel)
+ go h.Handle(log, ¬ificationRequest, messageChannel)
response := <-messageChannel
t.Errorf("#endc_configuration_update_handler_test.TestHandleFailureEndcConfigUpdate - failed to initialize logger, error: %s", err)
}
h := X2EnbConfigurationUpdateHandler{}
- E2Sessions := make(sessions.E2Sessions)
mBuf := rmrCgo.NewMBuf(tests.MessageType, 4,"RanName", &tests.DummyPayload, &tests.DummyXAction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now()}
messageChannel := make(chan *models.NotificationResponse)
- go h.Handle(log, E2Sessions, ¬ificationRequest, messageChannel)
+ go h.Handle(log, ¬ificationRequest, messageChannel)
response := <-messageChannel
defer reader.Close()
rmrResponseChannel := make(chan *models.NotificationResponse, config.NotificationResponseBuffer)
- rmrService := services.NewRmrService(rmrConfig, msgImpl, controllers.E2Sessions, rmrResponseChannel)
+ rmrService := services.NewRmrService(rmrConfig, msgImpl, rmrResponseChannel)
var ranSetupManager = managers.NewRanSetupManager(logger, rmrService, rNibWriter.GetRNibWriter)
var ranReconnectionManager = managers.NewRanReconnectionManager(logger, config, reader.GetRNibReader, rNibWriter.GetRNibWriter, ranSetupManager)
var nManager = notificationmanager.NewNotificationManager(reader.GetRNibReader, rNibWriter.GetRNibWriter, ranReconnectionManager)
"e2mgr/providers/rmrmsghandlerprovider"
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"time"
}
//TODO add NEWHandler with log
-func (m NotificationManager) HandleMessage(logger *logger.Logger, e2Sessions sessions.E2Sessions, mbuf *rmrCgo.MBuf, responseChannel chan<- *models.NotificationResponse) {
+func (m NotificationManager) HandleMessage(logger *logger.Logger, mbuf *rmrCgo.MBuf, responseChannel chan<- *models.NotificationResponse) {
notificationHandler, err := m.notificationHandlerProvider.GetNotificationHandler(mbuf.MType)
}
notificationRequest := models.NewNotificationRequest(mbuf.Meid, *mbuf.Payload, time.Now(), string(*mbuf.XAction))
- go notificationHandler.Handle(logger, e2Sessions, notificationRequest, responseChannel)
+ go notificationHandler.Handle(logger, notificationRequest, responseChannel)
}
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"testing"
)
-func initRanLostConnectionTest(t *testing.T) (*logger.Logger,*mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *RanReconnectionManager) {
+func initRanLostConnectionTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *RanReconnectionManager) {
logger, err := logger.InitLogger(logger.DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
rnibWriterProvider := func() rNibWriter.RNibWriter {
return writerMock
}
- ranSetupManager := NewRanSetupManager(logger,rmrService, rnibWriterProvider)
+ ranSetupManager := NewRanSetupManager(logger, rmrService, rnibWriterProvider)
ranReconnectionManager := NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
- return logger,rmrMessengerMock, readerMock, writerMock, ranReconnectionManager
+ return logger, rmrMessengerMock, readerMock, writerMock, ranReconnectionManager
}
func TestRanReconnectionGetNodebFailure(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
var nodebInfo *entities.NodebInfo
readerMock.On("GetNodeb", ranName).Return(nodebInfo, common.NewInternalError(errors.New("Error")))
}
func TestShutdownRanReconnection(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN}
var rnibErr error
}
func TestShuttingdownRanReconnection(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
var rnibErr error
}
func TestConnectingRanWithMaxAttemptsReconnection(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTING, ConnectionAttempts: 20}
var rnibErr error
}
func TestUnconnectableRanUpdateNodebInfoFailure(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN}
var rnibErr error
}
func TestConnectedRanExecuteSetupSuccess(t *testing.T) {
- _,rmrMessengerMock, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, rmrMessengerMock, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
- origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol:entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+ origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
var rnibErr error
readerMock.On("GetNodeb", ranName).Return(origNodebInfo, rnibErr)
updatedNodebInfo := *origNodebInfo
updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTING
updatedNodebInfo.ConnectionAttempts++
writerMock.On("UpdateNodebInfo", &updatedNodebInfo).Return(nil)
- rmrMessengerMock.On("SendMsg",mock.Anything, mock.AnythingOfType("int")).Return(&rmrCgo.MBuf{},nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.AnythingOfType("int")).Return(&rmrCgo.MBuf{}, nil)
err := ranReconnectionManager.ReconnectRan(ranName)
assert.Nil(t, err)
readerMock.AssertCalled(t, "GetNodeb", ranName)
}
func TestConnectedRanExecuteSetupFailure(t *testing.T) {
- _,_, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
+ _, _, readerMock, writerMock, ranReconnectionManager := initRanLostConnectionTest(t)
ranName := "test"
origNodebInfo := &entities.NodebInfo{RanName: ranName, GlobalNbId: &entities.GlobalNbId{PlmnId: "xxx", NbId: "yyy"}, ConnectionStatus: entities.ConnectionStatus_CONNECTED}
var rnibErr error
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
- "time"
)
type RanSetupManager struct {
// ExecuteSetup updates the connection status and number of attempts in the nodebInfo and send an endc/x2 setup request to establish a connection with the RAN
func (m *RanSetupManager) ExecuteSetup(nodebInfo *entities.NodebInfo, status entities.ConnectionStatus) error {
- //Fill details for the response handler
- requestDetails := models.SetupRequest{RanName: nodebInfo.RanName, RanPort: uint16(nodebInfo.Port), RanIp: nodebInfo.Ip}
- m.rmrService.E2sessions[nodebInfo.RanName] = sessions.E2SessionDetails{SessionStart: time.Now(), Request: &requestDetails}
-
// Update retries and connection status
if err := m.updateConnectionStatus(nodebInfo, status); err != nil {
- delete(m.rmrService.E2sessions, nodebInfo.RanName)
return e2managererrors.NewRnibDbError()
}
// Build the endc/x2 setup request
rmrMsgType, request, err := m.prepareSetupRequest(nodebInfo)
if err != nil {
- delete(m.rmrService.E2sessions, nodebInfo.RanName)
return err
}
if err := m.rmrService.SendRmrMessage(response); err != nil {
m.logger.Errorf("#RanSetupManager.ExecuteSetup - failed sending setup request to RMR: %s", err)
- delete(m.rmrService.E2sessions, nodebInfo.RanName)
-
// Decrement retries and connection status (disconnected)
if err := m.updateConnectionStatusDisconnected(nodebInfo); err != nil {
return e2managererrors.NewRnibDbError()
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"github.com/stretchr/testify/assert"
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
func TestNewIncomingRequestHandlerProvider(t *testing.T) {
return &mocks.RnibWriterMock{}
}
ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider, ranSetupManager)
assert.NotNil(t, provider)
}
}
ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider, ranSetupManager)
handler, err := provider.GetHandler(ShutdownRequest)
}
ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider, ranSetupManager)
handler, err := provider.GetHandler(X2SetupRequest)
}
ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider, ranSetupManager)
handler, err := provider.GetHandler(EndcSetupRequest)
"e2mgr/models"
"e2mgr/rNibWriter"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
handler rmrmsghandlers.NotificationHandler
}{
{rmrCgo.RIC_X2_SETUP_RESP, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewX2SetupResponseManager(), "X2 Setup Response")},
- {rmrCgo.RIC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewX2SetupFailureResponseManager(),"X2 Setup Failure Response")},
- {rmrCgo.RIC_ENDC_X2_SETUP_RESP, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewEndcSetupResponseManager(),"ENDC Setup Response")},
- {rmrCgo.RIC_ENDC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewEndcSetupFailureResponseManager(),"ENDC Setup Failure Response"),},
+ {rmrCgo.RIC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewX2SetupFailureResponseManager(), "X2 Setup Failure Response")},
+ {rmrCgo.RIC_ENDC_X2_SETUP_RESP, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewEndcSetupResponseManager(), "ENDC Setup Response")},
+ {rmrCgo.RIC_ENDC_X2_SETUP_FAILURE, rmrmsghandlers.NewSetupResponseNotificationHandler(rnibReaderProvider, rnibWriterProvider, managers.NewEndcSetupFailureResponseManager(), "ENDC Setup Failure Response"),},
{rmrCgo.RIC_SCTP_CONNECTION_FAILURE, rmrmsghandlers.NewRanLostConnectionHandler(ranReconnectionManager)},
{rmrCgo.RIC_ENB_LOAD_INFORMATION, rmrmsghandlers.NewEnbLoadInformationNotificationHandler(rnibWriterProvider)},
{rmrCgo.RIC_ENB_CONF_UPDATE, rmrmsghandlers.X2EnbConfigurationUpdateHandler{}},
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
// TODO: extract to test_utils
continue //TODO log error
}
- r.nManager.HandleMessage(r.Config.Logger, r.E2sessions, mbuf, r.RmrResponse)
+ r.nManager.HandleMessage(r.Config.Logger, mbuf, r.RmrResponse)
}
}
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"e2mgr/tests"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
func getRmrServiceReceiver(rmrMessengerMock *mocks.RmrMessengerMock, logger *logger.Logger) *RmrServiceReceiver {
"e2mgr/logger"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"strconv"
"sync"
)
type RmrService struct {
Config *RmrConfig
Messenger *rmrCgo.RmrMessenger
- E2sessions sessions.E2Sessions
RmrResponse chan *models.NotificationResponse
}
// NewRmrService instantiates a new Rmr service instance
-func NewRmrService(rmrConfig *RmrConfig, msrImpl rmrCgo.RmrMessenger, e2sessions sessions.E2Sessions, rmrResponse chan *models.NotificationResponse) *RmrService {
+func NewRmrService(rmrConfig *RmrConfig, msrImpl rmrCgo.RmrMessenger, rmrResponse chan *models.NotificationResponse) *RmrService {
return &RmrService{
Config: rmrConfig,
Messenger: msrImpl.Init("tcp:"+strconv.Itoa(rmrConfig.Port), rmrConfig.MaxMsgSize, rmrConfig.Flags, rmrConfig.Logger),
- E2sessions: e2sessions,
RmrResponse: rmrResponse,
}
}
"e2mgr/mocks"
"e2mgr/models"
"e2mgr/rmrCgo"
- "e2mgr/sessions"
"e2mgr/tests"
"fmt"
"github.com/stretchr/testify/assert"
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
rmrMessengerMock.On("Init", tests.GetPort(), tests.MaxMsgSize, tests.Flags, log).Return(&rmrMessenger)
- return NewRmrService(NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), messageChannel)
+ return NewRmrService(NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, messageChannel)
}
+++ /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.
-//
-
-package sessions
-
-import "time"
-import "e2mgr/models"
-/*
- * Container for session data
- * Note:
- * - If this is the only item in the session data, we should eliminate this session manager
- * and just send the start time as part of the xaction field in the RMR message.
- */
-type E2SessionDetails struct {
- SessionStart time.Time
- Request *models.SetupRequest
-}
-
-/*
- * Map of session id to session details.
- * Notes:
- * - Since the transaction id is the CellId, there is no
- * need to delete the entry when a response is received nor
- * provide a mechanism for removing stale entries (no response received).
- * Having said that, deleting the entry on a successful flow may still be a good idea
- * in order to avoid pinning large amount of memory (help the GC).
- *
- * TODO:
- * - Synchronize access.
- */
-type E2Sessions map[string]E2SessionDetails