ENV RMR_SEED_RT=router.txt
ENV RMR_VCTL_FILE=/tmp/rmr.verbose
EXPOSE 3800
-CMD ["sh", "-c", "./main -port=$port"]
+CMD ["sh", "-c", "./main -port=$port -f /etc/config/log-level.yaml"]
+
"e2mgr/services"
"e2mgr/services/rmrreceiver"
"e2mgr/services/rmrsender"
- "fmt"
+ //"fmt"
+ "flag"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
+ "github.com/spf13/viper"
+ "github.com/fsnotify/fsnotify"
"os"
"strconv"
)
const GeneralKeyDefaultValue = "{\"enableRic\":true}"
+const DEFAULT_CONFIG_FILE = "../resources/configuration.yaml"
+const DEFAULT_PORT = "8080"
+var Log *logger.Logger
func initKeys(logger *logger.Logger, sdl *sdlgo.SyncStorage) error {
ok, err := sdl.SetIfNotExists(common.GetRNibNamespace(), common.BuildGeneralConfigurationKey(), GeneralKeyDefaultValue)
return nil
}
+/**Dynamic log-level changes **/
+
+func loadConfig() {
+ viper.SetConfigFile(parseCmd())
+ if err := viper.ReadInConfig(); err != nil {
+ Log.Errorf("Error reading config file, %s", err)
+ }
+ Log.Infof("Using config file: %s\n", viper.ConfigFileUsed())
+ // Watch for config file changes and re-read data ...
+ watch()
+}
+func parseCmd() string {
+ var fileName *string
+ fileName = flag.String("f", DEFAULT_CONFIG_FILE, "Specify the configuration file.")
+ flag.String("port", DEFAULT_PORT, "Specify the port file.")
+ flag.Parse()
+
+ return *fileName
+}
+
+func watch() {
+ viper.WatchConfig()
+ viper.OnConfigChange(func(e fsnotify.Event) {
+ Log.Infof("config file changed %s", e.Name)
+ setLoglevel()
+ })
+}
+
+/*********MDC LOG CHNAGES ********/
+func setLoglevel() {
+ var loglevel int
+ if err := viper.UnmarshalKey("loglevel", &loglevel); err != nil {
+ Log.Errorf("Unmarshalling failed while reading %d", loglevel)
+ }
+
+ switch loglevel {
+ case 1:
+ Log.Infof("LOGLEVEL is set to ERROR\n")
+ case 2:
+ Log.Infof("LOGLEVEL is set to WARNING\n")
+ case 3:
+ Log.Infof("LOGLEVEL is set to INFO\n")
+ case 4:
+ Log.Infof("LOGLEVEL is set to DEBUG\n")
+ }
+ Log.SetLevel(loglevel)
+}
+
func main() {
config := configuration.ParseConfiguration()
- logLevel, _ := logger.LogLevelTokenToLevel(config.Logging.LogLevel)
- logger, err := logger.InitLogger(logLevel)
- if err != nil {
+ level := int8(4)
+ Log, _ = logger.InitLogger(level)
+ Log.SetFormat(0)
+ Log.SetMdc("e2mgr", "0.2.2")
+ /*if err != nil {
fmt.Printf("#app.main - failed to initialize logger, error: %s", err)
os.Exit(1)
- }
- logger.Infof("#app.main - Configuration %s", config)
+ }*/
+ Log.Infof("#app.main - Configuration %s", config)
+ loadConfig()
+
+ setLoglevel()
sdl := sdlgo.NewSyncStorage()
- err = initKeys(logger, sdl)
+ err := initKeys(Log, sdl)
if err != nil {
os.Exit(1)
}
defer sdl.Close()
- rnibDataService := services.NewRnibDataService(logger, config, reader.GetNewRNibReader(sdl), rNibWriter.GetRNibWriter(sdl, config.RnibWriter))
+ rnibDataService := services.NewRnibDataService(Log, config, reader.GetNewRNibReader(sdl), rNibWriter.GetRNibWriter(sdl, config.RnibWriter))
- ranListManager := managers.NewRanListManager(logger, rnibDataService)
+ ranListManager := managers.NewRanListManager(Log, rnibDataService)
err = ranListManager.InitNbIdentityMap()
if err != nil {
- logger.Errorf("#app.main - quit")
+ Log.Errorf("#app.main - quit")
os.Exit(1)
}
var msgImpl *rmrCgo.Context
- rmrMessenger := msgImpl.Init("tcp:"+strconv.Itoa(config.Rmr.Port), config.Rmr.MaxMsgSize, 0, logger)
- rmrSender := rmrsender.NewRmrSender(logger, rmrMessenger)
- e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, logger)
- routingManagerClient := clients.NewRoutingManagerClient(logger, config, clients.NewHttpClient())
- ranAlarmService := services.NewRanAlarmService(logger, config)
- ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(logger, rnibDataService, ranListManager, ranAlarmService)
- e2tAssociationManager := managers.NewE2TAssociationManager(logger, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
- e2tShutdownManager := managers.NewE2TShutdownManager(logger, config, rnibDataService, e2tInstancesManager, e2tAssociationManager, ranConnectStatusChangeManager)
- e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(logger, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
+ rmrMessenger := msgImpl.Init("tcp:"+strconv.Itoa(config.Rmr.Port), config.Rmr.MaxMsgSize, 0, Log)
+ rmrSender := rmrsender.NewRmrSender(Log, rmrMessenger)
+ e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, Log)
+ routingManagerClient := clients.NewRoutingManagerClient(Log, config, clients.NewHttpClient())
+ ranAlarmService := services.NewRanAlarmService(Log, config)
+ ranConnectStatusChangeManager := managers.NewRanConnectStatusChangeManager(Log, rnibDataService, ranListManager, ranAlarmService)
+ e2tAssociationManager := managers.NewE2TAssociationManager(Log, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager)
+ e2tShutdownManager := managers.NewE2TShutdownManager(Log, config, rnibDataService, e2tInstancesManager, e2tAssociationManager, ranConnectStatusChangeManager)
+ e2tKeepAliveWorker := managers.NewE2TKeepAliveWorker(Log, rmrSender, e2tInstancesManager, e2tShutdownManager, config)
rmrNotificationHandlerProvider := rmrmsghandlerprovider.NewNotificationHandlerProvider()
- rmrNotificationHandlerProvider.Init(logger, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
+ rmrNotificationHandlerProvider.Init(Log, config, rnibDataService, rmrSender, e2tInstancesManager, routingManagerClient, e2tAssociationManager, ranConnectStatusChangeManager, ranListManager)
- notificationManager := notificationmanager.NewNotificationManager(logger, rmrNotificationHandlerProvider)
- rmrReceiver := rmrreceiver.NewRmrReceiver(logger, rmrMessenger, notificationManager)
+ notificationManager := notificationmanager.NewNotificationManager(Log, rmrNotificationHandlerProvider)
+ rmrReceiver := rmrreceiver.NewRmrReceiver(Log, rmrMessenger, notificationManager)
nodebValidator := managers.NewNodebValidator()
- updateEnbManager := managers.NewUpdateEnbManager(logger, rnibDataService, nodebValidator)
- updateGnbManager := managers.NewUpdateGnbManager(logger, rnibDataService, nodebValidator)
+ updateEnbManager := managers.NewUpdateEnbManager(Log, rnibDataService, nodebValidator)
+ updateGnbManager := managers.NewUpdateGnbManager(Log, rnibDataService, nodebValidator)
e2tInstancesManager.ResetKeepAliveTimestampsForAllE2TInstances()
go rmrReceiver.ListenAndHandle()
go e2tKeepAliveWorker.Execute()
- httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
+ httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(Log, rmrSender, config, rnibDataService, e2tInstancesManager, routingManagerClient, ranConnectStatusChangeManager, nodebValidator, updateEnbManager, updateGnbManager, ranListManager)
rootController := controllers.NewRootController(rnibDataService)
- nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
- e2tController := controllers.NewE2TController(logger, httpMsgHandlerProvider)
- symptomController := controllers.NewSymptomdataController(logger, httpMsgHandlerProvider, rnibDataService, ranListManager)
- _ = httpserver.Run(logger, config.Http.Port, rootController, nodebController, e2tController, symptomController)
+ nodebController := controllers.NewNodebController(Log, httpMsgHandlerProvider)
+ e2tController := controllers.NewE2TController(Log, httpMsgHandlerProvider)
+ symptomController := controllers.NewSymptomdataController(Log, httpMsgHandlerProvider, rnibDataService, ranListManager)
+ //fmt.Println("loadconfig called at last")
+ //loadConfig()
+ _ = httpserver.Run(Log, config.Http.Port, rootController, nodebController, e2tController, symptomController)
+ //fmt.Println("loadconfig called at last")
+ //loadConfig()
}
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ level := int8(1)
+ log, err := logger.InitLogger(level)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
}
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
)
func setupNodebControllerTest(t *testing.T) (services.RNibDataService, *mocks.RnibReaderMock){
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
writer := httptest.NewRecorder()
rc.HandleHealthCheckRequest(writer, nil)
assert.Equal(t, http.StatusInternalServerError, writer.Result().StatusCode)
-}
\ No newline at end of file
+}
*/
func TestUnpackEndcX2SetupFailureResponseAndExtract(t *testing.T) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
var testCases = []struct {
response string
*/
func TestUnpackEndcX2SetupResponseAndExtract(t *testing.T) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(4)
+ logger, _ := logger.InitLogger(InfoLevel)
var testCases = []struct {
key *entities.GlobalNbId
*/
func TestUnpackX2SetupFailureResponseAndExtract(t *testing.T) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
var testCases = []struct {
response string
*/
func TestUnpackX2SetupResponseAndExtract(t *testing.T) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
var testCases = []struct {
key *entities.GlobalNbId
return nil, errors.New(fmt.Sprintf("unpacking error: %s", C.GoString(&errBuf[0])))
}
- if logger.DebugEnabled() {
+ //if logger.DebugEnabled() {
C.asn1_pdu_printer(pdu, C.size_t(len(errBuf)), &errBuf[0])
- logger.Debugf("#x2apPdu_asn1_unpacker.UnpackX2apPdu - PDU: %v packed size:%d", C.GoString(&errBuf[0]), packedBufferSize)
- }
+ //logger.Debugf("#x2apPdu_asn1_unpacker.UnpackX2apPdu - PDU: %v packed size:%d", C.GoString(&errBuf[0]), packedBufferSize)
+ //}
return pdu, nil
}
defer C.delete_pdu(pdu)
var refinedResponse = ""
- if logger.DebugEnabled() {
+ //if logger.DebugEnabled() {
buf := make([]C.char, 16*maxMessageBufferSize)
C.asn1_pdu_printer(pdu, C.size_t(len(buf)), &buf[0])
refinedResponse = C.GoString(&buf[0])
- }
+ //}
return &X2PduRefinedResponse{PduPrint: refinedResponse}, nil
}
*/
func TestUnpackX2apSetupResponse(t *testing.T) {
- logger, _ := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, _ := logger.InitLogger(DebugLevel)
wantPduAsStr := `SuccessfulOutcome ::= {
procedureCode: 6
/*unpacking error*/
func TestUnpackX2apSetupResponseUnpackError(t *testing.T) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
wantError := "unpacking error: #src/asn1codec_utils.c.unpack_pdu_aux - Failed to decode E2AP-PDU (consumed 0), error = 0 Success"
//--------------------2006002a
)
func TestPrepareEndcConfigurationUpdateFailurePDU(t *testing.T) {
- _,err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _,err := logger.InitLogger(InfoLevel)
if err!=nil{
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareEndcConfigurationUpdateFailurePDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2EnbConfigurationUpdateFailurePDU(t *testing.T) {
- _,err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _,err := logger.InitLogger(InfoLevel)
if err!=nil{
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2EnbConfigurationUpdateFailurePDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareEndcConfigurationUpdateAckPDU(t *testing.T) {
- _,err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _,err := logger.InitLogger(InfoLevel)
if err!=nil{
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareEndcConfigurationUpdateAckPDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2EnbConfigurationUpdateAckPDU(t *testing.T) {
- _,err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _,err := logger.InitLogger(InfoLevel)
if err!=nil{
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2EnbConfigurationUpdateAckPDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
if !strings.Contains(err.Error(), expected) {
t.Errorf("want :[%s], got: [%s]\n", expected, err)
}
-}
\ No newline at end of file
+}
)
func TestKnownCausesToX2ResetPDU(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestKnownCausesToX2ResetPDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2ResetPDUsFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
)
func TestPrepareX2ResetResponsePDU(t *testing.T) {
- _,err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ _,err := logger.InitLogger(InfoLevel)
if err!=nil{
t.Errorf("failed to initialize logger, error: %s", err)
}
}
func TestPrepareX2ResetResponsePDUFailure(t *testing.T) {
- _, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel:= int8(3)
+ _, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("failed to initialize logger, error: %s", err)
}
if !strings.Contains(err.Error(), expected) {
t.Errorf("want :[%s], got: [%s]\n", expected, err)
}
-}
\ No newline at end of file
+}
module e2mgr
require (
+ gerrit.o-ran-sc.org/r/com/golog v0.0.2
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.2.1
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.2.8
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader v1.2.1
gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.8.0
+ github.com/fsnotify/fsnotify v1.4.9
github.com/golang/protobuf v1.4.2
github.com/gorilla/mux v1.7.0
github.com/magiconair/properties v1.8.1
github.com/pkg/errors v0.8.1
github.com/spf13/viper v1.4.0
github.com/stretchr/testify v1.5.1
- go.uber.org/zap v1.11.0
gopkg.in/yaml.v2 v2.3.0
)
require (
github.com/davecgh/go-spew v1.1.1 // indirect
- github.com/fsnotify/fsnotify v1.4.9 // indirect
github.com/go-redis/redis v6.15.9+incompatible // indirect
github.com/hashicorp/hcl v1.0.0 // indirect
github.com/kr/pretty v0.2.0 // indirect
github.com/spf13/jwalterweatherman v1.1.0 // indirect
github.com/spf13/pflag v1.0.5 // indirect
github.com/stretchr/objx v0.2.0 // indirect
- go.uber.org/atomic v1.4.0 // indirect
- go.uber.org/multierr v1.2.0 // indirect
golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 // indirect
golang.org/x/text v0.3.2 // indirect
google.golang.org/protobuf v1.23.0 // indirect
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
+ k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 // indirect
)
replace gerrit.o-ran-sc.org/r/ric-plt/sdlgo => gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.8.0
+replace gerrit.o-ran-sc.org/r/com/golog => gerrit.o-ran-sc.org/r/com/golog.git v0.0.2
+
go 1.18
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+gerrit.o-ran-sc.org/r/com/golog.git v0.0.2 h1:Ix6SgFuzd6yW6Ur6+qDlGhDO65UYs8PiIkeAL1VaQ2o=
+gerrit.o-ran-sc.org/r/com/golog.git v0.0.2/go.mod h1:A7hUL52YQSO4dFIZNcj76XQ09C9PftAe3LyL7kqBnok=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.2.1 h1:3FFbXx55BODThXfyWAiz6cPXVELXFICDQUmJi13EoxM=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common v1.2.1/go.mod h1:QJ1uPPZosGbhxUWpUpeM5fLqFHdnWTrVnvW2DgyOCes=
gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities v1.2.1/go.mod h1:YaQ+XEI4PcAoISxp9wUpUr2TP0J7JihpQTD0G1Lpd4A=
github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
-go.uber.org/atomic v1.4.0 h1:cxzIVoETapQEqDhQu3QfnvXAV4AlzcvUCxkVUFw3+EU=
go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/multierr v1.2.0 h1:6I+W7f5VwC5SV9dNrZ3qXrDB9mD0dyGOi/ZJmYw03T4=
-go.uber.org/multierr v1.2.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-go.uber.org/zap v1.11.0 h1:gSmpCfs+R47a4yQPAI4xJ0IPDLTRGXskm6UelqNXpqE=
-go.uber.org/zap v1.11.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+k8s.io/utils v0.0.0-20230406110748-d93618cff8a2 h1:qY1Ad8PODbnymg2pRbkyMT/ylpTrCM8P2RJ0yroCyIk=
+k8s.io/utils v0.0.0-20230406110748-d93618cff8a2/go.mod h1:OLgZIPagt7ERELqWJFomSt595RzquPNLL48iOWgYOg0=
}
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ log, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
}
)
func setupUpdateNodebRequestHandlerTest(t *testing.T) ( *UpdateNodebRequestHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock){
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
)
func setupLostConnectionHandlerTest(isSuccessfulHttpPost bool) (*RanLostConnectionHandler, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.HttpClientMock) {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
config := &configuration.Configuration{
RnibRetryIntervalMs: 10,
MaxRnibConnectionAttempts: 3,
}
func NewSetupResponseTestContext(manager managers.ISetupResponseManager) *setupResponseTestContext {
- logger, _ := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ logger, _ := logger.InitLogger(InfoLevel)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
readerMock := &mocks.RnibReaderMock{}
writerMock := &mocks.RnibWriterMock{}
)
func initX2ResetResponseHandlerTest(t *testing.T) (X2ResetResponseHandler, *mocks.RnibReaderMock, *mocks.RmrMessengerMock) {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
if err != nil {
t.Errorf("#initX2ResetResponseHandlerTest - failed to initialize logger, error: %s", err)
}
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
}
package logger
import (
- "fmt"
- "go.uber.org/zap"
- "go.uber.org/zap/zapcore"
- "strings"
+ mdclog "gerrit.o-ran-sc.org/r/com/golog"
"time"
)
type Logger struct {
- Logger *zap.Logger
+ logger *mdclog.MdcLogger
}
-// Copied from zap logger
-//
-// A Level is a logging priority. Higher levels are more important.
-type LogLevel int8
-
-const (
- // DebugLevel logs are typically voluminous, and are usually disabled in
- // production.
- DebugLevel LogLevel = iota - 1
- // InfoLevel is the default logging priority.
- InfoLevel
- // WarnLevel logs are more important than Info, but don't need individual
- // human review.
- WarnLevel
- // ErrorLevel logs are high-priority. If an application is running smoothly,
- // it shouldn't generate any error-level logs.
- ErrorLevel
- // DPanicLevel logs are particularly important errors. In development the
- // logger panics after writing the message.
- DPanicLevel
- // PanicLevel logs a message, then panics.
- PanicLevel
- // FatalLevel logs a message, then calls os.Exit(1).
- FatalLevel
-
- _minLevel = DebugLevel
- _maxLevel = FatalLevel
-)
-
-var logLevelTokenToLevel = map[string] LogLevel {
- "debug" : DebugLevel,
- "info": InfoLevel,
- "warn": WarnLevel,
- "error": ErrorLevel,
- "dpanic": DPanicLevel,
- "panic": PanicLevel,
- "fatal": FatalLevel,
-}
-
-func LogLevelTokenToLevel(level string) (LogLevel, bool) {
- if level, ok := logLevelTokenToLevel[strings.TrimSpace(strings.ToLower(level))];ok {
- return level, true
- }
- return _maxLevel+1, false
-}
-
-func InitLogger(requested LogLevel) (*Logger, error) {
- var logger *zap.Logger
- var err error
- switch requested {
- case DebugLevel:
- logger, err = initLoggerByLevel(zapcore.DebugLevel)
- case InfoLevel:
- logger, err = initLoggerByLevel(zapcore.InfoLevel)
- case WarnLevel:
- logger, err = initLoggerByLevel(zapcore.WarnLevel)
- case ErrorLevel:
- logger, err = initLoggerByLevel(zapcore.ErrorLevel)
- case DPanicLevel:
- logger, err = initLoggerByLevel(zapcore.DPanicLevel)
- case PanicLevel:
- logger, err = initLoggerByLevel(zapcore.PanicLevel)
- case FatalLevel:
- logger, err = initLoggerByLevel(zapcore.FatalLevel)
- default:
- err = fmt.Errorf("Invalid logging Level :%d",requested)
- }
- if err != nil {
- return nil, err
- }
- return &Logger{Logger:logger}, nil
-
-}
-func(l *Logger)Sync() error {
- l.Debugf("#logger.Sync - Going to flush buffered log")
- return l.Logger.Sync()
+func InitLogger(loglevel int8 ) (*Logger, error) {
+ name := "e2mgr"
+ log ,err:= NewLogger(name)
+ return log,err
}
-func (l *Logger)Infof(formatMsg string, a ...interface{}) {
- if l.InfoEnabled() {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Info(msg, zap.Any("mdc", l.getTimeStampMdc()))
- }
+func NewLogger(name string) (*Logger, error) {
+ l,err:= mdclog.InitLogger(name)
+ return &Logger{
+ logger: l,
+ },err
}
-func (l *Logger)Debugf(formatMsg string, a ...interface{}) {
- if l.DebugEnabled(){
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Debug(msg, zap.Any("mdc", l.getTimeStampMdc()))
- }
+func (l *Logger) SetFormat(logMonitor int) {
+ l.logger.Mdclog_format_initialize(logMonitor)
}
-func (l *Logger)Errorf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Error(msg, zap.Any("mdc", l.getTimeStampMdc()))
+func (l *Logger) SetLevel(level int) {
+ l.logger.LevelSet(mdclog.Level(level))
}
-func (l *Logger)Warnf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Warn(msg, zap.Any("mdc", l.getTimeStampMdc()))
+func (l *Logger) SetMdc(key string, value string) {
+ l.logger.MdcAdd(key, value)
}
-func (l *Logger) getTimeStampMdc() map[string]string {
- timeStr := time.Now().Format("2006-01-02 15:04:05.000")
- mdc := map[string]string{"time": timeStr}
- return mdc
+func (l *Logger) Errorf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Error(pattern, args...)
}
-func (l *Logger)InfoEnabled()bool{
- return l.Logger.Core().Enabled(zap.InfoLevel)
+func (l *Logger) Warnf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Warning(pattern, args...)
}
-func (l *Logger)DebugEnabled()bool{
- return l.Logger.Core().Enabled(zap.DebugLevel)
+func (l *Logger) Infof(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Info(pattern, args...)
}
-func (l *Logger)DPanicf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.DPanic(msg, zap.Any("mdc", l.getTimeStampMdc()))
+func (l *Logger) Debugf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Debug(pattern, args...)
}
-
-func initLoggerByLevel(l zapcore.Level) (*zap.Logger, error) {
- cfg := zap.Config{
- Encoding: "json",
- Level: zap.NewAtomicLevelAt(l),
- OutputPaths: []string{"stdout"},
- ErrorOutputPaths: []string{"stderr"},
- EncoderConfig: zapcore.EncoderConfig{
- MessageKey: "msg",
-
- LevelKey: "crit",
- EncodeLevel: zapcore.CapitalLevelEncoder,
-
- TimeKey: "ts",
- EncodeTime: epochMillisIntegerTimeEncoder,
-
- CallerKey: "id",
- EncodeCaller: e2ManagerCallerEncoder,
- },
- }
- return cfg.Build()
-}
-
-func e2ManagerCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
- enc.AppendString("E2Manager")
-}
-
-func epochMillisIntegerTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
- nanos := t.UnixNano()
- millis := int64(nanos) / int64(time.Millisecond)
- enc.AppendInt64(millis)
-}
-
+++ /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 logger
-
-import (
- "bytes"
- "github.com/stretchr/testify/assert"
- "go.uber.org/zap"
- "go.uber.org/zap/zapcore"
- "io"
- "os"
- "testing"
-)
-
-func TestInitDebugLoggerSuccess(t *testing.T) {
- log, err := InitLogger(DebugLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.DebugLevel))
-}
-
-func TestInitInfoLoggerSuccess(t *testing.T) {
- log, err := InitLogger(InfoLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.InfoLevel))
-}
-
-func TestInitWarnLoggerSuccess(t *testing.T) {
- log, err := InitLogger(WarnLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.WarnLevel))
-}
-
-func TestInitErrorLoggerSuccess(t *testing.T) {
- log, err := InitLogger(ErrorLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.ErrorLevel))
-}
-
-func TestInitDPanicLoggerSuccess(t *testing.T) {
- log, err := InitLogger(DPanicLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.DPanicLevel))
-}
-
-func TestInitPanicLoggerSuccess(t *testing.T) {
- log, err := InitLogger(PanicLevel)
- assert.Nil(t, err)
- assert.NotNil(t, log)
- assert.True(t, log.Logger.Core().Enabled(zap.PanicLevel))
-}
-
-func TestInitInfoLoggerFailure(t *testing.T) {
- log, err := InitLogger(99)
- assert.NotNil(t, err)
- assert.Nil(t, log)
-}
-
-func TestSyncSuccess(t *testing.T){
- logFile, err := os.Create("./loggerTest.txt")
- if err != nil{
- t.Errorf("logger_test.TestSyncSuccess - failed to create file, error: %s", err)
- }
- old := os.Stdout
- os.Stdout = logFile
- log, err := InitLogger(DebugLevel)
- if err != nil {
- t.Errorf("logger_test.TestSyncSuccess - failed to initialize logger, error: %s", err)
- }
- err = log.Sync()
- assert.Nil(t, err)
-
- os.Stdout = old
- logFile, err = os.Open("./loggerTest.txt")
- if err != nil{
- t.Errorf("logger_test.TestSyncSuccess - failed to open file, error: %s", err)
- }
- var buf bytes.Buffer
- _, err = io.Copy(&buf, logFile)
- if err != nil {
- t.Errorf("logger_test.TestSyncSuccess - failed to copy bytes, error: %s", err)
- }
- debugRecord,_ :=buf.ReadString('\n')
- errorRecord,_ :=buf.ReadString('\n')
-
- assert.NotEmpty(t, debugRecord)
- assert.Empty(t, errorRecord)
- err = os.Remove("./loggerTest.txt")
- if err != nil {
- t.Errorf("logger_test.TestSyncSuccess - failed to remove file, error: %s", err)
- }
-
-}
-
-func TestSyncFailure(t *testing.T){
- log, err := InitLogger(DebugLevel)
- err = log.Sync()
- assert.NotNil(t, err)
-}
-
-func TestDebugEnabledFalse(t *testing.T){
- entryNum, log := countRecords(InfoLevel, t)
- assert.False(t, log.DebugEnabled())
- assert.Equal(t,3, entryNum)
-}
-
-func TestDebugEnabledTrue(t *testing.T){
- entryNum, log := countRecords(DebugLevel, t)
- assert.True(t, log.DebugEnabled())
- assert.Equal(t,4, entryNum)
-}
-
-func TestDPanicfDebugLevel(t *testing.T){
- assert.True(t,validateRecordExists(DebugLevel, zap.DPanicLevel, t))
-}
-
-func TestDPanicfInfoLevel(t *testing.T){
- assert.True(t,validateRecordExists(InfoLevel, zap.DPanicLevel, t))
-}
-
-func TestErrorfDebugLevel(t *testing.T) {
- assert.True(t,validateRecordExists(DebugLevel, zap.ErrorLevel, t))
-}
-
-func TestErrorfInfoLevel(t *testing.T) {
- assert.True(t,validateRecordExists(InfoLevel, zap.ErrorLevel, t))
-}
-
-func TestInfofDebugLevel(t *testing.T) {
- assert.True(t,validateRecordExists(DebugLevel, zap.InfoLevel, t))
-}
-
-func TestInfofInfoLevel(t *testing.T) {
- assert.True(t,validateRecordExists(InfoLevel, zap.InfoLevel, t))
-}
-
-func TestDebugfDebugLevel(t *testing.T) {
- assert.True(t,validateRecordExists(DebugLevel, zap.DebugLevel, t))
-}
-
-func TestDebugfInfoLevel(t *testing.T) {
- assert.False(t,validateRecordExists(InfoLevel, zap.DebugLevel, t))
-}
-
-func TestInfofFatalLevel(t *testing.T) {
- assert.False(t,validateRecordExists(FatalLevel, zap.InfoLevel, t))
-}
-
-func TestDebugfFatalLevel(t *testing.T) {
- assert.False(t,validateRecordExists(FatalLevel, zap.DebugLevel, t))
-}
-
-func TestWarnfWarnLevel(t *testing.T) {
- assert.True(t,validateRecordExists(WarnLevel, zap.WarnLevel, t))
-}
-
-func TestWarnfDebugLevel(t *testing.T) {
- assert.True(t,validateRecordExists(DebugLevel, zap.WarnLevel, t))
-}
-
-func TestWarnfInfoLevel(t *testing.T) {
- assert.True(t,validateRecordExists(InfoLevel, zap.WarnLevel, t))
-}
-
-func TestWarnfFatalLevel(t *testing.T) {
- assert.False(t,validateRecordExists(FatalLevel, zap.WarnLevel, t))
-}
-
-func TestLogLevelTokenToLevel(t *testing.T) {
- level, ok := LogLevelTokenToLevel("deBug")
- assert.True(t, ok)
- assert.True(t, level == DebugLevel)
-
- level, ok = LogLevelTokenToLevel("infO")
- assert.True(t, ok)
- assert.True(t, level == InfoLevel)
-
- level, ok = LogLevelTokenToLevel("Warn")
- assert.True(t, ok)
- assert.True(t, level == WarnLevel)
-
- level, ok = LogLevelTokenToLevel("eRror")
- assert.True(t, ok)
- assert.True(t, level == ErrorLevel)
-
- level, ok = LogLevelTokenToLevel("Dpanic ")
- assert.True(t, ok)
- assert.True(t, level == DPanicLevel)
-
- level, ok = LogLevelTokenToLevel(" panic ")
- assert.True(t, ok)
- assert.True(t, level == PanicLevel)
-
- level, ok = LogLevelTokenToLevel("fatal")
- assert.True(t, ok)
- assert.True(t, level == FatalLevel)
-
- level, ok = LogLevelTokenToLevel("zzz")
- assert.False(t, ok)
- assert.True(t, level > FatalLevel)
-
-}
-func countRecords(logLevel LogLevel, t *testing.T) (int, *Logger){
- old := os.Stdout
- r, w, _ :=os.Pipe()
- os.Stdout = w
- log, err := InitLogger(logLevel)
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err)
- }
- log.Infof("%v, %v, %v", 1, "abc", 0.1)
- log.Debugf("%v, %v, %v", 1, "abc", 0.1)
- log.Errorf("%v, %v, %v", 1, "abc", 0.1)
- log.DPanicf("%v, %v, %v", 1, "abc", 0.1)
- err = w.Close()
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err)
- }
- os.Stdout = old
- var buf bytes.Buffer
- _, err = io.Copy(&buf, r)
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err)
- }
- entryNum := 0
- s,_:= buf.ReadString('\n')
- for len(s) > 0{
- entryNum +=1
- s,_= buf.ReadString('\n')
- }
- return entryNum, log
-}
-
-func validateRecordExists(logLevel LogLevel, recordLevel zapcore.Level, t *testing.T) bool {
- old := os.Stdout
- r, w, _ :=os.Pipe()
- os.Stdout = w
- log, err := InitLogger(logLevel)
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to initialize logger, error: %s", err)
- }
- switch recordLevel{
- case zap.DebugLevel:
- log.Debugf("%v, %v, %v", 1, "abc", 0.1)
- case zap.InfoLevel:
- log.Infof("%v, %v, %v", 1, "abc", 0.1)
- case zap.WarnLevel:
- log.Warnf("%v, %v, %v", 1, "abc", 0.1)
- case zap.ErrorLevel:
- log.Errorf("%v, %v, %v", 1, "abc", 0.1)
- case zap.DPanicLevel:
- log.DPanicf("%v, %v, %v", 1, "abc", 0.1)
- }
- err = w.Close()
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to close writer, error: %s", err)
- }
- os.Stdout = old
- var buf bytes.Buffer
- _, err = io.Copy(&buf, r)
- if err != nil {
- t.Errorf("logger_test.TestSyncFailure - failed to copy bytes, error: %s", err)
- }
- entryNum := 0
- s,_:= buf.ReadString('\n')
- for len(s) > 0{
- entryNum +=1
- s,_= buf.ReadString('\n')
- }
- return entryNum == 1
-}
\ No newline at end of file
)\r
\r
func initE2ResetStatusChangeTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *RanResetManager) {\r
- logger, err := logger.InitLogger(logger.DebugLevel)\r
+ DebugLevel := int8(4)\r
+ logger, err := logger.InitLogger(DebugLevel)\r
if err != nil {\r
t.Errorf("#... - failed to initialize logger, error: %s", err)\r
}\r
const PodName = "som_ pod_name"
func initE2TInstancesManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, *E2TInstancesManager) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
)
func initE2TKeepAliveTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *mocks.E2TShutdownManagerMock, *E2TKeepAliveWorker) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
rmrMessengerMock.AssertCalled(t, "SendMsg", req, false)
e2tShutdownManagerMock.AssertCalled(t, "Shutdown", e2tInstance1)
-}
\ No newline at end of file
+}
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
const EventChannelForTest = "RAN_CONNECTION_STATUS_CHANGE"
func initRanConnectStatusChangeManagerTest(t *testing.T) (*mocks.RnibWriterMock, *mocks.RanListManagerMock, *mocks.RanAlarmServiceMock, *RanConnectStatusChangeManager) {
- log, err := logger.InitLogger(logger.DebugLevel)
+ Debug := int8(4)
+ log, err := logger.InitLogger(Debug)
if err != nil {
t.Errorf("#... - failed to initialize log, error: %s", err)
}
const e2tAddress = "10.10.2.15:9800"
func initRanLostConnectionTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock, *mocks.RnibReaderMock, *mocks.RnibWriterMock, *RanDisconnectionManager, *mocks.HttpClientMock) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
)
func initRanListManagerTest(t *testing.T) (*mocks.RnibReaderMock, *mocks.RnibWriterMock, RanListManager) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Fatalf("#... - failed to initialize logger, error: %s", err)
}
)
func initRanSetupManagerTest(t *testing.T) (*mocks.RmrMessengerMock, *mocks.RnibWriterMock, *RanSetupManager) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
}
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
}
)
func initRanStatusChangeManagerTest(t *testing.T) (*logger.Logger, *mocks.RmrMessengerMock, *rmrsender.RmrSender) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Fatalf("#initStatusChangeManagerTest - failed to initialize logger, error: %s", err)
}
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
)
func initUpdateEnbManagerTest(t *testing.T) (*UpdateEnbManager, *logger.Logger, services.RNibDataService, *NodebValidator) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
)
func initUpdateGnbManagerTest(t *testing.T) (*UpdateGnbManager, *logger.Logger, services.RNibDataService, *NodebValidator) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
}
func TestGetMessageAsBytes(t *testing.T){
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#nodeb_controller_test.TestHandleRequestSuccess - failed to initialize logger, error: %s", err)
}
e2 := models.NewE2RequestMessage(transactionId, tests.RanIp, uint16(tests.Port), tests.RanName, tests.DummyPayload)
bytes := e2.GetMessageAsBytes(log)
assert.Equal(t, expectedMessageAsBytesHex, hex.EncodeToString(bytes))
-}
\ No newline at end of file
+}
}
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#delete_all_request_handler_test.TestHandleSuccessFlow - failed to initialize logger, error: %s", err)
}
}*/
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ log, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#rmr_c_go_api_test.initLog - failed to initialize logger, error: %s", err)
}
//TODO: change to assert or return error
func (ctx *Context) checkContextInitialized() {
if ctx.RmrCtx == nil {
- if ctx.Logger != nil {
+ /*if ctx.Logger != nil {
ctx.Logger.DPanicf("#rmrCgoUtils.checkContextInitialized - The RMR router has not been initialized")
- }
+ }*/
panic("#rmrCgoUtils.checkContextInitialized - The RMR router has not been initialized. To initialize router please call Init() method")
}
}
func RanAlarmServiceTest(t *testing.T) (RanAlarmService, *logger.Logger, *configuration.Configuration) {
-
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
)
func TestListenAndHandle(t *testing.T) {
- log, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ log, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#rmr_service_test.TestListenAndHandle - failed to initialize logger, error: %s", err)
}
// TODO: extract to test_utils
func initLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(3)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Fatalf("#initLog - failed to initialize logger, error: %s", err)
}
}
func setupRnibDataServiceTestWithMaxAttempts(t *testing.T, maxAttempts int) (*rNibDataService, *mocks.RnibReaderMock, *mocks.RnibWriterMock) {
- logger, err := logger.InitLogger(logger.DebugLevel)
+ DebugLevel := int8(4)
+ logger, err := logger.InitLogger(DebugLevel)
if err != nil {
t.Errorf("#... - failed to initialize logger, error: %s", err)
}
)
func InitLog(t *testing.T) *logger.Logger {
- log, err := logger.InitLogger(logger.InfoLevel)
+ InfoLevel := int8(1)
+ log, err := logger.InitLogger(InfoLevel)
if err != nil {
t.Errorf("#test.utils.InitLog - failed to initialize logger, error: %s", err)
}
// 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 logger
import (
- "fmt"
- "go.uber.org/zap"
- "go.uber.org/zap/zapcore"
- "strings"
+ mdclog "gerrit.o-ran-sc.org/r/com/golog"
"time"
)
type Logger struct {
- Logger *zap.Logger
-}
-
-// Copied from zap logger
-//
-// A Level is a logging priority. Higher levels are more important.
-type LogLevel int8
-
-const (
- // DebugLevel logs are typically voluminous, and are usually disabled in
- // production.
- DebugLevel LogLevel = iota - 1
- // InfoLevel is the default logging priority.
- InfoLevel
- // WarnLevel logs are more important than Info, but don't need individual
- // human review.
- WarnLevel
- // ErrorLevel logs are high-priority. If an application is running smoothly,
- // it shouldn't generate any error-level logs.
- ErrorLevel
- // DPanicLevel logs are particularly important errors. In development the
- // logger panics after writing the message.
- DPanicLevel
- // PanicLevel logs a message, then panics.
- PanicLevel
- // FatalLevel logs a message, then calls os.Exit(1).
- FatalLevel
-
- _minLevel = DebugLevel
- _maxLevel = FatalLevel
-)
-
-var logLevelTokenToLevel = map[string] LogLevel {
- "debug" : DebugLevel,
- "info": InfoLevel,
- "warn": WarnLevel,
- "error": ErrorLevel,
- "dpanic": DPanicLevel,
- "panic": PanicLevel,
- "fatal": FatalLevel,
+ logger *mdclog.MdcLogger
}
-func LogLevelTokenToLevel(level string) (LogLevel, bool) {
- if level, ok := logLevelTokenToLevel[strings.TrimSpace(strings.ToLower(level))];ok {
- return level, true
- }
- return _maxLevel+1, false
+func InitLogger(loglevel int8 ) (*Logger, error) {
+ name := "e2mgr"
+ log ,err:= NewLogger(name)
+ return log,err
}
-func InitLogger(requested LogLevel) (*Logger, error) {
- var logger *zap.Logger
- var err error
- switch requested {
- case DebugLevel:
- logger, err = initLoggerByLevel(zapcore.DebugLevel)
- case InfoLevel:
- logger, err = initLoggerByLevel(zapcore.InfoLevel)
- case WarnLevel:
- logger, err = initLoggerByLevel(zapcore.WarnLevel)
- case ErrorLevel:
- logger, err = initLoggerByLevel(zapcore.ErrorLevel)
- case DPanicLevel:
- logger, err = initLoggerByLevel(zapcore.DPanicLevel)
- case PanicLevel:
- logger, err = initLoggerByLevel(zapcore.PanicLevel)
- case FatalLevel:
- logger, err = initLoggerByLevel(zapcore.FatalLevel)
- default:
- err = fmt.Errorf("Invalid logging Level :%d",requested)
- }
- if err != nil {
- return nil, err
- }
- return &Logger{Logger:logger}, nil
-
-}
-func(l *Logger)Sync() error {
- l.Debugf("#logger.Sync - Going to flush buffered log")
- return l.Logger.Sync()
+func NewLogger(name string) (*Logger, error) {
+ l,err:= mdclog.InitLogger(name)
+ return &Logger{
+ logger: l,
+ },err
}
-func (l *Logger)Infof(formatMsg string, a ...interface{}) {
- if l.InfoEnabled() {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Info(msg, zap.Any("mdc", l.getTimeStampMdc()))
- }
+func (l *Logger) SetFormat(logMonitor int) {
+ l.logger.Mdclog_format_initialize(logMonitor)
}
-func (l *Logger)Debugf(formatMsg string, a ...interface{}) {
- if l.DebugEnabled(){
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Debug(msg, zap.Any("mdc", l.getTimeStampMdc()))
- }
+func (l *Logger) SetLevel(level int) {
+ l.logger.LevelSet(mdclog.Level(level))
}
-func (l *Logger)Errorf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Error(msg, zap.Any("mdc", l.getTimeStampMdc()))
+func (l *Logger) SetMdc(key string, value string) {
+ l.logger.MdcAdd(key, value)
}
-func (l *Logger)Warnf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.Warn(msg, zap.Any("mdc", l.getTimeStampMdc()))
+func (l *Logger) Errorf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Error(pattern, args...)
}
-func (l *Logger) getTimeStampMdc() map[string]string {
- timeStr := time.Now().Format("2006-01-02 15:04:05.000")
- mdc := map[string]string{"time": timeStr}
- return mdc
+func (l *Logger) Warnf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Warning(pattern, args...)
}
-func (l *Logger)InfoEnabled()bool{
- return l.Logger.Core().Enabled(zap.InfoLevel)
+func (l *Logger) Infof(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Info(pattern, args...)
}
-func (l *Logger)DebugEnabled()bool{
- return l.Logger.Core().Enabled(zap.DebugLevel)
+func (l *Logger) Debugf(pattern string, args ...interface{}) {
+ l.SetMdc("time", time.Now().Format(time.RFC3339))
+ l.logger.Debug(pattern, args...)
}
-
-func (l *Logger)DPanicf(formatMsg string, a ...interface{}) {
- msg := fmt.Sprintf(formatMsg, a...)
- l.Logger.DPanic(msg, zap.Any("mdc", l.getTimeStampMdc()))
-}
-
-func initLoggerByLevel(l zapcore.Level) (*zap.Logger, error) {
- cfg := zap.Config{
- Encoding: "json",
- Level: zap.NewAtomicLevelAt(l),
- OutputPaths: []string{"stdout"},
- ErrorOutputPaths: []string{"stderr"},
- EncoderConfig: zapcore.EncoderConfig{
- MessageKey: "msg",
-
- LevelKey: "crit",
- EncodeLevel: zapcore.CapitalLevelEncoder,
-
- TimeKey: "ts",
- EncodeTime: epochMillisIntegerTimeEncoder,
-
- CallerKey: "id",
- EncodeCaller: xAppMockCallerEncoder,
- },
- }
- return cfg.Build()
-}
-
-func xAppMockCallerEncoder(caller zapcore.EntryCaller, enc zapcore.PrimitiveArrayEncoder) {
- enc.AppendString("xAppMock")
-}
-
-func epochMillisIntegerTimeEncoder(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
- nanos := t.UnixNano()
- millis := int64(nanos) / int64(time.Millisecond)
- enc.AppendInt64(millis)
-}
-
func main() {
- logLevel, _ := logger.LogLevelTokenToLevel("info")
+ //logLevel, _ := logger.LogLevelTokenToLevel("info")
+ logLevel := int8(1)
logger, err := logger.InitLogger(logLevel)
if err != nil {
fmt.Printf("#app.main - failed to initialize logger, error: %s", err)
Code Review / ric-plt / e2mgr.git / commitdiff