admserver.cc

此源代码只用于学习,不得用于其他商业活动 .

/*
* Copyright (c) 2002, 南京联创系统集成股份有限公司综合结算产品部
* All rights reserved.
*
* 文件名称：admserver.cc
* 摘    要：用来监控结算系统中所有的业务进程
*
* 当前版本：
* 作    者：冯亮([e-mail])
* 完成日期：
*/
#include "admserver.h"
#include "c++dcl.h"

#define LINE_LENGTH 8192

char gv_chConfigFile[STRING_LEN];
char gv_chLogFile[STRING_LEN];
char gv_chCommonConfigFile[STRING_LEN];
C_ShareMemory gv_ShareMemory;

int main(int argc, char *argv[])
{
	ios::sync_with_stdio();

	char *pchAppPath = 0;
	if(2 == argc)
	{
		if(strcmp(argv[1], "-k") == 0)
		{
			if(gv_ShareMemory.DestroyShareMemory())
			{
				printf("%s killed!\n", argv[0]);
			}
			else
			{
				printf("%s has been killed!\n", argv[0]);
			}
			KillProc(argc, argv);
			return 0;
		}
		else
		{
			printf("%s: Parammeter error! \n", argv[0]);
			return -1;
		}
	}

	/*判断程序是否已经运行*/
	if(ProcIsExist(argc, argv))
	{
		printf("Admserver has been started!\n");
		return -1;
	}

	InitDaemon();

	signal(SIGINT, UserTerm);
	signal(SIGTERM, UserTerm);
	signal(SIGQUIT, UserTerm);
	signal(SIGFPE, UserTerm);
	signal(SIGSEGV, UserTerm);

	/*根据环境变量获得配置文件的位置*/
	if((pchAppPath = getenv("SETTLE_HOME")) == 0)
	{
		printf("Admserver:Not get the environment \"SETTLE_HOME\" in main!\n");
		return -1;
	}

	FullPath(pchAppPath);
	strcpy(gv_chConfigFile, pchAppPath);
	strcat(gv_chConfigFile, CONFIG_FILE);
	strcpy(gv_chCommonConfigFile, pchAppPath);
	strcat(gv_chCommonConfigFile, COMMON_CONFIG_FILE);

	SetWorkPath();

	if(3 == argc)
	{
		if(StoreDbInfo(argc, argv) != 0)
		{
			return -1;
		}

		char szApp[STRING_LEN];
		char *Argv[3];

		Argv[0] = argv[0];

		strcpy(szApp, pchAppPath);
		strcat(szApp, "bin/");
		strcat(szApp, argv[0]);

		execvp(szApp, Argv);

	}

	AdmServer();
	return 0;
}

int StoreDbInfo(int argc, char **argv)
{
	C_Config Config;

	char szUser[STRING_LEN];
	memset(szUser, 0, sizeof(szUser));

	if(Config.GetParam(gv_chCommonConfigFile, "ParamForDb", "User", szUser) == false)
	{
		printf(
			"Config file error at %s-->%s-->%s\n",
			gv_chCommonConfigFile,
			"ParamForDb",
			"User"
			);
		return -1;
	}

	if(strcmp(szUser, argv[1]) != 0)
	{
		printf("The input id is not equal to the id configed in common.ini");
		return -1;
	}

	char szEncrypted[STRING_LEN];
	memset(szEncrypted, 0, sizeof(szEncrypted));

	//加密
	Encrypt(argv[2], szEncrypted);

	//将密文存入配置文件
	if(Config.SetParam(gv_chCommonConfigFile, "ParamForDb", "PassWord", szEncrypted) == false)
	{
		printf(
			"Config file error at %s-->%s-->%s\n",
			gv_chCommonConfigFile,
			"ParamForDb",
			"PassWord"
			);
		return -1;
	}

	return 0;
}

