ctempfilemanager.cpp

Mysql的处理

	if (bResult && cTemp.length() > 0)
	{
		m_mapPath.insert(pairPath(SHORT_BS, cTemp));
	}
	else
	{
		//默认有一个bs路径
		m_mapPath.insert(pairPath(SHORT_BS, STRING_BS_PATH));
	}

	cTemp = "";
	bResult = configxml.GetValue(CONF_BS2_PATH, cTemp);
	if (bResult && cTemp.length() > 0)
	{
		m_mapPath.insert(pairPath(SHORT_BS2, cTemp));
	}

	cTemp = "";
	bResult = configxml.GetValue(CONF_BS3_PATH, cTemp);
	if (bResult && cTemp.length() > 0)
	{
		m_mapPath.insert(pairPath(SHORT_BS3, cTemp));
	}

	return true;
}

/**********************************************************************
*Function Name: cdrInit
*Sescription: 初始化CDR
*Input: [const string&] 传入的CDR字符串
*Output: [bool] true--初始化成功; false--初始化失败
*Remark: 
**********************************************************************/
bool CTempFileManager::cdrInit(const string& strCdr)
{
	VECBS vecBs;
	GetBsVec(GCDR, &vecBs);
	
	typedef pair<short, CFNPManager*> pairBs;
	MAPBSOBJECT mapBs;

	for (short i=0; i < vecBs.size(); i++)
	{
		//GCDR生成文件名变量初始化
		CFNPManager* pCdrCFNPManager = new CFNPManager;

		if (NULL == pCdrCFNPManager)
		{
			printf("New %s CFNPManager error.\n", strCdr);
			return false;
		}

		mapBs.insert(pairBs(vecBs.at(i), pCdrCFNPManager));
	}

	typedef pair<string, MAPBSOBJECT> paitTemp;
	m_mapCFNPManager.insert(paitTemp(strCdr, mapBs));

	return true;
}

/**********************************************************************
*Function Name: getCurrentTicks
*Sescription: 获得当前时间(秒)
*Input: [time_t*] 保存当前时间的整型变量
*Output: [bool] true--成功; false--失败
*Remark: 
**********************************************************************/
bool CTempFileManager::getCurrentTicks(time_t* ltimeOut)
{
	// 获得当前系统时间(秒)
	if (time(ltimeOut) == -1)
	{
		printf("get cur time is error!\n");
		return false;
	}
}
	
/**********************************************************************
*Function Name: isTimeOfTempFileReached
*Sescription: 判断临时文件是否超时
*Input: [const long] 用来判断是否超时的时间变量
*Output: [bool] true--成功; false--失败
*Remark: 
**********************************************************************/
bool CTempFileManager::isTimeOfTempFileReached(const long nTime)
{
	time_t ltimeOut;
	getCurrentTicks(&ltimeOut);
	
	return (ltimeOut - nTime) >= m_nTimeLimitOfCdrSavedForTransferFile;
}

/**********************************************************************
*Function Name: getCurDateTime
*Sescription: 得到当前时间
*Input: [char*] 存储当前时间变量
*		[int*]  存储当前小时
*		[int*]  存储当前分钟
*		[int*]  存储当前秒
*Output: [bool] true--成功; false--失败
*Remark: 
**********************************************************************/
bool CTempFileManager::getCurDateTime(char* cCurdatetime, int* nhour, int* nMin, int* nSec)
{
	time_t     ltime;
	struct tm* tm_string;
	int        ich;

	if (time(&ltime) == -1)
	{
		printf("GetCurrentDay()::time() is error!\n");
		return false;
	}

	tm_string = localtime(&ltime);
	ich = strftime(cCurdatetime, 16, "%Y%m%d-%H%M%S", tm_string);
	*nhour = tm_string->tm_hour;
	*nMin = tm_string->tm_min;
	*nSec = tm_string->tm_sec;
	
	if (ich < 0)
	{
		printf("GetCurrentDay()::strftime() is error!\n");
		return false;
	}

	return true;
}

/**********************************************************************
*Function Name: getCdrStringFromMacro
*Sescription: 根据传入的宏得到三种存储方式对应的宏串
*Input: [const string&] 5种存储方式对应的宏
*Output: [string] 三种存储方式对应的宏，例如：CDR或GCDR
*Remark: 
**********************************************************************/
string CTempFileManager::getCdrStringFromMacro(const string& strCdr)
{
	//m_nSaveUpFileType等于EACHCDR时
	string strRet = strCdr;

	if (m_nSaveUpFileType == UNIONCDR)
	{
		strRet = CDR;
	}
	else if(m_nSaveUpFileType == GGSSCDR)
	{
		if (strCdr.compare(GCDR) == 0)
		{
			strRet = GGSNCDR;
		}
		else
		{
			strRet = SGSNCDR;
		}
	}	

	return strRet;
}

