cdrcombination.cpp

Mysql的处理

/********************************************************************************/
/* 系 统 名：计费网关		                              					　	*/
/* 文 件 名：CdrCombination.cpp                                        			*/
/* 作    者：冯睿                                                           	*/
/* 日    期：2006.05.13                                                       	*/
/* 功能描述：话单合并类的定义                                          		  	*/
/* 版　　本：V1.0                                                             	*/
/********************************************************************************/
#include <iostream>
#include "CdrCombination.h"
#include "CDRWriteCombined.h"
#include <time.h>


#include <stdlib.h>
#include "CdrDefine.h"
#include "CDR.h"
#include "oradb.h"
#include "CDRReadForBill.h"
#include "ConfigXml.h"

#include <pthread.h>
#include <fstream>
using namespace std;

//#include "../../../../include/shm/ShareMemory.h"
//#include "ShareMemory.h"
//using namespace SHM;

#define AREA_ASN1 20
#define AREA_GCDR 30

// define program flag
#define PROGRAM_VACANCY 0
#define PROGRAM_GTP 20
#define PROGRAM_ASN1 30
#define PROGRAM_GCDR 50

#define BUFFER_SIZE_GCDR 3 * 1024
#define NUM_OF_CDR_READ 5
#define NUM_OF_CDR_DATA_VOL_READ NUM_OF_CDR_READ*4
#define LEN_OF_FILE_NAME 100
#define LEN_OF_STRING 50
//#define FILE_NAME_OF_CONFIG "/space/cgateway/cg/src/common/shm/charginggateway.xml"
//#define FILE_NAME_OF_CONFIG "/space/cgateway/cg/src/config/charginggateway.xml"
//#define FILE_NAME_OF_CONFIG "../../src/config/charginggateway.xml"
//#define FILE_NAME_OF_CONFIG "../config/charginggateway.xml"
#define FILE_NAME_OF_CONFIG "../charginggateway.xml"

//How many fields are required to combine?
#define COMBINATION_FIELD_NUM 5

C_CDR g_cdr;

//const  map<CidAndGgsnAddrStruct, S_CGCDR_C*>::size_type C_GCdrCombination::GCDRCG_MAX_SIZE=2;
map<CidAndGgsnAddrStruct, S_CGCDR_C*>::size_type C_GCdrCombination::GCDRCG_MAX_SIZE=10;
map<CidAndGgsnAddrStruct, S_CGCDR_C*> map_GCdrCg;

/*const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_NORMAL=1;
const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_ABNORMAL=2;
const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_REACHLIMIT=3;*/

const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_NORMAL=0;
const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_ABNORMAL=1;
const unsigned int C_GCdrCombination::CONSOLIDATION_RESULT_REACHLIMIT=3;


unsigned long S_CGCDR_C::GCDRCG_NUM_LIMIT_OF_COMBINED=20;

//time limit of combined, in milliseconds
unsigned long C_GCdrCombination::GCDRCG_TIME_LIMIT_OF_COMBINED=5;

unsigned long C_GCdrCombination::GCDRCG_DURATION_MIN = 0;
unsigned long C_GCdrCombination::GCDRCG_DURATION_MAX = 1000000;

string C_GCdrCombination::GCDRCG_MAX_RECORD_SEQUENCE_NUMBER = "1000";
	
//trigger types
const unsigned int C_GCdrCombination::TRIGGER_TYPE_NORMAL = 0;//C-ID & GGSN addr
const unsigned int C_GCdrCombination::TRIGGER_TYPE_TIME = 1;//time trigger

string C_GCdrCombination::TRIGGER_TIME_START = "200606101000"; //start time value for its trigger
string C_GCdrCombination::TRIGGER_TIME_END =   "200606201100"; //end time value for its trigger
string C_GCdrCombination::DB_USER = "cgdb";
string C_GCdrCombination::DB_PASSWORD = "cgdb";
string C_GCdrCombination::DB_DBNAME = "";
	
string C_GCdrCombination::OUTPUT_OR_NOT = "false";

