"e2mgr/configuration"
"e2mgr/e2managererrors"
"e2mgr/logger"
+ "e2mgr/managers"
"e2mgr/models"
"e2mgr/providers/httpmsghandlerprovider"
"e2mgr/rNibWriter"
"encoding/json"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"github.com/gorilla/mux"
+ "io"
+ "io/ioutil"
"net/http"
+ "net/http/httputil"
+ "strings"
)
const (
ParamRanName = "ranName"
+ LimitRequest = 1000
)
type IController interface {
ShutdownHandler(writer http.ResponseWriter, r *http.Request)
X2ResetHandler(writer http.ResponseWriter, r *http.Request)
+ X2SetupHandler(writer http.ResponseWriter, r *http.Request)
+ EndcSetupHandler(writer http.ResponseWriter, r *http.Request)
}
type Controller struct {
}
func NewController(logger *logger.Logger, rmrService *services.RmrService, rNibReaderProvider func() reader.RNibReader, rNibWriterProvider func() rNibWriter.RNibWriter,
- config *configuration.Configuration) *Controller {
+ config *configuration.Configuration, ranSetupManager *managers.RanSetupManager) *Controller {
- provider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrService, config, rNibWriterProvider, rNibReaderProvider)
+ provider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrService, config, rNibWriterProvider, rNibReaderProvider, ranSetupManager)
return &Controller{
logger: logger,
handlerProvider: provider,
}
func (c *Controller) ShutdownHandler(writer http.ResponseWriter, r *http.Request) {
- c.logger.Infof("[Client -> E2 Manager] #controller.ShutdownHandler - request: %v", prettifyRequest(r))
- c.handleRequest(writer, &r.Header, httpmsghandlerprovider.ShutdownRequest, nil, false, http.StatusNoContent)
+ c.logger.Infof("[Client -> E2 Manager] #controller.ShutdownHandler - request: %v", c.prettifyRequest(r))
+ c.handleRequest(writer, &r.Header, httpmsghandlerprovider.ShutdownRequest, nil, false)
}
func (c *Controller) X2ResetHandler(writer http.ResponseWriter, r *http.Request) {
- c.logger.Infof("[Client -> E2 Manager] #controller.X2ResetHandler - request: %v", prettifyRequest(r))
+ c.logger.Infof("[Client -> E2 Manager] #controller.X2ResetHandler - request: %v", c.prettifyRequest(r))
request := models.ResetRequest{}
vars := mux.Vars(r)
ranName := vars[ParamRanName]
- if !c.extractJsonBody(r, &request, writer) {
+ if r.ContentLength > 0 && !c.extractJsonBody(r, &request, writer) {
return
}
request.RanName = ranName
- c.handleRequest(writer, &r.Header, httpmsghandlerprovider.ResetRequest, request, false, http.StatusNoContent)
+ c.handleRequest(writer, &r.Header, httpmsghandlerprovider.ResetRequest, request, false)
}
-func (c *Controller) extractJsonBody(r *http.Request, request models.Request, writer http.ResponseWriter) bool {
- if r.ContentLength <= 0 {
- return true
+func (c *Controller) X2SetupHandler(writer http.ResponseWriter, r *http.Request) {
+ c.logger.Infof("[Client -> E2 Manager] #controller.X2SetupHandler - request: %v", c.prettifyRequest(r))
+
+ request := models.SetupRequest{}
+
+ if !c.extractJsonBody(r, &request, writer) {
+ return
+ }
+
+ c.handleRequest(writer, &r.Header, httpmsghandlerprovider.X2SetupRequest, request, true)
+}
+
+func (c *Controller) EndcSetupHandler(writer http.ResponseWriter, r *http.Request) {
+ c.logger.Infof("[Client -> E2 Manager] #controller.EndcSetupHandler - request: %v", c.prettifyRequest(r))
+
+ request := models.SetupRequest{}
+
+ if !c.extractJsonBody(r, &request, writer) {
+ return
}
- decoder := json.NewDecoder(r.Body)
+ c.handleRequest(writer, &r.Header, httpmsghandlerprovider.EndcSetupRequest, request, true)
+}
+
+func (c *Controller) extractJsonBody(r *http.Request, request models.Request, writer http.ResponseWriter) bool {
+ defer r.Body.Close()
+ body, err := ioutil.ReadAll(io.LimitReader(r.Body, LimitRequest))
- err := decoder.Decode(request)
+ if err != nil {
+ c.logger.Errorf("[Client -> E2 Manager] #controller.extractJsonBody - unable to extract json body - error: %s", err)
+ c.handleErrorResponse(e2managererrors.NewInvalidJsonError(), writer)
+ return false
+ }
+ err = json.Unmarshal(body, &request)
if err != nil {
c.logger.Errorf("[Client -> E2 Manager] #controller.extractJsonBody - unable to extract json body - error: %s", err)
c.handleErrorResponse(e2managererrors.NewInvalidJsonError(), writer)
}
func (c *Controller) handleRequest(writer http.ResponseWriter, header *http.Header, requestName httpmsghandlerprovider.IncomingRequest,
- request models.Request, validateHeader bool, httpStatusResponse int) {
+ request models.Request, validateHeader bool) {
if validateHeader {
return
}
- err = handler.Handle(c.logger, request)
+ err = handler.Handle(request)
if err != nil {
c.handleErrorResponse(err, writer)
return
}
- writer.WriteHeader(httpStatusResponse)
- c.logger.Infof("[E2 Manager -> Client] #controller.handleRequest - status response: %v", httpStatusResponse)
+ writer.WriteHeader(http.StatusNoContent)
+ c.logger.Infof("[E2 Manager -> Client] #controller.handleRequest - status response: %v", http.StatusNoContent)
}
func (c *Controller) validateRequestHeader(header *http.Header) error {
c.logger.Errorf("#controller.handleErrorResponse - Cannot send response. writer:%v", writer)
}
}
+
+func (c *Controller) prettifyRequest(request *http.Request) string {
+ dump, _ := httputil.DumpRequest(request, true)
+ requestPrettyPrint := strings.Replace(string(dump), "\r\n", " ", -1)
+ return strings.Replace(requestPrettyPrint, "\n", "", -1)
+}
"e2mgr/configuration"
"e2mgr/e2managererrors"
"e2mgr/logger"
+ "e2mgr/managers"
"e2mgr/mocks"
"e2mgr/models"
"e2mgr/providers/httpmsghandlerprovider"
"testing"
)
+func TestX2SetupSuccess(t *testing.T) {
+/* log := initLog(t)
+
+ rmrMessengerMock := &mocks.RmrMessengerMock{}
+ readerMock := &mocks.RnibReaderMock{}
+ readerProvider := func() reader.RNibReader {
+ return readerMock
+ }
+ writerMock := &mocks.RnibWriterMock{}
+ writerProvider := func() rNibWriter.RNibWriter {
+ return writerMock
+ }
+ config := configuration.ParseConfiguration()
+
+ header := http.Header{}
+ header.Set("Content-Type", "application/json")
+
+ writer := httptest.NewRecorder()
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
+
+ httpRequest := tests.GetHttpRequest()
+ httpRequest.Header = header
+ controller.X2SetupHandler(writer, httpRequest)
+
+ assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)*/
+}
+
func TestShutdownHandlerRnibError(t *testing.T) {
log := initLog(t)
config := configuration.ParseConfiguration()
readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
writer := httptest.NewRecorder()
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
controller.ShutdownHandler(writer, tests.GetHttpRequest())
var errorResponse = parseJsonRequest(t, writer.Body)
}
writer := httptest.NewRecorder()
-
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
header := &http.Header{}
- controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true, http.StatusNoContent)
+ controller.handleRequest(writer, header, httpmsghandlerprovider.ShutdownRequest, nil, true)
var errorResponse = parseJsonRequest(t, writer.Body)
err := e2managererrors.NewHeaderValidationError()
readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
writer := httptest.NewRecorder()
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
controller.ShutdownHandler(writer, tests.GetHttpRequest())
assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
}
writer := httptest.NewRecorder()
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
err := e2managererrors.NewInternalError()
controller.handleErrorResponse(err, writer)
return writerMock
}
writer := httptest.NewRecorder()
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
err := e2managererrors.NewCommandAlreadyInProgressError()
controller.handleErrorResponse(err, writer)
return writerMock
}
config := configuration.ParseConfiguration()
-
- controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, getRmrService(rmrMessengerMock, log), readerProvider, writerProvider, config, ranSetupManager)
header := http.Header{}
header.Set("Content-Type", "application/json")
rmrService := getRmrService(rmrMessengerMock, log)
writer := httptest.NewRecorder()
- controller := NewController(log, rmrService, readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, rmrService, readerProvider, writerProvider, config, ranSetupManager)
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
rmrService := getRmrService(rmrMessengerMock, log)
writer := httptest.NewRecorder()
- controller := NewController(log, rmrService, readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, rmrService, readerProvider, writerProvider, config, ranSetupManager)
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
rmrService := getRmrService(rmrMessengerMock, log)
writer := httptest.NewRecorder()
- controller := NewController(log, rmrService, readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, rmrService, readerProvider, writerProvider, config, ranSetupManager)
// Invalid json: attribute name without quotes (should be "cause":).
b := strings.NewReader("{cause:\"protocol:transfer-syntax-error\"")
config := configuration.ParseConfiguration()
rmrService := getRmrService(rmrMessengerMock, log)
-
- controller := NewController(log, rmrService, readerProvider, writerProvider, config)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ controller := NewController(log, rmrService, readerProvider, writerProvider, config, ranSetupManager)
writer := httptest.NewRecorder()
controller.handleErrorResponse(e2managererrors.NewRnibDbError(), writer)
import (
"e2mgr/logger"
"e2mgr/models"
- "e2mgr/providers/httpmsghandlerprovider"
"e2mgr/rNibWriter"
"e2mgr/services"
"e2mgr/sessions"
"e2mgr/utils"
"encoding/json"
- "errors"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
- "github.com/go-ozzo/ozzo-validation"
- "github.com/go-ozzo/ozzo-validation/is"
"github.com/golang/protobuf/jsonpb"
"github.com/gorilla/mux"
"net/http"
- "net/http/httputil"
- "strings"
- "sync"
"time"
)
const (
- parseErrorCode int = 401
validationErrorCode int = 402
notFoundErrorCode int = 404
internalErrorCode int = 501
- requiredInputErrorMessage = "Mandatory fields are missing"
validationFailedMessage = "Validation failed"
- parseErrorMessage = "Parse failure"
notFoundErrorMessage = "Resource not found"
internalErrorMessage = "Internal Server Error. Please try again later"
- sendMessageErrorMessage = "Failed to send message. For more information please check logs"
)
var E2Sessions = make(sessions.E2Sessions)
var errorChannel chan error
type INodebController interface {
- HandleRequest(writer http.ResponseWriter, request *http.Request)
GetNodebIdList (writer http.ResponseWriter, request *http.Request)
GetNodeb(writer http.ResponseWriter, request *http.Request)
HandleHealthCheckRequest(writer http.ResponseWriter, request *http.Request)
}
}
-func prettifyRequest(request *http.Request) string {
- dump, _ := httputil.DumpRequest(request, true)
- requestPrettyPrint := strings.Replace(string(dump), "\r\n", " ", -1)
- return strings.Replace(requestPrettyPrint, "\n", "", -1)
-}
-
-func (rc NodebController) HandleRequest(writer http.ResponseWriter, request *http.Request) {
- startTime := time.Now()
- rc.Logger.Infof("[Client -> E2 Manager] #nodeb_controller.HandleRequest - request: %v", prettifyRequest(request))
-
- vars := mux.Vars(request)
- messageTypeParam := vars["messageType"]
- requestHandlerProvider := httpmsghandlerprovider.NewRequestHandlerProvider(rc.rnibWriterProvider)
- handler, err := requestHandlerProvider.GetHandler(rc.Logger, messageTypeParam)
-
- if err != nil {
- handleErrorResponse(rc.Logger, http.StatusNotFound, notFoundErrorCode, notFoundErrorMessage, writer, startTime)
- return
- }
-
- requestDetails, err := parseJson(rc.Logger, request)
-
- if err != nil {
- handleErrorResponse(rc.Logger, http.StatusBadRequest, parseErrorCode, parseErrorMessage, writer, startTime)
- return
- }
-
- rc.Logger.Infof("#nodeb_controller.HandleRequest - request: %+v", requestDetails)
-
- if err := validateRequestDetails(rc.Logger, requestDetails); err != nil {
- handleErrorResponse(rc.Logger, http.StatusBadRequest, validationErrorCode, requiredInputErrorMessage, writer, startTime)
- return
- }
-
- err = handler.PreHandle(rc.Logger, &requestDetails)
-
- if err != nil {
- handleErrorResponse(rc.Logger, http.StatusInternalServerError, internalErrorCode, err.Error(), writer, startTime)
- return
- }
-
- rc.Logger.Infof("[E2 Manager -> Client] #nodeb_controller.HandleRequest - http status: 200")
- writer.WriteHeader(http.StatusOK)
-
- var wg sync.WaitGroup
-
- go handler.CreateMessage(rc.Logger, &requestDetails, messageChannel, E2Sessions, startTime, wg)
-
- go rc.rmrService.SendMessage(handler.GetMessageType(), messageChannel, errorChannel, wg)
-
- wg.Wait()
-
- err = <-errorChannel
-
- if err != nil {
- handleErrorResponse(rc.Logger, http.StatusInternalServerError, internalErrorCode, sendMessageErrorMessage, writer, startTime)
- return
- }
-
- printHandlingRequestElapsedTimeInMs(rc.Logger, startTime)
-}
-
func (rc NodebController) GetNodebIdList (writer http.ResponseWriter, request *http.Request) {
startTime := time.Now()
rnibReaderService := services.NewRnibReaderService(rc.rnibReaderProvider)
vars := mux.Vars(request)
ranName := vars["ranName"]
// WAS: respondingNode, rnibError := reader.GetRNibReader().GetNodeb(ranName)
- rnibReaderService := services.NewRnibReaderService(rc.rnibReaderProvider);
+ rnibReaderService := services.NewRnibReaderService(rc.rnibReaderProvider)
respondingNode, rnibError := rnibReaderService.GetNodeb(ranName)
if rnibError != nil {
rc.Logger.Errorf("%v", rnibError)
writer.WriteHeader(http.StatusOK)
}
-func parseJson(logger *logger.Logger, request *http.Request) (models.RequestDetails, error) {
- var requestDetails models.RequestDetails
- if err := json.NewDecoder(request.Body).Decode(&requestDetails); err != nil {
- logger.Errorf("#nodeb_controller.parseJson - cannot deserialize incoming request. request: %v, error: %v", request, err)
- return requestDetails, err
- }
- return requestDetails, nil
-}
-
-func validateRequestDetails(logger *logger.Logger, requestDetails models.RequestDetails) error {
-
- if requestDetails.RanPort == 0 {
- logger.Errorf("#nodeb_controller.validateRequestDetails - validation failure: port cannot be zero")
- return errors.New("port: cannot be blank")
- }
- err := validation.ValidateStruct(&requestDetails,
- validation.Field(&requestDetails.RanIp, validation.Required, is.IP),
- validation.Field(&requestDetails.RanName, validation.Required),
- )
- if err != nil {
- logger.Errorf("#nodeb_controller.validateRequestDetails - validation failure, error: %v", err)
- }
-
- return err
-}
-
func handleErrorResponse(logger *logger.Logger, httpStatus int, errorCode int, errorMessage string, writer http.ResponseWriter, startTime time.Time) {
errorResponseDetails := models.ErrorResponse{errorCode, errorMessage}
errorResponse, _ := json.Marshal(errorResponseDetails)
"e2mgr/services"
"e2mgr/sessions"
"e2mgr/tests"
- "fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"github.com/gorilla/mux"
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/mock"
"io/ioutil"
"net/http"
"net/http/httptest"
"testing"
)
-const x2SetupMessageType = "x2-setup"
-
func TestNewRequestController(t *testing.T) {
rnibReaderProvider := func() reader.RNibReader {
return &mocks.RnibReaderMock{}
assert.NotNil(t, NewNodebController(&logger.Logger{}, &services.RmrService{}, rnibReaderProvider, rnibWriterProvider))
}
-func TestHandleRequestSuccess(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("#nodeb_controller_test.TestHandleRequestSuccess - failed to initialize logger, error: %s", err)
- }
-
- rmrMessengerMock := &mocks.RmrMessengerMock{}
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
-
- rmrMessengerMock.On("SendMsg",
- mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
- tests.MaxMsgSize).Return(mbuf, nil)
-
- writer := httptest.NewRecorder()
-
- handleRequest(writer, log, rmrMessengerMock, tests.GetHttpRequest(), x2SetupMessageType)
- assert.Equal(t, http.StatusOK, writer.Result().StatusCode)
-}
-
-func TestHandleRequestFailure_InvalidRequestDetails(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
- }
-
- rmrMessengerMock := &mocks.RmrMessengerMock{}
- var mbuf *rmrCgo.MBuf
-
- rmrMessengerMock.On("SendMsg",
- mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
- tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
-
- writer := httptest.NewRecorder()
-
- handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidRequestDetails(), x2SetupMessageType)
- assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
-}
-
-func TestHandleRequestFailure_InvalidMessageType(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("#nodeb_controller_test.TestHandleRequestFailure - failed to initialize logger, error: %s", err)
- }
-
- rmrMessengerMock := &mocks.RmrMessengerMock{}
- var mbuf *rmrCgo.MBuf
-
- rmrMessengerMock.On("SendMsg",
- mock.AnythingOfType(fmt.Sprintf("%T", mbuf)),
- tests.MaxMsgSize).Return(mbuf, errors.New("test failure"))
-
- writer := httptest.NewRecorder()
-
- handleRequest(writer, log, rmrMessengerMock, tests.GetInvalidMessageType(), "dummy")
- assert.Equal(t, http.StatusNotFound, writer.Result().StatusCode)
-}
-
func TestHandleHealthCheckRequest(t *testing.T) {
rc := NewNodebController(nil, nil, nil, nil)
writer := httptest.NewRecorder()
assert.Equal(t, writer.Result().StatusCode, http.StatusOK)
}
-func handleRequest(writer *httptest.ResponseRecorder, log *logger.Logger, rmrMessengerMock *mocks.RmrMessengerMock,
- request *http.Request, messageType string) {
- rmrService := getRmrService(rmrMessengerMock, log)
- request = mux.SetURLVars(request, map[string]string{"messageType": messageType})
-
- var nodebInfo *entities.NodebInfo
- var nbIdentity *entities.NbIdentity
-
- rnibWriterMock := mocks.RnibWriterMock{}
- rnibWriterMock.On("SaveNodeb",
- mock.AnythingOfType(fmt.Sprintf("%T", nbIdentity)),
- mock.AnythingOfType(fmt.Sprintf("%T", nodebInfo))).Return(nil)
-
- rnibReaderProvider := func() reader.RNibReader {
- return &mocks.RnibReaderMock{}
- }
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &rnibWriterMock
- }
-
- NewNodebController(log, rmrService, rnibReaderProvider, rnibWriterProvider).HandleRequest(writer, request)
-}
-
func getRmrService(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *services.RmrService {
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
messageChannel := make(chan *models.NotificationResponse)
for _, tc := range testCases {
t.Run(tc.packedPdu, func(t *testing.T) {
- payload, _, err := PreparePackedEndcX2SetupRequest(MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, tc.eNBId, tc.eNBIdBitqty, ricFlag)
+ payload, _, err := preparePackedEndcX2SetupRequest(MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, tc.eNBId, tc.eNBIdBitqty, ricFlag)
if err != nil {
t.Errorf("want: success, got: pack failed. Error: %v\n", err)
} else {
eNBIdBitqty := uint(Macro_eNB_ID)
wantError := "packing error: #src/asn1codec_utils.c.pack_pdu_aux - Encoded output of E2AP-PDU, is too big:53"
- _, _, err := PreparePackedEndcX2SetupRequest(40 /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+ _, _, err := preparePackedEndcX2SetupRequest(40 /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, eNBId, eNBIdBitqty, ricFlag)
if err != nil {
if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
t.Errorf("want failure: %s, got: %s", wantError, err)
"unsafe"
)
-//TODO: replace the constant in setup_request_handler.go
const (
MaxAsn1PackedBufferSize = 4096
MaxAsn1CodecMessageBufferSize = 4096
for _, tc := range testCases {
t.Run(tc.packedPdu, func(t *testing.T) {
- payload, _, err :=PreparePackedX2SetupRequest(MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, tc.eNBId, tc.eNBIdBitqty,ricFlag)
+ payload, _, err := preparePackedX2SetupRequest(MaxAsn1PackedBufferSize /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, tc.eNBId, tc.eNBIdBitqty,ricFlag)
if err != nil {
t.Errorf("want: success, got: pack failed. Error: %v\n", err)
} else {
ricFlag := []byte{0xbb, 0xbc, 0xcc} /*pLMNId [3]bytes*/
eNBId := []byte{0xab, 0xcd, 0xe}
eNBIdBitqty := uint(Macro_eNB_ID)
- _, _, err := PreparePackedX2SetupRequest(40 /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+ _, _, err := preparePackedX2SetupRequest(40 /*max packed buffer*/, MaxAsn1CodecMessageBufferSize /*max message buffer*/, pLMNId, eNBId, eNBIdBitqty, ricFlag)
if err != nil {
if 0 != strings.Compare(fmt.Sprintf("%s", err), wantError) {
t.Errorf("want failure: %s, got: %s", wantError, err)
import (
"fmt"
"github.com/pkg/errors"
+ "os"
"unsafe"
)
const (
+ EnvRicId = "RIC_ID"
ShortMacro_eNB_ID = 18
Macro_eNB_ID = 20
LongMacro_eNB_ID = 21
var PackedEndcX2setupRequestAsString string
var PackedX2setupRequestAsString string
-func PreparePackedEndcX2SetupRequest(maxAsn1PackedBufferSize int, maxAsn1CodecMessageBufferSize int, pLMNId []byte, eNB_Id []byte /*18, 20, 21, 28 bits length*/, bitqty uint, ricFlag []byte) ([]byte, string, error) {
+/*The Ric Id is the combination of pLMNId and ENBId*/
+var pLMNId []byte
+var eNBId []byte
+var eNBIdBitqty uint
+var ricFlag = []byte{0xbb, 0xbc, 0xcc} /*pLMNId [3]bytes*/
+
+func preparePackedEndcX2SetupRequest(maxAsn1PackedBufferSize int, maxAsn1CodecMessageBufferSize int, pLMNId []byte, eNB_Id []byte /*18, 20, 21, 28 bits length*/, bitqty uint, ricFlag []byte) ([]byte, string, error) {
packedBuf := make([]byte, maxAsn1PackedBufferSize)
errBuf := make([]C.char, maxAsn1CodecMessageBufferSize)
packedBufSize := C.ulong(len(packedBuf))
return packedBuf[:packedBufSize], pduAsString, nil
}
-func PreparePackedX2SetupRequest(maxAsn1PackedBufferSize int, maxAsn1CodecMessageBufferSize int, pLMNId []byte, eNB_Id []byte /*18, 20, 21, 28 bits length*/, bitqty uint, ricFlag []byte) ([]byte, string, error) {
+func preparePackedX2SetupRequest(maxAsn1PackedBufferSize int, maxAsn1CodecMessageBufferSize int, pLMNId []byte, eNB_Id []byte /*18, 20, 21, 28 bits length*/, bitqty uint, ricFlag []byte) ([]byte, string, error) {
packedBuf := make([]byte, maxAsn1PackedBufferSize)
errBuf := make([]C.char, maxAsn1CodecMessageBufferSize)
packedBufSize := C.ulong(len(packedBuf))
}
return packedBuf[:packedBufSize], pduAsString, nil
}
+
+//Expected value in RIC_ID = pLMN_Identity-eNB_ID/<eNB_ID size in bits>
+//<6 hex digits>-<6 or 8 hex digits>/<18|20|21|28>
+//Each byte is represented by two hex digits, the value in the lowest byte of the eNB_ID must be assigned to the lowest bits
+//For example, to get the value of ffffeab/28 the last byte must be 0x0b, not 0xb0 (-ffffea0b/28).
+func parseRicID(ricId string) error {
+ if _, err := fmt.Sscanf(ricId, "%6x-%8x/%2d", &pLMNId, &eNBId, &eNBIdBitqty); err != nil {
+ return fmt.Errorf("unable to extract the value of %s: %s", EnvRicId, err)
+ }
+
+ if len(pLMNId) < 3 {
+ return fmt.Errorf("invalid value for %s, len(pLMNId:%v) != 3", EnvRicId, pLMNId)
+ }
+
+ if len(eNBId) < 3 {
+ return fmt.Errorf("invalid value for %s, len(eNBId:%v) != 3 or 4", EnvRicId, eNBId)
+ }
+
+ if eNBIdBitqty != ShortMacro_eNB_ID && eNBIdBitqty != Macro_eNB_ID && eNBIdBitqty != LongMacro_eNB_ID && eNBIdBitqty != Home_eNB_ID {
+ return fmt.Errorf("invalid value for %s, eNBIdBitqty: %d", EnvRicId, eNBIdBitqty)
+ }
+
+ return nil
+}
+
+func init() {
+ var err error
+ ricId := os.Getenv(EnvRicId)
+ //ricId="bbbccc-ffff0e/20"
+ //ricId="bbbccc-abcd0e/20"
+ if err = parseRicID(ricId); err != nil {
+ panic(err)
+ }
+
+ PackedEndcX2setupRequest, PackedEndcX2setupRequestAsString, err = preparePackedEndcX2SetupRequest(MaxAsn1PackedBufferSize, MaxAsn1CodecMessageBufferSize, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+ if err != nil {
+ panic(err)
+ }
+ PackedX2setupRequest, PackedX2setupRequestAsString, err = preparePackedX2SetupRequest(MaxAsn1PackedBufferSize, MaxAsn1CodecMessageBufferSize, pLMNId, eNBId, eNBIdBitqty, ricFlag)
+ if err != nil {
+ panic(err)
+ }
+}
--- /dev/null
+/*******************************************************************************
+ *
+ * Copyright (c) 2019 AT&T Intellectual Property.
+ *
+ * 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 e2pdus
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+ "testing"
+)
+
+func TestParseRicId(t *testing.T) {
+ var testCases = []struct {
+ ricId string
+ pLMNId []byte
+ eNBId []byte
+ eNBIdBitqty uint
+ failure error
+ }{
+ {
+ ricId: "bbbccc-abcd02/18",
+ pLMNId: []byte{0xbb, 0xbc, 0xcc},
+ eNBId: []byte{0xab, 0xcd, 0x2}, /*00000010 -> 10000000*/
+ eNBIdBitqty: ShortMacro_eNB_ID,
+ },
+ {
+ ricId: "bbbccc-abcd0e/20",
+ pLMNId: []byte{0xbb, 0xbc, 0xcc},
+ eNBId: []byte{0xab, 0xcd, 0xe},
+ eNBIdBitqty: Macro_eNB_ID,
+ },
+ {
+ ricId: "bbbccc-abcd07/21",
+ pLMNId: []byte{0xbb, 0xbc, 0xcc},
+ eNBId: []byte{0xab, 0xcd, 0x7}, /*00000111 -> 00111000*/
+ eNBIdBitqty: LongMacro_eNB_ID,
+ },
+ {
+ ricId: "bbbccc-abcdef08/28",
+ pLMNId: []byte{0xbb, 0xbc, 0xcc},
+ eNBId: []byte{0xab, 0xcd, 0xef, 0x8},
+ eNBIdBitqty: Home_eNB_ID,
+ },
+ {
+ ricId: "",
+ failure: fmt.Errorf("unable to extract the value of RIC_ID: EOF"),
+ },
+
+ {
+ ricId: "bbbccc",
+ failure: fmt.Errorf("unable to extract the value of RIC_ID: unexpected EOF"),
+ },
+ {
+ ricId: "bbbccc-",
+ failure: fmt.Errorf("unable to extract the value of RIC_ID: EOF"),
+ },
+ {
+ ricId: "-bbbccc",
+ failure: fmt.Errorf("%s", "unable to extract the value of RIC_ID: no hex data for %x string"),
+ },
+ {
+ ricId: "/20",
+ failure: fmt.Errorf("%s", "unable to extract the value of RIC_ID: no hex data for %x string"),
+ },
+ {
+ ricId: "bbbcccdd-abcdef08/28", // pLMNId too long
+ failure: fmt.Errorf("unable to extract the value of RIC_ID: input does not match format"),
+ },
+ {
+ ricId: "bbbccc-abcdef0809/28", // eNBId too long
+ failure: fmt.Errorf("unable to extract the value of RIC_ID: input does not match format"),
+ },
+
+ {
+ ricId: "bbbc-abcdef08/28", // pLMNId too short
+ failure: fmt.Errorf("invalid value for RIC_ID, len(pLMNId:[187 188]) != 3"),
+ },
+ {
+ ricId: "bbbccc-abcd/28", // eNBId too short
+ failure: fmt.Errorf("invalid value for RIC_ID, len(eNBId:[171 205]) != 3 or 4"),
+ },
+ {
+ ricId: "bbbccc-abcdef08/239", // bit quantity too long - no error, will return 23 (which is invalid)
+ failure: fmt.Errorf("invalid value for RIC_ID, eNBIdBitqty: 23"),
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.ricId, func(t *testing.T) {
+
+ err := parseRicID(tc.ricId)
+ if err != nil {
+ if tc.failure == nil {
+ t.Errorf("want: success, got: parse failed. Error: %v\n", err)
+ } else {
+ if strings.Compare(err.Error(), tc.failure.Error()) != 0 {
+ t.Errorf("want: %s, got: %s\n", err, tc.failure)
+ }
+ }
+ } else {
+ if bytes.Compare(tc.pLMNId, pLMNId) != 0 {
+ t.Errorf("want: pLMNId = %v, got: pLMNId = %v", tc.pLMNId, pLMNId)
+ }
+
+ if bytes.Compare(tc.eNBId, eNBId) != 0 {
+ t.Errorf("want: eNBId = %v, got: eNBId = %v", tc.eNBId, eNBId)
+ }
+
+ if tc.eNBIdBitqty != eNBIdBitqty {
+ t.Errorf("want: eNBIdBitqty = %d, got: eNBIdBitqty = %d", tc.eNBIdBitqty, eNBIdBitqty)
+ }
+ }
+ })
+ }
+}
\ No newline at end of file
type DeleteAllRequestHandler struct {
readerProvider func() reader.RNibReader
writerProvider func() rNibWriter.RNibWriter
- rmrService *services.RmrService
- config *configuration.Configuration
+ rmrService *services.RmrService
+ config *configuration.Configuration
+ logger *logger.Logger
}
-func NewDeleteAllRequestHandler(rmrService *services.RmrService, config *configuration.Configuration, writerProvider func() rNibWriter.RNibWriter, readerProvider func() reader.RNibReader) *DeleteAllRequestHandler {
- return &DeleteAllRequestHandler {
+func NewDeleteAllRequestHandler(logger *logger.Logger, rmrService *services.RmrService, config *configuration.Configuration, writerProvider func() rNibWriter.RNibWriter,
+ readerProvider func() reader.RNibReader) *DeleteAllRequestHandler {
+ return &DeleteAllRequestHandler{
+ logger: logger,
readerProvider: readerProvider,
writerProvider: writerProvider,
- rmrService: rmrService,
- config: config,
+ rmrService: rmrService,
+ config: config,
}
}
-func (handler *DeleteAllRequestHandler) Handle(logger *logger.Logger, request models.Request) error {
+func (handler *DeleteAllRequestHandler) Handle(request models.Request) error {
- err, continueFlow := handler.updateNodebStates(logger, false)
+ err, continueFlow := handler.updateNodebStates(false)
if err != nil {
return err
}
- if continueFlow == false{
+ if continueFlow == false {
return nil
}
//TODO change to rmr_request
response := models.NotificationResponse{MgsType: rmrCgo.RIC_SCTP_CLEAR_ALL}
- if err:= handler.rmrService.SendRmrMessage(&response); err != nil {
- logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
- return e2managererrors.NewRmrError()
+ if err := handler.rmrService.SendRmrMessage(&response); err != nil {
+ handler.logger.Errorf("#DeleteAllRequestHandler.Handle - failed to send sctp clear all message to RMR: %s", err)
+ return e2managererrors.NewRmrError()
}
time.Sleep(time.Duration(handler.config.BigRedButtonTimeoutSec) * time.Second)
- logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
+ handler.logger.Infof("#DeleteAllRequestHandler.Handle - timer expired")
- err, _ = handler.updateNodebStates(logger, true)
+ err, _ = handler.updateNodebStates(true)
if err != nil {
return err
}
return nil
}
-func (handler *DeleteAllRequestHandler) updateNodebStates(logger *logger.Logger, timeoutExpired bool) (error, bool){
+func (handler *DeleteAllRequestHandler) updateNodebStates(timeoutExpired bool) (error, bool) {
nbIdentityList, err := handler.readerProvider().GetListNodebIds()
if err != nil {
- logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodes list from RNIB. Error: %s", err.Error())
+ handler.logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodes list from RNIB. Error: %s", err.Error())
return e2managererrors.NewRnibDbError(), false
}
}
numOfRanToShutDown := 0
- for _,nbIdentity := range nbIdentityList{
+ for _, nbIdentity := range nbIdentityList {
node, err := handler.readerProvider().GetNodeb((*nbIdentity).GetInventoryName())
if err != nil {
- logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodeB entity for ran name: %v from RNIB. Error: %s",
+ handler.logger.Errorf("#DeleteAllRequestHandler.updateNodebStates - failed to get nodeB entity for ran name: %v from RNIB. Error: %s",
(*nbIdentity).GetInventoryName(), err.Error())
continue
}
- if timeoutExpired{
+ if timeoutExpired {
- if handler.saveNodebShutDownState(logger, nbIdentity, node){
+ if handler.saveNodebShutDownState(nbIdentity, node) {
numOfRanToShutDown++
}
continue
}
- if handler.saveNodebNextState(logger, nbIdentity, node){
+ if handler.saveNodebNextState(nbIdentity, node) {
numOfRanToShutDown++
}
}
- if numOfRanToShutDown > 0{
- logger.Infof("#DeleteAllRequestHandler.updateNodebStates - update nodebs states in RNIB completed")
- }else {
- logger.Infof("#DeleteAllRequestHandler.updateNodebStates - nodebs states are not updated ")
+ if numOfRanToShutDown > 0 {
+ handler.logger.Infof("#DeleteAllRequestHandler.updateNodebStates - update nodebs states in RNIB completed")
+ } else {
+ handler.logger.Infof("#DeleteAllRequestHandler.updateNodebStates - nodebs states are not updated ")
return nil, false
}
return nil, true
}
-func (handler *DeleteAllRequestHandler) saveNodebNextState(logger *logger.Logger, nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool{
+func (handler *DeleteAllRequestHandler) saveNodebNextState(nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool {
- if node.ConnectionStatus == entities.ConnectionStatus_SHUTTING_DOWN{
+ if node.ConnectionStatus == entities.ConnectionStatus_SHUTTING_DOWN {
return true
}
err := handler.writerProvider().SaveNodeb(nbIdentity, node)
if err != nil {
- logger.Errorf("#DeleteAllRequestHandler.saveNodebNextState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
+ handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebNextState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
(*nbIdentity).GetInventoryName(), err.Error())
return false
}
- if logger.DebugEnabled() {
- logger.Debugf("#DeleteAllRequestHandler.saveNodebNextState - connection status of inventory name: %v changed to %v",
+ if handler.logger.DebugEnabled() {
+ handler.logger.Debugf("#DeleteAllRequestHandler.saveNodebNextState - connection status of inventory name: %v changed to %v",
(*nbIdentity).GetInventoryName(), nextStatus.String())
}
return true
}
-func (handler *DeleteAllRequestHandler) saveNodebShutDownState(logger *logger.Logger, nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool{
+func (handler *DeleteAllRequestHandler) saveNodebShutDownState(nbIdentity *entities.NbIdentity, node *entities.NodebInfo) bool {
- if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN{
+ if node.ConnectionStatus == entities.ConnectionStatus_SHUT_DOWN {
return false
}
if node.ConnectionStatus != entities.ConnectionStatus_SHUTTING_DOWN {
- logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - ignore, status is not Shutting Down, inventory name: %v ", (*nbIdentity).GetInventoryName())
+ handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - ignore, status is not Shutting Down, inventory name: %v ", (*nbIdentity).GetInventoryName())
return false
}
err := handler.writerProvider().SaveNodeb(nbIdentity, node)
if err != nil {
- logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
+ handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - failed to save nodeB entity for inventory name: %v to RNIB. Error: %s",
(*nbIdentity).GetInventoryName(), err.Error())
return false
}
- logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - Shut Down , inventory name: %v ", (*nbIdentity).GetInventoryName())
+ handler.logger.Errorf("#DeleteAllRequestHandler.saveNodebShutDownState - Shut Down , inventory name: %v ", (*nbIdentity).GetInventoryName())
return true
}
"testing"
)
-func TestHandleBeforeTimerGetListNodebIdsFailedFlow(t *testing.T){
+func TestHandleBeforeTimerGetListNodebIdsFailedFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
config := configuration.ParseConfiguration()
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
rnibErr := &common.ResourceNotFoundError{}
var nbIdentityList []*entities.NbIdentity
readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibErr)
expected := &e2managererrors.RnibDbError{}
- actual := handler.Handle(log, nil)
- if reflect.TypeOf(actual) != reflect.TypeOf(expected){
+ actual := handler.Handle(nil)
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
}
-func TestHandleAfterTimerGetListNodebIdsFailedFlow(t *testing.T){
+func TestHandleAfterTimerGetListNodebIdsFailedFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
rnibErr := &common.ResourceNotFoundError{}
//Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil).Return(nbIdentityList, rnibErr)
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
- nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3 := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
expected := &e2managererrors.RnibDbError{}
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
- if reflect.TypeOf(actual) != reflect.TypeOf(expected){
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
}
-func TestHandleSuccessFlow(t *testing.T){
+func TestHandleSuccessFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
//Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown
nbIdentityList := createIdentityList()
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
- nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3 := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
- nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
- updatedNb2AfterTimer := &entities.NodebInfo{RanName:"RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3AfterTimer := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, nil)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
assert.Nil(t, actual)
}
-func TestHandleSuccessGetNextStatusFlow(t *testing.T){
+func TestHandleSuccessGetNextStatusFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
//after timer: ShutDown->Ignore, ShuttingDown->ShutDown
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
- updatedNb1AfterTimer := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, nil)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
assert.Nil(t, actual)
}
-func TestHandleShuttingDownStatusFlow(t *testing.T){
+func TestHandleShuttingDownStatusFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
nbIdentityList := []*entities.NbIdentity{{InventoryName: "RanName_1"}}
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
- updatedNb1AfterTimer := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, nil)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
assert.Nil(t, actual)
}
-func TestHandleGetNodebFailedFlow(t *testing.T){
+func TestHandleGetNodebFailedFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
//Before timer: Disconnected->ShutDown(will fail), ShuttingDown->Ignore, Connected->ShuttingDown
nbIdentityList := createIdentityList()
errRnib := &common.ResourceNotFoundError{}
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
- nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, errRnib)
readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3 := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(errRnib)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
- nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, errRnib)
readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
- updatedNb2AfterTimer := &entities.NodebInfo{RanName:"RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3AfterTimer := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, nil)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
assert.Nil(t, actual)
}
-func TestHandleSaveFailedFlow(t *testing.T){
+func TestHandleSaveFailedFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
//Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
nbIdentityList := createIdentityList()
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
- nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
errRnib := &common.ResourceNotFoundError{}
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3 := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(errRnib)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
- nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
- updatedNb2AfterTimer := &entities.NodebInfo{RanName:"RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3AfterTimer := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(errRnib)
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, nil)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
assert.Nil(t, actual)
}
-func TestHandleSendRmrFailedFlow(t *testing.T){
+func TestHandleSendRmrFailedFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
config.BigRedButtonTimeoutSec = 1
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
//Before timer: Disconnected->ShutDown, ShuttingDown->Ignore, Connected->ShuttingDown(will fail)
nbIdentityList := createIdentityList()
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_DISCONNECTED,}
- nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_CONNECTED,}
+ nb2 := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_CONNECTED,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3, nil)
- updatedNb1 := &entities.NodebInfo{RanName:"RanName_1", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3 := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ updatedNb1 := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3 := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb1).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3).Return(nil)
readerMock.On("GetListNodebIds").Return(nbIdentityList, nil)
nb1AfterTimer := &entities.NodebInfo{RanName: "RanName_1", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
- nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
- nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ nb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
readerMock.On("GetNodeb", "RanName_1").Return(nb1AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_2").Return(nb2AfterTimer, nil)
readerMock.On("GetNodeb", "RanName_3").Return(nb3AfterTimer, nil)
- updatedNb2AfterTimer := &entities.NodebInfo{RanName:"RanName_2", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
- updatedNb3AfterTimer := &entities.NodebInfo{RanName:"RanName_3", ConnectionStatus:entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb2AfterTimer := &entities.NodebInfo{RanName: "RanName_2", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
+ updatedNb3AfterTimer := &entities.NodebInfo{RanName: "RanName_3", ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN,}
writerMock.On("SaveNodeb", mock.Anything, updatedNb2AfterTimer).Return(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
expected := e2managererrors.NewRmrError()
- mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize,"RanName" , &tests.DummyPayload, &tests.DummyXAction)
+ mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), tests.MaxMsgSize).Return(mbuf, expected)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
- if reflect.TypeOf(actual) != reflect.TypeOf(expected){
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
}
-func TestHandleGetListEnbIdsEmptyFlow(t *testing.T){
+func TestHandleGetListEnbIdsEmptyFlow(t *testing.T) {
log := initLog(t)
readerMock := &mocks.RnibReaderMock{}
rmrMessengerMock := &mocks.RmrMessengerMock{}
config := configuration.ParseConfiguration()
- handler := NewDeleteAllRequestHandler(getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
+ handler := NewDeleteAllRequestHandler(log, getRmrService(rmrMessengerMock, log), config, writerProvider, readerProvider)
var rnibError error
nbIdentityList := []*entities.NbIdentity{}
readerMock.On("GetListNodebIds").Return(nbIdentityList, rnibError)
- actual := handler.Handle(log, nil)
+ actual := handler.Handle(nil)
readerMock.AssertNumberOfCalls(t, "GetNodeb", 0)
assert.Nil(t, actual)
}
return log
}
-
func getRmrService(rmrMessengerMock *mocks.RmrMessengerMock, log *logger.Logger) *services.RmrService {
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)
-}
\ No newline at end of file
+ return services.NewRmrService(services.NewRmrConfig(tests.Port, tests.MaxMsgSize, tests.Flags, log), rmrMessenger, make(sessions.E2Sessions), 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 httpmsghandlers
-
-import (
- "e2mgr/e2pdus"
- "e2mgr/logger"
- "e2mgr/rNibWriter"
- "e2mgr/rnibBuilders"
- "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
- "sync"
- "time"
-
- "e2mgr/models"
- "e2mgr/rmrCgo"
- "e2mgr/sessions"
-)
-
-type EndcSetupRequestHandler struct {
- rnibWriterProvider func() rNibWriter.RNibWriter
-}
-
-func NewEndcSetupRequestHandler(rnibWriterProvider func() rNibWriter.RNibWriter) *EndcSetupRequestHandler {
- return &EndcSetupRequestHandler{
- rnibWriterProvider: rnibWriterProvider,
- }
-}
-
-func (handler EndcSetupRequestHandler) PreHandle(logger *logger.Logger, details *models.RequestDetails) error {
- nodebInfo, nodebIdentity := rnibBuilders.CreateInitialNodeInfo(details,entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
-
- rNibErr := handler.rnibWriterProvider().SaveNodeb(nodebIdentity, nodebInfo)
- if rNibErr != nil {
- logger.Errorf("#endc_setup_request_handler.PreHandle - failed to initial nodeb entity for ran name: %v in RNIB. Error: %s", details.RanName, rNibErr.Error())
- } else {
- logger.Infof("#endc_setup_request_handler.PreHandle - initial nodeb entity for ran name: %v was saved to RNIB ", details.RanName)
- }
-
- return rNibErr
-}
-
-func (EndcSetupRequestHandler) CreateMessage(logger *logger.Logger, requestDetails *models.RequestDetails, messageChannel chan *models.E2RequestMessage, e2sessions sessions.E2Sessions, startTime time.Time, wg sync.WaitGroup) {
-
- wg.Add(1)
-
- transactionId := requestDetails.RanName
- e2sessions[transactionId] = sessions.E2SessionDetails{SessionStart: startTime, Request: requestDetails}
- setupRequestMessage := models.NewE2RequestMessage(transactionId, requestDetails.RanIp, requestDetails.RanPort, requestDetails.RanName, e2pdus.PackedEndcX2setupRequest)
-
- logger.Debugf("#endc_setup_request_handler.CreateMessage - PDU: %s", e2pdus.PackedEndcX2setupRequestAsString)
- logger.Debugf("#endc_setup_request_handler.CreateMessage - setupRequestMessage was created successfuly. setup request details(transactionId = [%s]): %+v", transactionId, setupRequestMessage)
- messageChannel <- setupRequestMessage
-
- wg.Done()
-}
-
-func (EndcSetupRequestHandler) GetMessageType() int {
- return rmrCgo.RIC_ENDC_X2_SETUP_REQ
-}
+++ /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 httpmsghandlers
-
-import (
- "e2mgr/logger"
- "e2mgr/mocks"
- "e2mgr/models"
- "e2mgr/rNibWriter"
- "e2mgr/sessions"
- "github.com/stretchr/testify/assert"
- "sync"
- "testing"
- "time"
-)
-
-func TestNewEndcSetupRequestHandler(t *testing.T) {
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
- }
-
- h := NewEndcSetupRequestHandler(rnibWriterProvider)
- assert.NotNil(t, h)
-}
-
-func TestCreateEndcX2SetupMessageSuccess(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("#setup_request_handler_test.TestCreateMessageSuccess - failed to initialize logger, error: %s", err)
- }
- messageChannel := make(chan *models.E2RequestMessage)
- assert.NotPanics(t, func() { createEndcX2SetupMsg(log, messageChannel) })
- assert.NotEmpty(t, <-messageChannel)
-}
-
-func createEndcX2SetupMsg(log *logger.Logger, messageChannel chan *models.E2RequestMessage) {
- h := EndcSetupRequestHandler{}
- E2Sessions := make(sessions.E2Sessions)
- var wg sync.WaitGroup
- var rd models.RequestDetails
- go h.CreateMessage(log, &rd, messageChannel, E2Sessions, time.Now(), wg)
- wg.Wait()
-}
+++ /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 httpmsghandlers
-
-import (
- "e2mgr/logger"
- "e2mgr/models"
- "e2mgr/sessions"
- "sync"
- "time"
-)
-
-type Handler interface {
- PreHandle(logger *logger.Logger, details *models.RequestDetails) error
- CreateMessage(logger *logger.Logger, details *models.RequestDetails, messageChannel chan *models.E2RequestMessage, e2sessions sessions.E2Sessions, startTime time.Time, wg sync.WaitGroup)
- GetMessageType() int
-}
package httpmsghandlers
import (
- "e2mgr/logger"
"e2mgr/models"
)
type RequestHandler interface {
- Handle(logger *logger.Logger, request models.Request) error
+ Handle(request models.Request) error
}
// See the License for the specific language governing permissions and
// limitations under the License.
//
-
package httpmsghandlers
import (
- "e2mgr/e2pdus"
+ "e2mgr/e2managererrors"
"e2mgr/logger"
+ "e2mgr/managers"
+ "e2mgr/models"
"e2mgr/rNibWriter"
"e2mgr/rnibBuilders"
- "fmt"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
- "os"
- "sync"
- "time"
-
- "e2mgr/models"
- "e2mgr/rmrCgo"
- "e2mgr/sessions"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
+ "github.com/go-ozzo/ozzo-validation"
+ "github.com/go-ozzo/ozzo-validation/is"
)
const (
- ENV_RIC_ID = "RIC_ID"
- MaxAsn1CodecAllocationBufferSize = 64 * 1024
- MaxAsn1PackedBufferSize = 4096
- MaxAsn1CodecMessageBufferSize = 4096
+ X2SetupActivityName = "X2_SETUP"
+ EndcSetupActivityName = "ENDC_SETUP"
)
-
-/*The Ric Id is the combination of pLMNId and ENBId*/
-var pLMNId []byte
-var eNBId []byte
-var eNBIdBitqty uint
-var ricFlag = []byte{0xbb, 0xbc, 0xcc} /*pLMNId [3]bytes*/
-
type SetupRequestHandler struct {
- rnibWriterProvider func() rNibWriter.RNibWriter
+ readerProvider func() reader.RNibReader
+ writerProvider func() rNibWriter.RNibWriter
+ logger *logger.Logger
+ ranSetupManager *managers.RanSetupManager
+ protocol entities.E2ApplicationProtocol
}
-func NewSetupRequestHandler(rnibWriterProvider func() rNibWriter.RNibWriter) *SetupRequestHandler {
+func NewSetupRequestHandler(logger *logger.Logger, writerProvider func() rNibWriter.RNibWriter, readerProvider func() reader.RNibReader,
+ ranSetupManager *managers.RanSetupManager, protocol entities.E2ApplicationProtocol) *SetupRequestHandler {
return &SetupRequestHandler{
- rnibWriterProvider: rnibWriterProvider,
+ logger: logger,
+ readerProvider: readerProvider,
+ writerProvider: writerProvider,
+ ranSetupManager: ranSetupManager,
+ protocol: protocol,
}
}
-func (handler SetupRequestHandler) PreHandle(logger *logger.Logger, details *models.RequestDetails) error {
- nodebInfo, nodebIdentity := rnibBuilders.CreateInitialNodeInfo(details, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+func (handler *SetupRequestHandler) Handle(request models.Request) error {
- rNibErr := handler.rnibWriterProvider().SaveNodeb(nodebIdentity, nodebInfo)
- if rNibErr != nil {
- logger.Errorf("#setup_request_handler.PreHandle - failed to save initial nodeb entity for ran name: %v in RNIB. Error: %s", details.RanName, rNibErr.Error())
- } else {
- logger.Infof("#setup_request_handler.PreHandle - initial nodeb entity for ran name: %v was saved to RNIB ", details.RanName)
+ setupRequest := request.(models.SetupRequest)
+
+ err := handler.validateRequestDetails(setupRequest)
+ if err != nil {
+ return err
}
- return rNibErr
-}
+ nodebInfo, err := handler.readerProvider().GetNodeb(setupRequest.RanName)
+ if err != nil {
+ _, ok := err.(*common.ResourceNotFoundError)
+ if !ok {
+ handler.logger.Errorf("#SetupRequestHandler.Handle - failed to get nodeB entity for ran name: %v from RNIB. Error: %s",
+ setupRequest.RanName, err.Error())
+ return e2managererrors.NewRnibDbError()
+ }
+
+ result := handler.connectNewRan(&setupRequest, handler.protocol)
+ return result
+ }
-func (SetupRequestHandler) CreateMessage(logger *logger.Logger, requestDetails *models.RequestDetails, messageChannel chan *models.E2RequestMessage, e2sessions sessions.E2Sessions, startTime time.Time, wg sync.WaitGroup) {
+ result := handler.connectExistingRan(nodebInfo)
+ return result
+}
- wg.Add(1)
+func (handler *SetupRequestHandler) connectExistingRan(nodebInfo *entities.NodebInfo) error {
- transactionId := requestDetails.RanName
- e2sessions[transactionId] = sessions.E2SessionDetails{SessionStart: startTime, Request: requestDetails}
- setupRequestMessage := models.NewE2RequestMessage(transactionId, requestDetails.RanIp, requestDetails.RanPort, requestDetails.RanName, e2pdus.PackedX2setupRequest)
+ if nodebInfo.ConnectionStatus == entities.ConnectionStatus_SHUTTING_DOWN {
+ handler.logger.Errorf("#SetupRequestHandler.connectExistingRan - RAN: %s in wrong state (%s)", nodebInfo.RanName, entities.ConnectionStatus_name[int32(nodebInfo.ConnectionStatus)])
+ return e2managererrors.NewWrongStateError(handler.getActivityName(handler.protocol), entities.ConnectionStatus_name[int32(nodebInfo.ConnectionStatus)])
+ }
- logger.Debugf("#setup_request_handler.CreateMessage - PDU: %s", e2pdus.PackedX2setupRequestAsString)
- logger.Debugf("#setup_request_handler.CreateMessage - setupRequestMessage was created successfully. setup request details(transactionId = [%s]): %+v", transactionId, setupRequestMessage)
- messageChannel <- setupRequestMessage
+ status := entities.ConnectionStatus_CONNECTING
+ if nodebInfo.ConnectionStatus == entities.ConnectionStatus_CONNECTED{
+ status = nodebInfo.ConnectionStatus
+ }
+ nodebInfo.ConnectionAttempts = 0
- wg.Done()
+ result := handler.ranSetupManager.ExecuteSetup(nodebInfo, status)
+ return result
}
-//Expected value in RIC_ID = pLMN_Identity-eNB_ID/<eNB_ID size in bits>
-//<6 hex digits>-<6 or 8 hex digits>/<18|20|21|28>
-//Each byte is represented by two hex digits, the value in the lowest byte of the eNB_ID must be assigned to the lowest bits
-//For example, to get the value of ffffeab/28 the last byte must be 0x0b, not 0xb0 (-ffffea0b/28).
-func parseRicID(ricId string) error {
- if _, err := fmt.Sscanf(ricId, "%6x-%8x/%2d", &pLMNId, &eNBId, &eNBIdBitqty); err != nil {
- return fmt.Errorf("unable to extract the value of %s: %s", ENV_RIC_ID, err)
- }
-
- if len(pLMNId) < 3 {
- return fmt.Errorf("invalid value for %s, len(pLMNId:%v) != 3", ENV_RIC_ID, pLMNId)
- }
+func (handler *SetupRequestHandler) connectNewRan(request *models.SetupRequest, protocol entities.E2ApplicationProtocol) error {
- if len(eNBId) < 3 {
- return fmt.Errorf("invalid value for %s, len(eNBId:%v) != 3 or 4", ENV_RIC_ID, eNBId)
- }
+ nodebInfo, nodebIdentity := rnibBuilders.CreateInitialNodeInfo(request, protocol)
- if eNBIdBitqty != e2pdus.ShortMacro_eNB_ID && eNBIdBitqty != e2pdus.Macro_eNB_ID && eNBIdBitqty != e2pdus.LongMacro_eNB_ID && eNBIdBitqty != e2pdus.Home_eNB_ID {
- return fmt.Errorf("invalid value for %s, eNBIdBitqty: %d", ENV_RIC_ID, eNBIdBitqty)
+ rNibErr := handler.writerProvider().SaveNodeb(nodebIdentity, nodebInfo)
+ if rNibErr != nil {
+ handler.logger.Errorf("#SetupRequestHandler.connectNewRan - failed to initial nodeb entity for ran name: %v in RNIB. Error: %s", request.RanName, rNibErr.Error())
+ return e2managererrors.NewRnibDbError()
}
+ handler.logger.Infof("#SetupRequestHandler.connectNewRan - initial nodeb entity for ran name: %v was saved to RNIB ", request.RanName)
- return nil
+ result := handler.ranSetupManager.ExecuteSetup(nodebInfo, entities.ConnectionStatus_CONNECTING)
+ return result
}
-//TODO: remove Get
-func (SetupRequestHandler) GetMessageType() int {
- return rmrCgo.RIC_X2_SETUP_REQ
-}
+func (handler *SetupRequestHandler) validateRequestDetails(request models.SetupRequest) error {
-func init() {
- var err error
- ricId := os.Getenv(ENV_RIC_ID)
- //ricId="bbbccc-ffff0e/20"
- //ricId="bbbccc-abcd0e/20"
- if err = parseRicID(ricId); err != nil {
- panic(err)
+ if request.RanPort == 0 {
+ handler.logger.Errorf("#SetupRequestHandler.validateRequestDetails - validation failure: port cannot be zero")
+ return e2managererrors.NewRequestValidationError()
}
-
- e2pdus.PackedEndcX2setupRequest,e2pdus.PackedEndcX2setupRequestAsString, err = e2pdus.PreparePackedEndcX2SetupRequest(MaxAsn1PackedBufferSize, MaxAsn1CodecMessageBufferSize,pLMNId, eNBId, eNBIdBitqty, ricFlag )
- if err != nil{
- panic(err)
+ err := validation.ValidateStruct(&request,
+ validation.Field(&request.RanIp, validation.Required, is.IP),
+ validation.Field(&request.RanName, validation.Required),
+ )
+
+ if err != nil {
+ handler.logger.Errorf("#SetupRequestHandler.validateRequestDetails - validation failure, error: %v", err)
+ return e2managererrors.NewRequestValidationError()
}
- e2pdus.PackedX2setupRequest,e2pdus.PackedX2setupRequestAsString, err = e2pdus.PreparePackedX2SetupRequest(MaxAsn1PackedBufferSize, MaxAsn1CodecMessageBufferSize,pLMNId, eNBId, eNBIdBitqty, ricFlag )
- if err != nil{
- panic(err)
+
+ return nil
+}
+
+func (handler *SetupRequestHandler) getActivityName(protocol entities.E2ApplicationProtocol) string {
+ if protocol == entities.E2ApplicationProtocol_X2_SETUP_REQUEST {
+ return X2SetupActivityName
}
+ return EndcSetupActivityName
}
// See the License for the specific language governing permissions and
// limitations under the License.
//
-
package httpmsghandlers
import (
- "bytes"
+ "e2mgr/e2managererrors"
"e2mgr/e2pdus"
- "e2mgr/logger"
+ "e2mgr/managers"
"e2mgr/mocks"
"e2mgr/models"
"e2mgr/rNibWriter"
- "e2mgr/sessions"
- "fmt"
+ "e2mgr/rmrCgo"
+ "e2mgr/rnibBuilders"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"github.com/stretchr/testify/assert"
- "strings"
- "sync"
+ "github.com/stretchr/testify/mock"
+ "reflect"
"testing"
- "time"
)
-func TestNewSetupRequestHandler(t *testing.T) {
+func TestSetupHandleNewRanSave_Error(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+
+ ranName := "RanName"
+ rnibErr := &common.ResourceNotFoundError{}
+ sr := models.SetupRequest{"127.0.0.1", 8080, ranName,}
+
+ nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", ranName).Return(nb, rnibErr)
+
+ vErr := &common.ValidationError{}
+ updatedNb, _ := rnibBuilders.CreateInitialNodeInfo(&sr, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+ writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(vErr)
+
+ var nbUpdated = &entities.NodebInfo{RanName: ranName, Ip: sr.RanIp, Port: uint32(sr.RanPort), ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+ payload := e2pdus.PackedEndcX2setupRequest
+ xaction := []byte(ranName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+ actual := handler.Handle(sr)
+ expected := &e2managererrors.RnibDbError{}
+
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
- h := NewSetupRequestHandler(rnibWriterProvider)
- assert.NotNil(t, h)
+ writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
}
-func TestCreateMessageSuccess(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("#setup_request_handler_test.TestCreateMessageSuccess - failed to initialize logger, error: %s", err)
+func TestSetupHandleNewRan_Success(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+
+ ranName := "RanName"
+ rnibErr := &common.ResourceNotFoundError{}
+ sr := models.SetupRequest{"127.0.0.1", 8080, ranName,}
+
+ nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", ranName).Return(nb, rnibErr)
+
+ updatedNb, _ := rnibBuilders.CreateInitialNodeInfo(&sr, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+ writerMock.On("SaveNodeb", mock.Anything, updatedNb).Return(nil)
+
+ var nbUpdated = &entities.NodebInfo{RanName: ranName, Ip: sr.RanIp, Port: uint32(sr.RanPort), ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+ payload := e2pdus.PackedEndcX2setupRequest
+ xaction := []byte(ranName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+ actual := handler.Handle(sr)
+
+ assert.Nil(t, actual)
+
+ writerMock.AssertNumberOfCalls(t, "SaveNodeb", 1)
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
+}
+
+func TestEndcSetupHandleRmr_Error(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+
+ ranName := "RanName"
+ nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", ranName).Return(nb, nil)
+
+ var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+ var nbDisconnected = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 0}
+ writerMock.On("UpdateNodebInfo", nbDisconnected).Return(nil)
+
+ payload := e2pdus.PackedEndcX2setupRequest
+ xaction := []byte(ranName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+ rmrErr := &e2managererrors.RmrError{}
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, rmrErr)
+
+ sr := models.SetupRequest{"127.0.0.1", 8080, ranName,}
+ actual := handler.Handle(sr)
+
+ if reflect.TypeOf(actual) != reflect.TypeOf(rmrErr) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, rmrErr)
}
- messageChannel := make(chan *models.E2RequestMessage)
- assert.NotPanics(t, func() { createMsg(log, messageChannel) })
- assert.NotEmpty(t, <-messageChannel)
+
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 2)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
+}
+
+func TestEndcSetupHandleExistingDisconnectedRan_Success(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST)
+
+ ranName := "RanName"
+ nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", ranName).Return(nb, nil)
+
+ var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+ payload := e2pdus.PackedEndcX2setupRequest
+ xaction := []byte(ranName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+ sr := models.SetupRequest{"127.0.0.1", 8080, ranName,}
+ actual := handler.Handle(sr)
+
+ assert.Nil(t, actual)
+
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
}
-func TestParseRicId(t *testing.T) {
- var testCases = []struct {
- ricId string
- pLMNId []byte
- eNBId []byte
- eNBIdBitqty uint
- failure error
- }{
- {
- ricId: "bbbccc-abcd02/18",
- pLMNId: []byte{0xbb, 0xbc, 0xcc},
- eNBId: []byte{0xab, 0xcd, 0x2}, /*00000010 -> 10000000*/
- eNBIdBitqty: e2pdus.ShortMacro_eNB_ID,
- },
- {
- ricId: "bbbccc-abcd0e/20",
- pLMNId: []byte{0xbb, 0xbc, 0xcc},
- eNBId: []byte{0xab, 0xcd, 0xe},
- eNBIdBitqty: e2pdus.Macro_eNB_ID,
- },
- {
- ricId: "bbbccc-abcd07/21",
- pLMNId: []byte{0xbb, 0xbc, 0xcc},
- eNBId: []byte{0xab, 0xcd, 0x7}, /*00000111 -> 00111000*/
- eNBIdBitqty: e2pdus.LongMacro_eNB_ID,
- },
- {
- ricId: "bbbccc-abcdef08/28",
- pLMNId: []byte{0xbb, 0xbc, 0xcc},
- eNBId: []byte{0xab, 0xcd, 0xef, 0x8},
- eNBIdBitqty: e2pdus.Home_eNB_ID,
- },
- {
- ricId: "",
- failure: fmt.Errorf("unable to extract the value of RIC_ID: EOF"),
- },
-
- {
- ricId: "bbbccc",
- failure: fmt.Errorf("unable to extract the value of RIC_ID: unexpected EOF"),
- },
- {
- ricId: "bbbccc-",
- failure: fmt.Errorf("unable to extract the value of RIC_ID: EOF"),
- },
- {
- ricId: "-bbbccc",
- failure: fmt.Errorf("%s", "unable to extract the value of RIC_ID: no hex data for %x string"),
- },
- {
- ricId: "/20",
- failure: fmt.Errorf("%s", "unable to extract the value of RIC_ID: no hex data for %x string"),
- },
- {
- ricId: "bbbcccdd-abcdef08/28", // pLMNId too long
- failure: fmt.Errorf("unable to extract the value of RIC_ID: input does not match format"),
- },
- {
- ricId: "bbbccc-abcdef0809/28", // eNBId too long
- failure: fmt.Errorf("unable to extract the value of RIC_ID: input does not match format"),
- },
-
- {
- ricId: "bbbc-abcdef08/28", // pLMNId too short
- failure: fmt.Errorf("invalid value for RIC_ID, len(pLMNId:[187 188]) != 3"),
- },
- {
- ricId: "bbbccc-abcd/28", // eNBId too short
- failure: fmt.Errorf("invalid value for RIC_ID, len(eNBId:[171 205]) != 3 or 4"),
- },
- {
- ricId: "bbbccc-abcdef08/239", // bit quantity too long - no error, will return 23 (which is invalid)
- failure: fmt.Errorf("invalid value for RIC_ID, eNBIdBitqty: 23"),
- },
+func TestX2SetupHandleExistingConnectedRan_Success(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ ranName := "RanName"
+ nb := &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", ranName).Return(nb, nil)
+
+ var nbUpdated = &entities.NodebInfo{RanName: ranName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", nbUpdated).Return(nil)
+
+ payload := e2pdus.PackedX2setupRequest
+ xaction := []byte(ranName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, mock.Anything).Return(msg, nil)
+
+ sr := models.SetupRequest{"127.0.0.1", 8080, ranName,}
+ actual := handler.Handle(sr)
+
+ assert.Nil(t, actual)
+
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
+}
+
+func TestX2SetupHandleRnibGet_Error(t *testing.T) {
+ readerMock, _, handler,rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ rnibErr := &common.ValidationError{}
+ nb := &entities.NodebInfo{RanName: "RanName", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ readerMock.On("GetNodeb", "RanName").Return(nb, rnibErr)
+
+ sr := models.SetupRequest{"127.0.0.1", 8080, "RanName",}
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.RnibDbError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
+ }
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+}
+
+func TestX2SetupHandleShuttingDownRan_Error(t *testing.T) {
+ readerMock, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ nb := &entities.NodebInfo{RanName: "RanName", ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN,}
+ readerMock.On("GetNodeb", "RanName").Return(nb, nil)
+
+ sr := models.SetupRequest{"127.0.0.1", 8080, "RanName",}
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.WrongStateError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
+ }
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+}
+
+func TestX2SetupHandleNoPort_Error(t *testing.T) {
+ _, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ sr := models.SetupRequest{"127.0.0.1", 0, "RanName",}
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.RequestValidationError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
+ }
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+}
+
+func TestX2SetupHandleNoRanName_Error(t *testing.T) {
+ _, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ sr := models.SetupRequest{}
+ sr.RanPort = 8080
+ sr.RanIp = "127.0.0.1"
+
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.RequestValidationError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+}
- for _, tc := range testCases {
- t.Run(tc.ricId, func(t *testing.T) {
-
- err := parseRicID(tc.ricId)
- if err != nil {
- if tc.failure == nil {
- t.Errorf("want: success, got: parse failed. Error: %v\n", err)
- } else {
- if strings.Compare(err.Error(), tc.failure.Error()) != 0 {
- t.Errorf("want: %s, got: %s\n", err, tc.failure)
- }
- }
- } else {
- if bytes.Compare(tc.pLMNId, pLMNId) != 0 {
- t.Errorf("want: pLMNId = %v, got: pLMNId = %v", tc.pLMNId, pLMNId)
- }
-
- if bytes.Compare(tc.eNBId, eNBId) != 0 {
- t.Errorf("want: eNBId = %v, got: eNBId = %v", tc.eNBId, eNBId)
- }
-
- if tc.eNBIdBitqty != eNBIdBitqty {
- t.Errorf("want: eNBIdBitqty = %d, got: eNBIdBitqty = %d", tc.eNBIdBitqty, eNBIdBitqty)
- }
- }
- })
+func TestX2SetupHandleNoIP_Error(t *testing.T) {
+ _, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ sr := models.SetupRequest{}
+ sr.RanPort = 8080
+ sr.RanName = "RanName"
+
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.RequestValidationError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
}
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
}
-func createMsg(log *logger.Logger, messageChannel chan *models.E2RequestMessage) {
- h := SetupRequestHandler{}
- E2Sessions := make(sessions.E2Sessions)
- var wg sync.WaitGroup
- var rd models.RequestDetails
- go h.CreateMessage(log, &rd, messageChannel, E2Sessions, time.Now(), wg)
- wg.Wait()
+
+func TestX2SetupHandleInvalidIp_Error(t *testing.T) {
+ _, writerMock, handler, rmrMessengerMock := initSetupRequestTest(t, entities.E2ApplicationProtocol_X2_SETUP_REQUEST)
+
+ sr := models.SetupRequest{}
+ sr.RanPort = 8080
+ sr.RanName = "RanName"
+ sr.RanIp = "invalid ip"
+
+ actual := handler.Handle(sr)
+
+ expected := &e2managererrors.RequestValidationError{}
+ if reflect.TypeOf(actual) != reflect.TypeOf(expected) {
+ t.Errorf("Error actual = %v, and Expected = %v.", actual, expected)
+ }
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
}
+
+func initSetupRequestTest(t *testing.T, protocol entities.E2ApplicationProtocol)(*mocks.RnibReaderMock, *mocks.RnibWriterMock, *SetupRequestHandler, *mocks.RmrMessengerMock) {
+ log := initLog(t)
+
+ readerMock := &mocks.RnibReaderMock{}
+ readerProvider := func() reader.RNibReader {
+ return readerMock
+ }
+ writerMock := &mocks.RnibWriterMock{}
+ writerProvider := func() rNibWriter.RNibWriter {
+ return writerMock
+ }
+
+ rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrService := getRmrService(rmrMessengerMock, log)
+
+ ranSetupManager := managers.NewRanSetupManager(log, rmrService, writerProvider)
+ handler := NewSetupRequestHandler(log, writerProvider, readerProvider, ranSetupManager, protocol)
+
+ return readerMock, writerMock, handler, rmrMessengerMock
+}
\ No newline at end of file
package httpmsghandlers
import (
- "e2mgr/configuration"
"e2mgr/e2managererrors"
"e2mgr/e2pdus"
"e2mgr/logger"
const (
X2_RESET_ACTIVITY_NAME = "X2_RESET"
)
+
type X2ResetRequestHandler struct {
readerProvider func() reader.RNibReader
writerProvider func() rNibWriter.RNibWriter
- rmrService *services.RmrService
- config *configuration.Configuration
+ rmrService *services.RmrService
+ logger *logger.Logger
}
-
-func NewX2ResetRequestHandler(rmrService *services.RmrService, config *configuration.Configuration, writerProvider func() rNibWriter.RNibWriter,
+func NewX2ResetRequestHandler(logger *logger.Logger, rmrService *services.RmrService, writerProvider func() rNibWriter.RNibWriter,
readerProvider func() reader.RNibReader) *X2ResetRequestHandler {
return &X2ResetRequestHandler{
readerProvider: readerProvider,
writerProvider: writerProvider,
- rmrService: rmrService,
- config: config,
+ rmrService: rmrService,
+ logger: logger,
}
}
-func (handler *X2ResetRequestHandler) Handle(logger *logger.Logger, request models.Request) error {
+func (handler *X2ResetRequestHandler) Handle(request models.Request) error {
resetRequest := request.(models.ResetRequest)
if len(resetRequest.Cause) == 0 {
resetRequest.Cause = e2pdus.OmInterventionCause
}
- payload, ok:= e2pdus.KnownCausesToX2ResetPDU(resetRequest.Cause)
+ payload, ok := e2pdus.KnownCausesToX2ResetPDU(resetRequest.Cause)
if !ok {
- logger.Errorf("#reset_request_handler.Handle - Unknown cause (%s)", resetRequest.Cause)
+ handler.logger.Errorf("#reset_request_handler.Handle - Unknown cause (%s)", resetRequest.Cause)
return e2managererrors.NewRequestValidationError()
}
- nodeb, err := handler.readerProvider().GetNodeb(resetRequest.RanName)
+ nodeb, err := handler.readerProvider().GetNodeb(resetRequest.RanName)
if err != nil {
- logger.Errorf("#reset_request_handler.Handle - failed to get status of RAN: %s from RNIB. Error: %s", resetRequest.RanName, err.Error())
+ handler.logger.Errorf("#reset_request_handler.Handle - failed to get status of RAN: %s from RNIB. Error: %s", resetRequest.RanName, err.Error())
_, ok := err.(*common.ResourceNotFoundError)
if ok {
return e2managererrors.NewResourceNotFoundError()
}
if nodeb.ConnectionStatus != entities.ConnectionStatus_CONNECTED {
- logger.Errorf("#reset_request_handler.Handle - RAN: %s in wrong state (%s)", resetRequest.RanName, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
- return e2managererrors.NewWrongStateError(X2_RESET_ACTIVITY_NAME,entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
+ handler.logger.Errorf("#reset_request_handler.Handle - RAN: %s in wrong state (%s)", resetRequest.RanName, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
+ return e2managererrors.NewWrongStateError(X2_RESET_ACTIVITY_NAME, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
}
response := models.NotificationResponse{MgsType: rmrCgo.RIC_X2_RESET, RanName: resetRequest.RanName, Payload: payload}
- if err:= handler.rmrService.SendRmrMessage(&response); err != nil {
- logger.Errorf("#reset_request_handler.Handle - failed to send reset message to RMR: %s", err)
- return e2managererrors.NewRmrError()
+ if err := handler.rmrService.SendRmrMessage(&response); err != nil {
+ handler.logger.Errorf("#reset_request_handler.Handle - failed to send reset message to RMR: %s", err)
+ return e2managererrors.NewRmrError()
}
- logger.Infof("#reset_request_handler.Handle - sent x2 reset to RAN: %s with cause: %s", resetRequest.RanName, resetRequest.Cause)
+ handler.logger.Infof("#reset_request_handler.Handle - sent x2 reset to RAN: %s with cause: %s", resetRequest.RanName, resetRequest.Cause)
return nil
}
-
-
package httpmsghandlers
import (
- "e2mgr/configuration"
"e2mgr/e2managererrors"
"e2mgr/mocks"
"e2mgr/models"
"testing"
)
-
-func TestHandleSuccessfulDefaultCause(t *testing.T){
+func TestHandleSuccessfulDefaultCause(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
// o&m intervention
- payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
+ payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
xaction := []byte(ranName)
- msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
rmrMessengerMock := &mocks.RmrMessengerMock{}
- rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(msg,nil)
+ rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
- readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
+ var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+ readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName})
+ actual := handler.Handle(models.ResetRequest{RanName: ranName})
assert.Nil(t, actual)
-
}
-func TestHandleSuccessfulRequestedCause(t *testing.T){
+func TestHandleSuccessfulRequestedCause(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
- payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
+ payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
xaction := []byte(ranName)
- msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
rmrMessengerMock := &mocks.RmrMessengerMock{}
- rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(msg,nil)
+ rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(msg, nil)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
- readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
+ var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+ readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"protocol:transfer-syntax-error"})
+ actual := handler.Handle(models.ResetRequest{RanName: ranName, Cause: "protocol:transfer-syntax-error"})
assert.Nil(t, actual)
}
-func TestHandleFailureUnknownCause(t *testing.T){
+func TestHandleFailureUnknownCause(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
-
rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
+
+ var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+ readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
-
- var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
- readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
-
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"XXX"})
+ actual := handler.Handle(models.ResetRequest{RanName: ranName, Cause: "XXX"})
assert.IsType(t, e2managererrors.NewRequestValidationError(), actual)
}
-func TestHandleFailureWrongState(t *testing.T){
+func TestHandleFailureWrongState(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
-
rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
-
- var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED }
- readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
+ var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED}
+ readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
+ actual := handler.Handle(models.ResetRequest{RanName: ranName})
assert.IsType(t, e2managererrors.NewWrongStateError(X2_RESET_ACTIVITY_NAME, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)]), actual)
-
}
-
-
-func TestHandleFailureRanNotFound(t *testing.T){
+func TestHandleFailureRanNotFound(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
-
rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
-
- readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError("nodeb not found"))
+ readerMock.On("GetNodeb", ranName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError("nodeb not found"))
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
+ actual := handler.Handle(models.ResetRequest{RanName: ranName})
assert.IsType(t, e2managererrors.NewResourceNotFoundError(), actual)
-
}
-
-func TestHandleFailureRnibError(t *testing.T){
+func TestHandleFailureRnibError(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
-
rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
+ readerMock.On("GetNodeb", ranName).Return(&entities.NodebInfo{}, common.NewInternalError(fmt.Errorf("internal error")))
- readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewInternalError(fmt.Errorf("internal error")))
-
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
+ actual := handler.Handle(models.ResetRequest{RanName: ranName})
assert.IsType(t, e2managererrors.NewRnibDbError(), actual)
-
}
-
-func TestHandleFailureRmrError(t *testing.T){
+func TestHandleFailureRmrError(t *testing.T) {
log := initLog(t)
ranName := "test1"
return writerMock
}
// o&m intervention
- payload:= []byte {0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
+ payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
xaction := []byte(ranName)
- msg:= rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xaction)
rmrMessengerMock := &mocks.RmrMessengerMock{}
- rmrMessengerMock.On("SendMsg",msg,mock.Anything).Return(&rmrCgo.MBuf{},fmt.Errorf("rmr error"))
+ rmrMessengerMock.On("SendMsg", msg, mock.Anything).Return(&rmrCgo.MBuf{}, fmt.Errorf("rmr error"))
- config := configuration.ParseConfiguration()
- rmrService:= getRmrService(rmrMessengerMock, log)
- handler := NewX2ResetRequestHandler(rmrService, config, writerProvider, readerProvider)
+ rmrService := getRmrService(rmrMessengerMock, log)
+ handler := NewX2ResetRequestHandler(log, rmrService, writerProvider, readerProvider)
- var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
- readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
+ var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
+ readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
+ actual := handler.Handle(models.ResetRequest{RanName: ranName})
assert.IsType(t, e2managererrors.NewRmrError(), actual)
-
}
)
func initRanLostConnectionTest(t *testing.T) (*logger.Logger, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *managers.RanReconnectionManager) {
+
logger := initLog(t)
rmrMessengerMock := &mocks.RmrMessengerMock{}
rnibWriterProvider := func() rNibWriter.RNibWriter {
return writerMock
}
-
- ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, rmrService)
+ ranSetupManager := managers.NewRanSetupManager(logger,rmrService, rnibWriterProvider)
+ ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
return logger, readerMock, writerMock, rmrMessengerMock, ranReconnectionManager
}
rmrResponseChannel := make(chan *models.NotificationResponse, config.NotificationResponseBuffer)
rmrService := services.NewRmrService(rmrConfig, msgImpl, controllers.E2Sessions, rmrResponseChannel)
- var ranReconnectionManager = managers.NewRanReconnectionManager(logger, config, reader.GetRNibReader, rNibWriter.GetRNibWriter, rmrService)
+ 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)
rmrServiceReceiver := receivers.NewRmrServiceReceiver(*rmrService, nManager)
go rmrService.SendResponse()
controller := controllers.NewNodebController(logger, rmrService, reader.GetRNibReader, rNibWriter.GetRNibWriter)
- newController := controllers.NewController(logger, rmrService, reader.GetRNibReader, rNibWriter.GetRNibWriter, config)
+ newController := controllers.NewController(logger, rmrService, reader.GetRNibReader, rNibWriter.GetRNibWriter, config, ranSetupManager)
runServer(config.Http.Port, controller, newController)
}
r.HandleFunc("/health", controller.HandleHealthCheckRequest).Methods("GET")
rr := r.PathPrefix("/nodeb").Subrouter()
- rr.HandleFunc("/{messageType}", controller.HandleRequest).Methods("POST")
rr.HandleFunc("/ids", controller.GetNodebIdList).Methods("GET") // nodeb/ids
rr.HandleFunc("/{ranName}", controller.GetNodeb).Methods("GET")
rr.HandleFunc("/shutdown", newController.ShutdownHandler).Methods("PUT")
rr.HandleFunc("/{ranName}/reset", newController.X2ResetHandler).Methods("PUT") // nodeb/{ranName}/reset
+ rr.HandleFunc("/x2-setup", newController.X2SetupHandler).Methods("POST")
+ rr.HandleFunc("/endc-setup", newController.EndcSetupHandler).Methods("POST")
}
controllerMock := &mocks.ControllerMock{}
controllerMock.On("ShutdownHandler").Return(nil)
controllerMock.On("X2ResetHandler").Return(nil)
+ controllerMock.On("X2SetupHandler").Return(nil)
+ controllerMock.On("EndcSetupHandler").Return(nil)
nodebControllerMock := &mocks.NodebControllerMock{}
- nodebControllerMock.On("HandleRequest").Return(nil)
nodebControllerMock.On("GetNodebIdList").Return(nil)
nodebControllerMock.On("GetNodeb").Return(nil)
nodebControllerMock.On("HandleHealthCheckRequest").Return(nil)
- router := mux.NewRouter();
+ router := mux.NewRouter()
initializeRoutes(router, nodebControllerMock, controllerMock)
return router, controllerMock, nodebControllerMock
}
-func TestRoutePostNodebMessageType(t *testing.T) {
- router, _, nodebControllerMock := setupRouterAndMocks()
+func TestRoutePostEndcSetup(t *testing.T) {
+ router, controllerMock, _ := setupRouterAndMocks()
+
+ req, err := http.NewRequest("POST", "/v1/nodeb/endc-setup", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ rr := httptest.NewRecorder()
+ router.ServeHTTP(rr, req)
+
+ controllerMock.AssertNumberOfCalls(t,"EndcSetupHandler", 1)
+}
+
+func TestRoutePostX2Setup(t *testing.T) {
+ router, controllerMock, _ := setupRouterAndMocks()
- req, err := http.NewRequest("POST", "/v1/nodeb/messageType", nil)
+ req, err := http.NewRequest("POST", "/v1/nodeb/x2-setup", nil)
if err != nil {
t.Fatal(err)
}
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- nodebControllerMock.AssertNumberOfCalls(t, "HandleRequest", 1)
+ controllerMock.AssertNumberOfCalls(t,"X2SetupHandler", 1)
}
func TestRouteGetNodebIds(t *testing.T) {
"e2mgr/configuration"
"e2mgr/logger"
"e2mgr/rNibWriter"
- "e2mgr/services"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
ranSetupManager *RanSetupManager
}
-func NewRanReconnectionManager(logger *logger.Logger, config *configuration.Configuration, rnibReaderProvider func() reader.RNibReader, rnibWriterProvider func() rNibWriter.RNibWriter, rmrService *services.RmrService) *RanReconnectionManager {
+func NewRanReconnectionManager(logger *logger.Logger, config *configuration.Configuration, rnibReaderProvider func() reader.RNibReader,
+ rnibWriterProvider func() rNibWriter.RNibWriter, ranSetupManager *RanSetupManager) *RanReconnectionManager {
return &RanReconnectionManager{
logger: logger,
config: config,
rnibReaderProvider: rnibReaderProvider,
rnibWriterProvider: rnibWriterProvider,
- ranSetupManager: NewRanSetupManager(logger,rmrService,rnibWriterProvider),
+ ranSetupManager: ranSetupManager,
}
}
return m.setConnectionStatusOfUnconnectableRan(nodebInfo)
}
-
- err := m.ranSetupManager.ExecuteSetup(nodebInfo)
+ err := m.ranSetupManager.ExecuteSetup(nodebInfo, entities.ConnectionStatus_CONNECTING)
if err != nil {
m.logger.Errorf("#RanReconnectionManager.ReconnectRan - RAN name: %s - Failed executing setup. Error: %v", inventoryName, err)
rnibWriterProvider := func() rNibWriter.RNibWriter {
return writerMock
}
-
- ranReconnectionManager := NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, rmrService)
+ ranSetupManager := NewRanSetupManager(logger,rmrService, rnibWriterProvider)
+ ranReconnectionManager := NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
return logger,rmrMessengerMock, readerMock, writerMock, ranReconnectionManager
}
}
}
-// Update retries and connection status (connecting)
-func (m *RanSetupManager) updateConnectionStatusConnecting(nodebInfo *entities.NodebInfo) error {
- // Update retries and connection status (connecting)
- nodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTING
+// Update retries and connection status
+func (m *RanSetupManager) updateConnectionStatus(nodebInfo *entities.NodebInfo, status entities.ConnectionStatus) error {
+ // Update retries and connection status
+ nodebInfo.ConnectionStatus = status
nodebInfo.ConnectionAttempts++
err := m.rnibWriterProvider().UpdateNodebInfo(nodebInfo)
if err != nil {
- m.logger.Errorf("#RanSetupManager.updateConnectionStatusConnecting - Ran name: %s - Failed updating RAN's connection status to CONNECTING : %s", nodebInfo.RanName, err)
+ m.logger.Errorf("#RanSetupManager.updateConnectionStatus - Ran name: %s - Failed updating RAN's connection status to %v : %s", nodebInfo.RanName, status.String(), err)
} else {
- m.logger.Infof("#RanSetupManager.updateConnectionStatusConnecting - Ran name: %s - Successfully updated rNib. RAN's current connection status: CONNECTING, RAN's current connection attempts: %d", nodebInfo.RanName, nodebInfo.ConnectionAttempts)
+ m.logger.Infof("#RanSetupManager.updateConnectionStatus - Ran name: %s - Successfully updated rNib. RAN's current connection status: %v, RAN's current connection attempts: %d", nodebInfo.RanName, status.String(), nodebInfo.ConnectionAttempts)
}
return err
}
// Decrement retries and connection status (disconnected)
func (m *RanSetupManager) updateConnectionStatusDisconnected(nodebInfo *entities.NodebInfo) error {
- // Update retries and connection status (connecting)
+ // Update retries and connection status
nodebInfo.ConnectionStatus = entities.ConnectionStatus_DISCONNECTED
nodebInfo.ConnectionAttempts--
err := m.rnibWriterProvider().UpdateNodebInfo(nodebInfo)
}
// 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) error {
+func (m *RanSetupManager) ExecuteSetup(nodebInfo *entities.NodebInfo, status entities.ConnectionStatus) error {
//Fill details for the response handler
- requestDetails := models.RequestDetails{RanName: nodebInfo.RanName, RanPort: uint16(nodebInfo.Port), RanIp: nodebInfo.Ip}
+ 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 (connecting)
- if err := m.updateConnectionStatusConnecting(nodebInfo); err != nil {
+ // Update retries and connection status
+ if err := m.updateConnectionStatus(nodebInfo, status); err != nil {
delete(m.rmrService.E2sessions, nodebInfo.RanName)
return e2managererrors.NewRnibDbError()
}
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err != nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
t.Errorf("want: success, got: error: %s", err)
}
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err != nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
t.Errorf("want: success, got: error: %s", err)
}
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err == nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
}
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err == nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
} else {
assert.IsType(t, e2managererrors.NewRnibDbError(), err)
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err == nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
} else {
assert.IsType(t, e2managererrors.NewRnibDbError(), err)
rmrService := getRmrService(rmrMessengerMock, log)
mgr := NewRanSetupManager(log, rmrService, writerProvider)
- if err := mgr.ExecuteSetup(initialNodeb); err == nil {
+ if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: error, got: success")
}
c.Called()
}
+func (c *ControllerMock) X2SetupHandler(writer http.ResponseWriter, r *http.Request){
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ c.Called()
+}
+
+func (c *ControllerMock) EndcSetupHandler(writer http.ResponseWriter, r *http.Request){
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ c.Called()
+}
\ No newline at end of file
package models
-type RequestDetails struct {
+type SetupRequest struct {
RanIp string `json:"ranIp"`
RanPort uint16 `json:"ranPort"`
RanName string `json:"ranName"`
"e2mgr/e2managererrors"
"e2mgr/handlers/httpmsghandlers"
"e2mgr/logger"
+ "e2mgr/managers"
"e2mgr/rNibWriter"
"e2mgr/services"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
type IncomingRequest string
const (
- ShutdownRequest IncomingRequest = "Shutdown"
- ResetRequest IncomingRequest = "Reset"
+ ShutdownRequest IncomingRequest = "Shutdown"
+ ResetRequest IncomingRequest = "Reset"
+ X2SetupRequest IncomingRequest = "X2SetupRequest"
+ EndcSetupRequest IncomingRequest = "EndcSetupRequest"
)
type IncomingRequestHandlerProvider struct {
logger *logger.Logger
}
-func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrService *services.RmrService, config *configuration.Configuration, rNibWriterProvider func() rNibWriter.RNibWriter, rNibReaderProvider func() reader.RNibReader) *IncomingRequestHandlerProvider {
+func NewIncomingRequestHandlerProvider(logger *logger.Logger, rmrService *services.RmrService, config *configuration.Configuration, rNibWriterProvider func() rNibWriter.RNibWriter,
+ rNibReaderProvider func() reader.RNibReader, ranSetupManager *managers.RanSetupManager) *IncomingRequestHandlerProvider {
return &IncomingRequestHandlerProvider{
- requestMap: initRequestHandlerMap(rmrService, config, rNibWriterProvider, rNibReaderProvider),
+ requestMap: initRequestHandlerMap(logger, rmrService, config, rNibWriterProvider, rNibReaderProvider, ranSetupManager),
logger: logger,
}
}
-func initRequestHandlerMap(rmrService *services.RmrService, config *configuration.Configuration, rNibWriterProvider func() rNibWriter.RNibWriter,
- rNibReaderProvider func() reader.RNibReader) map[IncomingRequest]httpmsghandlers.RequestHandler {
+func initRequestHandlerMap(logger *logger.Logger, rmrService *services.RmrService, config *configuration.Configuration, rNibWriterProvider func() rNibWriter.RNibWriter,
+ rNibReaderProvider func() reader.RNibReader, ranSetupManager *managers.RanSetupManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
return map[IncomingRequest]httpmsghandlers.RequestHandler{
- ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(rmrService, config, rNibWriterProvider, rNibReaderProvider), //TODO change to pointer
- ResetRequest: httpmsghandlers.NewX2ResetRequestHandler(rmrService, config, rNibWriterProvider, rNibReaderProvider), //TODO change to pointer
+ ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrService, config, rNibWriterProvider, rNibReaderProvider), //TODO change to pointer
+ ResetRequest: httpmsghandlers.NewX2ResetRequestHandler(logger, rmrService, rNibWriterProvider, rNibReaderProvider),
+ X2SetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibWriterProvider, rNibReaderProvider, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST),
+ EndcSetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibWriterProvider, rNibReaderProvider, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST), //TODO change to pointer
}
}
"e2mgr/e2managererrors"
"e2mgr/handlers/httpmsghandlers"
"e2mgr/logger"
+ "e2mgr/managers"
"e2mgr/mocks"
"e2mgr/models"
"e2mgr/rNibWriter"
writerProvider := func() rNibWriter.RNibWriter {
return &mocks.RnibWriterMock{}
}
-
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider)
- /*if provider == nil {
- t.Errorf("want: provider, got: nil")
- }*/
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
assert.NotNil(t, provider)
}
return &mocks.RnibWriterMock{}
}
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
handler, err := provider.GetHandler(ShutdownRequest)
- /*if handler == nil {
- t.Errorf("failed to get x2 setup handler")
- }*/
assert.NotNil(t, provider)
assert.Nil(t, err)
_, ok := handler.(*httpmsghandlers.DeleteAllRequestHandler)
assert.True(t, ok)
- /*if !ok {
- t.Errorf("failed to delete all handler")
- }*/
+}
+
+func TestX2SetupRequestHandler(t *testing.T) {
+ rmrMessengerMock := &mocks.RmrMessengerMock{}
+
+ log := initLog(t)
+ readerProvider := func() reader.RNibReader {
+ return &mocks.RnibReaderMock{}
+ }
+ writerProvider := func() rNibWriter.RNibWriter {
+ return &mocks.RnibWriterMock{}
+ }
+
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+
+ handler, err := provider.GetHandler(X2SetupRequest)
+
+ assert.NotNil(t, provider)
+ assert.Nil(t, err)
+
+ _, ok := handler.(*httpmsghandlers.SetupRequestHandler)
+
+ assert.True(t, ok)
+}
+
+func TestEndcSetupRequestHandler(t *testing.T) {
+ rmrMessengerMock := &mocks.RmrMessengerMock{}
+
+ log := initLog(t)
+ readerProvider := func() reader.RNibReader {
+ return &mocks.RnibReaderMock{}
+ }
+ writerProvider := func() rNibWriter.RNibWriter {
+ return &mocks.RnibWriterMock{}
+ }
+
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider,ranSetupManager)
+
+ handler, err := provider.GetHandler(EndcSetupRequest)
+
+ assert.NotNil(t, provider)
+ assert.Nil(t, err)
+
+ _, ok := handler.(*httpmsghandlers.SetupRequestHandler)
+
+ assert.True(t, ok)
}
func TestGetShutdownHandlerFailure(t *testing.T) {
return &mocks.RnibWriterMock{}
}
- provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider)
+ ranSetupManager := managers.NewRanSetupManager(log, getRmrService(rmrMessengerMock, log), rNibWriter.GetRNibWriter)
+ provider := NewIncomingRequestHandlerProvider(log, getRmrService(rmrMessengerMock, log), configuration.ParseConfiguration(), writerProvider, readerProvider, ranSetupManager)
_, actual := provider.GetHandler("test")
expected := &e2managererrors.InternalError{}
+++ /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 httpmsghandlerprovider
-
-import (
- "e2mgr/handlers/httpmsghandlers"
- "e2mgr/logger"
- "e2mgr/rNibWriter"
- "errors"
- "fmt"
-)
-
-var requestMap map[string]httpmsghandlers.Handler
-
-type RequestHandlerProvider struct{}
-
-func NewRequestHandlerProvider(rnibWriterProvider func() rNibWriter.RNibWriter) *RequestHandlerProvider {
- requestMap = initRequestMap(rnibWriterProvider)
- return &RequestHandlerProvider{}
-}
-
-func initRequestMap(rnibWriterProvider func() rNibWriter.RNibWriter) map[string]httpmsghandlers.Handler {
- return map[string]httpmsghandlers.Handler{
- "x2-setup": httpmsghandlers.NewSetupRequestHandler(rnibWriterProvider),
- "endc-setup": httpmsghandlers.NewEndcSetupRequestHandler(rnibWriterProvider),
- }
-}
-
-func (provider RequestHandlerProvider) GetHandler(logger *logger.Logger, requestType string) (httpmsghandlers.Handler, error) {
- handler, ok := requestMap[requestType]
-
- if !ok {
- errorMessage := fmt.Sprintf("#request_handler_provider.GetHandler - Cannot find handler for request type: %s", requestType)
- logger.Errorf(errorMessage)
- return nil, errors.New(errorMessage)
- }
-
- return handler, nil
-}
+++ /dev/null
-//
-// Copyright 2019 AT&T Intellectual Property
-// Copyright 2019 Nokia
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-package httpmsghandlerprovider
-
-import (
- "e2mgr/handlers/httpmsghandlers"
- "e2mgr/logger"
- "e2mgr/mocks"
- "e2mgr/rNibWriter"
- "testing"
-)
-
-const x2SetupRequestType = "x2-setup"
-const endcSetupRequestType = "endc-setup"
-
-/*
- * Verify consturctor.
- */
-func TestNewRequestHandlerProvider(t *testing.T) {
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
- }
-
- provider := NewRequestHandlerProvider(rnibWriterProvider)
- if provider == nil {
- t.Errorf("want: provider, got: nil")
- }
-}
-
-/*
- * Verify support for known providers.
- */
-
-func TestGetX2SetupRequestHandler(t *testing.T) {
-
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("failed to initialize logger, error: %s", err)
- }
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
- }
-
- provider := NewRequestHandlerProvider(rnibWriterProvider)
-
- handler, err := provider.GetHandler(log, x2SetupRequestType)
-
- if handler == nil {
- t.Errorf("failed to get x2 setup handler")
- }
-
- _, ok := handler.(*httpmsghandlers.SetupRequestHandler)
-
- if !ok {
- t.Errorf("failed to get x2 setup handler")
- }
-}
-
-func TestGetEndcSetupRequestHandler(t *testing.T) {
-
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("failed to initialize logger, error: %s", err)
- }
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
- }
-
- provider := NewRequestHandlerProvider(rnibWriterProvider)
-
- handler, err := provider.GetHandler(log, endcSetupRequestType)
-
- if handler == nil {
- t.Errorf("failed to get endc setup handler")
- }
-
- _, ok := handler.(*httpmsghandlers.EndcSetupRequestHandler)
-
- if !ok {
- t.Errorf("failed to get endc setup handler")
- }
-}
-
-/*
- * Verify handling of a request for an unsupported request.
- */
-
-func TestGetHandlerFailure(t *testing.T) {
- log, err := logger.InitLogger(logger.InfoLevel)
- if err != nil {
- t.Errorf("failed to initialize logger, error: %s", err)
- }
-
- rnibWriterProvider := func() rNibWriter.RNibWriter {
- return &mocks.RnibWriterMock{}
- }
-
- provider := NewRequestHandlerProvider(rnibWriterProvider)
-
- _, err = provider.GetHandler(log, "dummy")
-
- if err == nil {
- t.Errorf("Provider should had respond with error for dummy request type")
- }
-}
func TestGetNotificationHandlerSuccess(t *testing.T) {
logger := initLog(t)
- rmrService := getRmrService(&mocks.RmrMessengerMock{}, logger)
readerMock := &mocks.RnibReaderMock{}
rnibReaderProvider := func() reader.RNibReader {
rnibWriterProvider := func() rNibWriter.RNibWriter {
return writerMock
}
-
- ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, rmrService)
+ ranSetupManager := managers.NewRanSetupManager(logger, getRmrService(&mocks.RmrMessengerMock{}, logger), rNibWriter.GetRNibWriter)
+ ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
var testCases = []struct {
msgType int
func TestGetNotificationHandlerFailure(t *testing.T) {
logger := initLog(t)
- rmrService := getRmrService(&mocks.RmrMessengerMock{}, logger)
var testCases = []struct {
msgType int
return writerMock
}
- ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, rmrService)
+ ranSetupManager := managers.NewRanSetupManager(logger, getRmrService(&mocks.RmrMessengerMock{}, logger), rNibWriter.GetRNibWriter)
+ ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
provider := NewNotificationHandlerProvider(rnibReaderProvider, rnibWriterProvider, ranReconnectionManager)
t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
"e2mgr/models"
)
-func CreateInitialNodeInfo(requestDetails *models.RequestDetails, protocol entities.E2ApplicationProtocol) (*entities.NodebInfo, *entities.NbIdentity) {
+func CreateInitialNodeInfo(requestDetails *models.SetupRequest, protocol entities.E2ApplicationProtocol) (*entities.NodebInfo, *entities.NbIdentity) {
nodebInfo := &entities.NodebInfo{}
nodebInfo.Ip = requestDetails.RanIp
nodebInfo.Port = uint32(requestDetails.RanPort)
nodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTING
nodebInfo.E2ApplicationProtocol = protocol
nodebInfo.RanName = requestDetails.RanName
+ nodebInfo.ConnectionAttempts = 0
nodebIdentity := &entities.NbIdentity{}
nodebIdentity.InventoryName = requestDetails.RanName
return nodebInfo, nodebIdentity
-}
+}
\ No newline at end of file
const ranPort = uint16(30000)
func TestCreateInitialNodeInfo(t *testing.T) {
- requestDetails := &models.RequestDetails{
+ requestDetails := &models.SetupRequest{
RanName: ranName,
RanPort:ranPort,
RanIp:ranIP,
}
rmrService := getRmrService(rmrMessengerMock, logger)
-
- ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, rmrService)
+ ranSetupManager := managers.NewRanSetupManager(logger, rmrService, rNibWriter.GetRNibWriter)
+ ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibReaderProvider, rnibWriterProvider, ranSetupManager)
nManager := notificationmanager.NewNotificationManager(rnibReaderProvider, rnibWriterProvider, ranReconnectionManager)
return NewRmrServiceReceiver(*rmrService, nManager)
*/
type E2SessionDetails struct {
SessionStart time.Time
- Request *models.RequestDetails
+ Request *models.SetupRequest
}
/*
Code Review / ric-plt / e2mgr.git / commitdiff