/**********************************************************************
*Function Name: getCdrTempFileName
*Sescription: 根据传入的字符串得到三种存储方式对应的临时文件名字
*Input: [const string&] strCdr为三种存储方式对应的宏，例如：CDR或GCDR
*		[const short] 对应的三种bs之一
*		[char*] 存储获得的临时文件的名字
*Output: NONE
*Remark: 
**********************************************************************/
void CTempFileManager::getCdrTempFileName(const string& strCdr, const short nBs, char* cFileName)
{
	char CdrNameTempBack[LEN_OF_CDR_FILE_NAME];
	memset(CdrNameTempBack, 0, sizeof(CdrNameTempBack));

	if (m_nSaveUpFileType == EACHCDR)
	{
		if (strCdr.compare(GCDR) == 0)
		{
			strcpy(CdrNameTempBack, GCDRNAMETEMPBACK);
		}
		else if(strCdr.compare(MCDR) == 0)
		{
			strcpy(CdrNameTempBack, MCDRNAMETEMPBACK);
		}
		else if(strCdr.compare(SCDR) == 0)
		{
			strcpy(CdrNameTempBack, SCDRNAMETEMPBACK);
		}
		else if(strCdr.compare(SMOCDR) == 0)
		{
			strcpy(CdrNameTempBack, SMOCDRNAMETEMPBACK);
		}
		else if(strCdr.compare(SMTCDR) == 0)
		{
			strcpy(CdrNameTempBack, SMTCDRNAMETEMPBACK);
		}
	}
	else if (m_nSaveUpFileType == UNIONCDR)
	{
		strcpy(CdrNameTempBack, CDRNAMETEMPBACK);
	}
	else if(m_nSaveUpFileType == GGSSCDR)
	{
		if (strCdr.compare(GCDR) == 0 || strCdr.compare(GGSNCDR) == 0)
		{
			strcpy(CdrNameTempBack, GGSNCDRNAMETEMPBACK);
		}
		else
		{
			strcpy(CdrNameTempBack, SGSNCDRNAMETEMPBACK);
		}
	}

	string strTemp = "";

	getBsPath(nBs, strTemp);

	sprintf(cFileName, "%s%s", strTemp.c_str(), CdrNameTempBack);
}

/**********************************************************************
*Function Name: getCdrSFNameFromMacro
*Sescription: 根据传入的字符串得到三种存储方式对应的重新命名后的名字
*Input: [const string&] strCdr为三种存储方式对应的宏，例如：CDR或GCDR
*		[char*] 存储获得的重新命名后的文件名字
*Output: NONE
*Remark: 
**********************************************************************/
void CTempFileManager::getCdrSFNameFromMacro(const string& strCdr, char* cFileName)
{
	if (m_nSaveUpFileType == EACHCDR)
	{
		if (strCdr.compare(GCDR) == 0)
		{
			strcpy(cFileName, GNODEID);
		}
		else if(strCdr.compare(MCDR) == 0)
		{
			strcpy(cFileName, MNODEID);
		}
		else if(strCdr.compare(SCDR) == 0)
		{
			strcpy(cFileName, SNODEID);
		}
		else if(strCdr.compare(SMOCDR) == 0)
		{
			strcpy(cFileName, SMONODEID);
		}
		else if(strCdr.compare(SMTCDR) == 0)
		{
			strcpy(cFileName, SMTNODEID);
		}
	}
	else if (m_nSaveUpFileType == UNIONCDR)
	{
		strcpy(cFileName, UNIONNODEID);
	}
	else if(m_nSaveUpFileType == GGSSCDR)
	{
		if (strCdr.compare(GCDR) == 0 || strCdr.compare(GGSNCDR) == 0)
		{
			strcpy(cFileName, GGSNNODEID);
		}
		else
		{
			strcpy(cFileName, SGSNNODEID);
		}
	}
}