#define CONF_OUTPUT_OR_NOT "CdrCombination.GCDR.R99.OutputOrNot"
//const unsigned int C_GCdrCombination::TRIGGER_TYPE = C_GCdrCombination::TRIGGER_TYPE_TIME;//which trigger will be used?
unsigned int C_GCdrCombination::TRIGGER_TYPE = C_GCdrCombination::TRIGGER_TYPE_NORMAL;//which trigger will be used?

#define CONF_GCDRCG_MAX_SIZE "CdrCombination.GCDR.R99.GcdrcgMaxSize"
#define CONF_GCDRCG_NUM_LIMIT_OF_COMBINED "CdrCombination.GCDR.R99.GcdrcgNumLimitOfCombined"
#define CONF_GCDRCG_TIME_LIMIT_OF_COMBINED "CdrCombination.GCDR.R99.GcdrcgTimeLimitOfCombined"

#define CONF_GCDRCG_DURATION_MIN "CdrCombination.GCDR.R99.GcdrcgDurationMin"
#define CONF_GCDRCG_DURATION_MAX "CdrCombination.GCDR.R99.GcdrcgDurationMax"


#define CONF_GCDRCG_MAX_RECORD_SEQUENCE_NUMBER "CdrCombination.GCDR.R99.GcdrcgMaxRecordSequenceNumber"
#define CONF_TRIGGER_TYPE "CdrCombination.GCDR.R99.TriggerType"
#define CONF_TRIGGER_TIME_START "CdrCombination.GCDR.R99.TriggerTimeStart"
#define CONF_TRIGGER_TIME_END "CdrCombination.GCDR.R99.TriggerTimeEnd"
#define CONF_COMBINE_OR_NOT "CdrCombination.GCDR.R99.CombineOrNot"
#define CONF_DB_USER "Database.User"
#define CONF_DB_PASSWORD "Database.Password"
#define CONF_DB_DBNAME "Database.DbName"

//FILE *fptr2;
#define CAUSE_SGSNCHANGE_SORTING "10"
#define CAUSE_SGSNCHANGE_REAL "18"
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * CombinationForGcdr(void *pGCdrCom);
static void * ControlTimeLimit(void * pGCdrCom);

static char* Time()
{
	time_t t = time(0);
	tm* t2 = localtime(&t);
	static char szTime[40];
	snprintf(szTime, 40, "[%04d-%02d-%02d %02d:%02d:%02d]", 
		t2->tm_year+1900,
		t2->tm_mon+1,
		t2->tm_mday,
		t2->tm_hour,
		t2->tm_min,
		t2->tm_sec);

	return szTime;
}


static bool WriteCombinedGCdrErrorInfoToFile(char * pErrorInfo)
{
	if (NULL == pErrorInfo)
	{
		return false;
	}
	FILE * fp = fopen("CombinedGcdrErrorInfo.log", "a+");	
	fprintf(fp,"\n  CG-CDR  %s\n", Time());

	fprintf(fp,"ErrorInfo			:%s\n", pErrorInfo );

	fclose(fp);
	return true;
}


