Remove File ${EXECDIR}/${e2t_log_filename}
Remove File ${EXECDIR}/${rsm_log_filename}
Remove File ${EXECDIR}/${e2e_simu_log_filename}
+ Remove File ${EXECDIR}/${rm_sim_log_filename}
Remove File ${EXECDIR}/${e2adapter_log_filename}
Save logs
Run ${Save_e2t_log}
Run ${Save_rsm_log}
Run ${Save_e2e_simu_log}
+ Run ${Save_rm_sim_log}
Run ${Save_e2adapter_log}
${gnb_log_filename} Evaluate "gnb.${SUITE NAME}.log".replace(" ","-")
${rsm_log_filename} Evaluate "rsm.${SUITE NAME}.log".replace(" ","-")
${e2e_simu_log_filename} Evaluate "e2e_simu.${SUITE NAME}.log".replace(" ","-")
+ ${rm_sim_log_filename} Evaluate "rm_sim.${SUITE NAME}.log".replace(" ","-")
${e2adapter_log_filename} Evaluate "e2adapter.${SUITE NAME}.log".replace(" ","-")
${Save_sim_log} Evaluate 'docker logs --since ${starting_timestamp} gnbe2_simu > ${gnb_log_filename}'
${Save_e2mgr_log} Evaluate 'docker logs --since ${starting_timestamp} e2mgr > ${e2mgr_log_filename}'
${Save_e2t_log} Evaluate 'docker logs --since ${starting_timestamp} e2 > ${e2t_log_filename}'
${Save_rsm_log} Evaluate 'docker logs --since ${starting_timestamp} rsm > ${rsm_log_filename}'
${Save_e2e_simu_log} Evaluate 'docker logs --since ${starting_timestamp} e2e_simu > ${e2e_simu_log_filename}'
+ ${Save_rm_sim_log} Evaluate 'docker logs --since ${starting_timestamp} rm_sim > ${rm_sim_log_filename}'
${Save_e2adapter_log} Evaluate 'docker logs --since ${starting_timestamp} e2adapter > ${e2adapter_log_filename}'
Set Suite Variable ${e2t_log_filename}
Set Suite Variable ${e2mgr_log_filename}
Set Suite Variable ${gnb_log_filename}
Set Suite Variable ${rsm_log_filename}
- Set Suite Variable ${e2e_simu_log_filename}
+ Set Suite Variable ${e2e_simu_log_filename}
+ Set Suite Variable ${rm_sim_log_filename}
Set Suite Variable ${e2adapter_log_filename}
Set Suite Variable ${Save_sim_log}
Set Suite Variable ${Save_e2mgr_log}
Set Suite Variable ${Save_e2t_log}
Set Suite Variable ${Save_rsm_log}
Set Suite Variable ${Save_e2e_simu_log}
+ Set Suite Variable ${Save_rm_sim_log}
Set Suite Variable ${Save_e2adapter_log}
${flush} cleanup_db.flush
*** Variables ***
-${docker_number} 7
-${docker_number-1} 6
+${docker_number} 8
+${docker_number-1} 7
${ip_gnb_simu} 10.0.2.15
${ip_e2adapter} 10.0.2.15
${url} http://localhost:3800
${dbass_remove} docker rm dbass
${dbass_stop} docker stop dbass
${restart_simu} docker restart gnbe2_simu
-${start_e2} docker start e2
${stop_docker_e2} docker stop e2
${restart_docker_sim} docker restart gnbe2_simu
${Run_Config} docker exec gnbe2_simu pkill gnbe2_simu -INT
package main
import (
+ "e2mgr/clients"
"e2mgr/configuration"
"e2mgr/controllers"
"e2mgr/httpserver"
"fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
+ "net/http"
"os"
"strconv"
)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
e2tShutdownManager := managers.NewE2TShutdownManager(logger, rnibDataService, e2tInstancesManager)
e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
+ routingManagerClient := clients.NewRoutingManagerClient(logger, config, &http.Client{})
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient)
notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
rmrReceiver := rmrreceiver.NewRmrReceiver(logger, rmrMessenger, notificationManager)
"e2mgr/logger"
"e2mgr/models"
"encoding/json"
- "fmt"
"net/http"
)
const (
- AddE2TInstanceApiSuffix = "e2t"
+ AddE2TInstanceApiSuffix = "e2t"
+ AssociateRanToE2TInstanceApiSuffix = "associate-ran-to-e2t"
+ DissociateRanE2TInstanceApiSuffix = "dissociate-ran"
)
type RoutingManagerClient struct {
type IRoutingManagerClient interface {
AddE2TInstance(e2tAddress string) error
+ AssociateRanToE2TInstance(e2tAddress string, ranName string) error
+ DissociateRanE2TInstance(e2tAddress string, ranName string) error
}
func NewRoutingManagerClient(logger *logger.Logger, config *configuration.Configuration, httpClient HttpClient) *RoutingManagerClient {
}
func (c *RoutingManagerClient) AddE2TInstance(e2tAddress string) error {
+
data := models.NewRoutingManagerE2TData(e2tAddress)
+ url := c.config.RoutingManager.BaseUrl + AddE2TInstanceApiSuffix
+
+ return c.PostMessage(data, url)
+}
+
+func (c *RoutingManagerClient) AssociateRanToE2TInstance(e2tAddress string, ranName string) error {
+
+ data := models.NewRoutingManagerE2TData(e2tAddress, ranName)
+ url := c.config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
+
+ return c.PostMessage(data, url)
+}
+
+func (c *RoutingManagerClient) DissociateRanE2TInstance(e2tAddress string, ranName string) error {
+ data := models.NewRoutingManagerE2TData(e2tAddress, ranName)
+ url := c.config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
+
+ return c.PostMessage(data, url)
+}
+
+func (c *RoutingManagerClient) PostMessage(data *models.RoutingManagerE2TData, url string) error {
marshaled, err := json.Marshal(data)
if err != nil {
- return e2managererrors.NewRoutingManagerError(err)
+ return e2managererrors.NewRoutingManagerError()
}
body := bytes.NewBuffer(marshaled)
- c.logger.Infof("[E2M -> Routing Manager] #RoutingManagerClient.AddE2TInstance - request body: %+v", body)
+ c.logger.Infof("[E2M -> Routing Manager] #RoutingManagerClient.PostMessage - url: %s, request body: %+v", url, body)
- url := c.config.RoutingManager.BaseUrl + AddE2TInstanceApiSuffix
resp, err := c.httpClient.Post(url, "application/json", body)
if err != nil {
- c.logger.Errorf("#RoutingManagerClient.AddE2TInstance - failed sending request. error: %s", err)
- return e2managererrors.NewRoutingManagerError(err)
+ c.logger.Errorf("#RoutingManagerClient.PostMessage - failed sending request. error: %s", err)
+ return e2managererrors.NewRoutingManagerError()
}
defer resp.Body.Close()
- if resp.StatusCode == http.StatusCreated {
- c.logger.Infof("[Routing Manager -> E2M] #RoutingManagerClient.AddE2TInstance - success. http status code: %d", resp.StatusCode)
+ if resp.StatusCode >= http.StatusOK && resp.StatusCode < http.StatusMultipleChoices {
+ c.logger.Infof("[Routing Manager -> E2M] #RoutingManagerClient.PostMessage - success. http status code: %d", resp.StatusCode)
return nil
}
- c.logger.Errorf("[Routing Manager -> E2M] #RoutingManagerClient.AddE2TInstance - failure. http status code: %d", resp.StatusCode)
- return e2managererrors.NewRoutingManagerError(fmt.Errorf("invalid data"))
-}
+ c.logger.Errorf("[Routing Manager -> E2M] #RoutingManagerClient.PostMessage - failure. http status code: %d", resp.StatusCode)
+ return e2managererrors.NewRoutingManagerError()
+}
\ No newline at end of file
// This source code is part of the near-RT RIC (RAN Intelligent Controller)
// platform project (RICP).
+
package clients
import (
)
const E2TAddress = "10.0.2.15:38000"
+const RanName = "test1"
-// TODO: add response Body and dont check for nil in prod code. itll always be populated
func initRoutingManagerClientTest(t *testing.T) (*RoutingManagerClient, *mocks.HttpClientMock, *configuration.Configuration) {
logger := initLog(t)
assert.NotNil(t, err)
}
+func TestAssociateRanToE2TInstance_Success(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
+ respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+ err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
+ assert.Nil(t, err)
+}
+
+func TestAssociateRanToE2TInstance_RoutingManagerError(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
+ err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
+ assert.NotNil(t, err)
+}
+
+func TestAssociateRanToE2TInstance_RoutingManager_400(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + AssociateRanToE2TInstanceApiSuffix
+ respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body:respBody}, nil)
+ err := rmClient.AssociateRanToE2TInstance(E2TAddress, RanName)
+ assert.NotNil(t, err)
+}
+
+func TestDissociateRanE2TInstance_Success(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
+ respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusCreated, Body: respBody}, nil)
+ err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
+ assert.Nil(t, err)
+}
+
+func TestDissociateRanE2TInstance_RoutingManagerError(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{}, errors.New("error"))
+ err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
+ assert.NotNil(t, err)
+}
+
+func TestDissociateRanE2TInstance_RoutingManager_400(t *testing.T) {
+ rmClient, httpClientMock, config := initRoutingManagerClientTest(t)
+
+ data := models.NewRoutingManagerE2TData(E2TAddress,RanName)
+ marshaled, _ := json.Marshal(data)
+ body := bytes.NewBuffer(marshaled)
+ url := config.RoutingManager.BaseUrl + DissociateRanE2TInstanceApiSuffix
+ respBody := ioutil.NopCloser(bytes.NewBufferString(""))
+ httpClientMock.On("Post", url, "application/json", body).Return(&http.Response{StatusCode: http.StatusBadRequest, Body:respBody}, nil)
+ err := rmClient.DissociateRanE2TInstance(E2TAddress, RanName)
+ assert.NotNil(t, err)
+}
+
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
log, err := logger.InitLogger(logger.InfoLevel)
package e2managererrors
-import "fmt"
-
type RoutingManagerError struct {
- *BaseError
}
-func NewRoutingManagerError(err error) *RoutingManagerError {
- return &RoutingManagerError{
- &BaseError{
- Code: 511,
- Message: fmt.Sprintf("Routing manager error: %s", err),
- },
- }
+func NewRoutingManagerError() *RoutingManagerError {
+ return &RoutingManagerError{}
}
func (e *RoutingManagerError) Error() string {
- return e.Message
+ return "Routing Manager Error"
}
package rmrmsghandlers
import (
+ "e2mgr/clients"
"e2mgr/logger"
"e2mgr/managers"
"e2mgr/models"
"e2mgr/services"
"encoding/json"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
)
type E2TermInitNotificationHandler struct {
rnibDataService services.RNibDataService
ranReconnectionManager *managers.RanReconnectionManager
e2tInstancesManager managers.IE2TInstancesManager
+ routingManagerClient clients.IRoutingManagerClient
}
-func NewE2TermInitNotificationHandler(logger *logger.Logger, ranReconnectionManager *managers.RanReconnectionManager, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager) E2TermInitNotificationHandler {
+func NewE2TermInitNotificationHandler(logger *logger.Logger, ranReconnectionManager *managers.RanReconnectionManager, rnibDataService services.RNibDataService, e2tInstancesManager managers.IE2TInstancesManager, routingManagerClient clients.IRoutingManagerClient) E2TermInitNotificationHandler {
return E2TermInitNotificationHandler{
logger: logger,
rnibDataService: rnibDataService,
ranReconnectionManager: ranReconnectionManager,
e2tInstancesManager: e2tInstancesManager,
+ routingManagerClient: routingManagerClient,
}
}
func (h E2TermInitNotificationHandler) Handle(request *models.NotificationRequest) {
unmarshalledPayload := models.E2TermInitPayload{}
- err := json.Unmarshal(request.Payload, &unmarshalledPayload)
+ err := json.Unmarshal(request.Payload, &unmarshalledPayload)
if err != nil {
h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Error unmarshaling E2 Term Init payload: %s", err)
return
}
- _ = h.e2tInstancesManager.AddE2TInstance(e2tAddress)
+ h.HandleNewE2TInstance(e2tAddress)
return
}
return
}
+ if e2tInstance.State == entities.ToBeDeleted{
+ h.logger.Infof("#E2TermInitNotificationHandler.Handle - E2T Address: %s - E2T instance status is: %s, ignore", e2tInstance.Address, e2tInstance.State)
+ return
+ }
+
+ if e2tInstance.State == entities.RoutingManagerFailure {
+ err := h.e2tInstancesManager.ActivateE2TInstance(e2tInstance)
+ if err != nil {
+ return
+ }
+ }
+
+ h.HandleExistingE2TInstance(e2tInstance)
+
+ h.logger.Infof("#E2TermInitNotificationHandler.Handle - Completed handling of E2_TERM_INIT")
+}
+
+func (h E2TermInitNotificationHandler) HandleExistingE2TInstance(e2tInstance *entities.E2TInstance) {
+
for _, ranName := range e2tInstance.AssociatedRanList {
if err := h.ranReconnectionManager.ReconnectRan(ranName); err != nil {
- h.logger.Errorf("#E2TermInitNotificationHandler.Handle - Ran name: %s - connection attempt failure, error: %s", ranName, err)
+ h.logger.Errorf("#E2TermInitNotificationHandler.HandleExistingE2TInstance - Ran name: %s - connection attempt failure, error: %s", ranName, err)
_, ok := err.(*common.ResourceNotFoundError)
if !ok {
break
}
}
}
-
- h.logger.Infof("#E2TermInitNotificationHandler.Handle - Completed handling of E2_TERM_INIT")
}
+
+func (h E2TermInitNotificationHandler) HandleNewE2TInstance(e2tAddress string) {
+
+ err := h.routingManagerClient.AddE2TInstance(e2tAddress)
+
+ if err != nil{
+ h.logger.Errorf("#E2TermInitNotificationHandler.HandleNewE2TInstance - e2t address: %s - routing manager failure", e2tAddress)
+ return
+ }
+
+ _ = h.e2tInstancesManager.AddE2TInstance(e2tAddress)
+}
\ No newline at end of file
const e2tInstanceAddress = "10.0.2.15"
const e2tInitPayload = "{\"address\":\"10.0.2.15\", \"fqdn\":\"\"}"
-func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock) {
+func initRanLostConnectionTest(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock, *mocks.E2TInstancesManagerMock, *mocks.RoutingManagerClientMock) {
logger := initLog(t)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
writerMock := &mocks.RnibWriterMock{}
+ routingManagerClientMock := &mocks.RoutingManagerClientMock{}
+
rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
+
ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManagerMock)
- handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManagerMock)
- return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock
+ handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManagerMock, routingManagerClientMock)
+
+ return logger, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, routingManagerClientMock
}
func initRanLostConnectionTestWithRealE2tInstanceManager(t *testing.T) (*logger.Logger, E2TermInitNotificationHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.RmrMessengerMock) {
readerMock := &mocks.RnibReaderMock{}
writerMock := &mocks.RnibWriterMock{}
+ routingManagerClientMock := &mocks.RoutingManagerClientMock{}
rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager)
- handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager)
+ handler := NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClientMock)
return logger, handler, readerMock, writerMock, rmrMessengerMock
}
func TestE2TermInitUnmarshalPayloadFailure(t *testing.T) {
- _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
handler.Handle(notificationRequest)
e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
}
func TestE2TermInitEmptyE2TAddress(t *testing.T) {
- _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("{\"address\":\"\"}")}
handler.Handle(notificationRequest)
e2tInstancesManagerMock.AssertNotCalled(t, "GetE2TInstance")
}
func TestE2TermInitGetE2TInstanceFailure(t *testing.T) {
- _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var e2tInstance *entities.E2TInstance
e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewInternalError(fmt.Errorf("internal error")))
notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
}
func TestE2TermInitNewE2TInstance(t *testing.T) {
- _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, _, _, e2tInstancesManagerMock, routingManagerClient := initRanLostConnectionTest(t)
var e2tInstance *entities.E2TInstance
e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
e2tInstance = entities.NewE2TInstance(e2tInstanceAddress)
e2tInstancesManagerMock.On("AddE2TInstance", e2tInstanceAddress).Return(nil)
+ routingManagerClient.On("AddE2TInstance", e2tInstanceAddress).Return(nil)
notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
handler.Handle(notificationRequest)
+ routingManagerClient.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress)
e2tInstancesManagerMock.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress)
}
+func TestE2TermInitNewE2TInstance_RoutingManagerError(t *testing.T) {
+ _, handler, _, _, _, e2tInstancesManagerMock, routingManagerClient := initRanLostConnectionTest(t)
+ var e2tInstance *entities.E2TInstance
+ e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, common.NewResourceNotFoundError("not found"))
+ e2tInstance = entities.NewE2TInstance(e2tInstanceAddress)
+ e2tInstancesManagerMock.On("AddE2TInstance", e2tInstanceAddress).Return(nil)
+ routingManagerClient.On("AddE2TInstance", e2tInstanceAddress).Return(fmt.Errorf("error"))
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+
+ handler.Handle(notificationRequest)
+
+ routingManagerClient.AssertCalled(t, "AddE2TInstance", e2tInstanceAddress)
+ e2tInstancesManagerMock.AssertNotCalled(t, "AddE2TInstance", e2tInstanceAddress)
+}
+
func TestE2TermInitExistingE2TInstanceNoAssociatedRans(t *testing.T) {
- _, handler, _, _, _, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, _, _, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
}
func TestE2TermInitHandlerSuccessOneRan(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
- var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
- var argNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
payload := e2pdus.PackedX2setupRequest
}
func TestE2TermInitHandlerSuccessOneRanShuttingdown(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
var initialNodeb = &entities.NodebInfo{RanName: RanName, ConnectionStatus: entities.ConnectionStatus_SHUTTING_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
rmrMessengerMock.AssertNotCalled(t, "SendMsg")
}
+func TestE2TermInitHandlerSuccessOneRan_ToBeDeleted(t *testing.T) {
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+ var rnibErr error
+
+ var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+
+ var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+
+ payload := e2pdus.PackedX2setupRequest
+ xaction := []byte(RanName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
+
+ e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
+ e2tInstance.State = entities.ToBeDeleted
+ e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+
+ e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+
+ handler.Handle(notificationRequest)
+
+ writerMock.AssertNotCalled(t, "UpdateNodebInfo")
+ rmrMessengerMock.AssertNotCalled(t, "SendMsg")
+}
+
+func TestE2TermInitHandlerSuccessOneRan_RoutingManagerFailure(t *testing.T) {
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+ var rnibErr error
+
+ var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+
+ var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+
+ payload := e2pdus.PackedX2setupRequest
+ xaction := []byte(RanName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
+
+ e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
+ e2tInstance.State = entities.RoutingManagerFailure
+ e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+
+ e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+ e2tInstancesManagerMock.On("ActivateE2TInstance", e2tInstance).Return(nil)
+ writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+
+ handler.Handle(notificationRequest)
+
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 1)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 1)
+}
+
+func TestE2TermInitHandlerSuccessOneRan_RoutingManagerFailure_Error(t *testing.T) {
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
+ var rnibErr error
+
+ var initialNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
+ readerMock.On("GetNodeb", RanName).Return(initialNodeb, rnibErr)
+
+ var argNodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTING, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST, ConnectionAttempts: 1}
+ writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+
+ payload := e2pdus.PackedX2setupRequest
+ xaction := []byte(RanName)
+ msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
+
+ e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
+ e2tInstance.State = entities.RoutingManagerFailure
+ e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
+
+ e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
+ e2tInstancesManagerMock.On("ActivateE2TInstance", e2tInstance).Return(fmt.Errorf(" Error "))
+ writerMock.On("UpdateNodebInfo", argNodeb).Return(rnibErr)
+
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(e2tInitPayload)}
+
+ handler.Handle(notificationRequest)
+
+ writerMock.AssertNumberOfCalls(t, "UpdateNodebInfo", 0)
+ rmrMessengerMock.AssertNumberOfCalls(t, "SendMsg", 0)
+}
+
func TestE2TermInitHandlerSuccessTwoRans(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
}
func TestE2TermInitHandlerSuccessTwoRansSecondRanShutdown(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_SHUT_DOWN, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
}
func TestE2TermInitHandlerSuccessThreeRansFirstRmrFailure(t *testing.T) {
- log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}}
}
func TestE2TermInitHandlerSuccessThreeRansSecondNotFoundFailure(t *testing.T) {
- log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}}
}
func TestE2TermInitHandlerSuccessThreeRansSecondRnibInternalErrorFailure(t *testing.T) {
- log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ log, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
ids := []*entities.NbIdentity{{InventoryName: "test1"}, {InventoryName: "test2"}, {InventoryName: "test3"}}
}
func TestE2TermInitHandlerSuccessZeroRans(t *testing.T) {
- _, handler, _, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, _, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstancesManagerMock.On("GetE2TInstance", e2tInstanceAddress).Return(e2tInstance, nil)
}
func TestE2TermInitHandlerFailureGetNodebInternalError(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var nodebInfo *entities.NodebInfo
readerMock.On("GetNodeb", "test1").Return(nodebInfo, common.NewInternalError(fmt.Errorf("internal error")))
}
func TestE2TermInitHandlerSuccessTwoRansSecondIsDisconnected(t *testing.T) {
- _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock := initRanLostConnectionTest(t)
+ _, handler, readerMock, writerMock, rmrMessengerMock, e2tInstancesManagerMock, _ := initRanLostConnectionTest(t)
var rnibErr error
var initialNodeb0 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
var initialNodeb1 = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED, E2ApplicationProtocol: entities.E2ApplicationProtocol_X2_SETUP_REQUEST}
SelectE2TInstance() (string, error)
AssociateRan(ranName string, e2tAddress string) error
DissociateRan(ranName string, e2tAddress string) error
+ ActivateE2TInstance(e2tInstance *entities.E2TInstance) error
ResetKeepAliveTimestamp(e2tAddress string) error
}
return nil
}
+func (h E2TInstancesManager) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error{
+
+ if e2tInstance == nil {
+ h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - e2tInstance empty")
+ return e2managererrors.NewInternalError()
+ }
+
+ h.logger.Infof("#E2TInstancesManager.ActivateE2TInstance - E2T Address: %s - activate E2T instance", e2tInstance.Address)
+
+ e2tInstance.State = entities.Active
+ e2tInstance.KeepAliveTimestamp = time.Now().UnixNano()
+
+ err := h.rnibDataService.SaveE2TInstance(e2tInstance)
+ if err != nil {
+ h.logger.Errorf("#E2TInstancesManager.ActivateE2TInstance - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tInstance.Address, err)
+ return err
+ }
+ return nil
+}
+
func (m *E2TInstancesManager) ResetKeepAliveTimestamp(e2tAddress string) error {
m.mux.Lock()
rnibWriterMock.AssertExpectations(t)
}
+func TestActivateE2TInstanceSuccess(t *testing.T) {
+ _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.State = entities.RoutingManagerFailure
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
+ err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
+ assert.Nil(t, err)
+ assert.Equal(t, entities.Active, e2tInstance1.State)
+ rnibWriterMock.AssertExpectations(t)
+}
+
+func TestActivateE2TInstance_RnibError(t *testing.T) {
+ _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.State = entities.RoutingManagerFailure
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
+
+ err := e2tInstancesManager.ActivateE2TInstance(e2tInstance1)
+ assert.NotNil(t, err)
+}
+
+func TestActivateE2TInstance_NoInstance(t *testing.T) {
+ _, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ err := e2tInstancesManager.ActivateE2TInstance(nil)
+
+ assert.NotNil(t, err)
+ rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
package notificationmanager
import (
+ "e2mgr/clients"
"e2mgr/configuration"
"e2mgr/logger"
"e2mgr/managers"
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
readerMock := &mocks.RnibReaderMock{}
-
writerMock := &mocks.RnibWriterMock{}
-
+ httpClient := &mocks.HttpClientMock{}
rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger)
rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
+ routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager,routingManagerClient)
notificationManager := NewNotificationManager(logger, rmrNotificationHandlerProvider )
return logger, readerMock, notificationManager
}
args := m.Called(e2tAddress)
return args.Error(0)
+}
+
+func (m *E2TInstancesManagerMock) ActivateE2TInstance(e2tInstance *entities.E2TInstance) error {
+ args := m.Called(e2tInstance)
+ return args.Error(0)
+
}
\ No newline at end of file
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This source code is part of the near-RT RIC (RAN Intelligent Controller)
+// platform project (RICP).
+
+package mocks
+
+import (
+ "github.com/stretchr/testify/mock"
+)
+
+type RoutingManagerClientMock struct {
+ mock.Mock
+}
+
+func (m *RoutingManagerClientMock) AddE2TInstance(e2tAddress string) error {
+
+ args := m.Called(e2tAddress)
+ return args.Error(0)
+}
+
+func (m *RoutingManagerClientMock) AssociateRanToE2TInstance(e2tAddress string, ranName string) error {
+
+ args := m.Called(e2tAddress, ranName)
+ return args.Error(0)
+}
+
+func (m *RoutingManagerClientMock) DissociateRanE2TInstance(e2tAddress string, ranName string) error {
+
+ args := m.Called(e2tAddress, ranName)
+ return args.Error(0)
+}
\ No newline at end of file
package rmrmsghandlerprovider
import (
+ "e2mgr/clients"
"e2mgr/configuration"
"e2mgr/converters"
"e2mgr/handlers/rmrmsghandlers"
provider.notificationHandlers[msgType] = handler
}
-func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager) {
+func (provider *NotificationHandlerProvider) Init(logger *logger.Logger, config *configuration.Configuration, rnibDataService services.RNibDataService, rmrSender *rmrsender.RmrSender, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager, routingManagerClient clients.IRoutingManagerClient) {
// Init converters
x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger)
endcConfigurationUpdateHandler := rmrmsghandlers.NewEndcConfigurationUpdateHandler(logger, rmrSender)
x2ResetResponseHandler := rmrmsghandlers.NewX2ResetResponseHandler(logger, rnibDataService, ranStatusChangeManager, x2ResetResponseExtractor)
x2ResetRequestNotificationHandler := rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender)
- e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager)
+ e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClient)
e2TKeepAliveResponseHandler := rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager)
provider.Register(rmrCgo.RIC_X2_SETUP_RESP, x2SetupResponseHandler)
package rmrmsghandlerprovider
import (
+ "e2mgr/clients"
"e2mgr/configuration"
"e2mgr/converters"
"e2mgr/handlers/rmrmsghandlers"
* Verify support for known providers.
*/
-func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, *managers.RanSetupManager, managers.IE2TInstancesManager) {
+func initTestCase(t *testing.T) (*logger.Logger, *configuration.Configuration, services.RNibDataService, *rmrsender.RmrSender, *managers.RanSetupManager, managers.IE2TInstancesManager, clients.IRoutingManagerClient) {
logger := initLog(t)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
readerMock := &mocks.RnibReaderMock{}
writerMock := &mocks.RnibWriterMock{}
+ httpClient := &mocks.HttpClientMock{}
rmrSender := initRmrSender(&mocks.RmrMessengerMock{}, logger)
rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
+ routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
- //ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager)
- //ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender)
- //
- //x2SetupResponseConverter := converters.NewX2SetupResponseConverter(logger)
- //x2SetupResponseManager := managers.NewX2SetupResponseManager(x2SetupResponseConverter)
- //
- //x2SetupFailureResponseConverter := converters.NewX2SetupFailureResponseConverter(logger)
- //x2SetupFailureResponseManager := managers.NewX2SetupFailureResponseManager(x2SetupFailureResponseConverter)
- //
- //endcSetupResponseConverter := converters.NewEndcSetupResponseConverter(logger)
- //endcSetupResponseManager := managers.NewEndcSetupResponseManager(endcSetupResponseConverter)
- //
- //
- //endcSetupFailureResponseConverter := converters.NewEndcSetupFailureResponseConverter(logger)
- //endcSetupFailureResponseManager := managers.NewEndcSetupFailureResponseManager(endcSetupFailureResponseConverter)
-
- return logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager
+ return logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient
}
func TestGetNotificationHandlerSuccess(t *testing.T) {
- logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager := initTestCase(t)
+ logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient := initTestCase(t)
ranReconnectionManager := managers.NewRanReconnectionManager(logger, configuration.ParseConfiguration(), rnibDataService, ranSetupManager, e2tInstancesManager)
ranStatusChangeManager := managers.NewRanStatusChangeManager(logger, rmrSender)
{rmrCgo.RIC_ENB_LOAD_INFORMATION, rmrmsghandlers.NewEnbLoadInformationNotificationHandler(logger, rnibDataService, converters.NewEnbLoadInformationExtractor(logger))},
{rmrCgo.RIC_ENB_CONF_UPDATE, rmrmsghandlers.NewX2EnbConfigurationUpdateHandler(logger, rmrSender)},
{rmrCgo.RIC_ENDC_CONF_UPDATE, rmrmsghandlers.NewEndcConfigurationUpdateHandler(logger, rmrSender)},
- {rmrCgo.RIC_E2_TERM_INIT, rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager)},
+ {rmrCgo.RIC_E2_TERM_INIT, rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager, routingManagerClient)},
{rmrCgo.E2_TERM_KEEP_ALIVE_RESP, rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager)},
{rmrCgo.RIC_X2_RESET_RESP, rmrmsghandlers.NewX2ResetResponseHandler(logger, rnibDataService, ranStatusChangeManager, converters.NewX2ResetResponseExtractor(logger))},
{rmrCgo.RIC_X2_RESET, rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender)},
for _, tc := range testCases {
provider := NewNotificationHandlerProvider()
- provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
+ provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient)
t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
handler, err := provider.GetNotificationHandler(tc.msgType)
if err != nil {
}
for _, tc := range testCases {
- logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager := initTestCase(t)
+ logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient := initTestCase(t)
provider := NewNotificationHandlerProvider()
- provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
+ provider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient)
t.Run(fmt.Sprintf("%d", tc.msgType), func(t *testing.T) {
_, err := provider.GetNotificationHandler(tc.msgType)
if err == nil {
port: 3801
maxMsgSize: 65536
routingManager:
- baseUrl: http://iltlv740.intl.att.com:8080/ric/v1/handles/
+ baseUrl: http://10.0.2.15:12020/ric/v1/handles/v1/
notificationResponseBuffer: 100
bigRedButtonTimeoutSec: 5
maxConnectionAttempts: 3
package rmrreceiver
import (
+ "e2mgr/clients"
"e2mgr/configuration"
"e2mgr/logger"
"e2mgr/managers"
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
readerMock := &mocks.RnibReaderMock{}
-
writerMock := &mocks.RnibWriterMock{}
-
+ httpClient := &mocks.HttpClientMock{}
rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
rmrMessenger := initRmrMessenger(logger)
rmrSender := rmrsender.NewRmrSender(logger, rmrMessenger)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
+ routingManagerClient := clients.NewRoutingManagerClient(logger, config, httpClient)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
+ rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager, routingManagerClient)
notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
return NewRmrReceiver(logger, rmrMessenger, notificationManager)
}
Code Review / ric-plt / e2mgr.git / commitdiff