/**********************************************************************
*Function Name: createFile
*Sescription: 创建临时文件
*Input: [const string&] 5种存储方式对应的宏
*		[const short] 对应的三种bs之一
*Output: [bool] true--成功; false--失败
*Remark: 
**********************************************************************/
bool CTempFileManager::createFile(const string& strCdr, const short nBs)
{
	bool bRet = true;

	//得到三种存储方式对应的宏
	string strTemp = getCdrStringFromMacro(strCdr);

	//得到临时文件名字
	char CdrNameTempBack[LEN_OF_CDR_FILE_NAME];
	memset(CdrNameTempBack, 0, sizeof(CdrNameTempBack));
	getCdrTempFileName(strCdr, nBs, CdrNameTempBack);

	//判断文件是否存在，如果不存在则创建
	if (access(CdrNameTempBack, F_OK) != 0)
	{			
		FILE* fpBack;

		fpBack = fopen(CdrNameTempBack, "a+");
		
		if (fpBack == NULL)
		{	
			printf("%s error\n", CdrNameTempBack);	
			return false;	
		}

		time_t nCurTime;
		getCurrentTicks(&nCurTime);

		//根据获得的字符串在map中查找
		map<string, MAPBSOBJECT>::iterator mapIte;
		map<short,CFNPManager*>::iterator mapBsAndFileInfo;

		mapIte = m_mapCFNPManager.find(strTemp);
		if (mapIte != m_mapCFNPManager.end())
		{
			mapBsAndFileInfo = mapIte->second.find(nBs);
			
			if (mapBsAndFileInfo != mapIte->second.end())
			{
				mapBsAndFileInfo->second->m_nTimeOfCdrFiltered = nCurTime;
				mapBsAndFileInfo->second->m_nSizeOfCdrSavedForTransforFile = 0;
				mapBsAndFileInfo->second->m_nNumOfCdrSavedForTransforFile = 0;

				if (m_bIsHaveFileHeader)
				{
					char CDRFileHeader[50];
					memset(CDRFileHeader,0x00,sizeof CDRFileHeader);
					fwrite(CDRFileHeader, sizeof(char), sizeof CDRFileHeader, fpBack);
					
					mapBsAndFileInfo->second->m_nSizeOfCdrSavedForTransforFile = 50;
				}
			}
			else
			{
				bRet = false;
			}
		}
		else
		{
			bRet = false;			
		}
		
		// 关闭临时文件
		fclose(fpBack);

		if (!bRet)
		{
			printf("Error in CreateTempFile function!\n");
			return bRet;
		}

		//将创建的临时文件放入map中统一管理
		addTempFile(CdrNameTempBack, strTemp, nBs);
	}

	return bRet;
}