/****************************************************************
**
**	Function: daemon_init
**	Purpose:  程序设置为守护进程
** 	Input Parammeters:
**	Return:	无
**	datetime:
**
*****************************************************************/
void InitDaemon(void)
{
	int i;

	switch(fork())
	{
		case -1:
			exit(-1);
		case 0:
			break;
		default:
			_exit(0);
	}
	setsid();
	switch(fork())
	{

		case -1:
			exit(-1);
		case 0:
			break;
		default:
			_exit(0);
	}
	close(0);
	for(i = 3; i < NOFILE; i++)
	{
		close(i);
	}
	return;
}

/****************************************************************
**
**	Function: SetWorkPath
**	Purpose:  设置进程的工作路径
** 	Input Parammeters:
**	Return:	-1:失败 0:成功
**	datetime:
**
*****************************************************************/
int SetWorkPath(void)
{
	char *pszAppPath = 0;

	char szWorkPath[STRING_LEN];
	memset(szWorkPath, 0, sizeof(szWorkPath));

	/*根据环境变量获得工作路径的位置*/
	if((pszAppPath = getenv("SETTLE_HOME")) == 0)
	{
		printf("Admserver:Not get the environment \"SETTLE_HOME\" in SetWorkPath!\n");
		return -1;
	}
	strcpy(szWorkPath, pszAppPath);
	FullPath(szWorkPath);
	strcat(szWorkPath, WORK_PATH);
	chdir(szWorkPath);
	return 0;
}

/****************************************************************
**
**	Function: UserTerm
**	Purpose:  退出程序并重置信号
** 	Input Parammeters:

**	Return:
**	datetime:
**
*****************************************************************/
void UserTerm(int signo)
{
	signal(SIGINT,SIG_DFL);
	signal(SIGTERM,SIG_DFL);
	signal(SIGQUIT,SIG_DFL);
	signal(SIGFPE,SIG_DFL);
	signal(SIGSEGV,SIG_DFL);
	exit(0);
}

/****************************************************************
**
**	Function: KillProc
**	Purpose:	停止进程以其所有子进程
** 	Input Parammeters:
**			同主函数
**	Return:
**	datetime:
**
*****************************************************************/
void KillProc(int argc,char *argv[])
{
	FILE *fp = 0;
	char *LoginName = 0;
	char ScanBuff[BUF_SIZE];
	char chTemp[BUF_SIZE];

	if((LoginName = getenv("LOGNAME")) == 0)
	{
		printf("Admserver:Not get the environment \"LOGNAME\" in KillProc!\n");
		exit(-1);
	}

	if(memcmp(argv[0], "./", 2) == 0)
	{
		strcpy(chTemp, argv[0] + 2);
	}
	else
	{
		strcpy(chTemp, argv[0]);
	}
	Trim(chTemp);

	sprintf(
		ScanBuff,
		"ps -fu %s|awk '{if($NF == \"%s\") print $2}'",
		LoginName,
		chTemp
		);

	if((fp = popen(ScanBuff ,"r")) == 0)
	{
		exit(-1);
	}

	while(fgets(ScanBuff,sizeof(ScanBuff),fp) != 0)
	{
		Trim(ScanBuff);
		if (atoi(ScanBuff) != getpid())
		{
			kill(atoi(ScanBuff),SIGTERM);
		}
	}
	pclose(fp);
	return;
}
/****************************************************************
**
**	Function: GetNextObject
**	Purpose:  得到下一个对象
** 	Input Parammeters:
	          Object -- 取出的字符串 Objects -- 原始的字符串
**	Return:	取出字符串后剩下的字符串
**	datetime:
**
*****************************************************************/
char *GetNextObject(char *Object,char *Objects)
{
	while((*Objects != '\0')&&(*Objects != '@'))
	{
		*Object = *Objects;
		Object++;
		Objects++;
	}
	*Object = '\0';
	if (*Objects == '@')
	{
		Objects++;
	}
	return Objects;
}

