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=be9c5d67fe1f1e44c22b15972eadb0797c2eba25;hpb=93b6d9cd271359453e24a7ddf4158095287cbfc7;p=ric-plt%2Fe2.git diff --git a/RIC-E2-TERMINATION/sctpThread.cpp b/RIC-E2-TERMINATION/sctpThread.cpp index be9c5d6..55f9083 100644 --- a/RIC-E2-TERMINATION/sctpThread.cpp +++ b/RIC-E2-TERMINATION/sctpThread.cpp @@ -60,6 +60,22 @@ boost::shared_ptr> boostLogger double cpuClock = 0.0; 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) { @@ -79,7 +95,7 @@ static int register_log_change_notify(const char *fileName) 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 *)strdup(fileName)); + return pthread_create(&tid, &cb_attr,&monitor_loglevel_change_handler,(void *)fileName); } @@ -129,7 +145,7 @@ static void * monitor_loglevel_change_handler(void* arg) #if !(defined(UNIT_TEST) || defined(MODULE_TEST)) if( errno == EAGAIN ) { } else { - fprintf( stderr, "### CRIT ### config listener read err: %s\n", strerror( errno ) ); + printf( "### CRIT ### config listener read err: %s\n", strerror( errno ) ); } continue; #endif @@ -490,13 +506,30 @@ 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 prometheusPath = 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", prometheusPath.c_str()); } @@ -803,6 +836,10 @@ void listener(sctp_params_t *params) { continue; } mdclog_write(MDCLOG_ERR, "Epoll wait failed, errno = %s", strerror(errno)); + if(events) + { + free(events); + } return; #endif } @@ -842,8 +879,12 @@ void listener(sctp_params_t *params) { #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; } @@ -851,6 +892,8 @@ 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 } @@ -860,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) { @@ -872,6 +917,8 @@ void listener(sctp_params_t *params) { (EPOLLIN | EPOLLET), params->sctpMap, nullptr, 0) != 0) { + if(peerInfo) + free(peerInfo); break; } break; @@ -1388,6 +1435,10 @@ int receiveDataFromSctp(struct epoll_event *events, 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; } @@ -1430,12 +1481,13 @@ int receiveDataFromSctp(struct epoll_event *events, 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; } -#ifdef UNIT_TEST +#else done = 1; break; #endif @@ -1699,6 +1751,68 @@ int collectServiceUpdate_RequestData(E2AP_PDU_t *pdu, #endif +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"}}); @@ -1771,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 @@ -1829,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; } @@ -1837,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", @@ -1844,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; } @@ -1887,6 +2018,11 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, 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); + + // 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; } @@ -1909,6 +2045,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, #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); + + // 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; @@ -1920,6 +2060,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, #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"); @@ -1933,6 +2077,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, #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; @@ -1979,6 +2127,10 @@ void asnInitiatingRequest(E2AP_PDU_t *pdu, #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; @@ -2026,6 +2178,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, #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; @@ -2065,6 +2221,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, #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; @@ -2086,6 +2246,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, #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"); @@ -2099,6 +2263,10 @@ void asnSuccessfulMsg(E2AP_PDU_t *pdu, #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"); @@ -2159,6 +2327,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, #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; @@ -2179,6 +2351,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, #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"); @@ -2192,6 +2368,10 @@ void asnUnSuccsesfulMsg(E2AP_PDU_t *pdu, #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"); @@ -2304,6 +2484,10 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf 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; } @@ -2315,6 +2499,10 @@ int PER_FromXML(ReportingMessages_t &message, RmrMessagesBuffer_t &rmrMessageBuf } 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", @@ -2322,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; } @@ -2401,6 +2597,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2418,6 +2618,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2432,6 +2636,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2446,6 +2654,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2460,6 +2672,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2474,6 +2690,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2491,6 +2711,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2509,6 +2733,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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_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"); @@ -2529,6 +2757,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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_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"); @@ -2546,6 +2778,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2563,6 +2799,10 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, #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"); @@ -2649,7 +2889,7 @@ int receiveXappMessages(Sctp_Map_t *sctpMap, } else if (rmrMessageBuffer.rcvMessage->state != 0) { mdclog_write(MDCLOG_ERR, "Failed to send RIC_HEALTH_CHECK_RESP, on RMR state = %d ( %s)", rmrMessageBuffer.rcvMessage->state, translateRmrErrorMessages(rmrMessageBuffer.rcvMessage->state).c_str()); - } else if (loglevel >= MDCLOG_DEBUG && ++counter % 100 == 0) { + } else if (loglevel >= MDCLOG_DEBUG && (++counter % 100 == 0)) { mdclog_write(MDCLOG_DEBUG, "Got %d RIC_HEALTH_CHECK_REQ Request send : OK", counter); }