static bool WriteCombinedGCdrToFile(S_CGCDR * cdr, 
				   S_LLOTV * p_llotv,
				   int nNumberOfDataVolume,
				   S_LCOMM * p_lcomm,
				   int nNumberOfSgsnAddr,
				   int nNumberOfCommb,
				   int size_contentInfo,
				   SortedRecSeqNumList * SortedRecSeqNum)
{
	if (NULL == cdr)
	{
		return false;
	}
	//pthread_mutex_lock( &g_mutex );
	FILE * fp = fopen("CombinedGcdr.log", "a+");	
	printf("Begin to write file\n");
	fprintf(fp,"\n  CG-CDR  %s\n", Time());

	fprintf(fp,"RecordType			:%d\n", cdr->RecordType );
	fprintf(fp,"NetworkInitiation	:%d\n", cdr->NetworkInitiatedPDPContext );
	fprintf(fp,"ServedIMSI			:%s\n", cdr->ServedIMSI );
	fprintf(fp,"GGSNAddress			:%s\n", cdr->GGSNAddress );
	fprintf(fp,"ChargingID			:%s\n", cdr->ChargingID );
	//fprintf(fp,"SGSNIPAddress		:%s\n", cdr->SGSNIPAddress );
	fprintf(fp,"AccessPointNameNI	:%s\n", cdr->AccessPointNameNI );
	fprintf(fp,"PDPType             :%s\n",cdr->PDPTypeNumber);
	fprintf(fp,"ServedPDPAddress    :%s\n",cdr->ServedPDPAddress);
	fprintf(fp,"DynamicAddressFlag  :%d\n",cdr->DynamicAddressFlag);
	
	
	//ok
	fprintf(fp,"RecordOpeningTime               :%s\n",cdr->RecordOpenTime);
	fprintf(fp,"CallDuration					:%s\n",cdr->CallDuration);
	//fprintf(fp,"CauseForRecClosing              :%s\n",cdr->CauseForRecClosing);
	fprintf(fp,"Diagnostics						:%s\n",cdr->Diagnostics);
	//fprintf(fp,"RecordSequenceNumber            :%s\n",cdr->RecordSequenceNumber);
	fprintf(fp,"NodeID							:%s\n",cdr->NodeID);
	//fprintf(fp,"RecordExtensions				:%s\n",cdr->RecordExtensions);
	//fprintf(fp,"LocalRecordSequenceNumber       :%s\n",cdr->LocalRecordSequeceNumnber);
	fprintf(fp,"APNSelectionMode				:%d\n",cdr->APNSelectionMode);
	fprintf(fp,"ServedMSISDN					:%s\n",cdr->ServedMSISDN);
	fprintf(fp,"ChargingCharacteristics         :%s\n",cdr->ChargingCharacteristics);
	fprintf(fp,"SgsnPlmnIdentifier					:%s\n",cdr->SgsnPlmnIdentifier);
	//ok

	fprintf(fp,"ConsolidationResult					:%s\n",cdr->ConsolidationResult);
	fprintf(fp,"ChargingCharacterSelectionMode					:%d\n",cdr->ChargingCharacterSelectionMode);
	fprintf(fp,"AnonyAccessIndicator					:%d\n",cdr->AnonyAccessIndicator);
	fprintf(fp,"RemotePdpAddr					:%s\n",cdr->RemotePdpAddr);

	if (NULL != p_llotv)
	{
		fprintf(fp,"List of Traffic Volumn {\n");
		for(int i = 0; i < nNumberOfDataVolume; i++)
		{
			fprintf(fp,"   {\n");
			fprintf(fp,"     QosRequested{\n");
			
			fprintf(fp,"       QoSNUMTS:			:%s\n",p_llotv[i].QoSRUMTS);
			fprintf(fp,"       Reliability:		:%d\n",p_llotv[i].QoSRReliability);
			fprintf(fp,"       Delay:				:%d\n",p_llotv[i].QoSRDelay);
			fprintf(fp,"       Precedence:		:%d\n",p_llotv[i].QoSRPrecedence);
			fprintf(fp,"       PeakThroughput:	:%s\n",p_llotv[i].QoSRPeakThrougput);
			fprintf(fp,"       MeanThroughput:	:%s\n",p_llotv[i].QoSRMeanThroughput);
			fprintf(fp,"     }\n");
			
			fprintf(fp,"     QosNegotiated{\n");
			fprintf(fp,"       QoSNUMTS:			:%s\n",p_llotv[i].QoSNUMTS);
			fprintf(fp,"       Reliability:		:%d\n",p_llotv[i].QoSNReliability);
			fprintf(fp,"       Delay:			:%d\n",p_llotv[i].QoSNDelay);
			fprintf(fp,"       Precedence:		:%d\n",p_llotv[i].QoSNPrecedence);
			fprintf(fp,"       PeakThroughput:	:%s\n",p_llotv[i].QoSNPeakThrougput);
			fprintf(fp,"       MeanThroughput:	:%s\n",p_llotv[i].QoSNMeanThroughput);
			fprintf(fp,"     }\n");
		
			fprintf(fp,"     DataVolumeGPRSUplink:			:%s\n",p_llotv[i].DataVolumeGPRSUp);
			fprintf(fp,"     DataVolumeGPRSDownlink:			:%s\n",p_llotv[i].DataVolumeGPRSDown);
			fprintf(fp,"     ChangeCondition:				:%d\n",p_llotv[i].ChangeCondition);
			fprintf(fp,"     ChangeTime:						:%s\n",p_llotv[i].ChangeTime);
		}
	}
	fprintf(fp,"   }\n");

	//cout<<"nNumberOfSgsnAddr:"<<nNumberOfSgsnAddr<<endl;
	//cout<<"nNumberOfCommb:"<<nNumberOfCommb<<endl;
	if (NULL != p_lcomm)
	{
		int i = 0;
		fprintf(fp,"SGSNIPAddress {\n");
		for(i = 0; i < nNumberOfSgsnAddr; i++)
		{
			if ((NULL != p_lcomm)&&
			(NULL != p_lcomm->SGSNAddr))
			{
				fprintf(fp,"       SGSNIPAddress %d:			:%s\n", i, p_lcomm->SGSNAddr);
				p_lcomm++;
			}
		}
		fprintf(fp,"   }\n");

		fprintf(fp,"CauseForRecClosing {\n");
		for(i=0; i < nNumberOfCommb; i++)
		{
			if ((NULL != p_lcomm)&&
			(NULL != p_lcomm->CauseForRecordClosing))
			{
				fprintf(fp,"       CauseForRecClosing :			:%s\n", p_lcomm->CauseForRecordClosing);
				p_lcomm++;
			}
			
		}

		fprintf(fp,"   }\n");

		fprintf(fp,"RecordSequenceNumber {\n");

		fprintf(fp,"       GGSNAddress :			:%s\n", p_lcomm->SGSNAddr);
		p_lcomm++;
		
		//for(i=0; i <= nNumberOfCommb; i++)
		for(i=1; i <= nNumberOfCommb; i++)
		{
			if ((NULL != p_lcomm)&&
			(NULL != p_lcomm->RSN))
			{
				fprintf(fp,"       RecordSequenceNumber :			:%s\n", p_lcomm->RSN);
				p_lcomm++;
			}
		}
		fprintf(fp,"   }\n");

		fprintf(fp,"LocalRecordSequenceNumber {\n");
		//for(i=0; i <= nNumberOfCommb; i++)
		fprintf(fp,"       GGSNAddress :			:%s\n", p_lcomm->SGSNAddr);
		p_lcomm++;

		for(i=1; i <= nNumberOfCommb; i++)
		{
			if ((NULL != p_lcomm)&&
			(NULL != p_lcomm->LRSN))
			{
				fprintf(fp,"       LocalRecordSequenceNumber :			:%s\n", p_lcomm->LRSN);
				p_lcomm++;
			}
		}

		fprintf(fp,"   }\n");

		fprintf(fp,"RecordExtensions {\n");
		fprintf(fp,"       ExtensionType :			:%s\n", p_lcomm->RSN);
		fprintf(fp,"       ContentInfoLength :			:%s\n\n", p_lcomm->LRSN);
		p_lcomm++;
		
		//for(i=0; i < nNumberOfCommb*NUM_OF_CONTENT_INFO_NODE; i++)
		for(i=0; i < size_contentInfo; i++)
		{
			if ((NULL != p_lcomm)&&
			(NULL != p_lcomm->NodeId)&&
			(NULL != p_lcomm->RSN)&&
			(NULL != p_lcomm->LRSN)&&
			(NULL != &(p_lcomm->RNC))&&
			(NULL != p_lcomm->RecordExtensions))
			{
				fprintf(fp,"       ServiceCode :			:%s\n", p_lcomm->NodeId);
				fprintf(fp,"       UpVolume :			:%s\n", p_lcomm->RSN);
				fprintf(fp,"       DownVolume :			:%s\n", p_lcomm->LRSN);
				fprintf(fp,"       UsageDuration :			:%d\n", p_lcomm->RNC);
				fprintf(fp,"       Url :			:%s\n\n", p_lcomm->RecordExtensions);
			}
			p_lcomm++;
		}

		fprintf(fp,"   }\n");
	}
	fprintf(fp,"SortedRecSeqNum {\n");
	
	if (NULL != SortedRecSeqNum)
	{
		while(NULL != SortedRecSeqNum)
		{
			fprintf(fp,"\n       RecordSequenceNumber-> :			:%s\n", SortedRecSeqNum->RecordSequenceNumber);
			fprintf(fp,"       RecordOpenTime-> :			:%s\n", SortedRecSeqNum->RecordOpenTime);
			fprintf(fp,"       CallDuration-> :			:%s\n", SortedRecSeqNum->CallDuration);
			SortedRecSeqNum = SortedRecSeqNum->next;
		}
	}
	fprintf(fp,"   }\n");

	fclose(fp);
	printf("Succeeed to write file\n");
	//pthread_mutex_unlock( &g_mutex );
	return true;
}