/*
*	Function Name	:ProcIsExist
*	Description	:检查本进程是否已经存在
*	Input Param	:与main函数同
*	Returns		:true(存在) or false(不存在)
*	complete	:
*/
bool ProcIsExist(int argc, char *argv[])
{
	int i;
	int iNums = 0;
	FILE *fp = 0;
	char *lv_chPoint = 0;
	char *pchLoginName = 0;
	char chScanBuff[LINE_LENGTH];
	char chCommandLine[LINE_LENGTH];
	char chTemp[LINE_LENGTH];
	memset(chScanBuff, 0, sizeof(chScanBuff));
	memset(chCommandLine, 0, sizeof(chCommandLine));
	memset(chTemp, 0, sizeof(chTemp));

	if((pchLoginName = getenv("LOGNAME")) == 0)
	{
		printf("Admserver:Not get the environment \"LOGNAME\" in ProcIsExist!\n");
		return false;
	}
	lv_chPoint = argv[0];
	for(i = 0; *lv_chPoint; lv_chPoint++, i++)
	{
		if (*lv_chPoint == '/')
		{
			i = -1;
			continue;
		}
		chCommandLine[i] = *lv_chPoint;
	}
	chCommandLine[i] = '\0';

	Trim(chCommandLine);
	sprintf(
		chScanBuff,
		"ps -fu %s | cut -c 40-",
		pchLoginName
		);
	if((fp = popen(chScanBuff , "r")) == 0)
	{
		return false;
	}
	while(fgets(chScanBuff, sizeof(chScanBuff), fp) != 0)
	{
		memset(chTemp, 0, sizeof(chTemp));
		strcpy(chTemp, chScanBuff);
		lv_chPoint = strchr(chScanBuff, ':');
		if(lv_chPoint == 0)
		{
			memset(chScanBuff, 0, sizeof(chScanBuff));
			continue;
		}
		lv_chPoint += 3;
		memset(chTemp, 0, sizeof(chTemp));
		strcpy(chTemp, lv_chPoint);
		Trim(chTemp);
		lv_chPoint = chTemp;

		memset(chScanBuff, 0, sizeof(chScanBuff));

		for(i = 0; (*lv_chPoint) && (*lv_chPoint != ' '); lv_chPoint++,i++)
		{
			if (*lv_chPoint == '/')
			{
				i = -1;
				continue;
			}
			chScanBuff[i] = *lv_chPoint;
		}
		chScanBuff[i] = 0;
		lv_chPoint = strchr(chTemp, ' ');

		Trim(chScanBuff);
		Trim(chCommandLine);
		if(strcmp(chScanBuff, chCommandLine) == 0)
		{
			iNums++;
		}
		memset(chScanBuff, 0, sizeof(chScanBuff));
	}//end while(fgets(chScanBuff, sizeof(chScanBuff), fp) != 0)
	pclose(fp);
	if(iNums > 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

/****************************************************************
**
**	Function: ProcessExist
**	Purpose:  判断进程是否存在
** 	Input Parammeters:
	          ProcessIndex -- 进程在共享内存的位置号
**	Return:	true -- 进程存在  false -- 进程不存在
**	datetime:
**
*****************************************************************/
bool ProcessExist(int ProcessIndex)
{
	FILE *fp = 0;
	char *LoginName = 0;
	char ScanBuff[BUF_SIZE];
	S_ShareMemoryInformation ShareMemoryInformation;
	memset(&ShareMemoryInformation, 0, sizeof(S_ShareMemoryInformation));
	if((LoginName = getenv("LOGNAME")) == 0)
	{
		printf("Admserver:Not get the environment \"LOGNAME\" in ProcessExist!\n");
		return false;
	}
	gv_ShareMemory.ReadShareMemory(ProcessIndex,&ShareMemoryInformation);
	if(strlen(ShareMemoryInformation.procid) == 0)
	{
		return false;
	}
	sprintf(
		ScanBuff,
		"ps -fu %s|awk '{if($2 == \"%s\") print $2}'",
		LoginName,
		ShareMemoryInformation.procid
		);

	if((fp = popen(ScanBuff ,"r")) == 0)
	{
		return false;
	}

	if (fgets(ScanBuff,sizeof(ScanBuff),fp) != 0)
	{
		pclose(fp);
		return true;
	}
	else
	{
		pclose(fp);
		return false;
	}
}

/****************************************************************
**
**	Function: GetShareMemInfo
**	Purpose:  得到存放在共享内存中的进程及主机信息
** 	Input Parammeters:
	          Reply -- 进程信息  Object -- 进程位置
**	Return:
**	datetime:
**
*****************************************************************/
void GetShareMemInfo(char *Reply,char *Object)
{
	S_ShareMemoryInformation ShareMemoryInformation;

	memset(&ShareMemoryInformation, 0, sizeof(ShareMemoryInformation));

	char ErrorCDRRate[10+1];
	float fRate;
	unsigned long CurrentTotal[MON_MAXPROC];
	static unsigned long LastTotal[MON_MAXPROC];

	while((*Object != '/')&&(*Object != '\0')&&(*Object != '@'))
	{
		*Reply = *Object;
		Reply++;
		Object++;
	}

	gv_ShareMemory.ReadShareMemory(atoi(Object+1),&ShareMemoryInformation);

	CurrentTotal[atoi(Object + 1)] = ShareMemoryInformation.total;
	if(ShareMemoryInformation.total == 0)
	{
		fRate = ((float)ShareMemoryInformation.error)/((float)(ShareMemoryInformation.total + 1));
	}
	else
	{
		fRate = ((float)ShareMemoryInformation.error)/((float)ShareMemoryInformation.total);
	}

	sprintf(ErrorCDRRate, "%5.2f%%\0", fRate*100);


	//下面这两项没有完成
	GetSysInfo(ShareMemoryInformation.hostinformation.hostcpu, ShareMemoryInformation.hostinformation.hostmem);
	GetProcInfo(atoi(Object+1), ShareMemoryInformation.processcpu, ShareMemoryInformation.processmem);

	if(CurrentTotal[atoi(Object + 1)] == LastTotal[atoi(Object + 1)])
	{
		memset(ShareMemoryInformation.cdrprocspeed, 0, sizeof(ShareMemoryInformation.cdrprocspeed));
		strcpy(ShareMemoryInformation.cdrprocspeed, "   0条/秒");
	}

	LastTotal[atoi(Object + 1)] = CurrentTotal[atoi(Object + 1)];
	//一共15项
	sprintf(Reply,"@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s@%s",
		ShareMemoryInformation.startdate,
		ShareMemoryInformation.starttime,
		ShareMemoryInformation.procid,
		ShareMemoryInformation.object,
		ShareMemoryInformation.status,
		ShareMemoryInformation.step,
		ShareMemoryInformation.count,
		ShareMemoryInformation.totalsize,
		ShareMemoryInformation.finishedsize,
		ShareMemoryInformation.processcpu,
		ShareMemoryInformation.processmem,
		ShareMemoryInformation.cdrprocspeed,
		ErrorCDRRate,
		ShareMemoryInformation.hostinformation.hostcpu,
		ShareMemoryInformation.hostinformation.hostmem
		);

	if(ProcessExist(atoi(Object+1)) == false)
	{
		memset(&ShareMemoryInformation, 0, sizeof(ShareMemoryInformation));
		gv_ShareMemory.WriteShareMemory(atoi(Object+1),&ShareMemoryInformation);
	}
	return;
}

/****************************************************************
**
**	Function: GetDiskInfo
**	Purpose:  得到磁盘信息
** 	Input Parammeters:
	          Reply -- 磁盘信息  Object -- 磁盘目录
**	Return:
**	datetime:
**
*****************************************************************/
void GetDiskInfo(char *Reply,char *Object)
{
	struct statvfs status;
	unsigned long ulTotalBlocks;
	unsigned long ulAvailBlocks;

	while((*Object != '/')&&(*Object != '\0')&&(*Object != '@'))
	{
		*Reply = *Object;
		Reply++;
		Object++;
	}
	if(IsDirectory(Object))
	{
		statvfs(Object, &status);
		ulTotalBlocks = static_cast<unsigned long>(status.f_blocks*(status.f_frsize/1024.0));
		ulAvailBlocks = static_cast<unsigned long>(status.f_bavail*(status.f_frsize/1024.0));
		sprintf(