"net/http/httptest"
"strings"
"testing"
+ "unsafe"
)
const (
payload := e2pdus.PackedX2setupRequest
var xAction []byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
payload := e2pdus.PackedEndcX2setupRequest
var xAction []byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err != nil {
t.Errorf("Error cannot deserialize json request")
}
- json.Unmarshal(body, &errorResponse)
+ _ =json.Unmarshal(body, &errorResponse)
return errorResponse
}
ranName := "test1"
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
var xAction []byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
writer := httptest.NewRecorder()
// o&m intervention
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
var xAction []byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
writer := httptest.NewRecorder()
writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
- mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, e2managererrors.NewRmrError())
_, err := h.Handle(nil)
assert.IsType(t, &e2managererrors.RmrError{}, err)
writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
- mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
resp, err := h.Handle(nil)
assert.Nil(t, err)
writerMock.On("SaveE2TInstance", &updatedE2tInstance).Return(nil)
rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
- mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
writerMock.On("SaveE2TInstance", &updatedE2tInstance2).Return(nil)
rmrMessage := models.RmrMessage{MsgType: rmrCgo.RIC_SCTP_CLEAR_ALL}
- mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ mbuf := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, nil)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
updatedNb := *nodebInfo
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(nil)
_, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
assert.Nil(t, err)
+ readerMock.AssertExpectations(t)
+ writerMock.AssertExpectations(t)
+ e2tInstancesManagerMock.AssertExpectations(t)
+ ranSetupManagerMock.AssertExpectations(t)
}
func TestSetupNewRanAssociateRanFailure(t *testing.T) {
- readerMock, writerMock, handler, e2tInstancesManagerMock, _, httpClientMock := 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("AddRansToInstance", E2TAddress, []string{RanName}).Return(e2managererrors.NewRnibDbError())
setupRequest := &models.SetupRequest{"127.0.0.1", 8080, RanName,}
nb, nbIdentity := createInitialNodeInfo(setupRequest, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+ nb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("SaveNodeb", nbIdentity, mock.Anything).Return(nil)
writerMock.On("UpdateNodebInfo", nb).Return(nil)
nb.AssociatedE2TInstanceAddress = E2TAddress
nb.ConnectionAttempts = 0
mockHttpClientAssociateRan(httpClientMock)
+ updatedNb := *nb
+ updatedNb.ConnectionAttempts = 0
+ updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+
_, err := handler.Handle(*setupRequest)
+ assert.NotNil(t, err)
assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+ readerMock.AssertExpectations(t)
+ writerMock.AssertExpectations(t)
+ e2tInstancesManagerMock.AssertExpectations(t)
+ ranSetupManagerMock.AssertExpectations(t)
+ httpClientMock.AssertExpectations(t)
}
func TestSetupNewRanSaveNodebFailure(t *testing.T) {
updatedNb := *nodebInfo
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
_, err := handler.Handle(setupRequest)
+ assert.NotNil(t, err)
assert.IsType(t, &e2managererrors.RnibDbError{}, err)
readerMock.AssertExpectations(t)
writerMock.AssertExpectations(t)
updatedNb := *nodebInfo
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(e2managererrors.NewRmrError())
_, err := handler.Handle(setupRequest)
updatedNb := *nodebInfo
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(nil)
_, err := handler.Handle(setupRequest)
ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
}
-func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanFailure(t *testing.T) {
- 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("AddRansToInstance", E2TAddress, []string{RanName}).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")
- ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
-}
-
-func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanSucceedsUpdateNodebFails(t *testing.T) {
- 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("AddRansToInstance", E2TAddress, []string{RanName}).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{} */&common.InternalError{}, err)
- ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
-}
-
-func TestSetupExistingRanWithoutAssocE2TInstanceExecuteSetupFailure(t *testing.T) {
- 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("AddRansToInstance", E2TAddress, []string{RanName}).Return(nil)
- updatedNb := *nb
- updatedNb.AssociatedE2TInstanceAddress = E2TAddress
- updatedNb.ConnectionAttempts = 0
- writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
- ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(e2managererrors.NewRnibDbError())
- _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
- assert.IsType(t, &e2managererrors.RnibDbError{}, err)
-}
-
-func TestSetupExistingRanWithoutAssocE2TInstanceSuccess(t *testing.T) {
- 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("AddRansToInstance", E2TAddress, []string{RanName}).Return(nil)
- updatedNb := *nb
- updatedNb.AssociatedE2TInstanceAddress = E2TAddress
- updatedNb.ConnectionAttempts = 0
- writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
- ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(nil)
- _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
- assert.Nil(t, err)
-}
+//func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanFailure(t *testing.T) {
+// 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("AddRansToInstance", E2TAddress, []string{RanName}).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")
+// ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
+//}
+
+//func TestSetupExistingRanWithoutAssocE2TInstanceAssociateRanSucceedsUpdateNodebFails(t *testing.T) {
+// 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("AddRansToInstance", E2TAddress, []string{RanName}).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{} */&common.InternalError{}, err)
+// ranSetupManagerMock.AssertNotCalled(t, "ExecuteSetup")
+//}
+
+//func TestSetupExistingRanWithoutAssocE2TInstanceExecuteSetupFailure(t *testing.T) {
+// 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("AddRansToInstance", E2TAddress, []string{RanName}).Return(nil)
+// updatedNb := *nb
+// updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+// updatedNb.ConnectionAttempts = 0
+// writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
+// ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(e2managererrors.NewRnibDbError())
+// _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
+// assert.IsType(t, &e2managererrors.RnibDbError{}, err)
+//}
+//
+//func TestSetupExistingRanWithoutAssocE2TInstanceSuccess(t *testing.T) {
+// 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("AddRansToInstance", E2TAddress, []string{RanName}).Return(nil)
+// updatedNb := *nb
+// updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+// updatedNb.ConnectionAttempts = 0
+// writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
+// ranSetupManagerMock.On("ExecuteSetup", &updatedNb, entities.ConnectionStatus_CONNECTING).Return(nil)
+// _, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
+// assert.Nil(t, err)
+//}
func TestSetupExistingRanWithAssocE2TInstanceUpdateNodebFailure(t *testing.T) {
readerMock, writerMock, handler, e2tInstancesManagerMock, ranSetupManagerMock, _ := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
writerMock.On("UpdateNodebInfo", &updatedNb2).Return(nil)
payload := e2pdus.PackedX2setupRequest
xaction := []byte(RanName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction, nil)
rmrMessengerMock.On("SendMsg",mock.Anything, true).Return(msg, e2managererrors.NewRmrError())
writerMock.On("UpdateNodebInfo", &updatedNb3).Return(nil)
_, err := handler.Handle(models.SetupRequest{"127.0.0.1", 8080, RanName,})
"e2mgr/services/rmrsender"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "unsafe"
)
const (
}
var xAction []byte
-
- msg := models.NewRmrMessage(rmrCgo.RIC_X2_RESET, resetRequest.RanName, payload, xAction)
+ var msgSrc unsafe.Pointer
+ msg := models.NewRmrMessage(rmrCgo.RIC_X2_RESET, resetRequest.RanName, payload, xAction, msgSrc)
err = handler.rmrSender.Send(msg)
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"github.com/stretchr/testify/assert"
"testing"
+ "unsafe"
)
func setupX2ResetRequestHandlerTest(t *testing.T) (*X2ResetRequestHandler, *mocks.RmrMessengerMock, *mocks.RnibReaderMock) {
// o&m intervention
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
var xAction[]byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
ranName := "test1"
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
var xAction[]byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
// o&m intervention
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
var xAction[]byte
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", msg, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("rmr error"))
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
import (
"bytes"
"e2mgr/configuration"
+ "e2mgr/e2managererrors"
"e2mgr/logger"
"e2mgr/managers"
"e2mgr/models"
return
}
}
- nodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
err = h.e2tAssociationManager.AssociateRan(e2tIpAddress, nodebInfo)
if err != nil{
h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to associate E2T to nodeB entity. Error: %s", ranName, err)
+ if _, ok := err.(*e2managererrors.RoutingManagerError); ok{
+ h.handleUnsuccessfulResponse(nodebInfo, request)
+ }
return
}
+ h.handleSuccessfulResponse(ranName, request, setupRequest)
+}
+
+func (h E2SetupRequestNotificationHandler) handleUnsuccessfulResponse(nodebInfo *entities.NodebInfo, req *models.NotificationRequest){
+ failureResponse := models.NewE2SetupFailureResponseMessage(models.TimeToWaitEnum.V60s)
+ h.logger.Debugf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", failureResponse)
+
+ responsePayload, err := xml.Marshal(&failureResponse.E2APPDU)
+ if err != nil{
+ h.logger.Warnf("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", nodebInfo.RanName, responsePayload)
+ }
+
+ responsePayload = replaceEmptyTagsWithSelfClosing(responsePayload)
+
+ msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_FAILURE, nodebInfo.RanName, responsePayload, req.TransactionId, req.GetMsgSrc())
+ h.logger.Infof("#E2SetupRequestNotificationHandler.handleUnsuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", nodebInfo.RanName, msg)
+ _ = h.rmrSender.WhSend(msg)
+
+}
+
+func (h E2SetupRequestNotificationHandler) handleSuccessfulResponse(ranName string, req *models.NotificationRequest, setupRequest *models.E2SetupRequestMessage){
ricNearRtId, err := convertTo20BitString(h.config.GlobalRicId.RicNearRtId)
if err != nil{
- h.logger.Errorf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - failed to convert RicNearRtId value %s to 20 bit string . Error: %s", ranName, h.config.GlobalRicId.RicNearRtId, err)
+ h.logger.Errorf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - failed to convert RicNearRtId value %s to 20 bit string . Error: %s", ranName, h.config.GlobalRicId.RicNearRtId, err)
return
}
successResponse := models.NewE2SetupSuccessResponseMessage(h.config.GlobalRicId.PlmnId, ricNearRtId,setupRequest)
- h.logger.Debugf("#E2SetupRequestNotificationHandler.Handle - E2_SETUP_RESPONSE has been built successfully %+v", successResponse)
+ h.logger.Debugf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - E2_SETUP_RESPONSE has been built successfully %+v", successResponse)
responsePayload, err := xml.Marshal(&successResponse.E2APPDU)
if err != nil{
- h.logger.Warnf("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
+ h.logger.Warnf("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - Error marshalling RIC_E2_SETUP_RESP. Payload: %s", ranName, responsePayload)
}
- responsePayload = replaceCriticalityTagsWithSelfClosing(responsePayload)
+ responsePayload = replaceEmptyTagsWithSelfClosing(responsePayload)
- msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_RESP, ranName, responsePayload, request.TransactionId)
- h.logger.Infof("#E2SetupRequestNotificationHandler.Handle - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
+ msg := models.NewRmrMessage(rmrCgo.RIC_E2_SETUP_RESP, ranName, responsePayload, req.TransactionId, req.GetMsgSrc())
+ h.logger.Infof("#E2SetupRequestNotificationHandler.handleSuccessfulResponse - RAN name: %s - RIC_E2_SETUP_RESP message has been built successfully. Message: %x", ranName, msg)
_ = h.rmrSender.Send(msg)
}
-func replaceCriticalityTagsWithSelfClosing(responsePayload []byte) []byte {
- responseString := strings.Replace(string(responsePayload), "<reject></reject>", "<reject/>", -1)
- responseString = strings.Replace(responseString, "<ignore></ignore>", "<ignore/>", -1)
+
+func replaceEmptyTagsWithSelfClosing(responsePayload []byte) []byte {
+ responseString := strings.NewReplacer(
+ "<reject></reject>", "<reject/>",
+ "<ignore></ignore>", "<ignore/>",
+ "<transport-resource-unavailable></transport-resource-unavailable>", "<transport-resource-unavailable/>",
+ "<v60s></v60s>", "<v60s/>",
+ "<v20s></v20s>", "<v20s/>",
+ "<v10s></v10s>", "<v10s/>",
+ "<v5s></v5s>", "<v5s/>",
+ "<v2s></v2s>", "<v2s/>",
+ "<v1s></v1s>", "<v1s/>",
+ ).Replace(string(responsePayload))
return []byte(responseString)
}
routingManagerClientMock.On("AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything).Return(errors.New("association error"))
var errEmpty error
rmrMessage := &rmrCgo.MBuf{}
- rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
+ rmrMessengerMock.On("WhSendMsg", mock.Anything, mock.Anything).Return(rmrMessage, errEmpty)
prefBytes := []byte(prefix)
notificationRequest := &models.NotificationRequest{RanName: nodebRanName, Payload: append(prefBytes, xmlGnb...)}
writerMock.AssertCalled(t, "SaveNodeb", mock.Anything, mock.Anything)
routingManagerClientMock.AssertCalled(t, "AssociateRanToE2TInstance", e2tInstanceFullAddress, mock.Anything)
writerMock.AssertCalled(t, "UpdateNodebInfo", mock.Anything)
- e2tInstancesManagerMock.AssertCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
- rmrMessengerMock.AssertCalled(t, "SendMsg", mock.Anything, mock.Anything)
+ e2tInstancesManagerMock.AssertNotCalled(t, "AddRansToInstance", mock.Anything, mock.Anything)
+ rmrMessengerMock.AssertCalled(t, "WhSendMsg", mock.Anything, mock.Anything)
}
return nil, err
}
- return models.NewNotificationRequest(ranName, packedByteSlice, time.Now(), transactionId), nil
+ return models.NewNotificationRequest(ranName, packedByteSlice, time.Now(), transactionId, nil), nil
}
func createNotificationRequestAndHandle(ranName string, transactionId []byte, loadInformationHandler EnbLoadInformationNotificationHandler, pdu string) error {
if err != nil {
h.logger.Errorf("#endc_configuration_update_handler.Handle - unpack failed. Error: %v", err)
- msg := models.NewRmrMessage(rmrCgo.RIC_ENDC_CONF_UPDATE_FAILURE, request.RanName, e2pdus.PackedEndcConfigurationUpdateFailure, request.TransactionId)
+ msg := models.NewRmrMessage(rmrCgo.RIC_ENDC_CONF_UPDATE_FAILURE, request.RanName, e2pdus.PackedEndcConfigurationUpdateFailure, request.TransactionId, request.GetMsgSrc())
_ = h.rmrSender.Send(msg)
h.logger.Infof("#EndcConfigurationUpdateHandler.Handle - Summary: elapsed time for receiving and handling endc configuration update initiating message from E2 terminator: %f ms", utils.ElapsedTime(request.StartTime))
h.logger.Infof("#endc_configuration_update_handler.Handle - Endc configuration update initiating message received")
h.logger.Debugf("#endc_configuration_update_handler.Handle - Endc configuration update initiating message payload: %s", refinedMessage.PduPrint)
- msg := models.NewRmrMessage(rmrCgo.RIC_ENDC_CONF_UPDATE_ACK, request.RanName, e2pdus.PackedEndcConfigurationUpdateAck, request.TransactionId)
+ msg := models.NewRmrMessage(rmrCgo.RIC_ENDC_CONF_UPDATE_ACK, request.RanName, e2pdus.PackedEndcConfigurationUpdateAck, request.TransactionId, request.GetMsgSrc())
_ = h.rmrSender.Send(msg)
h.logger.Infof("#EndcConfigurationUpdateHandler.Handle - Summary: elapsed time for receiving and handling endc configuration update initiating message from E2 terminator: %f ms", utils.ElapsedTime(request.StartTime))
"fmt"
"testing"
"time"
+ "unsafe"
)
const PackedEndcConfigurationUpdateAck = "2025000a00000100f70003000000"
var payload []byte
_, _ = fmt.Sscanf(PackedEndcConfigurationUpdateAck, "%x", &payload)
+ var msgSrc unsafe.Pointer
- mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_CONF_UPDATE_ACK, len(payload), ranName, &payload, &xAction)
+ mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_CONF_UPDATE_ACK, len(payload), ranName, &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
TransactionId: *mBuf.XAction}
var err error
var payload []byte
_, _ = fmt.Sscanf(PackedEndcConfigurationUpdateFailure, "%x", &payload)
+ var msgSrc unsafe.Pointer
- mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_CONF_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction)
+ mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_CONF_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: 0, Payload: []byte{0}, StartTime: time.Now(),
TransactionId: *mBuf.XAction}
rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"testing"
+ "unsafe"
)
const (
var xAction []byte
resourceStatusPayload := models.NewResourceStatusPayload(nodeType, enums.RIC_TO_RAN)
resourceStatusJson, _ := json.Marshal(resourceStatusPayload)
- return rmrCgo.NewMBuf(rmrCgo.RAN_CONNECTED, len(resourceStatusJson), RanName, &resourceStatusJson, &xAction)
+ var msgSrc unsafe.Pointer
+ return rmrCgo.NewMBuf(rmrCgo.RAN_CONNECTED, len(resourceStatusJson), RanName, &resourceStatusJson, &xAction, msgSrc)
}
func executeHandleSetupFailureResponse(t *testing.T, tc setupFailureResponseTestCase) (*setupResponseTestContext, *entities.NodebInfo) {
return
}
- msg := models.NewRmrMessage(rmrCgo.RIC_X2_RESET_RESP, request.RanName, e2pdus.PackedX2ResetResponse, request.TransactionId)
+ msg := models.NewRmrMessage(rmrCgo.RIC_X2_RESET_RESP, request.RanName, e2pdus.PackedX2ResetResponse, request.TransactionId, request.GetMsgSrc())
_ = h.rmrSender.Send(msg)
h.logger.Infof("#X2ResetRequestNotificationHandler.Handle - Summary: elapsed time for receiving and handling reset request message from E2 terminator: %f ms", utils.ElapsedTime(request.StartTime))
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"testing"
"time"
+ "unsafe"
)
func initX2ResetRequestNotificationHandlerTest(t *testing.T) (X2ResetRequestNotificationHandler, *mocks.RnibReaderMock, *mocks.RmrMessengerMock) {
var xAction []byte
resourceStatusPayload := models.NewResourceStatusPayload(nodeType, messageDirection)
resourceStatusJson, _ := json.Marshal(resourceStatusPayload)
- return rmrCgo.NewMBuf(rmrCgo.RAN_RESTARTED, len(resourceStatusJson), RanName, &resourceStatusJson, &xAction)
+ var msgSrc unsafe.Pointer
+ return rmrCgo.NewMBuf(rmrCgo.RAN_RESTARTED, len(resourceStatusJson), RanName, &resourceStatusJson, &xAction, msgSrc)
}
func TestHandleX2ResetRequestNotificationSuccess(t *testing.T) {
h, readerMock, rmrMessengerMock := initX2ResetRequestNotificationHandlerTest(t)
ranName := "test"
xAction := []byte("123456aa")
- notificationRequest := models.NewNotificationRequest(ranName, []byte{}, time.Now(), xAction)
+ notificationRequest := models.NewNotificationRequest(ranName, []byte{}, time.Now(), xAction, nil)
nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, NodeType: entities.Node_ENB}
var err error
readerMock.On("GetNodeb", ranName).Return(nb, err)
- resetResponseMbuf := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET_RESP, len(e2pdus.PackedX2ResetResponse), ranName, &e2pdus.PackedX2ResetResponse, &xAction)
+ var msgSrc unsafe.Pointer
+ resetResponseMbuf := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET_RESP, len(e2pdus.PackedX2ResetResponse), ranName, &e2pdus.PackedX2ResetResponse, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", resetResponseMbuf, true).Return(&rmrCgo.MBuf{}, err)
ranRestartedMbuf := getRanRestartedMbuf(nb.NodeType, enums.RAN_TO_RIC)
rmrMessengerMock.On("SendMsg", ranRestartedMbuf, true).Return(&rmrCgo.MBuf{}, err)
var payload []byte
xAction := []byte("123456aa")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: xAction}
h, readerMock, rmrMessengerMock := initX2ResetRequestNotificationHandlerTest(t)
var payload []byte
xAction := []byte("123456aa")
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(), TransactionId: xAction}
nb := &entities.NodebInfo{RanName: mBuf.Meid, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
var rnibErr error
h, readerMock, rmrMessengerMock := initX2ResetRequestNotificationHandlerTest(t)
var payload []byte
var xAction []byte
- mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ mBuf := rmrCgo.NewMBuf(tests.MessageType, len(payload), "RanName", &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId: xAction}
if err != nil {
h.logger.Errorf("#x2enb_configuration_update_handler.Handle - unpack failed. Error: %v", err)
- msg := models.NewRmrMessage(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_FAILURE, request.RanName, e2pdus.PackedX2EnbConfigurationUpdateFailure, request.TransactionId)
+ msg := models.NewRmrMessage(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_FAILURE, request.RanName, e2pdus.PackedX2EnbConfigurationUpdateFailure, request.TransactionId, request.GetMsgSrc())
_ = h.rmrSender.Send(msg)
h.logger.Infof("#X2EnbConfigurationUpdateHandler.Handle - Summary: elapsed time for receiving and handling enb configuration update initiating message from E2 terminator: %f ms", utils.ElapsedTime(request.StartTime))
h.logger.Infof("#x2enb_configuration_update_handler.Handle - Enb configuration update initiating message received")
h.logger.Debugf("#x2enb_configuration_update_handler.Handle - Enb configuration update initiating message payload: %s", refinedMessage.PduPrint)
- msg := models.NewRmrMessage(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_ACK, request.RanName, e2pdus.PackedX2EnbConfigurationUpdateAck,request.TransactionId)
+ msg := models.NewRmrMessage(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_ACK, request.RanName, e2pdus.PackedX2EnbConfigurationUpdateAck,request.TransactionId, request.GetMsgSrc())
_ = h.rmrSender.Send(msg)
h.logger.Infof("#X2EnbConfigurationUpdateHandler.Handle - Summary: elapsed time for receiving and handling enb configuration update initiating message from E2 terminator: %f ms", utils.ElapsedTime(request.StartTime))
"fmt"
"testing"
"time"
+ "unsafe"
)
const PackedX2EnbConfigurationUpdateAck = "200800080000010011400100"
xAction := []byte("123456aa")
var payload []byte
_, _ = fmt.Sscanf(PackedX2EnbConfigurationUpdateAck, "%x", &payload)
+ var msgSrc unsafe.Pointer
- mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_ACK, len(payload), ranName, &payload, &xAction)
+ mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_ACK, len(payload), ranName, &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId:xAction}
var err error
var payload []byte
_, _ = fmt.Sscanf(PackedX2EnbConfigurationUpdateFailure, "%x", &payload)
+ var msgSrc unsafe.Pointer
- mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction)
+ mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction, msgSrc)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: 0, Payload: []byte{0},
StartTime: time.Now(), TransactionId:xAction}
rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
import (
"e2mgr/clients"
+ "e2mgr/e2managererrors"
"e2mgr/logger"
"e2mgr/services"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
ranName := nodebInfo.RanName
m.logger.Infof("#E2TAssociationManager.AssociateRan - Associating RAN %s to E2T Instance address: %s", ranName, e2tAddress)
- 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.AddRansToInstance(e2tAddress, []string{ranName})
+ err := m.associateRanAndUpdateNodeb(e2tAddress, nodebInfo)
if err != nil {
- m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed to add RAN to E2T instance %s. Error: %s", ranName, e2tAddress, err)
+ m.logger.Errorf("#E2TAssociationManager.AssociateRan - RoutingManager failure: Failed to associate RAN %s to E2T %s. Error: %s", nodebInfo, e2tAddress, err)
return err
}
- err = m.rmClient.AssociateRanToE2TInstance(e2tAddress, ranName)
+ err = m.e2tInstanceManager.AddRansToInstance(e2tAddress, []string{ranName})
if err != nil {
- m.logger.Errorf("#E2TAssociationManager.AssociateRan - RoutingManager failure: Failed to associate RAN %s to E2T %s. Error: %s", ranName, e2tAddress, err)
+ m.logger.Errorf("#E2TAssociationManager.AssociateRan - RAN name: %s - Failed to add RAN to E2T instance %s. Error: %s", ranName, e2tAddress, err)
+ return e2managererrors.NewRnibDbError()
}
m.logger.Infof("#E2TAssociationManager.AssociateRan - successfully associated RAN %s with E2T %s", ranName, e2tAddress)
return nil
}
+func (m *E2TAssociationManager) associateRanAndUpdateNodeb(e2tAddress string, nodebInfo *entities.NodebInfo) error {
+
+ rmErr := m.rmClient.AssociateRanToE2TInstance(e2tAddress, nodebInfo.RanName)
+ if rmErr != nil {
+ nodebInfo.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
+ } else {
+ nodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTED
+ nodebInfo.AssociatedE2TInstanceAddress = e2tAddress
+ nodebInfo.ConnectionAttempts = 0
+ }
+ rNibErr := m.rnibDataService.UpdateNodebInfo(nodebInfo)
+ if rNibErr != nil {
+ m.logger.Errorf("#E2TAssociationManager.associateRanAndUpdateNodeb - RAN name: %s - Failed to update nodeb entity in rNib. Error: %s", nodebInfo.RanName, rNibErr)
+ }
+ var err error
+ if rmErr != nil {
+ err = e2managererrors.NewRoutingManagerError()
+ } else if rNibErr != nil{
+ err = e2managererrors.NewRnibDbError()
+ }
+ return err
+}
+
func (m *E2TAssociationManager) DissociateRan(e2tAddress string, ranName string) error {
m.logger.Infof("#E2TAssociationManager.DissociateRan - Dissociating RAN %s from E2T Instance address: %s", ranName, e2tAddress)
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/mock"
"io/ioutil"
"net/http"
"testing"
updatedNb := *nb
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
e2tInstance := &entities.E2TInstance{Address: E2TAddress}
readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
}
func TestAssociateRanRoutingManagerError(t *testing.T) {
- manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
+ manager, _, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, false)
nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
writerMock.On("UpdateNodebInfo", nb).Return(nil)
- e2tInstance := &entities.E2TInstance{Address: E2TAddress}
- readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
- writerMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
err := manager.AssociateRan(E2TAddress, nb)
- assert.Nil(t, err)
- readerMock.AssertExpectations(t)
+ assert.NotNil(t, err)
+ assert.IsType(t, &e2managererrors.RoutingManagerError{}, err)
writerMock.AssertExpectations(t)
httpClientMock.AssertExpectations(t)
}
func TestAssociateRanUpdateNodebError(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
- //mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
+ mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
updatedNb := *nb
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(e2managererrors.NewRnibDbError())
err := manager.AssociateRan(E2TAddress, nb)
func TestAssociateRanGetE2tInstanceError(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
- //mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
+ mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
updatedNb := *nb
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
var e2tInstance *entities.E2TInstance
readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, errors.New("test"))
func TestAssociateRanSaveE2tInstanceError(t *testing.T) {
manager, readerMock, writerMock, httpClientMock := initE2TAssociationManagerTest(t)
- //mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
+ mockHttpClient(httpClientMock, clients.AssociateRanToE2TInstanceApiSuffix, true)
nb := &entities.NodebInfo{RanName: RanName, AssociatedE2TInstanceAddress: "", ConnectionAttempts: 1}
updatedNb := *nb
updatedNb.ConnectionAttempts = 0
updatedNb.AssociatedE2TInstanceAddress = E2TAddress
+ updatedNb.ConnectionStatus = entities.ConnectionStatus_CONNECTED
writerMock.On("UpdateNodebInfo", &updatedNb).Return(nil)
e2tInstance := &entities.E2TInstance{Address: E2TAddress}
readerMock.On("GetE2TInstance", E2TAddress).Return(e2tInstance, nil)
"github.com/stretchr/testify/mock"
"testing"
"time"
+ "unsafe"
)
func initE2TKeepAliveTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TShutdownManagerMock, *E2TKeepAliveWorker) {
e2tKeepAliveWorker.SendKeepAliveRequest()
var payload, xAction []byte
- req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction, msgSrc)
rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
}
time.Sleep(time.Duration(500) * time.Millisecond)
var payload, xAction []byte
- req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction, msgSrc)
rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
e2tShutdownManagerMock.AssertCalled(t, "Shutdown", e2tInstance1)
return err
}
- notificationRequest := models.NewNotificationRequest(mbuf.Meid, *mbuf.Payload, time.Now(), *mbuf.XAction)
+ notificationRequest := models.NewNotificationRequest(mbuf.Meid, *mbuf.Payload, time.Now(), *mbuf.XAction, mbuf.GetMsgSrc())
go notificationHandler.Handle(notificationRequest)
return nil
}
"e2mgr/services"
"e2mgr/services/rmrsender"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "unsafe"
)
type RanSetupManager struct {
// Send the endc/x2 setup request
var xAction []byte
- msg := models.NewRmrMessage(rmrMsgType, nodebInfo.RanName, request.GetMessageAsBytes(m.logger), xAction)
+ var msgSrc unsafe.Pointer
+ msg := models.NewRmrMessage(rmrMsgType, nodebInfo.RanName, request.GetMessageAsBytes(m.logger), xAction, msgSrc)
err = m.rmrSender.Send(msg)
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"testing"
+ "unsafe"
)
func initRanSetupManagerTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibWriterMock, *RanSetupManager) {
writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
payload := e2pdus.PackedX2setupRequest
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
payload := e2pdus.PackedEndcX2setupRequest
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
writerMock.On("UpdateNodebInfo", argNodebDisconnected).Return(rnibErr)
payload := []byte{0}
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
writerMock.On("UpdateNodebInfo", argNodebDisconnected).Return(rnibErr)
payload := []byte{0}
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
writerMock.On("UpdateNodebInfo", argNodebDisconnected).Return(common.NewInternalError(fmt.Errorf("DB error")))
payload := []byte{0}
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
payload := e2pdus.PackedX2setupRequest
- xaction := []byte(ranName)
- msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+ xAction := []byte(ranName)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
"e2mgr/services/rmrsender"
"encoding/json"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "unsafe"
)
type RanStatusChangeManager struct {
}
var xAction []byte
- rmrMessage := models.NewRmrMessage(msgType, nodebInfo.RanName, resourceStatusJson, xAction)
+ var msgSrc unsafe.Pointer
+ rmrMessage := models.NewRmrMessage(msgType, nodebInfo.RanName, resourceStatusJson, xAction, msgSrc)
return m.rmrSender.Send(rmrMessage)
}
return args.Get(0).(*rmrCgo.MBuf), args.Error(1)
}
+func (m *RmrMessengerMock) WhSendMsg(msg *rmrCgo.MBuf, printLogs bool) (*rmrCgo.MBuf, error){
+ args := m.Called(msg, printLogs)
+ return args.Get(0).(*rmrCgo.MBuf), args.Error(1)
+}
+
func (m *RmrMessengerMock) RecvMsg() (*rmrCgo.MBuf, error){
args := m.Called()
return args.Get(0).(*rmrCgo.MBuf), args.Error(1)
--- /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 models
+import (
+ "encoding/xml"
+)
+
+
+type TimeToWait = int
+
+var TimeToWaitEnum = struct{
+ V60s TimeToWait
+ V20s TimeToWait
+ V10s TimeToWait
+ V5s TimeToWait
+ V2s TimeToWait
+ V1s TimeToWait
+}{60, 20, 10, 5, 2, 1}
+
+var timeToWaitMap = map[TimeToWait]interface{}{
+ TimeToWaitEnum.V60s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V60s string `xml:"v60s"`
+ }{},
+ TimeToWaitEnum.V20s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V20s string `xml:"v20s"`
+ }{},
+ TimeToWaitEnum.V10s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V10s string `xml:"v10s"`
+ }{},
+ TimeToWaitEnum.V5s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V5s string `xml:"v5s"`
+ }{},
+ TimeToWaitEnum.V2s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V2s string `xml:"v2s"`
+ }{},
+ TimeToWaitEnum.V1s : struct {
+ XMLName xml.Name `xml:"TimeToWait"`
+ Text string `xml:",chardata"`
+ V1s string `xml:"v1s"`
+ }{},
+}
+
+func NewE2SetupSuccessResponseMessage(plmnId string, ricId string, request *E2SetupRequestMessage) E2SetupResponseMessage{
+ outcome := SuccessfulOutcome{}
+ outcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs = make([]E2setupResponseIEs, 2)
+ outcome.ProcedureCode = "1"
+ outcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].ID = "4"
+ outcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].Value = GlobalRICID{GlobalRICID: struct {
+ Text string `xml:",chardata"`
+ PLMNIdentity string `xml:"pLMN-Identity"`
+ RicID string `xml:"ric-ID"`
+ }{PLMNIdentity:plmnId, RicID:ricId}}
+ outcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].ID = "9"
+ outcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].Value = RANfunctionsIDList{RANfunctionsIDList: struct {
+ Text string `xml:",chardata"`
+ ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
+ }{ProtocolIESingleContainer:extractRanFunctionsIDList(request)}}
+ return E2SetupResponseMessage{E2APPDU:E2APPDU{Outcome:outcome}}
+}
+
+func NewE2SetupFailureResponseMessage(timeToWait TimeToWait) E2SetupResponseMessage{
+ outcome := UnsuccessfulOutcome{}
+ outcome.Value.E2setupFailure.ProtocolIEs.E2setupFailureIEs = make([]E2setupFailureIEs, 2)
+ outcome.ProcedureCode = "1"
+ outcome.Value.E2setupFailure.ProtocolIEs.E2setupFailureIEs[0].ID = "1"
+ outcome.Value.E2setupFailure.ProtocolIEs.E2setupFailureIEs[0].Value.Value = Cause{}
+ outcome.Value.E2setupFailure.ProtocolIEs.E2setupFailureIEs[1].ID = "31"
+ outcome.Value.E2setupFailure.ProtocolIEs.E2setupFailureIEs[1].Value.Value = timeToWaitMap[timeToWait]
+ return E2SetupResponseMessage{E2APPDU:E2APPDU{Outcome:outcome}}
+}
+
+type E2SetupResponseMessage struct {
+ XMLName xml.Name `xml:"E2SetupSuccessResponseMessage"`
+ Text string `xml:",chardata"`
+ E2APPDU E2APPDU
+}
+
+type E2APPDU struct {
+ XMLName xml.Name `xml:"E2AP-PDU"`
+ Text string `xml:",chardata"`
+ Outcome interface{}
+}
+
+type SuccessfulOutcome struct {
+ XMLName xml.Name `xml:"successfulOutcome"`
+ Text string `xml:",chardata"`
+ ProcedureCode string `xml:"procedureCode"`
+ Criticality struct {
+ Text string `xml:",chardata"`
+ Reject string `xml:"reject"`
+ } `xml:"criticality"`
+ Value struct {
+ Text string `xml:",chardata"`
+ E2setupResponse struct {
+ Text string `xml:",chardata"`
+ ProtocolIEs struct {
+ Text string `xml:",chardata"`
+ E2setupResponseIEs []E2setupResponseIEs`xml:"E2setupResponseIEs"`
+ } `xml:"protocolIEs"`
+ } `xml:"E2setupResponse"`
+ } `xml:"value"`
+}
+
+type E2setupResponseIEs struct {
+ Text string `xml:",chardata"`
+ ID string `xml:"id"`
+ Criticality struct {
+ Text string `xml:",chardata"`
+ Reject string `xml:"reject"`
+ } `xml:"criticality"`
+ Value interface{}`xml:"value"`
+}
+
+type GlobalRICID struct {
+ Text string `xml:",chardata"`
+ GlobalRICID struct {
+ Text string `xml:",chardata"`
+ PLMNIdentity string `xml:"pLMN-Identity"`
+ RicID string `xml:"ric-ID"`
+ } `xml:"GlobalRIC-ID"`
+}
+
+type RANfunctionsIDList struct {
+ Text string `xml:",chardata"`
+ RANfunctionsIDList struct {
+ Text string `xml:",chardata"`
+ ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
+ } `xml:"RANfunctionsID-List"`
+}
+
+type ProtocolIESingleContainer struct {
+ Text string `xml:",chardata"`
+ ID string `xml:"id"`
+ Criticality struct {
+ Text string `xml:",chardata"`
+ Ignore string `xml:"ignore"`
+ } `xml:"criticality"`
+ Value struct {
+ Text string `xml:",chardata"`
+ RANfunctionIDItem struct {
+ Text string `xml:",chardata"`
+ RanFunctionID string `xml:"ranFunctionID"`
+ RanFunctionRevision string `xml:"ranFunctionRevision"`
+ } `xml:"RANfunctionID-Item"`
+ } `xml:"value"`
+}
+
+
+type UnsuccessfulOutcome struct {
+ XMLName xml.Name `xml:"unsuccessfulOutcome"`
+ Text string `xml:",chardata"`
+ ProcedureCode string `xml:"procedureCode"`
+ Criticality struct {
+ Text string `xml:",chardata"`
+ Reject string `xml:"reject"`
+ } `xml:"criticality"`
+ Value struct {
+ Text string `xml:",chardata"`
+ E2setupFailure struct {
+ Text string `xml:",chardata"`
+ ProtocolIEs struct {
+ Text string `xml:",chardata"`
+ E2setupFailureIEs []E2setupFailureIEs`xml:"E2setupFailureIEs"`
+ } `xml:"protocolIEs"`
+ } `xml:"E2setupFailure"`
+ } `xml:"value"`
+}
+
+type E2setupFailureIEs struct {
+ Text string `xml:",chardata"`
+ ID string `xml:"id"`
+ Criticality struct {
+ Text string `xml:",chardata"`
+ Ignore string `xml:"ignore"`
+ } `xml:"criticality"`
+ Value struct {
+ Text string `xml:",chardata"`
+ Value interface{}
+ } `xml:"value"`
+}
+
+type Cause struct {
+ XMLName xml.Name `xml:"Cause"`
+ Text string `xml:",chardata"`
+ Transport struct {
+ Text string `xml:",chardata"`
+ TransportResourceUnavailable string `xml:"transport-resource-unavailable"`
+ } `xml:"transport"`
+}
+
+func extractRanFunctionsIDList(request *E2SetupRequestMessage) []ProtocolIESingleContainer{
+ list := &request.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[1].Value.RANfunctionsList
+ ids := make([]ProtocolIESingleContainer,len(list.ProtocolIESingleContainer))
+ for i := 0; i< len(ids); i++{
+ ids[i] = convertToRANfunctionID(list, i)
+ }
+ return ids
+}
+
+func convertToRANfunctionID(list *RANfunctionsList, i int) ProtocolIESingleContainer{
+ id := ProtocolIESingleContainer{}
+ id.ID = "6"
+ id.Value.RANfunctionIDItem.RanFunctionID = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionID
+ id.Value.RANfunctionIDItem.RanFunctionRevision = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionRevision
+ return id
+}
\ No newline at end of file
+++ /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 models
-import (
- "encoding/xml"
-)
-
-type E2SetupSuccessResponseMessage struct {
- XMLName xml.Name `xml:"E2SetupSuccessResponseMessage"`
- Text string `xml:",chardata"`
- E2APPDU E2APPDU `xml:"E2AP-PDU"`
-}
-
-type E2APPDU struct {
- XMLName xml.Name `xml:"E2AP-PDU"`
- Text string `xml:",chardata"`
- SuccessfulOutcome struct {
- Text string `xml:",chardata"`
- ProcedureCode string `xml:"procedureCode"`
- Criticality struct {
- Text string `xml:",chardata"`
- Reject string `xml:"reject"`
- } `xml:"criticality"`
- Value struct {
- Text string `xml:",chardata"`
- E2setupResponse struct {
- Text string `xml:",chardata"`
- ProtocolIEs struct {
- Text string `xml:",chardata"`
- E2setupResponseIEs []E2setupResponseIEs`xml:"E2setupResponseIEs"`
- } `xml:"protocolIEs"`
- } `xml:"E2setupResponse"`
- } `xml:"value"`
- } `xml:"successfulOutcome"`
-}
-
-type E2setupResponseIEs struct {
- Text string `xml:",chardata"`
- ID string `xml:"id"`
- Criticality struct {
- Text string `xml:",chardata"`
- Reject string `xml:"reject"`
- } `xml:"criticality"`
- Value interface{}`xml:"value"`
-}
-
-type GlobalRICID struct {
- Text string `xml:",chardata"`
- GlobalRICID struct {
- Text string `xml:",chardata"`
- PLMNIdentity string `xml:"pLMN-Identity"`
- RicID string `xml:"ric-ID"`
- } `xml:"GlobalRIC-ID"`
-}
-
-type RANfunctionsIDList struct {
- Text string `xml:",chardata"`
- RANfunctionsIDList struct {
- Text string `xml:",chardata"`
- ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
- } `xml:"RANfunctionsID-List"`
-}
-
-type ProtocolIESingleContainer struct {
- Text string `xml:",chardata"`
- ID string `xml:"id"`
- Criticality struct {
- Text string `xml:",chardata"`
- Ignore string `xml:"ignore"`
- } `xml:"criticality"`
- Value struct {
- Text string `xml:",chardata"`
- RANfunctionIDItem struct {
- Text string `xml:",chardata"`
- RanFunctionID string `xml:"ranFunctionID"`
- RanFunctionRevision string `xml:"ranFunctionRevision"`
- } `xml:"RANfunctionID-Item"`
- } `xml:"value"`
-}
-
-func NewE2SetupSuccessResponseMessage(plmnId string, ricId string, request *E2SetupRequestMessage) E2SetupSuccessResponseMessage{
- msg := E2SetupSuccessResponseMessage{}
- msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs = make([]E2setupResponseIEs, 2)
- msg.E2APPDU.SuccessfulOutcome.ProcedureCode = "1"
- msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].ID = "4"
- msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[0].Value = GlobalRICID{GlobalRICID: struct {
- Text string `xml:",chardata"`
- PLMNIdentity string `xml:"pLMN-Identity"`
- RicID string `xml:"ric-ID"`
- }{PLMNIdentity:plmnId, RicID:ricId}}
- msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].ID = "9"
- msg.E2APPDU.SuccessfulOutcome.Value.E2setupResponse.ProtocolIEs.E2setupResponseIEs[1].Value = RANfunctionsIDList{RANfunctionsIDList: struct {
- Text string `xml:",chardata"`
- ProtocolIESingleContainer []ProtocolIESingleContainer `xml:"ProtocolIE-SingleContainer"`
- }{ProtocolIESingleContainer:extractRanFunctionsIDList(request)}}
- return msg
-}
-
-func extractRanFunctionsIDList(request *E2SetupRequestMessage) []ProtocolIESingleContainer{
- list := &request.E2APPDU.InitiatingMessage.Value.E2setupRequest.ProtocolIEs.E2setupRequestIEs[1].Value.RANfunctionsList
- ids := make([]ProtocolIESingleContainer,len(list.ProtocolIESingleContainer))
- for i := 0; i< len(ids); i++{
- ids[i] = convertToRANfunctionID(list, i)
- }
- return ids
-}
-
-func convertToRANfunctionID(list *RANfunctionsList, i int) ProtocolIESingleContainer{
- id := ProtocolIESingleContainer{}
- id.ID = "6"
- id.Value.RANfunctionIDItem.RanFunctionID = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionID
- id.Value.RANfunctionIDItem.RanFunctionRevision = list.ProtocolIESingleContainer[i].Value.RANfunctionItem.RanFunctionRevision
- return id
-}
\ No newline at end of file
package models
-import "time"
+import (
+ "time"
+ "unsafe"
+)
type NotificationRequest struct {
RanName string
Payload []byte
StartTime time.Time
TransactionId []byte
+ msgSrc unsafe.Pointer
}
-func NewNotificationRequest(ranName string, payload []byte, startTime time.Time, transactionId []byte) *NotificationRequest {
+func NewNotificationRequest(ranName string, payload []byte, startTime time.Time, transactionId []byte, msgSrc unsafe.Pointer) *NotificationRequest {
return &NotificationRequest{
ranName,
len(payload),
payload,
startTime,
transactionId,
+ msgSrc,
}
}
+
+func (r NotificationRequest) GetMsgSrc() unsafe.Pointer{
+ return r.msgSrc
+}
package models
+import "unsafe"
+
type RmrMessage struct {
MsgType int
RanName string
Payload []byte
XAction []byte
+ msgSrc unsafe.Pointer
}
-func NewRmrMessage(msgType int, ranName string, payload []byte, xAction []byte) *RmrMessage {
+func NewRmrMessage(msgType int, ranName string, payload []byte, xAction []byte, msgSrc unsafe.Pointer) *RmrMessage {
return &RmrMessage{
- MsgType: msgType,
- RanName: ranName,
- Payload: payload,
- XAction: xAction,
+ msgType,
+ ranName,
+ payload,
+ xAction,
+ msgSrc,
}
}
+
+func (m RmrMessage) GetMsgSrc() unsafe.Pointer{
+ return m.msgSrc
+}
return convertToMBuf(ctx.Logger, currCMBuf), nil
}
+func (ctx *Context) WhSendMsg(msg *MBuf, printLogs bool) (*MBuf, error) {
+ ctx.checkContextInitialized()
+ ctx.Logger.Debugf("#rmrCgoApi.WhSendMsg - Going to wormhole send message. MBuf: %v", *msg)
+
+ whid := C.rmr_wh_open(ctx.RmrCtx, (*C.char)(msg.GetMsgSrc())) // open direct connection, returns wormhole ID
+ ctx.Logger.Infof("#rmrCgoApi.WhSendMsg - The wormhole id %v has been received", whid)
+ defer C.rmr_wh_close(ctx.RmrCtx, whid)
+
+ allocatedCMBuf := ctx.getAllocatedCRmrMBuf(ctx.Logger, msg, ctx.MaxMsgSize)
+ state := allocatedCMBuf.state
+ if state != RMR_OK {
+ errorMessage := fmt.Sprintf("#rmrCgoApi.WhSendMsg - Failed to get allocated message. state: %v - %s", state, states[int(state)])
+ return nil, errors.New(errorMessage)
+ }
+
+ if printLogs {
+ transactionId := string(*msg.XAction)
+ tmpTid := strings.TrimSpace(transactionId)
+ ctx.Logger.Infof("[E2 Manager -> RMR] #rmrCgoApi.WhSendMsg - Going to send message %v for transaction id: %s", *msg, tmpTid)
+ }
+
+ currCMBuf := C.rmr_wh_send_msg(ctx.RmrCtx, whid, allocatedCMBuf)
+ defer C.rmr_free_msg(currCMBuf)
+
+ state = currCMBuf.state
+
+ if state != RMR_OK {
+ errorMessage := fmt.Sprintf("#rmrCgoApi.WhSendMsg - Failed to send message. state: %v - %s", state, states[int(state)])
+ return nil, errors.New(errorMessage)
+ }
+
+ return convertToMBuf(ctx.Logger, currCMBuf), nil
+}
+
+
func (ctx *Context) RecvMsg() (*MBuf, error) {
ctx.checkContextInitialized()
ctx.Logger.Debugf("#rmrCgoApi.RecvMsg - Going to receive message")
"github.com/stretchr/testify/assert"
"io/ioutil"
"testing"
+ "unsafe"
)
var (
}
func TestNewMBufSuccess(t *testing.T) {
- msg := rmrCgo.NewMBuf(tests.MessageType, len(tests.DummyPayload), "RanName", &tests.DummyPayload, &tests.DummyXAction)
+ var msgSrc unsafe.Pointer
+ msg := rmrCgo.NewMBuf(tests.MessageType, len(tests.DummyPayload), "RanName", &tests.DummyPayload, &tests.DummyXAction, msgSrc)
assert.NotNil(t, msg)
assert.NotEmpty(t, msg.Payload)
assert.NotEmpty(t, msg.XAction)
"unsafe"
)
-func NewMBuf(mType int, len int, meid string, payload *[]byte, xAction *[]byte) *MBuf {
+func NewMBuf(mType int, len int, meid string, payload *[]byte, xAction *[]byte, msgSrc unsafe.Pointer) *MBuf {
return &MBuf{
- MType: mType,
- Len: len,
- Meid: meid,
- Payload: payload,
- XAction: xAction,
+ mType,
+ len,
+ meid,
+ payload,
+ xAction,
+ msgSrc,
}
}
const (
RMR_MAX_XACTION_LEN = int(C.RMR_MAX_XID)
RMR_MAX_MEID_LEN = int(C.RMR_MAX_MEID)
+ RMR_MAX_SRC_LEN = int(C.RMR_MAX_SRC)
//states
RMR_OK = C.RMR_OK
Meid string //Managed entity id (RAN name)
Payload *[]byte
XAction *[]byte
+ msgSrc unsafe.Pointer
}
func (m MBuf) String() string {
return fmt.Sprintf("{ MType: %d, Len: %d, Meid: %q, Xaction: %q, Payload: [%x] }", m.MType, m.Len, m.Meid, m.XAction, m.Payload)
}
+func (m MBuf) GetMsgSrc() unsafe.Pointer {
+ return m.msgSrc
+}
+
type Context struct {
MaxMsgSize int
Flags int
type RmrMessenger interface {
Init(port string, maxMsgSize int, flags int, logger *logger.Logger) RmrMessenger
SendMsg(msg *MBuf, printLogs bool) (*MBuf, error)
+ WhSendMsg(msg *MBuf, printLogs bool) (*MBuf, error)
RecvMsg() (*MBuf, error)
IsReady() bool
Close()
Len: int(m.len),
Payload: &payloadArr,
XAction: &xActionArr,
+ msgSrc: C.CBytes(make([]byte, RMR_MAX_SRC_LEN)),
}
+ C.rmr_get_src(m, (*C.uchar)(mbuf.msgSrc)) // Capture message source
+
meidBuf := make([]byte, RMR_MAX_MEID_LEN)
if meidCstr := C.rmr_get_meid(m, (*C.uchar)(unsafe.Pointer(&meidBuf[0]))); meidCstr != nil {
mbuf.Meid = strings.TrimRight(string(meidBuf), "\000")
rte|12002|10.0.2.15:38000
rte|12003|10.0.2.15:38000
mse|12002,10.0.2.15:38000|-1|gnb:208-092-303030
+mse|12003,10.0.2.15:38000|-1|gnb:208-092-303030
newrt|end
}
}
+func (r *RmrSender) WhSend(rmrMessage *models.RmrMessage) error {
+ msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
+
+ _, err := r.messenger.WhSendMsg(msg, true)
+
+ if err != nil {
+ r.logger.Errorf("#RmrSender.WhSend - RAN name: %s , Message type: %d - Failed sending message. Error: %v", rmrMessage.RanName, rmrMessage.MsgType, err)
+ return err
+ }
+
+ r.logger.Infof("#RmrSender.WhSend - RAN name: %s , Message type: %d - Successfully sent RMR message", rmrMessage.RanName, rmrMessage.MsgType)
+ return nil
+}
+
func (r *RmrSender) Send(rmrMessage *models.RmrMessage) error {
- msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
_, err := r.messenger.SendMsg(msg, true)
}
func (r *RmrSender) SendWithoutLogs(rmrMessage *models.RmrMessage) error {
- msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+ msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction, rmrMessage.GetMsgSrc())
_, err := r.messenger.SendMsg(msg, false)
"fmt"
"github.com/stretchr/testify/assert"
"testing"
+ "unsafe"
)
func initRmrSenderTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock) {
ranName := "test"
payload := []byte("some payload")
var xAction []byte
- mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
- rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction)
+ rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
rmrSender := NewRmrSender(logger, rmrMessenger)
err := rmrSender.Send(rmrMsg)
ranName := "test"
payload := []byte("some payload")
var xAction []byte
- mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction)
+ var msgSrc unsafe.Pointer
+ mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction, msgSrc)
rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, fmt.Errorf("rmr send failure"))
- rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction)
+ rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction, nil)
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
rmrSender := NewRmrSender(logger, rmrMessenger)
err := rmrSender.Send(rmrMsg)
Code Review / ric-plt / e2mgr.git / commitdiff