/**********************************************************************
*Function Name: saveFile
*Sescription: 保存临时文件
*Input: [const string&] 5种存储方式对应的宏
*		[const short] 对应的三种bs之一
*		[char*] 临时文件的名字
*		[char*] 重新命名后的名字
*		[CFNPManager*] 
*		[char*] GGSN和SGSN地址
*Output: [bool] true--成功; false--失败
*Remark: 
**********************************************************************/
bool CTempFileManager::saveFile(const string& strCdr,
								 const short nBs, 
								 char* cTempName, 
								 char* NODEID, 
								 CFNPManager* pCFNPManager, 
								 char* cGgsnOrSgsnAddr)
{
	char cCurdatetime[LEN_OF_TIME];
	int nhour = 0;
	int nMin = 0;
	int nSec = 0;

	memset(cCurdatetime, 0, sizeof(cCurdatetime));

	// 得到当前时间
	getCurDateTime(cCurdatetime, &nhour, &nMin, &nSec);

	if (pCFNPManager->m_nSerialNum >= SERNUMMAX)
	{
		// reset the sn to zero
		pCFNPManager->m_nSerialNum = 1;
	}
	
	long serialNum = pCFNPManager->m_nSerialNum;

	char CdrSaveFileName[LEN_OF_CDR_FILE_NAME];
	char CdrSaveFileNameBack[LEN_OF_CDR_FILE_NAME];

	memset(CdrSaveFileName, 0, sizeof(CdrSaveFileName));
	memset(CdrSaveFileNameBack, 0, sizeof(CdrSaveFileNameBack));

	string strTemp = "";

	getBsPath(nBs, strTemp);

	// 文件命名规范
	if (m_bIsSerialNumFixed)
	{
		if (m_bIsCloseTimestamp)
		{
			sprintf(CdrSaveFileName, "%s%s%s-%06d", strTemp.c_str(), COMMON_DIRECTORY, NODEID, serialNum);
			sprintf(CdrSaveFileNameBack, "%s%s%s-%06d", strTemp.c_str(), TEMP_DIRECTORY, NODEID, serialNum);
		}
		else
		{
			sprintf(CdrSaveFileName, "%s%s%s-%06d.%s", strTemp.c_str(), COMMON_DIRECTORY, NODEID, serialNum, cCurdatetime);
			sprintf(CdrSaveFileNameBack, "%s%s%s-%06d.%s", strTemp.c_str(), TEMP_DIRECTORY, NODEID, serialNum, cCurdatetime);
		}
	}
	else
	{
		if (m_bIsCloseTimestamp)
		{
			sprintf(CdrSaveFileName, "%s%s%s-%d", strTemp.c_str(), COMMON_DIRECTORY, NODEID, serialNum);
			sprintf(CdrSaveFileNameBack, "%s%s%s-%d", strTemp.c_str(), TEMP_DIRECTORY, NODEID, serialNum);
		}
		else
		{
			sprintf(CdrSaveFileName, "%s%s%s-%d.%s", strTemp.c_str(), COMMON_DIRECTORY, NODEID, serialNum, cCurdatetime);
			sprintf(CdrSaveFileNameBack, "%s%s%s-%d.%s", strTemp.c_str(), TEMP_DIRECTORY, NODEID, serialNum, cCurdatetime);
		}
	}

	if (m_nSaveUpFileType == GGSSCDR && strlen(cGgsnOrSgsnAddr) > 0)
	{
		char CdrSaveFileNameTemp[LEN_OF_CDR_FILE_NAME];
		char CdrSaveFileNameBackTemp[LEN_OF_CDR_FILE_NAME];

		memset(CdrSaveFileNameTemp, 0, sizeof(CdrSaveFileNameTemp));
		memset(CdrSaveFileNameBackTemp, 0, sizeof(CdrSaveFileNameBackTemp));

		//将GGSN和SGSN地址中的"."改为"#"
		changeAddrForGgsnAndSgsn(cGgsnOrSgsnAddr);

		sprintf(CdrSaveFileNameTemp, "%s.%s", CdrSaveFileName, cGgsnOrSgsnAddr);
		sprintf(CdrSaveFileNameBackTemp, "%s.%s", CdrSaveFileNameBack, cGgsnOrSgsnAddr);

		strcpy(CdrSaveFileName, CdrSaveFileNameTemp);
		strcpy(CdrSaveFileNameBack, CdrSaveFileNameBackTemp);
	}

	if (m_bIsHaveFileHeader)
	{
		int   FileLength = pCFNPManager->m_nSizeOfCdrSavedForTransforFile;
		long  FileOpeningTimeStamp = pCFNPManager->m_nTimeOfCdrFiltered;
		long  LastestCDRAppendedTimeStamp = 0;
		int   FileSequNum = pCFNPManager->m_nSerialNum;
		int   NumOfNowCDRFile = 0;
		string strTempFileName(cTempName);

		map<string, VECCDRDBINFO>::iterator mapIte = m_mapDBFileCdrInfo.find(strTempFileName);

		if (mapIte != m_mapDBFileCdrInfo.end())
		{
			NumOfNowCDRFile = mapIte->second.size();
		}

		getCurrentTicks(&LastestCDRAppendedTimeStamp);
    
		//网元的文件信息需要重新获得
		if (m_nSaveUpFileType == GGSSCDR && strlen(cGgsnOrSgsnAddr) > 0)
		{
			map<short, MAPMACROADDRINFO>::iterator mapBsGgsnAndSgsnIte;

			mapBsGgsnAndSgsnIte = m_mapGgsnAndSgsnFile.find(nBs);
			if (mapBsGgsnAndSgsnIte != m_mapGgsnAndSgsnFile.end())
			{
				map<string, MAPADDRANDFILEINFO>::iterator mapGgsnAndSgsnFileIte;

				mapGgsnAndSgsnFileIte = mapBsGgsnAndSgsnIte->second.find(strCdr);
				if (mapGgsnAndSgsnFileIte != mapBsGgsnAndSgsnIte->second.end())
				{
					map<string, sFILEINFO>::iterator mapFileAddrIte;

					mapFileAddrIte = mapGgsnAndSgsnFileIte->second.find(cGgsnOrSgsnAddr);
					if (mapFileAddrIte != mapGgsnAndSgsnFileIte->second.end())
					{
						FileLength = mapFileAddrIte->second.nSizeOfCdrSavedForTransforFile;
						FileOpeningTimeStamp = mapFileAddrIte->second.nTimeOfCdrFiltered;
						FileSequNum = mapFileAddrIte->second.nNumOfCdrSavedForTransforFile;
					}
				}
			}
		}
		
		CreateCdrFileHeader(cTempName,
							FileLength,