X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=RIC-E2-TERMINATION%2FsctpThread.cpp;h=55f90833ec011a944d4293c5b462061f79d800b4;hb=c9d8d2891c793e9b90ae0f4d91e32e28df0faef1;hp=540334d6b2196edaed590e0f00627b20b094a475;hpb=ba7dcac2f93b5055cbeccf64e3c5053b7d7cda77;p=ric-plt%2Fe2.git diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index 540334d..55f9083 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -23,10 +23,15 @@ #include <3rdparty/oranE2/RANfunctions-List.h> #include "sctpThread.h" #include "BuildRunName.h" - +#include //#include "3rdparty/oranE2SM/E2SM-gNB-NRT-RANfunction-Definition.h" //#include "BuildXml.h" //#include "pugixml/src/pugixml.hpp" +#include +#include +#include +#include +#include using namespace std; //using namespace std::placeholders; @@ -41,6 +46,7 @@ using namespace prometheus; // need to expose without the include of gcov extern "C" void __gcov_flush(void); +#define LOG_FILE_CONFIG_MAP "CONFIG_MAP_NAME" static void catch_function(int signal) { __gcov_flush(); @@ -52,13 +58,207 @@ BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(my_logger, src::logger_mt) boost::shared_ptr> boostLogger; double cpuClock = 0.0; -bool jsonTrace = true; +bool jsonTrace = false; + +char* getinterfaceip() +{ + char hostname[256]; + char *IP; + struct hostent *host_entry; + int retVal; + retVal = gethostname(hostname, sizeof(hostname)); + if ( retVal == -1 ) + return NULL; + host_entry = gethostbyname(hostname); + if ( host_entry == NULL ) + return NULL; + IP = inet_ntoa(*((struct in_addr*) host_entry->h_addr_list[0])); + return IP; +} + + +static int enable_log_change_notify(const char* fileName) +{ + int ret = -1; + struct stat fileInfo; + if ( lstat(fileName,&fileInfo) == 0 ) + { + ret = register_log_change_notify(fileName); + } + return ret; +} + + +static int register_log_change_notify(const char *fileName) +{ + pthread_attr_t cb_attr; + pthread_t tid; + pthread_attr_init(&cb_attr); + pthread_attr_setdetachstate(&cb_attr,PTHREAD_CREATE_DETACHED); + return pthread_create(&tid, &cb_attr,&monitor_loglevel_change_handler,(void *)fileName); +} + + +static void * monitor_loglevel_change_handler(void* arg) +{ + char *fileName = (char*) arg; + int ifd; // the inotify file des + int wfd; // the watched file des + ssize_t n = 0; + char rbuf[4096]; // large read buffer as the event is var len + fd_set fds; + int res = 0; + struct timeval timeout; + char* dname=NULL; // directory name + char* bname = NULL; // basename + char* tok=NULL; + char* log_level=NULL; + + dname = strdup( fileName); // defrock the file name into dir and basename + if( (tok = strrchr( dname, '/' )) != NULL ) { + *tok = '\0'; + bname = strdup( tok+1 ); + } + + + ifd = inotify_init1( 0 ); // initialise watcher setting blocking read (no option) + if( ifd < 0 ) { + fprintf( stderr, "### ERR ### unable to initialise file watch %s\n", strerror( errno ) ); + } else { + wfd = inotify_add_watch( ifd, dname, IN_MOVED_TO | IN_CLOSE_WRITE ); // we only care about close write changes + + if( wfd < 0 ) { + fprintf( stderr, "### ERR ### unable to add watch on config file %s: %s\n", fileName, strerror( errno ) ); + } else { + + + memset( &timeout, 0, sizeof(timeout) ); + while( 1 ) { + FD_ZERO (&fds); + FD_SET (ifd, &fds); + timeout.tv_sec=1; + res = select (ifd + 1, &fds, NULL, NULL, &timeout); + if(res) + { + n = read( ifd, rbuf, sizeof( rbuf ) ); // read the event + if( n < 0 ) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + if( errno == EAGAIN ) { + } else { + printf( "### CRIT ### config listener read err: %s\n", strerror( errno ) ); + } + continue; +#endif + } + + //Retrieving Log Level from configmap by parsing configmap file + log_level = parse_file(fileName); + update_mdc_log_level_severity(log_level); //setting log level + free(log_level); + } + } + inotify_rm_watch(ifd,wfd); + } + close(ifd); + } + free(bname); + free(dname); + + pthread_exit(NULL); +} + +void update_mdc_log_level_severity(char* log_level) +{ + mdclog_severity_t level = MDCLOG_ERR; + + if(log_level == NULL) + { + printf("### ERR ### Invalid Log-Level Configuration in ConfigMap, Default Log-Level Applied: %d\n",level); + } + else if(strcasecmp(log_level,"1")==0) + { + level = MDCLOG_ERR; + } + else if(strcasecmp(log_level,"2")==0) + { + level = MDCLOG_WARN; + } + else if(strcasecmp(log_level,"3")==0) + { + level = MDCLOG_INFO; + } + else if(strcasecmp(log_level,"4")==0) + { + level = MDCLOG_DEBUG; + } + + mdclog_level_set(level); +} +static char* parse_file(char* filename) +{ + char *token=NULL; + char *search = ": "; + char *string_match = "log-level"; + bool found = false; + FILE *file = fopen ( filename, "r" ); + if ( file != NULL ) + { + char line [ 128 ]; + while ( fgets ( line, sizeof line, file ) != NULL ) + { + token = strtok(line, search); + if(strcmp(token,string_match)==0) + { + found = true; + token = strtok(NULL, search); + token = strtok(token, "\n");//removing newline if any + break; + } + } + fclose ( file ); + } + if(found) + return(strdup(token)); + else + return(NULL); +} + +char *read_env_param(const char*envkey) +{ + if(envkey) + { + char *value = getenv(envkey); + if(value) + return strdup(value); + } + return NULL; +} + +void dynamic_log_level_change() +{ + char *logFile_Name = read_env_param(LOG_FILE_CONFIG_MAP); + char* log_level_init=NULL; + if(logFile_Name) + { + log_level_init = parse_file(logFile_Name); + update_mdc_log_level_severity(log_level_init); //setting log level + free(log_level_init); + + } + enable_log_change_notify(logFile_Name); + free(logFile_Name); + +} void init_log() { + int log_change_monitor = 0; mdclog_attr_t *attr; mdclog_attr_init(&attr); mdclog_attr_set_ident(attr, "E2Terminator"); mdclog_init(attr); + if(mdclog_format_initialize(log_change_monitor)!=0) + mdclog_write(MDCLOG_ERR, "Failed to intialize MDC log format !!!"); + dynamic_log_level_change(); mdclog_attr_destroy(attr); } auto start_time = std::chrono::high_resolution_clock::now(); @@ -68,12 +268,12 @@ double age() { return seconds_t(std::chrono::high_resolution_clock::now() - start_time).count(); } -double approx_CPU_MHz(unsigned sleeptime) { +double approx_CPU_MHz(unsigned sleepTime) { using namespace std::chrono_literals; uint32_t aux = 0; uint64_t cycles_start = rdtscp(aux); double time_start = age(); - std::this_thread::sleep_for(sleeptime * 1ms); + std::this_thread::sleep_for(sleepTime * 1ms); uint64_t elapsed_cycles = rdtscp(aux) - cycles_start; double elapsed_time = age() - time_start; return elapsed_cycles / elapsed_time; @@ -87,34 +287,40 @@ static long transactionCounter = 0; int buildListeningPort(sctp_params_t &sctpParams) { sctpParams.listenFD = socket(AF_INET6, SOCK_STREAM, IPPROTO_SCTP); if (sctpParams.listenFD <= 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error Opening socket, %s", strerror(errno)); return -1; +#endif } - struct sockaddr_in6 servaddr {}; - servaddr.sin6_family = AF_INET6; - servaddr.sin6_addr = in6addr_any; - servaddr.sin6_port = htons(sctpParams.sctpPort); - if (bind(sctpParams.listenFD, (SA *)&servaddr, sizeof(servaddr)) < 0 ) { + struct sockaddr_in6 serverAddress {}; + serverAddress.sin6_family = AF_INET6; + serverAddress.sin6_addr = in6addr_any; + serverAddress.sin6_port = htons(sctpParams.sctpPort); + if (bind(sctpParams.listenFD, (SA *)&serverAddress, sizeof(serverAddress)) < 0 ) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error binding port %d. %s", sctpParams.sctpPort, strerror(errno)); return -1; +#endif } if (setSocketNoBlocking(sctpParams.listenFD) == -1) { //mdclog_write(MDCLOG_ERR, "Error binding. %s", strerror(errno)); return -1; } if (mdclog_level_get() >= MDCLOG_DEBUG) { - struct sockaddr_in6 cliaddr {}; - socklen_t len = sizeof(cliaddr); - getsockname(sctpParams.listenFD, (SA *)&cliaddr, &len); + struct sockaddr_in6 clientAddress {}; + socklen_t len = sizeof(clientAddress); + getsockname(sctpParams.listenFD, (SA *)&clientAddress, &len); char buff[1024] {}; - inet_ntop(AF_INET6, &cliaddr.sin6_addr, buff, sizeof(buff)); - mdclog_write(MDCLOG_DEBUG, "My address: %s, port %d\n", buff, htons(cliaddr.sin6_port)); + inet_ntop(AF_INET6, &clientAddress.sin6_addr, buff, sizeof(buff)); + mdclog_write(MDCLOG_DEBUG, "My address: %s, port %d\n", buff, htons(clientAddress.sin6_port)); } if (listen(sctpParams.listenFD, SOMAXCONN) < 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Error listening. %s\n", strerror(errno)); return -1; +#endif } struct epoll_event event {}; event.events = EPOLLIN | EPOLLET; @@ -122,9 +328,11 @@ int buildListeningPort(sctp_params_t &sctpParams) { // add listening port to epoll if (epoll_ctl(sctpParams.epoll_fd, EPOLL_CTL_ADD, sctpParams.listenFD, &event)) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) printf("Failed to add descriptor to epoll\n"); mdclog_write(MDCLOG_ERR, "Failed to add descriptor to epoll. %s\n", strerror(errno)); return -1; +#endif } return 0; @@ -136,53 +344,41 @@ int buildConfiguration(sctp_params_t &sctpParams) { const int size = 2048; auto fileSize = file_size(p); if (fileSize > size) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "File %s larger than %d", p.string().c_str(), size); return -1; +#endif } } else { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Configuration File %s not exists", p.string().c_str()); return -1; +#endif } ReadConfigFile conf; if (conf.openConfigFile(p.string()) == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "Filed to open config file %s, %s", p.string().c_str(), strerror(errno)); return -1; +#endif } int rmrPort = conf.getIntValue("nano"); if (rmrPort == -1) { - mdclog_write(MDCLOG_ERR, "illigal RMR port "); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "illegal RMR port "); return -1; +#endif } sctpParams.rmrPort = (uint16_t)rmrPort; snprintf(sctpParams.rmrAddress, sizeof(sctpParams.rmrAddress), "%d", (int) (sctpParams.rmrPort)); - - auto tmpStr = conf.getStringValue("loglevel"); + auto tmpStr = conf.getStringValue("volume"); if (tmpStr.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal loglevel. Set loglevel to MDCLOG_INFO"); - tmpStr = "info"; - } - transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); - - if ((tmpStr.compare("debug")) == 0) { - sctpParams.logLevel = MDCLOG_DEBUG; - } else if ((tmpStr.compare("info")) == 0) { - sctpParams.logLevel = MDCLOG_INFO; - } else if ((tmpStr.compare("warning")) == 0) { - sctpParams.logLevel = MDCLOG_WARN; - } else if ((tmpStr.compare("error")) == 0) { - sctpParams.logLevel = MDCLOG_ERR; - } else { - mdclog_write(MDCLOG_ERR, "illigal loglevel = %s. Set loglevel to MDCLOG_INFO", tmpStr.c_str()); - sctpParams.logLevel = MDCLOG_INFO; - } - mdclog_level_set(sctpParams.logLevel); - - tmpStr = conf.getStringValue("volume"); - if (tmpStr.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal volume."); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "illegal volume."); return -1; +#endif } char tmpLogFilespec[VOLUME_URL_SIZE]; @@ -198,49 +394,63 @@ int buildConfiguration(sctp_params_t &sctpParams) { sctpParams.myIP = conf.getStringValue("local-ip"); if (sctpParams.myIP.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal local-ip."); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "illegal local-ip."); return -1; +#endif } int sctpPort = conf.getIntValue("sctp-port"); if (sctpPort == -1) { - mdclog_write(MDCLOG_ERR, "illigal SCTP port "); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "illegal SCTP port "); return -1; +#endif } sctpParams.sctpPort = (uint16_t)sctpPort; sctpParams.fqdn = conf.getStringValue("external-fqdn"); if (sctpParams.fqdn.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal external-fqdn"); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "illegal external-fqdn"); return -1; +#endif } std::string pod = conf.getStringValue("pod_name"); +#ifndef UNIT_TEST if (pod.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal pod_name in config file"); + mdclog_write(MDCLOG_ERR, "illegal pod_name in config file"); return -1; } auto *podName = getenv(pod.c_str()); if (podName == nullptr) { - mdclog_write(MDCLOG_ERR, "illigal pod_name or environment varible not exists : %s", pod.c_str()); + mdclog_write(MDCLOG_ERR, "illegal pod_name or environment variable not exists : %s", pod.c_str()); return -1; } else { sctpParams.podName.assign(podName); if (sctpParams.podName.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal pod_name"); + mdclog_write(MDCLOG_ERR, "illegal pod_name"); return -1; } } - +#endif tmpStr = conf.getStringValue("trace"); transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); if ((tmpStr.compare("start")) == 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_INFO, "Trace set to: start"); sctpParams.trace = true; +#endif } else if ((tmpStr.compare("stop")) == 0) { mdclog_write(MDCLOG_INFO, "Trace set to: stop"); sctpParams.trace = false; + } else { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "Trace was set to wrong value %s, set to stop", tmpStr.c_str()); + sctpParams.trace = false; +#endif } jsonTrace = sctpParams.trace; @@ -260,16 +470,15 @@ int buildConfiguration(sctp_params_t &sctpParams) { sctpParams.podName.c_str()); if (mdclog_level_get() >= MDCLOG_INFO) { - mdclog_mdc_add("RMR Port", to_string(sctpParams.rmrPort).c_str()); - mdclog_mdc_add("LogLevel", to_string(sctpParams.logLevel).c_str()); - mdclog_mdc_add("volume", sctpParams.volume); - mdclog_mdc_add("tmpLogFilespec", tmpLogFilespec); - mdclog_mdc_add("my ip", sctpParams.myIP.c_str()); - mdclog_mdc_add("pod name", sctpParams.podName.c_str()); + mdclog_write(MDCLOG_DEBUG,"RMR Port: %s", to_string(sctpParams.rmrPort).c_str()); + mdclog_write(MDCLOG_DEBUG,"LogLevel: %s", to_string(sctpParams.logLevel).c_str()); + mdclog_write(MDCLOG_DEBUG,"volume: %s", sctpParams.volume); + mdclog_write(MDCLOG_DEBUG,"tmpLogFilespec: %s", tmpLogFilespec); + mdclog_write(MDCLOG_DEBUG,"my ip: %s", sctpParams.myIP.c_str()); + mdclog_write(MDCLOG_DEBUG,"pod name: %s", sctpParams.podName.c_str()); mdclog_write(MDCLOG_INFO, "running parameters for instance : %s", sctpParams.ka_message); } - mdclog_mdc_clean(); // Files written to the current working directory boostLogger = logging::add_file_log( @@ -280,7 +489,7 @@ int buildConfiguration(sctp_params_t &sctpParams) { //keywords::format = "[%TimeStamp%]: %Message%" // use each tmpStr with time stamp ); - // Setup a destination folder for collecting rotated (closed) files --since the same volumn can use rename() + // Setup a destination folder for collecting rotated (closed) files --since the same volume can use rename() boostLogger->locked_backend()->set_file_collector(sinks::file::make_collector( keywords::target = sctpParams.volume )); @@ -297,23 +506,40 @@ int buildConfiguration(sctp_params_t &sctpParams) { } void startPrometheus(sctp_params_t &sctpParams) { + auto podName = std::getenv("POD_NAME"); + string metric = "E2TBeta"; + if (strstr(podName, "alpha") != NULL) { + metric = "E2TAlpha"; + } + //Get eth0 interface IP + char* host = getinterfaceip(); + string hostip = host; + sctpParams.prometheusFamily = &BuildCounter() - .Name("E2T") - .Help("E2T message counter") + .Name(metric.c_str()) + .Help("E2T instance metrics") .Labels({{"POD_NAME", sctpParams.podName}}) .Register(*sctpParams.prometheusRegistry); - string promethusPath = sctpParams.prometheusPort + "," + "[::]:" + sctpParams.prometheusPort; + // Build E2T instance level metrics + buildE2TPrometheusCounters(sctpParams); + + string prometheusPath; + if (hostip.empty()) + prometheusPath = sctpParams.prometheusPort + "," + "[::]:" + sctpParams.prometheusPort; + else + prometheusPath = hostip + ":" + sctpParams.prometheusPort; + if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Start Prometheus Pull mode on %s", promethusPath.c_str()); + mdclog_write(MDCLOG_DEBUG, "Start Prometheus Pull mode on %s", prometheusPath.c_str()); } - sctpParams.prometheusExposer = new Exposer(promethusPath, 1); + sctpParams.prometheusExposer = new Exposer(prometheusPath, 1); sctpParams.prometheusExposer->RegisterCollectable(sctpParams.prometheusRegistry); } +#ifndef UNIT_TEST int main(const int argc, char **argv) { sctp_params_t sctpParams; - { std::random_device device{}; std::mt19937 generator(device()); @@ -327,8 +553,6 @@ int main(const int argc, char **argv) { unsigned num_cpus = std::thread::hardware_concurrency(); init_log(); - mdclog_level_set(MDCLOG_INFO); - if (std::signal(SIGINT, catch_function) == SIG_ERR) { mdclog_write(MDCLOG_ERR, "Error initializing SIGINT"); exit(1); @@ -355,7 +579,7 @@ int main(const int argc, char **argv) { //auto registry = std::make_shared(); sctpParams.prometheusRegistry = std::make_shared(); - //sctpParams.promtheusFamily = new Family("E2T", "E2T message counter", {{"E", sctpParams.podName}}); + //sctpParams.prometheusFamily = new Family("E2T", "E2T message counter", {{"E", sctpParams.podName}}); startPrometheus(sctpParams); @@ -365,7 +589,6 @@ int main(const int argc, char **argv) { mdclog_write(MDCLOG_ERR, "failed to open epoll descriptor"); exit(-1); } - getRmrContext(sctpParams); if (sctpParams.rmrCtx == nullptr) { close(sctpParams.epoll_fd); @@ -391,7 +614,7 @@ int main(const int argc, char **argv) { std::vector threads(num_cpus); // std::vector threads; - num_cpus = 1; + num_cpus = 3; for (unsigned int i = 0; i < num_cpus; i++) { threads[i] = std::thread(listener, &sctpParams); @@ -414,7 +637,7 @@ int main(const int argc, char **argv) { return 0; } - +#endif void handleTermInit(sctp_params_t &sctpParams) { sendTermInit(sctpParams); //send to e2 manager init of e2 term @@ -425,7 +648,7 @@ void handleTermInit(sctp_params_t &sctpParams) { auto xappMessages = num_of_XAPP_messages.load(std::memory_order_acquire); if (xappMessages > 0) { if (mdclog_level_get() >= MDCLOG_INFO) { - mdclog_write(MDCLOG_INFO, "Got a message from some appliction, stop sending E2_TERM_INIT"); + mdclog_write(MDCLOG_INFO, "Got a message from some application, stop sending E2_TERM_INIT"); } return; } @@ -454,7 +677,7 @@ void sendTermInit(sctp_params_t &sctpParams) { } else if (msg->state == 0) { rmr_free_msg(msg); if (mdclog_level_get() >= MDCLOG_INFO) { - mdclog_write(MDCLOG_INFO, "E2_TERM_INIT succsesfuly sent "); + mdclog_write(MDCLOG_INFO, "E2_TERM_INIT successfully sent "); } return; } else { @@ -482,7 +705,7 @@ cxxopts::ParseResult parse(int argc, char *argv[], sctp_params_t &sctpParams) { ("f,file", "config file name", cxxopts::value(sctpParams.configFileName)->default_value("config.conf")) ("h,help", "Print help"); - auto result = options.parse(argc, argv); + auto result = options.parse(argc, (const char **&)argv); if (result.count("help")) { std::cout << options.help({""}) << std::endl; @@ -500,9 +723,6 @@ int buildInotify(sctp_params_t &sctpParams) { sctpParams.inotifyFD = inotify_init1(IN_NONBLOCK); if (sctpParams.inotifyFD == -1) { mdclog_write(MDCLOG_ERR, "Failed to init inotify (inotify_init1) %s", strerror(errno)); - close(sctpParams.rmrListenFd); - rmr_close(sctpParams.rmrCtx); - close(sctpParams.epoll_fd); return -1; } @@ -537,11 +757,14 @@ int buildInotify(sctp_params_t &sctpParams) { void listener(sctp_params_t *params) { int num_of_SCTP_messages = 0; auto totalTime = 0.0; - mdclog_mdc_clean(); - mdclog_level_set(params->logLevel); - std::thread::id this_id = std::this_thread::get_id(); //save cout + auto pod_name = std::getenv("POD_NAME"); + auto container_name = std::getenv("CONTAINER_NAME"); + auto service_name = std::getenv("SERVICE_NAME"); + auto host_name = std::getenv("HOST_NAME"); + auto system_name = std::getenv("SYSTEM_NAME"); + auto pid = std::to_string(getpid()).c_str(); streambuf *oldCout = cout.rdbuf(); ostringstream memCout; // create new cout @@ -553,7 +776,12 @@ void listener(sctp_params_t *params) { char tid[32]; memcpy(tid, memCout.str().c_str(), memCout.str().length() < 32 ? memCout.str().length() : 31); tid[memCout.str().length()] = 0; - mdclog_mdc_add("thread id", tid); + mdclog_mdc_add("SYSTEM_NAME", system_name); + mdclog_mdc_add("HOST_NAME", host_name); + mdclog_mdc_add("SERVICE_NAME", service_name); + mdclog_mdc_add("CONTAINER_NAME", container_name); + mdclog_mdc_add("POD_NAME", pod_name); + mdclog_mdc_add("PID", pid); if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "started thread number %s", tid); @@ -580,7 +808,7 @@ void listener(sctp_params_t *params) { ReportingMessages_t message {}; -// for (int i = 0; i < MAX_RMR_BUFF_ARRY; i++) { +// for (int i = 0; i < MAX_RMR_BUFF_ARRAY; i++) { // rmrMessageBuffer.rcvBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); // rmrMessageBuffer.sendBufferedMessages[i] = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); // } @@ -589,8 +817,13 @@ void listener(sctp_params_t *params) { if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Start EPOLL Wait. Timeout = %d", params->epollTimeOut); } +#ifndef UNIT_TEST auto numOfEvents = epoll_wait(params->epoll_fd, events, MAXEVENTS, params->epollTimeOut); +#else + auto numOfEvents = 1; +#endif if (numOfEvents == 0) { // time out +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "got epoll timeout"); } @@ -603,7 +836,12 @@ void listener(sctp_params_t *params) { continue; } mdclog_write(MDCLOG_ERR, "Epoll wait failed, errno = %s", strerror(errno)); + if(events) + { + free(events); + } return; +#endif } for (auto i = 0; i < numOfEvents; i++) { if (mdclog_level_get() >= MDCLOG_DEBUG) { @@ -631,13 +869,22 @@ void listener(sctp_params_t *params) { in_len = sizeof(in_addr); auto *peerInfo = (ConnectedCU_t *)calloc(1, sizeof(ConnectedCU_t)); + if(peerInfo == nullptr){ + mdclog_write(MDCLOG_ERR, "calloc failed"); + break; + } peerInfo->sctpParams = params; peerInfo->fileDescriptor = accept(params->listenFD, &in_addr, &in_len); if (peerInfo->fileDescriptor == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* We have processed all incoming connections. */ + if(peerInfo) + free(peerInfo); break; } else { + if(peerInfo) + free(peerInfo); mdclog_write(MDCLOG_ERR, "Accept error, errno = %s", strerror(errno)); break; } @@ -645,7 +892,10 @@ void listener(sctp_params_t *params) { if (setSocketNoBlocking(peerInfo->fileDescriptor) == -1) { mdclog_write(MDCLOG_ERR, "setSocketNoBlocking failed to set new connection %s on port %s\n", hostBuff, portBuff); close(peerInfo->fileDescriptor); + if(peerInfo) + free(peerInfo); break; +#endif } auto ans = getnameinfo(&in_addr, in_len, peerInfo->hostName, NI_MAXHOST, @@ -653,6 +903,8 @@ void listener(sctp_params_t *params) { if (ans < 0) { mdclog_write(MDCLOG_ERR, "Failed to get info on connection request. %s\n", strerror(errno)); close(peerInfo->fileDescriptor); + if(peerInfo) + free(peerInfo); break; } if (mdclog_level_get() >= MDCLOG_DEBUG) { @@ -665,16 +917,18 @@ void listener(sctp_params_t *params) { (EPOLLIN | EPOLLET), params->sctpMap, nullptr, 0) != 0) { + if(peerInfo) + free(peerInfo); break; } break; } } else if (params->rmrListenFd == events[i].data.fd) { // got message from XAPP - num_of_XAPP_messages.fetch_add(1, std::memory_order_release); + //num_of_XAPP_messages.fetch_add(1, std::memory_order_release); num_of_messages.fetch_add(1, std::memory_order_release); if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "new message from RMR"); + mdclog_write(MDCLOG_DEBUG, "new RMR message"); } if (receiveXappMessages(params->sctpMap, rmrMessageBuffer, @@ -710,6 +964,9 @@ void listener(sctp_params_t *params) { end.tv_nsec - start.tv_nsec); } } +#ifdef UNIT_TEST + break; +#endif } } @@ -721,12 +978,19 @@ void handleConfigChange(sctp_params_t *sctpParams) { char buf[4096] __attribute__ ((aligned(__alignof__(struct inotify_event)))); const struct inotify_event *event; char *ptr; - +#ifdef UNIT_TEST + struct inotify_event tmpEvent; +#endif path p = (sctpParams->configFilePath + "/" + sctpParams->configFileName).c_str(); auto endlessLoop = true; while (endlessLoop) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) auto len = read(sctpParams->inotifyFD, buf, sizeof buf); +#else + auto len=10; +#endif if (len == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (errno != EAGAIN) { mdclog_write(MDCLOG_ERR, "read %s ", strerror(errno)); endlessLoop = false; @@ -736,10 +1000,16 @@ void handleConfigChange(sctp_params_t *sctpParams) { endlessLoop = false; continue; } +#endif } for (ptr = buf; ptr < buf + len; ptr += sizeof(struct inotify_event) + event->len) { - event = (const struct inotify_event *)ptr; +#ifndef UNIT_TEST + event = (const struct inotify_event *)ptr; +#else + tmpEvent.mask = (uint32_t)IN_CLOSE_WRITE; + event = &tmpEvent; +#endif if (event->mask & (uint32_t)IN_ISDIR) { continue; } @@ -749,10 +1019,12 @@ void handleConfigChange(sctp_params_t *sctpParams) { // not the directory } if (event->len) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) auto retVal = strcmp(sctpParams->configFileName.c_str(), event->name); if (retVal != 0) { continue; } +#endif } // only the file we want if (event->mask & (uint32_t)IN_CLOSE_WRITE) { @@ -777,10 +1049,9 @@ void handleConfigChange(sctp_params_t *sctpParams) { p.string().c_str(), strerror(errno)); return; } - auto tmpStr = conf.getStringValue("loglevel"); if (tmpStr.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal loglevel. Set loglevel to MDCLOG_INFO"); + mdclog_write(MDCLOG_ERR, "illegal loglevel. Set loglevel to MDCLOG_INFO"); tmpStr = "info"; } transform(tmpStr.begin(), tmpStr.end(), tmpStr.begin(), ::tolower); @@ -788,7 +1059,9 @@ void handleConfigChange(sctp_params_t *sctpParams) { if ((tmpStr.compare("debug")) == 0) { mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_DEBUG"); sctpParams->logLevel = MDCLOG_DEBUG; - } else if ((tmpStr.compare("info")) == 0) { + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + else if ((tmpStr.compare("info")) == 0) { mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_INFO"); sctpParams->logLevel = MDCLOG_INFO; } else if ((tmpStr.compare("warning")) == 0) { @@ -798,15 +1071,14 @@ void handleConfigChange(sctp_params_t *sctpParams) { mdclog_write(MDCLOG_INFO, "Log level set to MDCLOG_ERR"); sctpParams->logLevel = MDCLOG_ERR; } else { - mdclog_write(MDCLOG_ERR, "illigal loglevel = %s. Set loglevel to MDCLOG_INFO", tmpStr.c_str()); + mdclog_write(MDCLOG_ERR, "illegal loglevel = %s. Set loglevel to MDCLOG_INFO", tmpStr.c_str()); sctpParams->logLevel = MDCLOG_INFO; } +#endif mdclog_level_set(sctpParams->logLevel); - - tmpStr = conf.getStringValue("trace"); if (tmpStr.length() == 0) { - mdclog_write(MDCLOG_ERR, "illigal trace. Set trace to stop"); + mdclog_write(MDCLOG_ERR, "illegal trace. Set trace to stop"); tmpStr = "stop"; } @@ -826,6 +1098,9 @@ void handleConfigChange(sctp_params_t *sctpParams) { endlessLoop = false; } +#ifdef UNIT_TEST + break; +#endif } } } @@ -849,6 +1124,7 @@ void handleEinprogressMessages(struct epoll_event &event, socklen_t retValLen = 0; auto rc = getsockopt(peerInfo->fileDescriptor, SOL_SOCKET, SO_ERROR, &retVal, &retValLen); if (rc != 0 || retVal != 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (rc != 0) { rmrMessageBuffer.sendMessage->len = snprintf((char *)rmrMessageBuffer.sendMessage->payload, 256, "%s|Failed SCTP Connection, after EINPROGRESS the getsockopt%s", @@ -866,12 +1142,13 @@ void handleEinprogressMessages(struct epoll_event &event, if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } +#endif memset(peerInfo->asnData, 0, peerInfo->asnLength); peerInfo->asnLength = 0; peerInfo->mtype = 0; return; } - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) peerInfo->isConnected = true; if (modifyToEpoll(params->epoll_fd, peerInfo, (EPOLLIN | EPOLLET), params->sctpMap, peerInfo->enodbName, @@ -899,6 +1176,7 @@ void handleEinprogressMessages(struct epoll_event &event, memset(peerInfo->asnData, 0, peerInfo->asnLength); peerInfo->asnLength = 0; peerInfo->mtype = 0; +#endif } @@ -910,7 +1188,7 @@ void handlepoll_error(struct epoll_event &event, auto *peerInfo = (ConnectedCU_t *)event.data.ptr; mdclog_write(MDCLOG_ERR, "epoll error, events %0x on fd %d, RAN NAME : %s", event.events, peerInfo->fileDescriptor, peerInfo->enodbName); - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) rmrMessageBuffer.sendMessage->len = snprintf((char *)rmrMessageBuffer.sendMessage->payload, 256, "%s|Failed SCTP Connection", peerInfo->enodbName); @@ -922,7 +1200,7 @@ void handlepoll_error(struct epoll_event &event, if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } - +#endif close(peerInfo->fileDescriptor); params->sctpMap->erase(peerInfo->enodbName); cleanHashEntry((ConnectedCU_t *) event.data.ptr, params->sctpMap); @@ -939,17 +1217,13 @@ int setSocketNoBlocking(int socket) { auto flags = fcntl(socket, F_GETFL, 0); if (flags == -1) { - mdclog_mdc_add("func", "fcntl"); mdclog_write(MDCLOG_ERR, "%s, %s", __FUNCTION__, strerror(errno)); - mdclog_mdc_clean(); return -1; } flags = (unsigned) flags | (unsigned) O_NONBLOCK; if (fcntl(socket, F_SETFL, flags) == -1) { - mdclog_mdc_add("func", "fcntl"); mdclog_write(MDCLOG_ERR, "%s, %s", __FUNCTION__, strerror(errno)); - mdclog_mdc_clean(); return -1; } @@ -970,22 +1244,28 @@ void cleanHashEntry(ConnectedCU_t *val, Sctp_Map_t *m) { m->erase(searchBuff); m->erase(val->enodbName); +#ifndef UNIT_TEST free(val); +#endif } /** * - * @param fd file discriptor + * @param fd file descriptor * @param data the asn data to send * @param len length of the data * @param enodbName the enodbName as in the map for printing purpose * @param m map host information * @param mtype message number - * @return 0 success, anegative number on fail + * @return 0 success, a negative number on fail */ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_t *m) { auto loglevel = mdclog_level_get(); +#ifndef UNIT_TEST int fd = peerInfo->fileDescriptor; +#else + int fd = FILE_DESCRIPTOR; +#endif if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Send SCTP message for CU %s, %s", message.message.enodbName, __FUNCTION__); @@ -997,12 +1277,16 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ continue; } mdclog_write(MDCLOG_ERR, "error writing to CU a message, %s ", strerror(errno)); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (!peerInfo->isConnected) { mdclog_write(MDCLOG_ERR, "connection to CU %s is still in progress.", message.message.enodbName); return -1; } +#endif +#ifndef UNIT_TEST cleanHashEntry(peerInfo, m); close(fd); +#endif char key[MAX_ENODB_NAME_SIZE * 2]; snprintf(key, MAX_ENODB_NAME_SIZE * 2, "msg:%s|%d", message.message.enodbName, message.message.messageType); @@ -1014,7 +1298,9 @@ int sendSctpMsg(ConnectedCU_t *peerInfo, ReportingMessages_t &message, Sctp_Map_ free(tmp); } m->erase(key); +#ifndef UNIT_TEST return -1; +#endif } message.message.direction = 'D'; // send report.buffer of size @@ -1072,7 +1358,7 @@ int receiveDataFromSctp(struct epoll_event *events, message.peerInfo = (ConnectedCU_t *)events->data.ptr; struct timespec start{0, 0}; - struct timespec decodestart{0, 0}; + struct timespec decodeStart{0, 0}; struct timespec end{0, 0}; E2AP_PDU_t *pdu = nullptr; @@ -1084,8 +1370,12 @@ int receiveDataFromSctp(struct epoll_event *events, } // read the buffer directly to rmr payload message.message.asndata = rmrMessageBuffer.sendMessage->payload; +#ifndef UNIT_TEST message.message.asnLength = rmrMessageBuffer.sendMessage->len = read(message.peerInfo->fileDescriptor, rmrMessageBuffer.sendMessage->payload, RECEIVE_SCTP_BUFFER_SIZE); +#else + message.message.asnLength = rmrMessageBuffer.sendMessage->len; +#endif if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Finish Read from SCTP %d fd message length = %ld", @@ -1121,7 +1411,7 @@ int receiveDataFromSctp(struct epoll_event *events, } if (loglevel >= MDCLOG_DEBUG) { - char printBuffer[4096]{}; + char printBuffer[RECEIVE_SCTP_BUFFER_SIZE]{}; char *tmp = printBuffer; for (size_t i = 0; i < (size_t)message.message.asnLength; ++i) { snprintf(tmp, 3, "%02x", message.message.asndata[i]); @@ -1133,27 +1423,38 @@ int receiveDataFromSctp(struct epoll_event *events, message.peerInfo->enodbName, end.tv_sec - start.tv_sec, end.tv_nsec - start.tv_nsec); mdclog_write(MDCLOG_DEBUG, "PDU buffer length = %ld, data = : %s", message.message.asnLength, printBuffer); - clock_gettime(CLOCK_MONOTONIC, &decodestart); + clock_gettime(CLOCK_MONOTONIC, &decodeStart); } - +#ifndef UNIT_TEST auto rval = asn_decode(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, (void **) &pdu, - message.message.asndata, message.message.asnLength); + message.message.asndata, message.message.asnLength); +#else + asn_dec_rval_t rval = {RC_OK, 0}; + pdu = (E2AP_PDU_t*)rmrMessageBuffer.sendMessage->tp_buf; +#endif if (rval.code != RC_OK) { mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) E2AP PDU from RAN : %s", rval.code, message.peerInfo->enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } break; } if (loglevel >= MDCLOG_DEBUG) { clock_gettime(CLOCK_MONOTONIC, &end); mdclog_write(MDCLOG_DEBUG, "After Encoding E2AP PDU for : %s, Read time is : %ld seconds, %ld nanoseconds", - message.peerInfo->enodbName, end.tv_sec - decodestart.tv_sec, end.tv_nsec - decodestart.tv_nsec); + message.peerInfo->enodbName, end.tv_sec - decodeStart.tv_sec, end.tv_nsec - decodeStart.tv_nsec); char *printBuffer; size_t size; FILE *stream = open_memstream(&printBuffer, &size); asn_fprint(stream, &asn_DEF_E2AP_PDU, pdu); mdclog_write(MDCLOG_DEBUG, "Encoding E2AP PDU past : %s", printBuffer); - clock_gettime(CLOCK_MONOTONIC, &decodestart); + clock_gettime(CLOCK_MONOTONIC, &decodeStart); + + fclose(stream); + free(printBuffer); } switch (pdu->present) { @@ -1162,7 +1463,7 @@ int receiveDataFromSctp(struct epoll_event *events, break; } case E2AP_PDU_PR_successfulOutcome: { //successful outcome - asnSuccsesfulMsg(pdu, sctpMap, message, rmrMessageBuffer); + asnSuccessfulMsg(pdu, sctpMap, message, rmrMessageBuffer); break; } case E2AP_PDU_PR_unsuccessfulOutcome: { //Unsuccessful Outcome @@ -1177,14 +1478,19 @@ int receiveDataFromSctp(struct epoll_event *events, clock_gettime(CLOCK_MONOTONIC, &end); mdclog_write(MDCLOG_DEBUG, "After processing message and sent to rmr for : %s, Read time is : %ld seconds, %ld nanoseconds", - message.peerInfo->enodbName, end.tv_sec - decodestart.tv_sec, end.tv_nsec - decodestart.tv_nsec); + message.peerInfo->enodbName, end.tv_sec - decodeStart.tv_sec, end.tv_nsec - decodeStart.tv_nsec); } numOfMessages++; +#ifndef UNIT_TEST if (pdu != nullptr) { - ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); - //ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); - //pdu = nullptr; + // ASN_STRUCT_RESET(asn_DEF_E2AP_PDU, pdu); /* With reset we were not freeing the memory and was causing the leak here. */ + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; } +#else + done = 1; + break; +#endif } if (done) { @@ -1197,12 +1503,13 @@ int receiveDataFromSctp(struct epoll_event *events, "%s|CU disconnected unexpectedly", message.peerInfo->enodbName); message.message.asndata = rmrMessageBuffer.sendMessage->payload; - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (sendRequestToXapp(message, RIC_SCTP_CONNECTION_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "SCTP_CONNECTION_FAIL message failed to send to xAPP"); } +#endif /* Closing descriptor make epoll remove it from the set of descriptors which are monitored. */ close(message.peerInfo->fileDescriptor); @@ -1217,7 +1524,7 @@ int receiveDataFromSctp(struct epoll_event *events, return 0; } -static void buildAndsendSetupRequest(ReportingMessages_t &message, +static void buildAndSendSetupRequest(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer, E2AP_PDU_t *pdu/*, string const &messageName, @@ -1229,20 +1536,42 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, asn_enc_rval_t er; auto buffer_size = RECEIVE_SCTP_BUFFER_SIZE * 2; - unsigned char buffer[RECEIVE_SCTP_BUFFER_SIZE * 2]; + unsigned char *buffer = nullptr; + buffer = (unsigned char *) calloc(buffer_size, sizeof(unsigned char)); + if(!buffer) + { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) + mdclog_write(MDCLOG_ERR, "Allocating buffer for %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + return; +#endif + } while (true) { er = asn_encode_to_buffer(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, pdu, buffer, buffer_size); if (er.encoded == -1) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); return; +#endif } else if (er.encoded > (ssize_t) buffer_size) { buffer_size = er.encoded + 128; +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) mdclog_write(MDCLOG_WARN, "Buffer of size %d is to small for %s. Reallocate buffer of size %d", (int) buffer_size, asn_DEF_E2AP_PDU.name, buffer_size); buffer_size = er.encoded + 128; -// free(buffer); + + unsigned char *newBuffer = nullptr; + newBuffer = (unsigned char *) realloc(buffer, buffer_size); + if (!newBuffer) + { + // out of memory + mdclog_write(MDCLOG_ERR, "Reallocating buffer for %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + free(buffer); + return; + } + buffer = newBuffer; continue; +#endif } buffer[er.encoded] = '\0'; break; @@ -1284,8 +1613,9 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, static unsigned char tx[32]; snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMsg, tx, strlen((const char *) tx)); - +#ifndef UNIT_TEST rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg); +#endif if (rmrMsg == nullptr) { mdclog_write(MDCLOG_ERR, "RMR failed to send returned nullptr"); } else if (rmrMsg->state != 0) { @@ -1295,7 +1625,9 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, rmrMsg->state = 0; mdclog_write(MDCLOG_INFO, "RETRY sending Message %d to Xapp from %s", rmrMsg->mtype, rmr_get_meid(rmrMsg, (unsigned char *) meid)); +#ifndef UNIT_TEST rmrMsg = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMsg); +#endif if (rmrMsg == nullptr) { mdclog_write(MDCLOG_ERR, "RMR failed send returned nullptr"); } else if (rmrMsg->state != 0) { @@ -1314,9 +1646,13 @@ static void buildAndsendSetupRequest(ReportingMessages_t &message, } message.peerInfo->gotSetup = true; buildJsonMessage(message); + if (rmrMsg != nullptr) { rmr_free_msg(rmrMsg); } + free(buffer); + + return; } #if 0 @@ -1415,7 +1751,69 @@ int collectServiceUpdate_RequestData(E2AP_PDU_t *pdu, #endif -void buildPrometheuslist(ConnectedCU_t *peerInfo, Family *prometheusFamily) { +void buildE2TPrometheusCounters(sctp_params_t &sctpParams) { + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupResponseMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &sctpParams.prometheusFamily->Add({{"counter", "SetupResponseBytes"}}); + + sctpParams.e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestFailureMsgs"}}); + sctpParams.e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup] = &sctpParams.prometheusFamily->Add({{"counter", "SetupRequestFailureBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_ErrorIndication)] = &sctpParams.prometheusFamily->Add({{"counter", "ErrorIndicationMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_ErrorIndication)] = &sctpParams.prometheusFamily->Add({{"counter", "ErrorIndicationBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetRequestMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetRequestBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetAckMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset] = &sctpParams.prometheusFamily->Add({{"counter", "ResetAckBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateBytes"}}); + + sctpParams.e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateRespMsgs"}}); + sctpParams.e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateRespBytes"}}); + + sctpParams.e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateFailureMsgs"}}); + sctpParams.e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceUpdateFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlFailureMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol] = &sctpParams.prometheusFamily->Add({{"counter", "RICControlFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionFailureMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionFailureBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteBytes"}}); + + sctpParams.e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteAckMsgs"}}); + sctpParams.e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteAckBytes"}}); + + sctpParams.e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteFailMsgs"}}); + sctpParams.e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete] = &sctpParams.prometheusFamily->Add({{"counter", "RICSubscriptionDeleteFailBytes"}}); + + sctpParams.e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication] = &sctpParams.prometheusFamily->Add({{"counter", "RICIndicationMsgs"}}); + sctpParams.e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication] = &sctpParams.prometheusFamily->Add({{"counter", "RICIndicationBytes"}}); + + sctpParams.e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceQueryMsgs"}}); + sctpParams.e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery] = &sctpParams.prometheusFamily->Add({{"counter", "RICServiceQueryBytes"}}); +} + +void buildPrometheusList(ConnectedCU_t *peerInfo, Family *prometheusFamily) { peerInfo->counters[IN_INITI][MSG_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Messages"}}); peerInfo->counters[IN_INITI][BYTES_COUNTER][(ProcedureCode_id_E2setup)] = &prometheusFamily->Add({{peerInfo->enodbName, "IN"}, {"SetupRequest", "Bytes"}}); @@ -1487,6 +1885,7 @@ void buildPrometheuslist(ConnectedCU_t *peerInfo, Family *prometheusFam peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Messages"}}); peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][(ProcedureCode_id_RICserviceUpdate)] = &prometheusFamily->Add({{peerInfo->enodbName, "OUT"}, {"RICserviceUpdateFailure", "Bytes"}}); } + /** * * @param pdu @@ -1506,7 +1905,7 @@ int collectSetupRequestData(E2AP_PDU_t *pdu, if (ie->value.present == E2setupRequestIEs__value_PR_GlobalE2node_ID) { if (buildRanName(message.peerInfo->enodbName, ie) < 0) { mdclog_write(MDCLOG_ERR, "Bad param in E2setupRequestIEs GlobalE2node_ID.\n"); - // no mesage will be sent + // no message will be sent return -1; } @@ -1545,6 +1944,10 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) setup response from E2MGR : %s", rval.code, message.message.enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } @@ -1553,6 +1956,10 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu rmrMessageBuffer.sendMessage->payload, buff_size); if (er.encoded == -1) { mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } else if (er.encoded > (ssize_t)buff_size) { mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", @@ -1560,9 +1967,17 @@ int XML_From_PER(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBu asn_DEF_E2AP_PDU.name, __func__, __LINE__); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } rmrMessageBuffer.sendMessage->len = er.encoded; + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return 0; } @@ -1596,14 +2011,19 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, break; } - buildPrometheuslist(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); + buildPrometheusList(message.peerInfo, message.peerInfo->sctpParams->prometheusFamily); string messageName("E2setupRequest"); string ieName("E2setupRequestIEs"); message.message.messageType = RIC_E2_SETUP_REQ; message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); - buildAndsendSetupRequest(message, rmrMessageBuffer, pdu); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment((double)message.message.asnLength); + + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); break; } case ProcedureCode_id_RICserviceUpdate: { @@ -1622,18 +2042,29 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, string messageName("RICserviceUpdate"); string ieName("RICserviceUpdateIEs"); message.message.messageType = RIC_SERVICE_UPDATE; +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment((double)message.message.asnLength); - buildAndsendSetupRequest(message, rmrMessageBuffer, pdu); + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment((double)message.message.asnLength); +#endif + buildAndSendSetupRequest(message, rmrMessageBuffer, pdu); break; } case ProcedureCode_id_ErrorIndication: { if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got ErrorIndication %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_ERROR_INDICATION, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "RIC_ERROR_INDICATION failed to send to xAPP"); } @@ -1643,9 +2074,14 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); +#endif if (XML_From_PER(message, rmrMessageBuffer) < 0) { break; } @@ -1688,12 +2124,18 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, ie->value.choice.RICrequestID.ricInstanceID, ie->value.choice.RICrequestID.ricRequestorID); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication]->Increment(); message.peerInfo->counters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_RICindication]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_RICindication]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { - mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request"); + mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request"); } } if (messageSent) { @@ -1719,7 +2161,7 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, * @param message * @param rmrMessageBuffer */ -void asnSuccsesfulMsg(E2AP_PDU_t *pdu, +void asnSuccessfulMsg(E2AP_PDU_t *pdu, Sctp_Map_t *sctpMap, ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuffer) { @@ -1733,8 +2175,14 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Reset %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment((double)message.message.asnLength); +#endif if (XML_From_PER(message, rmrMessageBuffer) < 0) { break; } @@ -1770,13 +2218,18 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu, rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *)message.message.enodbName, strlen(message.message.enodbName)); - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { - mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request"); + mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request"); } } if (messageSent) { @@ -1790,8 +2243,14 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_RESP, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription successful message failed to send to xAPP"); } @@ -1801,8 +2260,14 @@ void asnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_DEL_RESP, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription delete successful message failed to send to xAPP"); } @@ -1859,12 +2324,18 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, strlen((const char *) tx)); rmr_bytes2meid(rmrMessageBuffer.sendMessage, (unsigned char *) message.message.enodbName, strlen(message.message.enodbName)); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment((double)message.message.asnLength); +#endif sendRmrMessage(rmrMessageBuffer, message); messageSent = true; } else { - mdclog_write(MDCLOG_ERR, "RIC request id missing illigal request"); + mdclog_write(MDCLOG_ERR, "RIC request id missing illegal request"); } } if (messageSent) { @@ -1877,8 +2348,14 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscription %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription unsuccessful message failed to send to xAPP"); } @@ -1888,8 +2365,14 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, if (logLevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got RICsubscriptionDelete %s", message.message.enodbName); } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment((double)message.message.asnLength); +#endif if (sendRequestToXapp(message, RIC_SUB_FAILURE, rmrMessageBuffer) != 0) { mdclog_write(MDCLOG_ERR, "Subscription Delete unsuccessful message failed to send to xAPP"); } @@ -1898,9 +2381,9 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, default: { mdclog_write(MDCLOG_WARN, "Undefined or not supported message = %ld", procedureCode); message.message.messageType = 0; // no RMR message type yet - +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) buildJsonMessage(message); - +#endif break; } } @@ -1991,18 +2474,35 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf } auto rval = asn_decode(nullptr, ATS_BASIC_XER, &asn_DEF_E2AP_PDU, (void **) &pdu, rmrMessageBuffer.rcvMessage->payload, rmrMessageBuffer.rcvMessage->len); + if (mdclog_level_get() >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "%s After decoding the XML to PDU", __func__ ); + } if (rval.code != RC_OK) { +#ifdef UNIT_TEST + return 0; +#endif mdclog_write(MDCLOG_ERR, "Error %d Decoding (unpack) setup response from E2MGR : %s", rval.code, message.message.enodbName); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } int buff_size = RECEIVE_XAPP_BUFFER_SIZE; auto er = asn_encode_to_buffer(nullptr, ATS_ALIGNED_BASIC_PER, &asn_DEF_E2AP_PDU, pdu, rmrMessageBuffer.rcvMessage->payload, buff_size); + if (mdclog_level_get() >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "%s After encoding PDU to PER", __func__ ); + } if (er.encoded == -1) { mdclog_write(MDCLOG_ERR, "encoding of %s failed, %s", asn_DEF_E2AP_PDU.name, strerror(errno)); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } else if (er.encoded > (ssize_t)buff_size) { mdclog_write(MDCLOG_ERR, "Buffer of size %d is to small for %s, at %s line %d", @@ -2010,9 +2510,17 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf asn_DEF_E2AP_PDU.name, __func__, __LINE__); + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return -1; } rmrMessageBuffer.rcvMessage->len = er.encoded; + if (pdu != nullptr) { + ASN_STRUCT_FREE(asn_DEF_E2AP_PDU, pdu); + pdu = nullptr; + } return 0; } @@ -2026,18 +2534,19 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf int receiveXappMessages(Sctp_Map_t *sctpMap, RmrMessagesBuffer_t &rmrMessageBuffer, struct timespec &ts) { + int loglevel = mdclog_level_get(); if (rmrMessageBuffer.rcvMessage == nullptr) { //we have error mdclog_write(MDCLOG_ERR, "RMR Allocation message, %s", strerror(errno)); return -1; } - if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Call to rmr_rcv_msg"); - } +// if (loglevel >= MDCLOG_DEBUG) { +// mdclog_write(MDCLOG_DEBUG, "Call to rmr_rcv_msg"); +// } rmrMessageBuffer.rcvMessage = rmr_rcv_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage); if (rmrMessageBuffer.rcvMessage == nullptr) { - mdclog_write(MDCLOG_ERR, "RMR Receving message with null pointer, Realloc rmr mesage buffer"); + mdclog_write(MDCLOG_ERR, "RMR Receiving message with null pointer, Reallocated rmr message buffer"); rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); return -2; } @@ -2048,8 +2557,11 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, // get message payload //auto msgData = msg->payload; +#ifdef UNIT_TEST + rmrMessageBuffer.rcvMessage->state = 0; +#endif if (rmrMessageBuffer.rcvMessage->state != 0) { - mdclog_write(MDCLOG_ERR, "RMR Receving message with stat = %d", rmrMessageBuffer.rcvMessage->state); + mdclog_write(MDCLOG_ERR, "RMR Receiving message with stat = %d", rmrMessageBuffer.rcvMessage->state); return -1; } rmr_get_meid(rmrMessageBuffer.rcvMessage, (unsigned char *)message.message.enodbName); @@ -2062,18 +2574,34 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, case RIC_HEALTH_CHECK_REQ: break; default: +#ifdef UNIT_TEST + break; +#endif mdclog_write(MDCLOG_ERR, "Failed to send message no CU entry %s", message.message.enodbName); return -1; } } + if (rmrMessageBuffer.rcvMessage->mtype != RIC_HEALTH_CHECK_REQ) { + num_of_XAPP_messages.fetch_add(1, std::memory_order_release); + + } switch (rmrMessageBuffer.rcvMessage->mtype) { case RIC_E2_SETUP_RESP : { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_RESP"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_RESP"); return -6; @@ -2081,11 +2609,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_E2_SETUP_FAILURE : { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2_SETUP_FAILURE"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_E2setup]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_E2setup]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_SETUP_FAILURE"); return -6; @@ -2093,8 +2630,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_ERROR_INDICATION: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_ERROR_INDICATION"); + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_ErrorIndication]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_ERROR_INDICATION"); return -6; @@ -2102,8 +2648,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_SUB_REQ: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_SUB_REQ"); + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscription]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscription]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SUB_REQ"); return -6; @@ -2111,8 +2666,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_SUB_DEL_REQ: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_SUB_DEL_REQ"); + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICsubscriptionDelete]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SUB_DEL_REQ"); return -6; @@ -2120,8 +2684,17 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_CONTROL_REQ: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_CONTROL_REQ"); + } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICcontrol]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICcontrol]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_CONTROL_REQ"); return -6; @@ -2129,11 +2702,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_SERVICE_QUERY: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_QUERY"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_QUERY"); return -6; @@ -2141,11 +2723,24 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_SERVICE_UPDATE_ACK: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_ACK"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { + mdclog_write(MDCLOG_ERR, "error in PER_FromXML"); break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); - message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); + message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "Before sending to CU"); + } if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_ACK"); return -6; @@ -2153,11 +2748,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_SERVICE_UPDATE_FAILURE: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_SERVICE_UPDATE_FAILURE"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); - message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceQuery]->Increment(rmrMessageBuffer.rcvMessage->len); + message.peerInfo->counters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][MSG_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_UN_SUCC][BYTES_COUNTER][ProcedureCode_id_RICserviceUpdate]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_SERVICE_UPDATE_FAILURE"); return -6; @@ -2165,11 +2769,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_E2_RESET_REQ: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_REQ"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[OUT_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[IN_INITI][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); + message.peerInfo->sctpParams->e2tCounters[IN_INITI][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_RESET"); return -6; @@ -2177,11 +2790,20 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, break; } case RIC_E2_RESET_RESP: { + if (loglevel >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "RIC_E2_RESET_RESP"); + } if (PER_FromXML(message, rmrMessageBuffer) != 0) { break; } +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) message.peerInfo->counters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); message.peerInfo->counters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); + + // Update E2T instance level metrics + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][MSG_COUNTER][ProcedureCode_id_Reset]->Increment(); + message.peerInfo->sctpParams->e2tCounters[OUT_SUCC][BYTES_COUNTER][ProcedureCode_id_Reset]->Increment(rmrMessageBuffer.rcvMessage->len); +#endif if (sendDirectionalSctpMsg(rmrMessageBuffer, message, 0, sctpMap) != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_E2_RESET_RESP"); return -6; @@ -2233,45 +2855,49 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen); +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); +#endif if (rmrMessageBuffer.sendMessage == nullptr) { rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "Failed to send E2_TERM_KEEP_ALIVE_RESP RMR message returned NULL"); } else if (rmrMessageBuffer.sendMessage->state != 0) { mdclog_write(MDCLOG_ERR, "Failed to send E2_TERM_KEEP_ALIVE_RESP, on RMR state = %d ( %s)", rmrMessageBuffer.sendMessage->state, translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str()); - } else if (mdclog_level_get() >= MDCLOG_DEBUG) { + } else if (loglevel >= MDCLOG_DEBUG) { mdclog_write(MDCLOG_DEBUG, "Got Keep Alive Request send : %s", rmrMessageBuffer.ka_message); } break; } case RIC_HEALTH_CHECK_REQ: { + static int counter = 0; // send message back - rmr_bytes2payload(rmrMessageBuffer.sendMessage, + rmr_bytes2payload(rmrMessageBuffer.rcvMessage, (unsigned char *)"OK", 2); - rmrMessageBuffer.sendMessage->mtype = RIC_HEALTH_CHECK_RESP; - rmrMessageBuffer.sendMessage->state = 0; + rmrMessageBuffer.rcvMessage->mtype = RIC_HEALTH_CHECK_RESP; + rmrMessageBuffer.rcvMessage->state = 0; static unsigned char tx[32]; auto txLen = snprintf((char *) tx, sizeof tx, "%15ld", transactionCounter++); - rmr_bytes2xact(rmrMessageBuffer.sendMessage, tx, txLen); - rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); - if (rmrMessageBuffer.sendMessage == nullptr) { - rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); + rmr_bytes2xact(rmrMessageBuffer.rcvMessage, tx, txLen); + rmrMessageBuffer.rcvMessage = rmr_rts_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.rcvMessage); + //rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); + if (rmrMessageBuffer.rcvMessage == nullptr) { + rmrMessageBuffer.rcvMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP RMR message returned NULL"); - } else if (rmrMessageBuffer.sendMessage->state != 0) { + } else if (rmrMessageBuffer.rcvMessage->state != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP, on RMR state = %d ( %s)", - rmrMessageBuffer.sendMessage->state, translateRmrErrorMessages(rmrMessageBuffer.sendMessage->state).c_str()); - } else if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "Got RIC_HEALTH_CHECK_REQ Request send : OK"); + rmrMessageBuffer.rcvMessage->state, translateRmrErrorMessages(rmrMessageBuffer.rcvMessage->state).c_str()); + } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == 0)) { + mdclog_write(MDCLOG_DEBUG, "Got %d RIC_HEALTH_CHECK_REQ Request send : OK", counter); } break; } default: - mdclog_write(MDCLOG_WARN, "Message Type : %d is not seported", rmrMessageBuffer.rcvMessage->mtype); + mdclog_write(MDCLOG_WARN, "Message Type : %d is not supported", rmrMessageBuffer.rcvMessage->mtype); message.message.asndata = rmrMessageBuffer.rcvMessage->payload; message.message.asnLength = rmrMessageBuffer.rcvMessage->len; message.message.time.tv_nsec = ts.tv_nsec; @@ -2301,6 +2927,9 @@ int sendDirectionalSctpMsg(RmrMessagesBuffer_t &messageBuffer, ReportingMessages_t &message, int failedMsgId, Sctp_Map_t *sctpMap) { + if (mdclog_level_get() >= MDCLOG_DEBUG) { + mdclog_write(MDCLOG_DEBUG, "send message: %d to %s address", message.message.messageType, message.message.enodbName); + } getRequestMetaData(message, messageBuffer); if (mdclog_level_get() >= MDCLOG_INFO) { @@ -2351,8 +2980,9 @@ int addToEpoll(int epoll_fd, event.data.ptr = peerInfo; event.events = events; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, peerInfo->fileDescriptor, &event) < 0) { +#if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_ADD (may chack not to quit here), %s, %s %d", + mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here), %s, %s %d", strerror(errno), __func__, __LINE__); } close(peerInfo->fileDescriptor); @@ -2371,8 +3001,9 @@ int addToEpoll(int epoll_fd, } else { peerInfo->enodbName[0] = 0; } - mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may chack not to quit here)"); + mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)"); return -1; +#endif } return 0; } @@ -2399,7 +3030,7 @@ int modifyToEpoll(int epoll_fd, event.events = events; if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, peerInfo->fileDescriptor, &event) < 0) { if (mdclog_level_get() >= MDCLOG_DEBUG) { - mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_MOD (may chack not to quit here), %s, %s %d", + mdclog_write(MDCLOG_DEBUG, "epoll_ctl EPOLL_CTL_MOD (may check not to quit here), %s, %s %d", strerror(errno), __func__, __LINE__); } close(peerInfo->fileDescriptor); @@ -2414,7 +3045,7 @@ int modifyToEpoll(int epoll_fd, free(tmp); } sctpMap->erase(key); - mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may chack not to quit here)"); + mdclog_write(MDCLOG_ERR, "epoll_ctl EPOLL_CTL_ADD (may check not to quit here)"); return -1; } return 0; @@ -2423,9 +3054,11 @@ int modifyToEpoll(int epoll_fd, int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &message) { buildJsonMessage(message); - +#ifndef UNIT_TEST rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); - +#else + rmrMessageBuffer.sendMessage->state = RMR_ERR_RETRY; +#endif if (rmrMessageBuffer.sendMessage == nullptr) { rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer"); @@ -2440,7 +3073,9 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m mdclog_write(MDCLOG_INFO, "RETRY sending Message type %d to Xapp from %s", rmrMessageBuffer.sendMessage->mtype, rmr_get_meid(rmrMessageBuffer.sendMessage, (unsigned char *)meid)); +#ifndef UNIT_TEST rmrMessageBuffer.sendMessage = rmr_send_msg(rmrMessageBuffer.rmrCtx, rmrMessageBuffer.sendMessage); +#endif if (rmrMessageBuffer.sendMessage == nullptr) { mdclog_write(MDCLOG_ERR, "RMR failed send message returned with NULL pointer"); rmrMessageBuffer.sendMessage = rmr_alloc_msg(rmrMessageBuffer.rmrCtx, RECEIVE_XAPP_BUFFER_SIZE); @@ -2466,6 +3101,9 @@ int sendRmrMessage(RmrMessagesBuffer_t &rmrMessageBuffer, ReportingMessages_t &m } void buildJsonMessage(ReportingMessages_t &message) { +#ifdef UNIT_TEST + jsonTrace = true; +#endif if (jsonTrace) { message.outLen = sizeof(message.base64Data); base64::encode((const unsigned char *) message.message.asndata, @@ -2511,7 +3149,7 @@ string translateRmrErrorMessages(int state) { str = "RMR_OK - state is good"; break; case RMR_ERR_BADARG: - str = "RMR_ERR_BADARG - argument passd to function was unusable"; + str = "RMR_ERR_BADARG - argument passed to function was unusable"; break; case RMR_ERR_NOENDPT: str = "RMR_ERR_NOENDPT - send//call could not find an endpoint based on msg type"; @@ -2566,5 +3204,3 @@ string translateRmrErrorMessages(int state) { } return str; } - -