static bool ConvertOGcdrToCdrCg(S_OGCDR2 *pGCdr, S_CGCDR *pGCdrCg, int numOfCdrRead)
{
	S_OGCDR2 *pGCdrTmp;
	S_CGCDR *pGCdrCgTmp;
	
	//输入参数合法性检测
	if ((NULL == pGCdr)||
	    (NULL == pGCdrCg))
	{
		return false;
	}
	
	pGCdrTmp = pGCdr;
	pGCdrCgTmp = pGCdrCg;
	
	for (int i =0; i < numOfCdrRead; i++)
	{
		pGCdrCg[i].RecordType = pGCdr[i].RecordType;
		pGCdrCg[i].NetworkInitiatedPDPContext = pGCdr[i].NetworkInitiatedPDPContext;

		memcpy(pGCdrCg[i].ServedIMSI,
			  pGCdr[i].ServedIMSI,
			  strlen(pGCdr[i].ServedIMSI));		

		memcpy(pGCdrCg[i].GGSNAddress,
			  pGCdr[i].GGSNAddress,
			  strlen(pGCdr[i].GGSNAddress));		

		memcpy(pGCdrCg[i].ChargingID,
			  pGCdr[i].ChargingID,
			  strlen(pGCdr[i].ChargingID));		

		memcpy(pGCdrCg[i].AccessPointNameNI,
			  pGCdr[i].AccessPointNameNI,
			  strlen(pGCdr[i].AccessPointNameNI));		

		memcpy(pGCdrCg[i].PDPTypeNumber,
			  pGCdr[i].PDPTypeNumber,
			  strlen(pGCdr[i].PDPTypeNumber));		

		memcpy(pGCdrCg[i].ServedPDPAddress,
			  pGCdr[i].ServedPDPAddress,
			  strlen(pGCdr[i].ServedPDPAddress));		

		pGCdrCg[i].DynamicAddressFlag = pGCdr[i].DynamicAddressFlag;

		memcpy(pGCdrCg[i].RecordOpenTime,
			  pGCdr[i].RecordOpenTime,
			  strlen(pGCdr[i].RecordOpenTime));		

		memcpy(pGCdrCg[i].CallDuration,
			  pGCdr[i].CallDuration,
			  strlen(pGCdr[i].CallDuration));		

		//pGCdrCg[i].Diagnostics = pGCdr[i].Diagnostics;
		memcpy(pGCdrCg[i].Diagnostics,
			pGCdr[i].Diagnostics,
			sizeof(pGCdrCg[i].Diagnostics));

		memcpy(pGCdrCg[i].NodeID,
			  pGCdr[i].NodeID,
			  strlen(pGCdr[i].NodeID));		

		pGCdrCg[i].APNSelectionMode = pGCdr[i].APNSelectionMode;

		memcpy(pGCdrCg[i].ServedMSISDN,
			  pGCdr[i].ServedMSISDN,
			  strlen(pGCdr[i].ServedMSISDN));		

		memcpy(pGCdrCg[i].SgsnPlmnIdentifier,
			  pGCdr[i].SgsnPlmnIdentifier,
			  strlen(pGCdr[i].SgsnPlmnIdentifier));		

		memcpy(pGCdrCg[i].SGSNIPAddress,
			  pGCdr[i].SGSNIPAddress,
			  strlen(pGCdr[i].SGSNIPAddress));