--- /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.
+#
+##############################################################################
+
+*** Settings ***
+Documentation Keep Alive
--- /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.
+#
+##############################################################################
+*** Settings ***
+Suite Setup Prepare Enviorment
+Resource ../Resource/resource.robot
+Resource ../Resource/Keywords.robot
+Resource ../Resource/scripts_variables.robot
+Library ../Scripts/find_error_script.py
+Library OperatingSystem
+Library Collections
+
+
+*** Test Cases ***
+
+Stop E2T
+ stop_e2
+ Sleep 1s
+
+Prepare logs for tests
+ Remove log files
+ Save logs
+
+Verify Is Dead Message Printed
+ ${result} find_error_script.find_error ${EXECDIR} ${e2mgr_log_filename} ${e2_is_dead_message_printed}
+ Should Be Equal As Strings ${result} True
+
+Start E2T
+ start_e2
\ No newline at end of file
Remove log files
Save logs
-Verify RSM Resource Status Request Message Sent
+Verify RSM Resource Status Request Message Not Sent
${result} find_rmr_message.verify_logs ${EXECDIR} ${rsm_log_filename} ${RIC_RES_STATUS_REQ_message_type_successfully_sent} ${RAN_NAME_test1}
Should Be Equal As Strings ${result} False
\ No newline at end of file
${e2mgr_log_filename} Evaluate "e2mgr.${SUITE NAME}.log".replace(" ","-")
${gnb_log_filename} Evaluate "gnb.${SUITE NAME}.log".replace(" ","-")
${rsm_log_filename} Evaluate "rsm.${SUITE NAME}.log".replace(" ","-")
- ${e2e_simu_log_filename} Evaluate "e2esimu.${SUITE NAME}.log".replace(" ","-")
+ ${e2e_simu_log_filename} Evaluate "e2e_simu.${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} e2esimu > ${e2e_simu_log_filename}'
+ ${Save_e2e_simu_log} Evaluate 'docker logs --since ${starting_timestamp} e2e_simu > ${e2e_simu_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}
${first_retry_to_retrieve_from_db} RnibDataService.retry - retrying 1 GetNodeb
${third_retry_to_retrieve_from_db} RnibDataService.retry - after 3 attempts of GetNodeb
${RIC_RES_STATUS_REQ_message_type_successfully_sent} Message type: 10090 - Successfully sent RMR message
+${E2_TERM_KEEP_ALIVE_REQ_message_type_successfully_sent} Message type: 1101 - Successfully sent RMR message
+${e2_is_dead_message_printed} E2TShutdownManager.Shutdown - E2T e2t.att.com:38000 is Dead, RIP
${RAN_NAME_test1} RAN name: test1
${RAN_NAME_test2} RAN name: test2
${E2ADAPTER_Setup_Resp} Send dummy ENDCX2SetupResponse to RIC
rmrSender := rmrsender.NewRmrSender(logger, rmrMessenger)
ranSetupManager := managers.NewRanSetupManager(logger, rmrSender, rnibDataService)
e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
+ e2tShutdownManager := managers.NewE2TShutdownManager(logger, rnibDataService, e2tInstancesManager)
+ e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, ranSetupManager, e2tInstancesManager)
defer rmrMessenger.Close()
go rmrReceiver.ListenAndHandle()
+ go e2tKeepAliveWorker.Execute()
httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager)
rootController := controllers.NewRootController(rnibDataService)
nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
_ = httpserver.Run(logger, config.Http.Port, rootController, nodebController)
-}
-
-
+}
\ No newline at end of file
Port int
MaxMsgSize int
}
- NotificationResponseBuffer int
- BigRedButtonTimeoutSec int
- MaxConnectionAttempts int
- MaxRnibConnectionAttempts int
- RnibRetryIntervalMs int
+ NotificationResponseBuffer int
+ BigRedButtonTimeoutSec int
+ MaxConnectionAttempts int
+ MaxRnibConnectionAttempts int
+ RnibRetryIntervalMs int
+ KeepAliveResponseTimeoutMs int
+ KeepAliveDelayMs int
}
-func ParseConfiguration() *Configuration{
+func ParseConfiguration() *Configuration {
viper.SetConfigType("yaml")
viper.SetConfigName("configuration")
viper.AddConfigPath("E2Manager/resources/")
- viper.AddConfigPath("./resources/") //For production
- viper.AddConfigPath("../resources/") //For test under Docker
+ viper.AddConfigPath("./resources/") //For production
+ viper.AddConfigPath("../resources/") //For test under Docker
viper.AddConfigPath("../../resources/") //For test under Docker
err := viper.ReadInConfig()
if err != nil {
config.MaxConnectionAttempts = viper.GetInt("maxConnectionAttempts")
config.MaxRnibConnectionAttempts = viper.GetInt("maxRnibConnectionAttempts")
config.RnibRetryIntervalMs = viper.GetInt("rnibRetryIntervalMs")
+ config.KeepAliveResponseTimeoutMs = viper.GetInt("keepAliveResponseTimeoutMs")
+ config.KeepAliveDelayMs = viper.GetInt("KeepAliveDelayMs")
return &config
}
-func (c *Configuration)fillLoggingConfig(logConfig *viper.Viper) {
+func (c *Configuration) fillLoggingConfig(logConfig *viper.Viper) {
if logConfig == nil {
panic(fmt.Sprintf("#configuration.fillLoggingConfig - failed to fill logging configuration: The entry 'logging' not found\n"))
}
c.Logging.LogLevel = logConfig.GetString("logLevel")
}
-func (c *Configuration)fillHttpConfig(httpConfig *viper.Viper) {
+func (c *Configuration) fillHttpConfig(httpConfig *viper.Viper) {
if httpConfig == nil {
panic(fmt.Sprintf("#configuration.fillHttpConfig - failed to fill HTTP configuration: The entry 'http' not found\n"))
}
c.Http.Port = httpConfig.GetInt("port")
}
-func (c *Configuration)fillRmrConfig(rmrConfig *viper.Viper) {
+func (c *Configuration) fillRmrConfig(rmrConfig *viper.Viper) {
if rmrConfig == nil {
panic(fmt.Sprintf("#configuration.fillRmrConfig - failed to fill RMR configuration: The entry 'rmr' not found\n"))
}
c.Rmr.Port = rmrConfig.GetInt("port")
c.Rmr.MaxMsgSize = rmrConfig.GetInt("maxMsgSize")
}
-
assert.Equal(t, "info", config.Logging.LogLevel)
assert.Equal(t, 100, config.NotificationResponseBuffer)
assert.Equal(t, 5, config.BigRedButtonTimeoutSec)
+ assert.Equal(t, 1500, config.KeepAliveResponseTimeoutMs)
+ assert.Equal(t, 500, config.KeepAliveDelayMs)
}
func TestParseConfigurationFileNotFoundFailure(t *testing.T) {
var xAction []byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
header := http.Header{}
header.Set("Content-Type", "application/json")
var xAction[]byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_X2_SETUP_REQ, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
header := http.Header{}
header.Set("Content-Type", "application/json")
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
var xAction []byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", msg).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
writer := httptest.NewRecorder()
module e2mgr
require (
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.27
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.27
- gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.27
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.28
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.28
+ gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.28
gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.5.0
github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a // indirect
github.com/go-ozzo/ozzo-validation v3.5.0+incompatible
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.26/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.27 h1:frasTDcg8Q8FgYutzJ+xSLHz9YseR2BmPSSBs4GI/1M=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.27/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.28 h1:Rewapfbc30ZkBaYB/3gW3W1BEivoiPdQm5UnmUswcMA=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.0.28/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.23 h1:akVZc8NWJ9oPujd7cQY3Ti3se4PF1/NoC+Dwt+YzINc=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.23/go.mod h1:GXiXLz4ORBeIr0FLIbzENRykgh3Po5uPkX2jICxnRF0=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.24 h1:5ZnhEUygvN5PuTXS2bNt6KavT+Wtuh9Vra+EqZIvw+Q=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.26/go.mod h1:Fh23KkroYw5CRBh39WzZzxpKSkpQWL3scdzGnMngLo8=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.27 h1:nvZDzuB/SYKDuF1It7M4/Y/iVlVrCZ0Ob8AITAyppKo=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.27/go.mod h1:Fh23KkroYw5CRBh39WzZzxpKSkpQWL3scdzGnMngLo8=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.28 h1:+8Nn+Jn/AvhwBI1LtLsNS1PtOGAOYUHdicOrMn/8mmU=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.0.28/go.mod h1:Fh23KkroYw5CRBh39WzZzxpKSkpQWL3scdzGnMngLo8=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.23 h1:TYV3HE2UNwGOWiA4C226/WhB94crwjuHKIFTgDDvo8I=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.23/go.mod h1:uZVjwZjfWV4JJzyQVO/O48Ykph57zfpfMB7nK+WGKX8=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.24 h1:Wwp36IoHwp091lXVCYLtFK6AMhoGAR4NYEgW1C42h6k=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.26/go.mod h1:DCf5H9yy6kNTXsnUgXAPSuJt22ca4pYm0mo2ovJhLrA=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.27 h1:sWjlU/wBiWIBeSixnr9etCqtNmS2LW8jv+x2JGpf2eI=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.27/go.mod h1:vZ/335+rRSQW82wcbc80fNNICSK3TiCqIxmkqeC2Pfo=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.28 h1:AaYvK59fxDXQUV9NCo6WuxDOvBQbnRU3WTPyJaYhkkg=
+gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.0.28/go.mod h1:vZ/335+rRSQW82wcbc80fNNICSK3TiCqIxmkqeC2Pfo=
gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.5.0 h1:+P3XuWKSaMbzh5PNtrW9gkZlCN0hKrZq+Cn8JetwBys=
gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.5.0/go.mod h1:y2WhrCvdLkAKdH+ySdHSOSehACJkTMyZghCGVcqoZzc=
github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, nil)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
_, actual := handler.Handle(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, nil)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
_, actual := handler.Handle(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb1AfterTimer).Return(nil)
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, nil)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
_, actual := handler.Handle(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(nil)
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, nil)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
_, actual := handler.Handle(nil)
writerMock.On("SaveNodeb", mock.Anything, updatedNb3AfterTimer).Return(errRnib)
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, nil)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, nil)
_, actual := handler.Handle(nil)
expected := e2managererrors.NewRmrError()
mbuf := rmrCgo.NewMBuf(tests.MessageType, tests.MaxMsgSize, "RanName", &tests.DummyPayload, &tests.DummyXAction)
- rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf))).Return(mbuf, expected)
+ rmrMessengerMock.On("SendMsg", mock.AnythingOfType(fmt.Sprintf("%T", mbuf)), true).Return(mbuf, expected)
_, actual := handler.Handle(nil)
var xAction[]byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", msg).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x40}
var xAction[]byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", msg).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", msg, true).Return(msg, nil)
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
payload := []byte{0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x01, 0x00, 0x05, 0x40, 0x01, 0x64}
var xAction[]byte
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", msg).Return(&rmrCgo.MBuf{}, fmt.Errorf("rmr error"))
+ rmrMessengerMock.On("SendMsg", msg, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("rmr error"))
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED}
readerMock.On("GetNodeb", ranName).Return(nodeb, nil)
xaction := []byte(RanName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName)
xaction := []byte(RanName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), RanName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, RanName, "test2")
//xaction = []byte(ids[1].InventoryName)
//msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ids[1].InventoryName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg0, fmt.Errorf("RMR Error"))
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg0, fmt.Errorf("RMR Error"))
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1", "test2", "test3")
//xaction = []byte(ids[1].InventoryName)
//msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ids[1].InventoryName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg0, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg0, nil)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1", "test2", "test3")
//xaction = []byte(ids[1].InventoryName)
//msg1 := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ids[1].InventoryName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg0, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg0, nil)
e2tInstance := entities.NewE2TInstance(e2tInstanceAddress)
e2tInstance.AssociatedRanList = append(e2tInstance.AssociatedRanList, "test1", "test2", "test3")
--- /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 rmrmsghandlers
+
+import (
+ "e2mgr/logger"
+ "e2mgr/managers"
+ "e2mgr/models"
+ "e2mgr/services"
+ "encoding/json"
+)
+
+type E2TKeepAliveResponseHandler struct {
+ logger *logger.Logger
+ rnibDataService services.RNibDataService
+ e2TInstancesManager managers.IE2TInstancesManager
+}
+
+func NewE2TKeepAliveResponseHandler(logger *logger.Logger, rnibDataService services.RNibDataService, e2TInstancesManager managers.IE2TInstancesManager) E2TKeepAliveResponseHandler {
+ return E2TKeepAliveResponseHandler{
+ logger: logger,
+ rnibDataService: rnibDataService,
+ e2TInstancesManager: e2TInstancesManager,
+ }
+}
+
+func (h E2TKeepAliveResponseHandler) Handle(request *models.NotificationRequest) {
+ unmarshalledPayload := models.E2TKeepAlivePayload{}
+ err := json.Unmarshal(request.Payload, &unmarshalledPayload)
+
+ if err != nil {
+ h.logger.Errorf("#E2TKeepAliveResponseHandler.Handle - Error unmarshaling RMR request payload: %v", err)
+ return
+ }
+
+ _ = h.e2TInstancesManager.ResetKeepAliveTimestamp(unmarshalledPayload.Address)
+}
--- /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 rmrmsghandlers
+
+import (
+ "e2mgr/configuration"
+ "e2mgr/logger"
+ "e2mgr/mocks"
+ "e2mgr/models"
+ "e2mgr/services"
+ "testing"
+)
+
+func initE2TKeepAliveTest(t *testing.T) (*logger.Logger, E2TKeepAliveResponseHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TInstancesManagerMock) {
+
+ logger := initLog(t)
+ config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+
+ readerMock := &mocks.RnibReaderMock{}
+ writerMock := &mocks.RnibWriterMock{}
+
+ rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+
+ e2tInstancesManagerMock := &mocks.E2TInstancesManagerMock{}
+ handler := NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManagerMock)
+ return logger, handler, readerMock, writerMock, e2tInstancesManagerMock
+}
+
+func TestE2TKeepAliveUnmarshalPayloadFailure(t *testing.T) {
+ _, handler, _, _, e2tInstancesManagerMock := initE2TKeepAliveTest(t)
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte("asd")}
+ handler.Handle(notificationRequest)
+ e2tInstancesManagerMock.AssertNotCalled(t, "ResetKeepAliveTimestamp")
+}
+
+func TestE2TKeepAliveUnmarshalPayloadSuccess(t *testing.T) {
+ _, handler, _, _, e2tInstancesManagerMock := initE2TKeepAliveTest(t)
+
+ jsonRequest := "{\"address\":\"10.10.2.15:9800\"}"
+ notificationRequest := &models.NotificationRequest{RanName: RanName, Payload: []byte(jsonRequest)}
+
+ e2tInstancesManagerMock.On("ResetKeepAliveTimestamp", "10.10.2.15:9800").Return(nil)
+ handler.Handle(notificationRequest)
+ e2tInstancesManagerMock.AssertCalled(t, "ResetKeepAliveTimestamp", "10.10.2.15:9800")
+}
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload, StartTime: time.Now(),
TransactionId: *mBuf.XAction}
var err error
- rmrMessengerMock.On("SendMsg", mBuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, err)
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf, true)
}
func TestHandleEndcConfigUpdateFailure(t *testing.T) {
mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENDC_CONF_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: 0, Payload: []byte{0}, StartTime: time.Now(),
TransactionId: *mBuf.XAction}
- rmrMessengerMock.On("SendMsg", mBuf).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
+ rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf, true)
}
testContext.readerMock.On("GetNodeb", RanName).Return(nodebInfo, rnibErr)
testContext.writerMock.On("SaveNodeb", mock.Anything, mock.Anything).Return(tc.saveNodebMockError)
- testContext.rmrMessengerMock.On("SendMsg", tc.statusChangeMbuf).Return(&rmrCgo.MBuf{}, tc.sendMsgError)
+ testContext.rmrMessengerMock.On("SendMsg", tc.statusChangeMbuf, true).Return(&rmrCgo.MBuf{}, tc.sendMsgError)
handler.Handle(¬ificationRequest)
return testContext, nodebInfo
assert.IsType(t, &entities.NodebInfo_Enb{}, nodebInfo.Configuration)
i, _ := nodebInfo.Configuration.(*entities.NodebInfo_Enb)
assert.NotNil(t, i.Enb)
- testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf)
+ testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf, true)
}
func TestX2SetupFailureResponse(t *testing.T) {
i, _ := nodebInfo.Configuration.(*entities.NodebInfo_Gnb)
assert.NotNil(t, i.Gnb)
- testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf)
+ testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf, true)
}
func TestEndcSetupFailureResponse(t *testing.T) {
assert.IsType(t, &entities.NodebInfo_Enb{}, nodebInfo.Configuration)
i, _ := nodebInfo.Configuration.(*entities.NodebInfo_Enb)
assert.NotNil(t, i.Enb)
- testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf)
+ testContext.rmrMessengerMock.AssertCalled(t, "SendMsg", tc.statusChangeMbuf, true)
}
var err error
readerMock.On("GetNodeb", ranName).Return(nb, err)
resetResponseMbuf := rmrCgo.NewMBuf(rmrCgo.RIC_X2_RESET_RESP, len(e2pdus.PackedX2ResetResponse), ranName, &e2pdus.PackedX2ResetResponse, &xAction)
- rmrMessengerMock.On("SendMsg", resetResponseMbuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", resetResponseMbuf, true).Return(&rmrCgo.MBuf{}, err)
ranRestartedMbuf := getRanRestartedMbuf(nb.NodeType, enums.RAN_TO_RIC)
- rmrMessengerMock.On("SendMsg", ranRestartedMbuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", ranRestartedMbuf, true).Return(&rmrCgo.MBuf{}, err)
h.Handle(notificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", resetResponseMbuf)
- rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", resetResponseMbuf, true)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf, true)
}
func TestHandleX2ResetRequestNotificationShuttingDownStatus(t *testing.T) {
var rnibErr error
readerMock.On("GetNodeb", RanName).Return(nb, rnibErr)
ranRestartedMbuf := getRanRestartedMbuf(nb.NodeType, enums.RIC_TO_RAN)
- rmrMessengerMock.On("SendMsg", ranRestartedMbuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", ranRestartedMbuf, true).Return(&rmrCgo.MBuf{}, err)
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf, true)
}
func TestX2ResetResponseSuccessEmptyIEs(t *testing.T) {
var rnibErr error
readerMock.On("GetNodeb", RanName).Return(nb, rnibErr)
ranRestartedMbuf := getRanRestartedMbuf(nb.NodeType, enums.RIC_TO_RAN)
- rmrMessengerMock.On("SendMsg", ranRestartedMbuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", ranRestartedMbuf, true).Return(&rmrCgo.MBuf{}, err)
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", ranRestartedMbuf, true)
}
func TestX2ResetResponseShuttingDown(t *testing.T) {
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: mBuf.Len, Payload: *mBuf.Payload,
StartTime: time.Now(), TransactionId:xAction}
var err error
- rmrMessengerMock.On("SendMsg", mBuf).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, err)
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf, true)
}
func TestHandleX2EnbConfigUpdateFailure(t *testing.T) {
mBuf := rmrCgo.NewMBuf(rmrCgo.RIC_ENB_CONFIGURATION_UPDATE_FAILURE, len(payload), ranName, &payload, &xAction)
notificationRequest := models.NotificationRequest{RanName: mBuf.Meid, Len: 0, Payload: []byte{0},
StartTime: time.Now(), TransactionId:xAction}
- rmrMessengerMock.On("SendMsg", mBuf).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
+ rmrMessengerMock.On("SendMsg", mBuf, true).Return(&rmrCgo.MBuf{}, fmt.Errorf("send failure"))
h.Handle(¬ificationRequest)
- rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg", mBuf, true)
}
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"math"
"sync"
+ "time"
)
type E2TInstancesManager struct {
type IE2TInstancesManager interface {
GetE2TInstance(e2tAddress string) (*entities.E2TInstance, error)
GetE2TInstances() ([]*entities.E2TInstance, error)
+ GetE2TInstancesNoLogs() ([]*entities.E2TInstance, error)
AddE2TInstance(e2tAddress string) error
RemoveE2TInstance(e2tInstance *entities.E2TInstance) error
SelectE2TInstance() (string, error)
AssociateRan(ranName string, e2tAddress string) error
DissociateRan(ranName string, e2tAddress string) error
+ ResetKeepAliveTimestamp(e2tAddress string) error
}
func NewE2TInstancesManager(rnibDataService services.RNibDataService, logger *logger.Logger) *E2TInstancesManager {
return e2tInstance, err
}
+func (m *E2TInstancesManager) GetE2TInstancesNoLogs() ([]*entities.E2TInstance, error) {
+ e2tAddresses, err := m.rnibDataService.GetE2TAddressesNoLogs()
+
+ if err != nil {
+ _, ok := err.(*common.ResourceNotFoundError)
+
+ if !ok {
+ m.logger.Errorf("#E2TInstancesManager.GetE2TInstancesNoLogs - Failed retrieving E2T addresses. error: %s", err)
+ }
+ return nil, err
+ }
+
+ if len(e2tAddresses) == 0 {
+ return []*entities.E2TInstance{}, nil
+ }
+
+ e2tInstances, err := m.rnibDataService.GetE2TInstancesNoLogs(e2tAddresses)
+
+ if err != nil {
+ _, ok := err.(*common.ResourceNotFoundError)
+
+ if !ok {
+ m.logger.Errorf("#E2TInstancesManager.GetE2TInstancesNoLogs - Failed retrieving E2T instances list. error: %s", err)
+ }
+ return e2tInstances, err
+ }
+
+ return e2tInstances, nil
+}
+
func (m *E2TInstancesManager) GetE2TInstances() ([]*entities.E2TInstance, error) {
e2tAddresses, err := m.rnibDataService.GetE2TAddresses()
m.logger.Infof("#E2TInstancesManager.AssociateRan - successfully associated RAN %s with E2T %s", ranName, e2tInstance.Address)
return nil
}
+
+func (m *E2TInstancesManager) ResetKeepAliveTimestamp(e2tAddress string) error {
+
+ m.mux.Lock()
+ defer m.mux.Unlock()
+
+ e2tInstance, err := m.rnibDataService.GetE2TInstanceNoLogs(e2tAddress)
+
+ if err != nil {
+ m.logger.Errorf("#E2TInstancesManager.ResetKeepAliveTimestamp - E2T Instance address: %s - Failed retrieving E2TInstance. error: %s", e2tAddress, err)
+ return err
+ }
+
+ if e2tInstance.State == entities.ToBeDeleted || e2tInstance.State == entities.RoutingManagerFailure {
+ m.logger.Warnf("#E2TInstancesManager.ResetKeepAliveTimestamp - Ignore. This Instance is about to deleted")
+ return nil
+
+ }
+
+ e2tInstance.KeepAliveTimestamp = time.Now().UnixNano()
+ err = m.rnibDataService.SaveE2TInstanceNoLogs(e2tInstance)
+
+ if err != nil {
+ m.logger.Errorf("#E2TInstancesManager.ResetKeepAliveTimestamp - E2T Instance address: %s - Failed saving E2TInstance. error: %s", e2tAddress, err)
+ return err
+ }
+
+ return nil
+}
\ No newline at end of file
+//
+// 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 managers
import (
rnibWriterMock.AssertExpectations(t)
}
+func TestResetKeepAliveTimestampGetInternalFailure(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ address := "10.10.2.15:9800"
+ e2tInstance := entities.NewE2TInstance(address)
+ rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, common.NewInternalError(errors.New("Error")))
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
+ err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
+ assert.NotNil(t, err)
+ rnibReaderMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
+func TestAResetKeepAliveTimestampSaveInternalFailure(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ address := "10.10.2.15:9800"
+ e2tInstance := entities.NewE2TInstance(address)
+ rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(common.NewInternalError(errors.New("Error")))
+
+ err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
+ assert.NotNil(t, err)
+}
+
+func TestResetKeepAliveTimestampSuccess(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ address := "10.10.2.15:9800"
+ e2tInstance := entities.NewE2TInstance(address)
+ rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+ rnibWriterMock.On("SaveE2TInstance", mock.Anything).Return(nil)
+
+ err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
+ assert.Nil(t, err)
+ rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
+ rnibWriterMock.AssertNumberOfCalls(t, "SaveE2TInstance", 1)
+}
+
+func TestResetKeepAliveTimestampToBeDeleted(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ address := "10.10.2.15:9800"
+ e2tInstance := entities.NewE2TInstance(address)
+ e2tInstance.State = entities.ToBeDeleted
+ rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+
+ err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
+ assert.Nil(t, err)
+ rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
+ rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
+func TestResetKeepAliveTimestampRoutingManagerFailure(t *testing.T) {
+ rnibReaderMock, rnibWriterMock, e2tInstancesManager := initE2TInstancesManagerTest(t)
+
+ address := "10.10.2.15:9800"
+ e2tInstance := entities.NewE2TInstance(address)
+ e2tInstance.State = entities.RoutingManagerFailure
+ rnibReaderMock.On("GetE2TInstance", address).Return(e2tInstance, nil)
+
+ err := e2tInstancesManager.ResetKeepAliveTimestamp(address)
+ assert.Nil(t, err)
+ rnibReaderMock.AssertCalled(t, "GetE2TInstance", address)
+ rnibWriterMock.AssertNotCalled(t, "SaveE2TInstance")
+}
+
func TestRemoveE2TInstance(t *testing.T) {
_, _, e2tInstancesManager := initE2TInstancesManagerTest(t)
e2tInstance1 := entities.NewE2TInstance(E2TAddress)
--- /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 managers
+
+import (
+ "e2mgr/configuration"
+ "e2mgr/logger"
+ "e2mgr/models"
+ "e2mgr/rmrCgo"
+ "e2mgr/services/rmrsender"
+ "time"
+)
+
+type E2TKeepAliveWorker struct {
+ logger *logger.Logger
+ e2tShutdownManager IE2TShutdownManager
+ e2TInstancesManager IE2TInstancesManager
+ rmrSender *rmrsender.RmrSender
+ config *configuration.Configuration
+}
+
+func NewE2TKeepAliveWorker(logger *logger.Logger, rmrSender *rmrsender.RmrSender, e2TInstancesManager IE2TInstancesManager, e2tShutdownManager IE2TShutdownManager, config *configuration.Configuration) E2TKeepAliveWorker {
+ return E2TKeepAliveWorker{
+ logger: logger,
+ e2tShutdownManager: e2tShutdownManager,
+ e2TInstancesManager: e2TInstancesManager,
+ rmrSender: rmrSender,
+ config: config,
+ }
+}
+
+func (h E2TKeepAliveWorker) Execute() {
+
+ h.logger.Infof("#E2TKeepAliveWorker.Execute - keep alive started")
+
+ ticker := time.NewTicker(time.Duration(h.config.KeepAliveDelayMs) * time.Millisecond)
+
+ for _= range ticker.C {
+
+ h.SendKeepAliveRequest()
+ h.E2TKeepAliveExpired()
+ }
+}
+
+func (h E2TKeepAliveWorker) E2TKeepAliveExpired() {
+
+ e2tInstances, err := h.e2TInstancesManager.GetE2TInstancesNoLogs()
+
+ if err != nil || len(e2tInstances) == 0 {
+ return
+ }
+
+ for _, e2tInstance := range e2tInstances {
+
+ delta := int64(time.Now().UnixNano()) - e2tInstance.KeepAliveTimestamp
+ timestampNanosec := int64(time.Duration(h.config.KeepAliveResponseTimeoutMs) * time.Millisecond)
+
+ if delta > timestampNanosec {
+
+ h.logger.Warnf("#E2TKeepAliveWorker.E2TKeepAliveExpired - e2t address: %s time expired, shutdown e2 instance", e2tInstance.Address)
+
+ h.e2tShutdownManager.Shutdown(e2tInstance)
+ }
+ }
+}
+
+func (h E2TKeepAliveWorker) SendKeepAliveRequest() {
+
+ request := models.RmrMessage{MsgType: rmrCgo.E2_TERM_KEEP_ALIVE_REQ}
+ h.rmrSender.SendWithoutLogs(&request)
+}
\ 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.
+//
+package managers
+
+import (
+ "e2mgr/configuration"
+ "e2mgr/logger"
+ "e2mgr/mocks"
+ "e2mgr/rmrCgo"
+ "e2mgr/services"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/mock"
+ "testing"
+ "time"
+)
+
+func initE2TKeepAliveTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TShutdownManagerMock, *E2TKeepAliveWorker) {
+ logger, err := logger.InitLogger(logger.DebugLevel)
+ if err != nil {
+ t.Errorf("#... - failed to initialize logger, error: %s", err)
+ }
+ config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3, KeepAliveResponseTimeoutMs: 400, KeepAliveDelayMs: 100}
+
+ readerMock := &mocks.RnibReaderMock{}
+ writerMock := &mocks.RnibWriterMock{}
+ e2tShutdownManagerMock := &mocks.E2TShutdownManagerMock{}
+
+ rnibDataService := services.NewRnibDataService(logger, config, readerMock, writerMock)
+ e2tInstancesManager := NewE2TInstancesManager(rnibDataService, logger)
+
+ rmrMessengerMock := &mocks.RmrMessengerMock{}
+ rmrSender := initRmrSender(rmrMessengerMock, logger)
+
+ e2tKeepAliveWorker := NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManagerMock, config)
+
+ return rmrMessengerMock, readerMock, writerMock, e2tShutdownManagerMock, &e2tKeepAliveWorker
+}
+
+func TestSendKeepAliveRequest(t *testing.T) {
+ rmrMessengerMock, _, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ rmrMessengerMock.On("SendMsg", mock.Anything, false).Return(&rmrCgo.MBuf{}, nil)
+
+ e2tKeepAliveWorker.SendKeepAliveRequest()
+
+ var payload, xAction []byte
+ req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
+
+ rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
+}
+
+func TestShutdownExpiredE2T_InternalError(t *testing.T) {
+ rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ readerMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")))
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ rmrMessengerMock.AssertNotCalled(t, "Shutdown")
+}
+
+func TestShutdownExpiredE2T_NoAddresses(t *testing.T) {
+ rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{}
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ rmrMessengerMock.AssertNotCalled(t, "Shutdown")
+}
+
+func TestShutdownExpiredE2T_NotExpired_InternalError(t *testing.T) {
+ rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{E2TAddress,E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+ e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+ e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+ readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, common.NewInternalError(errors.New("#reader.GetNodeb - Internal Error")))
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ rmrMessengerMock.AssertNotCalled(t, "Shutdown")
+}
+
+func TestShutdownExpiredE2T_NoE2T(t *testing.T) {
+ rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ readerMock.On("GetE2TAddresses").Return([]string{}, common.NewResourceNotFoundError("not found"))
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ rmrMessengerMock.AssertNotCalled(t, "Shutdown")
+}
+
+func TestShutdownExpiredE2T_NotExpired(t *testing.T) {
+ rmrMessengerMock, readerMock, _, _, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{E2TAddress,E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+ e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+ e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+ readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ rmrMessengerMock.AssertNotCalled(t, "Shutdown")
+}
+
+func TestShutdownExpiredE2T_One_E2TExpired(t *testing.T) {
+ _, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{E2TAddress,E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+
+ time.Sleep(time.Duration(400) * time.Millisecond)
+
+ e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+ e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+ readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
+ e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ e2tShutdownManagerMock.AssertNumberOfCalls(t, "Shutdown", 1)
+}
+
+func TestShutdownExpiredE2T_Two_E2TExpired(t *testing.T) {
+ _, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{E2TAddress,E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+
+ e2tInstance2 := entities.NewE2TInstance(E2TAddress2)
+ e2tInstance2.AssociatedRanList = []string{"test4","test5","test6", "test7"}
+
+ time.Sleep(time.Duration(400) * time.Millisecond)
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+ readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1, e2tInstance2}, nil)
+ e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
+ e2tShutdownManagerMock.On("Shutdown", e2tInstance2).Return(nil)
+
+ e2tKeepAliveWorker.E2TKeepAliveExpired()
+
+ e2tShutdownManagerMock.AssertNumberOfCalls(t, "Shutdown", 2)
+}
+
+func TestExecute_Two_E2TExpired(t *testing.T) {
+ rmrMessengerMock, readerMock, _, e2tShutdownManagerMock, e2tKeepAliveWorker := initE2TKeepAliveTest(t)
+
+ addresses := []string{E2TAddress,E2TAddress2}
+ e2tInstance1 := entities.NewE2TInstance(E2TAddress)
+ e2tInstance1.AssociatedRanList = []string{"test1","test2","test3"}
+
+ readerMock.On("GetE2TAddresses").Return(addresses, nil)
+ readerMock.On("GetE2TInstances",addresses).Return([]*entities.E2TInstance{e2tInstance1}, nil)
+ e2tShutdownManagerMock.On("Shutdown", e2tInstance1).Return(nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, false).Return(&rmrCgo.MBuf{}, nil)
+
+ go e2tKeepAliveWorker.Execute()
+
+ time.Sleep(time.Duration(500) * time.Millisecond)
+
+ var payload, xAction []byte
+ req := rmrCgo.NewMBuf(rmrCgo.E2_TERM_KEEP_ALIVE_REQ, 0, "", &payload, &xAction)
+
+ rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
+ e2tShutdownManagerMock.AssertCalled(t, "Shutdown", e2tInstance1)
+}
\ 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.
+//
+package managers
+
+import (
+ "e2mgr/logger"
+ "e2mgr/services"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+)
+
+
+type IE2TShutdownManager interface {
+ Shutdown(e2tInstance *entities.E2TInstance) error
+}
+
+type E2TShutdownManager struct {
+ logger *logger.Logger
+ rnibDataService services.RNibDataService
+ e2TInstancesManager IE2TInstancesManager
+}
+
+func NewE2TShutdownManager(logger *logger.Logger, rnibDataService services.RNibDataService, e2TInstancesManager IE2TInstancesManager) E2TShutdownManager {
+ return E2TShutdownManager{
+ logger: logger,
+ rnibDataService: rnibDataService,
+ e2TInstancesManager: e2TInstancesManager,
+ }
+}
+
+func (h E2TShutdownManager) Shutdown(e2tInstance *entities.E2TInstance) error{
+ h.logger.Infof("#E2TShutdownManager.Shutdown - E2T %s is Dead, RIP", e2tInstance.Address)
+
+ return nil
+}
updatedNodebInfo.ConnectionStatus = entities.ConnectionStatus_CONNECTING
updatedNodebInfo.ConnectionAttempts++
writerMock.On("UpdateNodebInfo", &updatedNodebInfo).Return(nil)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(&rmrCgo.MBuf{}, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, nil)
err := ranReconnectionManager.ReconnectRan(ranName)
assert.Nil(t, err)
readerMock.AssertCalled(t, "GetNodeb", ranName)
payload := e2pdus.PackedX2setupRequest
xaction := []byte(ranName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
t.Errorf("want: success, got: error: %s", err)
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).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err != nil {
t.Errorf("want: success, got: error: %s", err)
payload := []byte{0}
xaction := []byte(ranName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, fmt.Errorf("send failure"))
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
payload := []byte{0}
xaction := []byte(ranName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, fmt.Errorf("send failure"))
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
payload := []byte{0}
xaction := []byte(ranName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, fmt.Errorf("send failure"))
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, fmt.Errorf("send failure"))
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: failure, got: success")
payload := e2pdus.PackedX2setupRequest
xaction := []byte(ranName)
msg := rmrCgo.NewMBuf(rmrCgo.RIC_X2_SETUP_REQ, len(payload), ranName, &payload, &xaction)
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(msg, nil)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(msg, nil)
if err := mgr.ExecuteSetup(initialNodeb, entities.ConnectionStatus_CONNECTING); err == nil {
t.Errorf("want: error, got: success")
nodebInfo := entities.NodebInfo{NodeType: entities.Node_ENB}
var err error
- rmrMessengerMock.On("SendMsg", mock.Anything).Return(&rmrCgo.MBuf{}, err)
+ rmrMessengerMock.On("SendMsg", mock.Anything, true).Return(&rmrCgo.MBuf{}, err)
err = m.Execute(rmrCgo.RAN_CONNECTED, enums.RIC_TO_RAN, &nodebInfo)
assert.Nil(t, err)
return args.Get(0).([]*entities.E2TInstance), args.Error(1)
}
+
+func (m *E2TInstancesManagerMock) GetE2TInstancesNoLogs() ([]*entities.E2TInstance, error) {
+ args := m.Called()
+
+ return args.Get(0).([]*entities.E2TInstance), args.Error(1)
+}
+
+func (m *E2TInstancesManagerMock) ResetKeepAliveTimestamp(e2tAddress string) error {
+ args := m.Called(e2tAddress)
+ 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.
+//
+package mocks
+
+import (
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "github.com/stretchr/testify/mock"
+)
+
+type E2TShutdownManagerMock struct {
+ mock.Mock
+}
+
+func (m *E2TShutdownManagerMock) Shutdown(e2tInstance *entities.E2TInstance) error {
+ args := m.Called(e2tInstance)
+ return args.Error(0)
+}
\ No newline at end of file
return args.Get(0).(rmrCgo.RmrMessenger)
}
-func (m *RmrMessengerMock) SendMsg(msg *rmrCgo.MBuf) (*rmrCgo.MBuf, error){
- args := m.Called(msg)
+func (m *RmrMessengerMock) SendMsg(msg *rmrCgo.MBuf, printLogs bool) (*rmrCgo.MBuf, error){
+ args := m.Called(msg, printLogs)
return args.Get(0).(*rmrCgo.MBuf), args.Error(1)
}
+//
+// 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 models
type E2TermInitPayload struct {
--- /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 models
+
+type E2TKeepAlivePayload struct {
+ Address string `json:"address"`
+}
\ No newline at end of file
x2ResetResponseHandler := rmrmsghandlers.NewX2ResetResponseHandler(logger, rnibDataService, ranStatusChangeManager, x2ResetResponseExtractor)
x2ResetRequestNotificationHandler := rmrmsghandlers.NewX2ResetRequestNotificationHandler(logger, rnibDataService, ranStatusChangeManager, rmrSender)
e2TermInitNotificationHandler := rmrmsghandlers.NewE2TermInitNotificationHandler(logger, ranReconnectionManager, rnibDataService, e2tInstancesManager)
+ e2TKeepAliveResponseHandler := rmrmsghandlers.NewE2TKeepAliveResponseHandler(logger, rnibDataService, e2tInstancesManager)
provider.Register(rmrCgo.RIC_X2_SETUP_RESP, x2SetupResponseHandler)
provider.Register(rmrCgo.RIC_X2_SETUP_FAILURE, x2SetupFailureResponseHandler)
provider.Register(rmrCgo.RIC_X2_RESET_RESP, x2ResetResponseHandler)
provider.Register(rmrCgo.RIC_X2_RESET, x2ResetRequestNotificationHandler)
provider.Register(rmrCgo.RIC_E2_TERM_INIT, e2TermInitNotificationHandler)
+ provider.Register(rmrCgo.E2_TERM_KEEP_ALIVE_RESP, e2TKeepAliveResponseHandler)
}
{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.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)},
}
maxConnectionAttempts: 3
maxRnibConnectionAttempts: 3
rnibRetryIntervalMs: 10
+keepAliveResponseTimeoutMs: 1500
+keepAliveDelayMs: 500
return r
}
-func (ctx *Context) SendMsg(msg *MBuf) (*MBuf, error) {
+func (ctx *Context) SendMsg(msg *MBuf, printLogs bool) (*MBuf, error) {
ctx.checkContextInitialized()
ctx.Logger.Debugf("#rmrCgoApi.SendMsg - Going to send message. MBuf: %v", *msg)
allocatedCMBuf := ctx.getAllocatedCRmrMBuf(ctx.Logger, msg, ctx.MaxMsgSize)
return nil, errors.New(errorMessage)
}
- //TODO: if debug enabled
- transactionId := string(*msg.XAction)
- tmpTid := strings.TrimSpace(transactionId)
- ctx.Logger.Infof("[E2 Manager -> RMR] #rmrCgoApi.SendMsg - Going to send message %v for transaction id: %s", *msg, tmpTid)
+ if printLogs {
+ //TODO: if debug enabled
+ transactionId := string(*msg.XAction)
+ tmpTid := strings.TrimSpace(transactionId)
+ ctx.Logger.Infof("[E2 Manager -> RMR] #rmrCgoApi.SendMsg - Going to send message %v for transaction id: %s", *msg, tmpTid)
+ }
currCMBuf := C.rmr_send_msg(ctx.RmrCtx, allocatedCMBuf)
state = currCMBuf.state
- ctx.Logger.Debugf("#rmrCgoApi.SendMsg - The current message state: %v, message buffer:%v", state, currCMBuf)
if state != RMR_OK {
errorMessage := fmt.Sprintf("#rmrCgoApi.SendMsg - Failed to send message. state: %v - %s", state, states[int(state)])
return nil, errors.New(errorMessage)
}
- ctx.Logger.Debugf("#rmrCgoApi.SendMsg - The message has been sent successfully ")
return convertToMBuf(ctx.Logger, currCMBuf), nil
}
}
mbuf := convertToMBuf(ctx.Logger, currCMBuf)
- transactionId := string(*mbuf.XAction)
- tmpTid := strings.TrimSpace(transactionId)
- ctx.Logger.Infof("[RMR -> E2 Manager] #rmrCgoApi.RecvMsg - message %v has been received for transaction id: %s", *mbuf, tmpTid)
+
+ if mbuf.MType != E2_TERM_KEEP_ALIVE_RESP {
+
+ transactionId := string(*mbuf.XAction)
+ tmpTid := strings.TrimSpace(transactionId)
+ ctx.Logger.Infof("[RMR -> E2 Manager] #rmrCgoApi.RecvMsg - message %v has been received for transaction id: %s", *mbuf, tmpTid)
+ }
return mbuf, nil
}
}
msg := rmrCgo.NewMBuf(1, tests.MaxMsgSize, "test 1", &tests.DummyPayload, &tests.DummyXAction)
log.Debugf("#rmr_c_go_api_test.TestSendRecvMsgSuccess - Going to send the message: %#v\n", msg)
- result, err := msgr.SendMsg(msg)
+ result, err := msgr.SendMsg(msg, true)
assert.Nil(t, err)
assert.NotNil(t, result)
msg := rmrCgo.NewMBuf(10, tests.MaxMsgSize, "test 1", &tests.DummyPayload, &tests.DummyXAction)
log.Debugf("#rmr_c_go_api_test.TestSendMsgRmrInvalidMsgNumError - Going to send the message: %#v\n", msg)
- result, err := msgr.SendMsg(msg)
+ result, err := msgr.SendMsg(msg, true)
assert.NotNil(t, err)
assert.Nil(t, result)
msg := rmrCgo.NewMBuf(1, tests.MaxMsgSize, "test 1", &tests.DummyPayload, &tests.DummyXAction)
log.Debugf("#rmr_c_go_api_test.TestSendMsgRmrInvalidPortError - Going to send the message: %#v\n", msg)
- result, err := msgr.SendMsg(msg)
+ result, err := msgr.SendMsg(msg, true)
assert.NotNil(t, err)
assert.Nil(t, result)
RAN_CONNECTED = C.RAN_CONNECTED
RAN_RESTARTED = C.RAN_RESTARTED
RAN_RECONFIGURED = C.RAN_RECONFIGURED
+ E2_TERM_KEEP_ALIVE_REQ = C.E2_TERM_KEEP_ALIVE_REQ
+ E2_TERM_KEEP_ALIVE_RESP = C.E2_TERM_KEEP_ALIVE_RESP
)
const (
type RmrMessenger interface {
Init(port string, maxMsgSize int, flags int, logger *logger.Logger) RmrMessenger
- SendMsg(msg *MBuf) (*MBuf, error)
+ SendMsg(msg *MBuf, printLogs bool) (*MBuf, error)
RecvMsg() (*MBuf, error)
IsReady() bool
Close()
rte|1210|10.0.2.15:4801
rte|1220|10.0.2.15:4801
rte|10090|10.0.2.15:38000
+rte|1101|10.0.2.15:38000
newrt|end
func (r *RmrSender) Send(rmrMessage *models.RmrMessage) error {
msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
- _, err := r.messenger.SendMsg(msg)
+ _, err := r.messenger.SendMsg(msg, true)
if err != nil {
r.logger.Errorf("#RmrSender.Send - RAN name: %s , Message type: %d - Failed sending message. Error: %v", rmrMessage.RanName, rmrMessage.MsgType, err)
r.logger.Infof("#RmrSender.Send - RAN name: %s , Message type: %d - Successfully sent RMR message", rmrMessage.RanName, rmrMessage.MsgType)
return nil
}
+
+func (r *RmrSender) SendWithoutLogs(rmrMessage *models.RmrMessage) error {
+ msg := rmrCgo.NewMBuf(rmrMessage.MsgType, len(rmrMessage.Payload), rmrMessage.RanName, &rmrMessage.Payload, &rmrMessage.XAction)
+
+ _, err := r.messenger.SendMsg(msg, false)
+
+ if err != nil {
+ r.logger.Errorf("#RmrSender.Send - RAN name: %s , Message type: %d - Failed sending message. Error: %v", rmrMessage.RanName, rmrMessage.MsgType, err)
+ return err
+ }
+
+ return nil
+}
payload := []byte("some payload")
var xAction []byte
mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", mbuf).Return(&rmrCgo.MBuf{}, nil)
+ rmrMessengerMock.On("SendMsg", mbuf, true).Return(&rmrCgo.MBuf{}, nil)
rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction)
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
rmrSender := NewRmrSender(logger, rmrMessenger)
err := rmrSender.Send(rmrMsg)
assert.Nil(t, err)
- rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf, true)
}
payload := []byte("some payload")
var xAction []byte
mbuf := rmrCgo.NewMBuf(123, len(payload), ranName, &payload, &xAction)
- rmrMessengerMock.On("SendMsg", mbuf).Return(mbuf, fmt.Errorf("rmr send failure"))
+ rmrMessengerMock.On("SendMsg", mbuf, true).Return(mbuf, fmt.Errorf("rmr send failure"))
rmrMsg := models.NewRmrMessage(123, ranName, payload, xAction)
rmrMessenger := rmrCgo.RmrMessenger(rmrMessengerMock)
rmrSender := NewRmrSender(logger, rmrMessenger)
err := rmrSender.Send(rmrMsg)
- rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf)
+ rmrMessengerMock.AssertCalled(t, "SendMsg",mbuf, true)
assert.NotNil(t, err)
}
GetE2TAddresses() ([]string, error)
SaveE2TInstance(e2tInstance *entities.E2TInstance) error
SaveE2TAddresses(addresses []string) error
+ GetE2TInstanceNoLogs(address string) (*entities.E2TInstance, error)
+ GetE2TInstancesNoLogs(addresses []string) ([]*entities.E2TInstance, error)
+ SaveE2TInstanceNoLogs(e2tInstance *entities.E2TInstance) error
+ GetE2TAddressesNoLogs() ([]string, error)
}
type rNibDataService struct {
}
func (w *rNibDataService) GetE2TInstance(address string) (*entities.E2TInstance, error) {
-
var e2tInstance *entities.E2TInstance = nil
err := w.retry("GetE2TInstance", func() (err error) {
return e2tInstance, err
}
+func (w *rNibDataService) GetE2TInstanceNoLogs(address string) (*entities.E2TInstance, error) {
+ var e2tInstance *entities.E2TInstance = nil
+
+ err := w.retry("GetE2TInstance", func() (err error) {
+ e2tInstance, err = w.rnibReader.GetE2TInstance(address)
+ return
+ })
+
+ return e2tInstance, err
+}
+
func (w *rNibDataService) GetE2TInstances(addresses []string) ([]*entities.E2TInstance, error) {
w.logger.Infof("#RnibDataService.GetE2TInstances - addresses: %s", addresses)
var e2tInstances []*entities.E2TInstance = nil
return e2tInstances, err
}
+func (w *rNibDataService) GetE2TInstancesNoLogs(addresses []string) ([]*entities.E2TInstance, error) {
+
+ var e2tInstances []*entities.E2TInstance = nil
+
+ err := w.retry("GetE2TInstance", func() (err error) {
+ e2tInstances, err = w.rnibReader.GetE2TInstances(addresses)
+ return
+ })
+
+ return e2tInstances, err
+}
+
func (w *rNibDataService) GetE2TAddresses() ([]string, error) {
var e2tAddresses []string = nil
return e2tAddresses, err
}
+func (w *rNibDataService) GetE2TAddressesNoLogs() ([]string, error) {
+
+ var e2tAddresses []string = nil
+
+ err := w.retry("GetE2TAddresses", func() (err error) {
+ e2tAddresses, err = w.rnibReader.GetE2TAddresses()
+ return
+ })
+
+ return e2tAddresses, err
+}
+
func (w *rNibDataService) SaveE2TInstance(e2tInstance *entities.E2TInstance) error {
w.logger.Infof("#RnibDataService.SaveE2TInstance - E2T instance address: %s, state: %s, associated RANs count: %d, keep Alive ts: %d", e2tInstance.Address, e2tInstance.State, len(e2tInstance.AssociatedRanList), e2tInstance.KeepAliveTimestamp)
+
+ return w.SaveE2TInstanceNoLogs(e2tInstance)
+}
+
+func (w *rNibDataService) SaveE2TInstanceNoLogs(e2tInstance *entities.E2TInstance) error {
+
err := w.retry("SaveE2TInstance", func() (err error) {
err = w.rnibWriter.SaveE2TInstance(e2tInstance)
return
Code Review / ric-plt / e2mgr.git / commitdiff