myvtm/Module/mod_heartbeat/HeartBeatFSM.cpp

#include "stdafx.h"
#include "HeartBeatFSM.h"
#include "HeartBeat_UserErrorCode.h"
#include <regex>
#include "json/json.h"
#include <string.h>
#include <winpr/crt.h>

using namespace CardReadAdapter;
#include "EventCode.h"
const int DEFAULT_BUFLEN = 2048;
const int MAX_SEND_FAILED_TIMES = 5;
const int MAX_INIT_TIMES = 5;
//#define DEFAULT_PORT "408"

// Termainal Performance Counter Component [Josephus in 9:31:27 2016/4/23]
CONST ULONG COUNTER_INTERVAL_MS = 1000;

const char * AvailMemoryQuery	= "\\Memory\\Available MBytes";
const char * HandleNumQuery		= "\\Process(_Total)\\Handle Count";
const char * ThreadNumQuery		= "\\Process(_Total)\\Thread Count";
const char * ProcessNumQuery	= "\\System\\Processes";
const char * SystemElapsedQuery = "\\System\\System Up Time";
const char * ProcessTimeQuery	= "\\Processor Information(_Total)\\% Processor Time";

#define DIV (1024 * 1024)
#define DAY_DIV (24 * 60 * 60)
#define HOURS_DIV (60 * 60)
#define MINUS_DIV (60)

#ifdef DEVOPS_ON_ST /*DevOps流水线编译，ST环境*/
#define HAND_SHAKE_URL			"http://connectservice.paasst.cmbchina.cn/api/heartbeat/keep"
#define	CARDISSUER_STAND_MAIN_SERVER				"rvctsst.cmbchina.cn 30033"
#define CARDISSUER_STAND_BACKUP_SERVER				""
#define	CARDISSUER_STORE_MAIN_SERVER				"rvctsst.cmbchina.cn 30033"
#define CARDISSUER_STORE_BACKUP_SERVER				""

#elif defined(DEVOPS_ON_UAT)/*DevOps流水线编译，UAT环境*/
#define HAND_SHAKE_URL			"http://connectservice.paasuat.cmbchina.cn/api/heartbeat/keep"
#define	CARDISSUER_STAND_MAIN_SERVER				"rvctsuat.cmbchina.cn 30033"
#define CARDISSUER_STAND_BACKUP_SERVER				""
#define	CARDISSUER_STORE_MAIN_SERVER				"55.6.78.32 30033"
#define CARDISSUER_STORE_BACKUP_SERVER				""

#elif defined(DEVOPS_ON_PRD)/*DevOps流水线编译，PRD环境*/
#define HAND_SHAKE_URL			"https://connectservice.paas.cmbchina.cn/api/heartbeat/keep"
#define	CARDISSUER_STAND_MAIN_SERVER				"rvcts.cmbchina.cn 30033"
#define CARDISSUER_STAND_BACKUP_SERVER				""
#define	CARDISSUER_STORE_MAIN_SERVER				"rvccardstore.cmbchina.cn 30033"
#define CARDISSUER_STORE_BACKUP_SERVER				""

#else/*DevOps流水线编译，Dev环境&本地编译等非DevOps环境*/
#define HAND_SHAKE_URL			"http://connectservice.paasst.cmbchina.cn/api/heartbeat/keep"
#define	CARDISSUER_STAND_MAIN_SERVER				"rvctsst.cmbchina.cn 30033"
#define CARDISSUER_STAND_BACKUP_SERVER				""
#define	CARDISSUER_STORE_MAIN_SERVER				"rvctsst.cmbchina.cn 30033"
/*多个备机地址用分隔符'|'隔开，eg: rvctsst1.cmbchina.cn 30033|rvctsst2.cmbchina.cn 30033*/
#define CARDISSUER_STORE_BACKUP_SERVER				""
#endif

// End Performance Component [Josephus in 9:32:05 2016/4/23]

ErrorCodeEnum CHeartBeatFSM::OnInit()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","S");
	ErrorCodeEnum Error;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	CSystemStaticInfo sysInfo;
	Error = GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	if (Error != Error_Succeed) {
		LogWarn(Severity_Middle, Error_NotConfig, LOG_EVT_HEARTBEAT_LACK_CENSETTINGS, "获取GetSystemStaticInfo失败");
		return Error_DevLoadFileFailed;
	}

	Error = spEntityFunction->OpenConfig(Config_CenterSetting, spConfig);
	if (Error != Error_Succeed) {
		LogWarn(Severity_Middle, Error_NotConfig, LOG_EVT_HEARTBEAT_LACK_CENSETTINGS, "打开集中配置失败，请检查集中配置是否存在！");
		return Error_DevLoadFileFailed;
	}
	

	m_isCardStore = !sysInfo.strMachineType.Compare("RVC.CardStore", true);

	//ErrorCodeEnum rc = GetServerAddr(spConfig, m_isCardStore);
	ErrorCodeEnum rc = ParseServerAddr(m_isCardStore);

	if (Error_Succeed != rc) {
		LogWarn(Severity_Middle, Error_NotConfig, LOG_EVT_HEARTBEAT_SERVER_CFG_FAIL, "读取连接虚机服务配置失败，请检查配置是否正确！");
        return rc;
	}
	int tmpCrossUseJS = 0;
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "CrossUseJS", tmpCrossUseJS);
	if (tmpCrossUseJS == 1) {
		m_bCrossUseJS = true;//使用JS跨机接口
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossUseJS=%d", tmpCrossUseJS);
	}
	
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "LongConnInterval", m_longConnInterval);
	if (m_longConnInterval == 0) {
		//未配置
		m_longConnInterval = 60000;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_longConnInterval is not configured ,use default 60s", m_longConnInterval);
	}
	else {
		//已配置
		if (m_longConnInterval < 20000) {
			m_longConnInterval = 20000;//默认20s
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("LongConnInterval<20000ms ,use default 20s", m_longConnInterval);
		}
	}

	int intervalTemp = 0;
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "HandShakeConnInterval", intervalTemp);
	if (intervalTemp == 0) {
		//未配置
		m_handShakeConnInterval = 20000;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_handShakeConnInterval is not configured ,use default 20s", m_handShakeConnInterval);
	}
	else {
		//已配置
		if (intervalTemp < 10000) {
			m_handShakeConnInterval = 10000;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_handShakeConnInterval %d ms<10000ms ,use default 10s", intervalTemp);
		}
		else {
			m_handShakeConnInterval = intervalTemp;
		}
	}
	int tmpSleepMode = 0;
	Error =spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "SleepMode", tmpSleepMode);
	if(Error ==Error_Succeed){
		if (tmpSleepMode == 1) {
			m_bSleepMode = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SleepMode=%d", tmpSleepMode);
		}
	}

	//网络字节序
	//由于双活改造，改成固定ip，分行服务有处理
	//m_servIP = "99.1.100.215";
	m_dwServIP = inet_addr("99.1.100.215");


	CSimpleStringA csRunDiskName("C:\\");
	Error = GetEntityBase()->GetFunction()->GetPath("Run", csRunDiskName);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetPath of run is %s 0x%x", (LPCTSTR)csRunDiskName, Error);
	CAutoArray<CSimpleStringA> arrays = csRunDiskName.Split('\\');
	if(arrays.GetCount() > 0)
	{
		m_csRunDiskName = arrays[0] + "\\";
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Split rundisk file string(%s) failed", (LPCTSTR)csRunDiskName);
		return Error_Unexpect;
	}

	m_strHandShakeUrl = HAND_SHAKE_URL;
	//有心跳地址才启动心跳新线程
	if (!m_strHandShakeUrl.IsNullOrEmpty()) {
		NewHandShakeTask* task = new NewHandShakeTask(this);
		Error = this->GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		if (Error != Error_Succeed)
		{
			LogError(Severity_Middle, rc, 0, CSimpleStringA::Format("NewHandShakeTask Thread is fail,%d", (int)rc).GetData());
			m_testResult = Error_InvalidState;//启动心跳线程失败
			return Error_Exception;
		}
		else {
			LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_TASK_START,
				CSimpleStringA::Format("NewHandShakeTask task start,HandShakeConnInterval= %d ms, LongConnInterval = %d ms, url=%s", m_handShakeConnInterval,m_longConnInterval,m_strHandShakeUrl.GetData()));
		}
	}
	else {
		//提醒无心跳地址，旧心跳时间默认设置为20s
		m_longConnInterval = 20000;//设置为20s
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_TASK_NOT_START,"NewHandShakeTask task not start,HandShakeUrl is temp,LongConnInterval use default 20s");
	}




	return Error_Succeed;
}
ErrorCodeEnum CHeartBeatFSM::OnExit()
{
	return Error_NotImpl;
}
//Init(Stop)
void CHeartBeatFSM::s0_on_entry()
{
	//LOG_FUNCTION();
	
	{
		//check if can start to work(handshake...)
		//1.check if AccessAuthorization have finished
		//2.check if network connected
		//3.check if framework on Exitting or Terminating

		//all of above have checked,start to work
		if (m_pHandShakeConn != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("init connection.");
			m_pHandShakeConn->Close();
			m_pHandShakeConn->DecRefCount();
			m_pHandShakeConn = NULL;
		}
		FSMEvent *e = new FSMEvent(USER_EVT_START);
		PostEventFIFO(e);
		m_initTimes++;
		if (m_initTimes > 1) {
			Sleep(m_ConnectSleepInterval);
		}
		if (m_initTimes > MAX_INIT_TIMES)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("have try to init x times,give up!");
			//logwarn oiltest
			m_initTimes = 0;
		}
	}
	
}
void CHeartBeatFSM::s0_on_exit()
{
}
unsigned int CHeartBeatFSM::s0_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_START:
		{
			StartTask* task = new StartTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
		}
		return 0;
	default:
		break;
	}
	return 0;
}
//Starting
void CHeartBeatFSM::s1_on_entry()
{
	//LOG_FUNCTION();
}
void CHeartBeatFSM::s1_on_exit()
{
}
unsigned int CHeartBeatFSM::s1_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_STARTFINISHED:
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
		{
			HandShakeTask* task = new HandShakeTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
			return 0;
		}
		else 
		{
			// SetFlag for MobileDial entity. [Josephus in 11:40:29 2016/8/16]
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","D");
			return 1;
		}
		break;
	default:
		break;
	}
	return 0;
}
//Connnected
void CHeartBeatFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_initTimes = 0;
	m_testResult = Error_Succeed;
	LogEvent(Severity_Middle, LOG_EVT_HEARTBEAT_CONNECTED, "Branch heartbeat service connected.");
	//LogWarn(Severity_Low, Error_Unexpect, LOG_EVT_HEARTBEAT_CONNECTED, "Branch heartbeat service connected.");
}
void CHeartBeatFSM::s2_on_exit()
{
}
unsigned int CHeartBeatFSM::s2_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_INSTRUCTION:
		{
			InstructionEvent *pIE = dynamic_cast<InstructionEvent*>(pEvt);
			pEvt->SetHandled();
			DoInstruction(pIE->ctx);
		}
		break;
	case USER_EVT_HANDSHAKEFINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_STOP:
		pEvt->SetHandled();
		break;
	case USER_EVT_START:
		pEvt->SetHandled();
		break;
	case USER_EVT_CARD_ACTIVE:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s2 card active.");
								 pEvt->SetHandled();
								 CardActiveEvent *pcae = dynamic_cast<CardActiveEvent*>(pEvt);
								 CardActiveTask *pTask = new CardActiveTask(this);
								 pTask->ctx = pcae->ctx;
								 GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
		
		break;
	case USER_EVT_CARD_ACTIVE_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
//Lost
void CHeartBeatFSM::s3_on_entry()
{
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","L");
}
void CHeartBeatFSM::s3_on_exit()
{
}
unsigned int CHeartBeatFSM::s3_on_event(FSMEvent* pEvt)
{
	return 0;
}
//Reject
void CHeartBeatFSM::s4_on_entry()
{
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","R");
	FSMEvent *pStopEvt = new FSMEvent(USER_EVT_STOP);
	PostEventFIFO(pStopEvt);
}
void CHeartBeatFSM::s4_on_exit()
{
}
unsigned int CHeartBeatFSM::s4_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_STOP:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
//Failed
void CHeartBeatFSM::s5_on_entry()
{
	m_testResult = Error_InvalidState;
}
void CHeartBeatFSM::s5_on_exit()
{
}
unsigned int CHeartBeatFSM::s5_on_event(FSMEvent* pEvt)
{
	return 0;
}
int CHeartBeatFSM::Starting()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HeartBeat start to connect.");

	if (!m_pHandShakeConn) 
	{
		m_pHandShakeConn = new HeartBeatConnection(m_pEntity, this);
		if (m_pHandShakeConn != NULL)
		{
			CSimpleStringA connectedServ = "";
			bool bConn = m_pHandShakeConn->ConnectFromAddress(m_servStr, m_servStrBArr, connectedServ);
			
			if (!bConn) 
			{
				m_pHandShakeConn->Close();
				//delete m_pHandShakeConn;//oiltest
				m_pHandShakeConn->DecRefCount();
				m_pHandShakeConn = NULL;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cannot connect to server.");
				LogEvent(Severity_Middle, LOG_EVT_HEARTBEAT_UN_CONNECTED, "Branch heartbeat service unconnected.");
				LogWarn(Severity_Middle, Error_Unexpect, LOG_EVT_HEARTBEAT_UN_CONNECTED, "Branch heartbeat service unconnected.");
				return 1;
			}
			else {
				CSimpleStringA msg = "";
				if (!connectedServ.IsNullOrEmpty()) {
					msg = CSimpleStringA::Format("heartbeat service connected. server addr str = %s", connectedServ.GetData());
				}
				else {
					msg = CSimpleStringA::Format("heartbeat service connected. server use last time addr str ");
				}
				LogWarn(Severity_Low, Error_Succeed, LOG_EVT_HEARTBEAT_CONNECTED, msg);
				return 0;
			}
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HeartBeat connected.");
	return 0;
}
int CHeartBeatFSM::DoHandShake()
{
	if (m_pHandShakeConn) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start handshake");
		//oiltest sp_var_client_set has no write privilege!
		//GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","C");
		while (1)
		{
			
			if (!m_pHandShakeConn || !m_pHandShakeConn->IsConnectionOK())
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DoHandShake m_pHandShakeConn is disConnection");
				FSMEvent *e = new FSMEvent(USER_EVT_START);
				PostEventFIFO(e);
				break;
			}
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState", "C");
			m_pHandShakeConn->SendHandShake();

			if (m_bSleepMode) {
				Sleep(m_longConnInterval);//修改成可配置的时间间隔
			}
			else {
				int sleepTimeInterval = 10000;
				int remainSleepTime = m_longConnInterval;
				while (remainSleepTime > 0) {
					int sleepTime = 0;
					if (remainSleepTime >= sleepTimeInterval) {
						sleepTime = sleepTimeInterval;
					}
					else {
						sleepTime = remainSleepTime;
					}
					Sleep(sleepTime);
					remainSleepTime = remainSleepTime - sleepTime;
					if (!m_pHandShakeConn || !m_pHandShakeConn->IsConnectionOK()) {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_pHandShakeConn is disconnect");
						break;
					}
					else {
						//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_pHandShakeConn is connect");
					}
				}

			}
		}
	}
	return 0;
}

int CHeartBeatFSM::DoNewHandShake() {
	LOG_FUNCTION();
	int warnSum = 0;
	while (true)
	{
		if (warnSum == 50) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp send 50 times");
			warnSum = 0;
		}		
		IHttpFunc* client;
		client = create_http(HttpsLogCallBack);
		//发送心跳http请求
		bool isHeartBeatOk=false;
		bool bRet = HandShakeHttp(client, isHeartBeatOk);
		if (bRet) {
			if (!isHeartBeatOk) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp isHeartBeatOk=false");
			}
		}
		client->Destory();
		Sleep(m_handShakeConnInterval);//改为参数配置
		warnSum++;
	}
	return 0;
}

bool CHeartBeatFSM::HandShakeHttp(IHttpFunc* client,bool &isHeartBeatOk) {
	HttpStruct::SendHandShakeReq qTempReq;
	HttpStruct::SendHandShakeRet qTempRet;

	qTempReq.m_reqStr = HandShakeJsonStr();//请求参数
	qTempReq.m_url = m_strHandShakeUrl.GetData();//访问地址
	qTempReq.m_timeOut = 60;//设置传送超时时间为60s

	//qTempReq.m_printDbg = true;
	PROCESS_LINK_CONTEXT("LR0402503HandShake")
	if (!client->Post(qTempReq, qTempRet, &nextLink)) {
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_HTTP_ERROR, CSimpleStringA::Format("HandShakeHttp http req fail,url=%s, err=%s", qTempReq.m_url.c_str(), qTempRet.m_errMsg.c_str()).GetData());
		return false;//通讯失败
	}

	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("qTempRet=%s", qTempRet.m_retStr.c_str());


	Json::Reader reader;
	Json::Value rootRet;
	if (!reader.parse(qTempRet.m_retStr, rootRet, false))
	{
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_HTTP_ERROR, CSimpleStringA::Format("HandShakeHttp parse resp is fail,url=%s", qTempReq.m_url.c_str()).GetData());
		return false;//服务异常
	}
	
	bool isSucc = rootRet["success"].asBool();
	if (isSucc) {
		if (rootRet.isMember("data")) {
			if (rootRet["data"].asBool()) {
				isHeartBeatOk = true;//心跳正常
				return true;//服务正常
			}
			else {
				isHeartBeatOk = false;//心跳不正常
				return true;//服务正常
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp [success] is true,param [data] is lost");
			return false;//服务异常
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp [success] is false,errCode=%s,errStr=%s", qTempRet.m_userCode.c_str(),qTempRet.m_errMsg.c_str());
		return false;//服务异常
	}
}

/** 提取出来  [Gifur@202585]*/
static unsigned long GetLocalIP()
{
#ifdef RVC_OS_WIN
	char tmp[256];
	gethostname(tmp, sizeof(tmp));
	hostent* ent = gethostbyname(tmp);
	unsigned long ip = 0xffffffff;
	if (ent) {
		for (int i = 0; ent->h_addr_list[i]; ++i) {
			if (ent->h_addrtype == AF_INET) {
				struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
				if (in->S_un.S_un_b.s_b1 != 0) {
					if (in->S_un.S_un_b.s_b1 == 192)
						continue;
					ip = (in->S_un.S_un_b.s_b1 << 24) + (in->S_un.S_un_b.s_b2 << 16)
						+ (in->S_un.S_un_b.s_b3 << 8) + in->S_un.S_un_b.s_b4;
					break;
				}
			}
		}
	}

	return ip;
#else
	//oiltest
	return 0x0;
#endif //RVC_OS_WIN
}


string CHeartBeatFSM::HandShakeJsonStr() {
	//LOG_FUNCTION();
	string jsonStr = "";
	Json::Value root;
	Json::FastWriter fw;//写入对象
	Json::Value obj1, obj2, obj3;

	//写入shakehandvo对象
	CSystemStaticInfo sysSInfo;
	m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
	obj1["terminalNo"] = sysSInfo.strTerminalID.GetData();
	obj1["ip"] = 0;
	obj1["warningLevel"] = "";
	obj1["runState"] = "";
	obj1["customerHandle"] = "";
	obj1["callState"] = "";
	obj1["localMaintain"] = "";
	obj1["remoteMaintain"] = "";
	obj1["termStage"] = "";
	obj1["preTermStage"] = "";
	obj1["netState"] = "";
	obj1["preNetState"] = "";
	root["shakeHandVO"]=Json::Value(obj1);

	//写入shakeHandSystemInfo对象
	obj2["serverIP"] = (unsigned int)m_dwServIP;
	obj2["totalMem"] = 0;
	obj2["freeMem"] = 0;
	obj2["procNum"] = 0;
	obj2["threadNum"] = 0;
	obj2["handleNum"] = 0;
	obj2["freeDisk"] = 0;
	obj2["osStartTime"] = "";
	obj2["cpuLoad"] = 0;
	root["shakeHandSystemInfo"]=Json::Value(obj2);

	//写入shakeHandErrorVO对象

	obj3["warnLevel"] = 0;
	obj3["reserved1"] = "";
	obj3["errList"] = "";
	root["shakeHandErrorVO"]=Json::Value(obj3); 

	
	jsonStr = fw.write(root);
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeJsonStr")("HandShakeJsonStr=%s", jsonStr.c_str());
	return jsonStr;
}

void CHeartBeatFSM::HttpsLogCallBack(const char* logtxt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HttpsLogCallBack")("http dbg: %s", logtxt);
}


int CHeartBeatFSM::CardActive(SpReqAnsContext<HeartBeatService_CardActive_Req, HeartBeatService_CardActive_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		m_pHandShakeConn->SendCardActive(0,ctx->Req.slot, 0,(const char*)ctx->Req.term,(const char*)ctx->Req.account, ctx->Req.account.GetLength(), (const char*)ctx->Req.data, ctx->Req.data.GetLength(),0,0);
		ctx->Answer(Error_Succeed);
	}
	else
	{
		if (ctx->Req.account.GetLength() > 6)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("acc:%s****%s,no connection.", (const char*)ctx->Req.account.SubString(0, 6), (const char*)ctx->Req.account.SubString(ctx->Req.account.GetLength() - 4, 4));
		else
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("acc:%s, size:%d", (const char*)ctx->Req.account,ctx->Req.account.GetLength());
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
void CHeartBeatFSM::DoInstruction(SpReqAnsContext<HeartBeatService_Instruction_Req, HeartBeatService_Instruction_Ans>::Pointer ctx)
{
	switch(ctx->Req.type)
	{
	case INC_GLOBAL_SETTING_SYNC:
		break;
	case INC_COMM_RECONNECT:
		break;
	case INC_START_REMOTE_CONTROL:
		break;
	case INC_UPDATE_CHECK:
		break;
	case INC_RECOVER_SERVICE:
		break;
	case INC_PAUSE_SERVICE:
		break;
	case INC_AREA_SERVICE_SWITCH:
		break;
	default:
		break;
	}
}
ErrorCodeEnum CHeartBeatFSM::SetErrorList(int warmLevel,CSimpleStringA strList)
{
	m_warnLevel = warmLevel;
	m_entErrorList = strList;
	return Error_Succeed;
}
void CHeartBeatFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}
void CHeartBeatFSM::LocalPreOnline(int slot, CSimpleStringA fromTermNo,CSimpleStringA termNo, CSimpleStringA account, CSimpleStringA data, int type)
{
	LOG_FUNCTION();	
	DWORD dwUserCode = 0;
	if (!CheckCRASessionOrToConnect())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("to call local preonline, but can't connect to CardReadAdapter.");
		return;
	}

	CardReadAdapterService_PreOnline_Req req;
	CardReadAdapterService_PreOnline_Ans ans;
	CSimpleStringA errMsgData("");
	req.businessData = data;
	char buf[16];
	ZeroMemory(buf, sizeof(buf));
	_itoa(slot, buf, 10);
	CSimpleStringA kaku("kaku#");
	req.module = 1;
	req.reserved2.Init(2);
	req.reserved2[0] = kaku + CSimpleStringA(buf);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("local:%s", (const char*)req.reserved2[0]);
	req.reserved2[1] = account;
	CSimpleStringA inParam = CSimpleStringA::Format("PreOnline, CardStore heartbeat invodk PreOnline, slot:%s, accountLen:%d", req.reserved2[0].GetData(), account.GetLength());
	LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Inparam, inParam.GetData());
	ErrorCodeEnum eErr = (*m_pCRAClient)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 65000, dwUserCode);
	if (eErr != Error_Succeed){
		errMsgData = CSimpleStringA::Format("local preonline failed:%d(0x%x),dwUserCode:%d(0x%x)", eErr, eErr, dwUserCode, dwUserCode);
		LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Falied, errMsgData.GetData());
		if (eErr == Error_Duplication)
		{
			ReceivePreOnlineBack(Error_Duplication, "", 0, 0);
			return;
		}
		else if (eErr == Error_InvalidState)
		{
			errMsgData = "CardIssuerStore in use";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Duplication, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Duplication, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardStore_CardIssuer_In_Use, "CardIssuerStore in use");
			return;
		}
		else if (eErr == Error_DevNotAvailable)
		{
			errMsgData = "CardIssuerStore not available(open failed)";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardIssuer_Open_Failed, "CardIssuerStore not available(open failed)");
			return;
		}
		else if (eErr == Error_TimeOut)
		{
			errMsgData = "CardIssuerStore process cost too long";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA5301")("跨机时卡库处理耗时过长");
			LogError(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardIssuer_ProcessCostTooLong, "CardIssuerStore process cost too long");
			return;
		}

	}
	Sleep(500);
	CardReadAdapterService_QueryCardInfoOnStore_Req reqX;
	CardReadAdapterService_QueryCardInfoOnStore_Ans ansX;
	ErrorCodeEnum eErrX = Error_Unexpect;
	eErrX = (*m_pCRAClient)(EntityResource::getLink().upgradeLink())->QueryCardInfoOnStore(reqX, ansX,12000);
	if (eErrX != Error_Succeed)
	{
		errMsgData = CSimpleStringA::Format("QueryCardInfoOnStore failed.%d",eErrX);
		LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_QueryCardInfoOnStore_Falied, errMsgData.GetData());
		ansX.findCard = ansX.cardPos = 9999;
	}
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		if (type == 0) {
			m_pHandShakeConn->SendCardActive(1, slot, eErr, (const char*)termNo, (const char*)account,
				account.GetLength(), (const char*)ans.result, ans.result.GetLength(), ansX.findCard, ansX.cardPos, dwUserCode);
		}
		else {
			m_pHandShakeConn->SendCardActive(11, slot, eErr, (const char*)termNo, (const char*)account,
				account.GetLength(), (const char*)ans.result, ans.result.GetLength(), ansX.findCard, ansX.cardPos, dwUserCode);
		}
	}
}

void CHeartBeatFSM::LocalPreOnlineJS(int slot, CSimpleStringA fromTermNo, CSimpleStringA termNo, CSimpleStringA account, CSimpleStringA data, int type)
{
	LOG_FUNCTION();
	//modify by lwt 20240801 add invoke cardissuerStore interface
	DWORD dwUserCode = 0;
	if (!CheckCISSessionOrToConnect())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("to call local PreOnlineCrossJS, but can't connect to CardIssuerStore.");
		return;
	}

	CardIssuerStore::CardIssuerStoreService_PreOnlineCrossJS_Req req;
	CardIssuerStore::CardIssuerStoreService_PreOnlineCrossJS_Ans ans;
	CSimpleStringA errMsgData("");
	req.businessData = data;
	req.slot = slot;
	req.account = account;

	CSimpleStringA inParam = CSimpleStringA::Format("PreOnlineCrossJS, CardStore heartbeat invoke PreOnline, slot:%d, accountLen:%d", req.slot, req.account.GetLength());
	LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Inparam, inParam.GetData());
	ErrorCodeEnum eErr = (*m_pCISClient)(EntityResource::getLink().upgradeLink())->PreOnlineCrossJS(req, ans, 65000, dwUserCode);

	//特殊报错
	if (eErr != Error_Succeed) {
		errMsgData = CSimpleStringA::Format("local PreOnlineCrossJS failed:%d(0x%x),dwUserCode:%d(0x%x)", eErr, eErr, dwUserCode, dwUserCode);
		LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Falied, errMsgData.GetData());

		if (eErr == Error_InvalidState)
		{
			errMsgData = "CardIssuerStore in use";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Duplication, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Duplication, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardStore_CardIssuer_In_Use, "CardIssuerStore in use");
			return;
		}
		else if (eErr == Error_DevNotAvailable)
		{
			errMsgData = "CardIssuerStore not available(open failed)";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardIssuer_Open_Failed, "CardIssuerStore not available(open failed)");
			return;
		}
		else if (eErr == Error_TimeOut)
		{
			errMsgData = "CardIssuerStore process cost too long";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				if (type == 0) {
					m_pHandShakeConn->SendCardActive(1, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
				else {
					m_pHandShakeConn->SendCardActive(11, slot, Error_Hardware, (const char*)termNo, (const char*)account,
						account.GetLength(), errMsgData.GetData(), errMsgData.GetLength() + 1, 9999, 9999, dwUserCode);
				}
			}
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA5301")("跨机时卡库处理耗时过长");
			LogError(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardIssuer_ProcessCostTooLong, "CardIssuerStore process cost too long");
			return;
		}
	}

	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		if (type == 0) {
			m_pHandShakeConn->SendCardActive(1, slot, eErr, (const char*)termNo, (const char*)account,
				account.GetLength(), (const char*)ans.result, ans.result.GetLength(), ans.findCard, ans.cardPos, dwUserCode);
		}
		else {
			m_pHandShakeConn->SendCardActive(11, slot, eErr, (const char*)termNo, (const char*)account,
				account.GetLength(), (const char*)ans.result, ans.result.GetLength(), ans.findCard, ans.cardPos, dwUserCode);
		}
	}
}

void CHeartBeatFSM::ReceivePreOnlineBack(unsigned long errCode,CSimpleStringA data, unsigned long findCard, unsigned long cardPos, unsigned long userErrCode)
{
	if (!CheckCRASessionOrToConnect())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("while receive preonline result, but can't connect to CardReadAdapter.");
		return;
	}

	CardReadAdapterService_NotifyPreonline_Req req;
	CardReadAdapterService_NotifyPreonline_Ans ans;
	req.data = data;
	req.findCard = findCard;
	req.cardPos = cardPos;
	req.errCode = errCode;
	req.reserved1.Init(1);
	req.reserved1[0] = userErrCode;
	ErrorCodeEnum eErr = (*m_pCRAClient)(EntityResource::getLink().upgradeLink())->NotifyPreonline(req, ans, 10000);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("NotifyPreonline ret:%d",eErr);
}

ErrorCodeEnum CHeartBeatFSM::GetPerformCounter(TermianlCounter& counter)
{
	memset(&counter, 0, sizeof(TermianlCounter));
#ifdef RVC_OS_WIN
	PDH_STATUS Status;
	HQUERY Query = NULL;
	//HCOUNTER hcMemoryCount;
	HCOUNTER hcHandleCount, hcProcessCount, hcThreadCount;
	HCOUNTER hcElapsedTimeCount, hcProcessTimeCount;
	DWORD CounterType;
	MEMORYSTATUSEX statex;

	Status = PdhOpenQuery(NULL, NULL, &Query);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhOpenQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessTimeQuery, NULL, &hcProcessTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ProcessTimeQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, HandleNumQuery, NULL, &hcHandleCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for HandleNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ThreadNumQuery, NULL, &hcThreadCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ThreadNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessNumQuery, NULL, &hcProcessCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ProcessNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, SystemElapsedQuery, NULL, &hcElapsedTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for SystemElapsedQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}

	Status = PdhCollectQueryData(Query);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhCollectQueryData failed with 0x%x.\n", Status);
		goto Cleanup;
	}

	do
	{
		Sleep(COUNTER_INTERVAL_MS);

		Status = PdhCollectQueryData(Query);
		if (Status != ERROR_SUCCESS)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhCollectQueryData failed with status 0x%x.", Status);
			break;
		}

		memset(&statex, 0, sizeof(MEMORYSTATUSEX));
		statex.dwLength = sizeof(statex);

		if (GlobalMemoryStatusEx(&statex))
		{
			//Dbg("CPUUseRate:%u%%", statex.dwMemoryLoad);
			counter.totalMem = (unsigned short)(statex.ullTotalPhys / DIV);
			//Dbg("TotalPhysMemory:%I64dMB %d", statex.ullTotalPhys / DIV, counter.totalMem);
			counter.freeMem = (unsigned short)(statex.ullAvailPhys / DIV);
			//Dbg("AvailableMemory:%I64dMB %d", statex.ullAvailPhys / DIV, counter.freeMem);
		}

		PDH_FMT_COUNTERVALUE counterValue;
		//Status = PdhGetFormattedCounterValue(hcMemoryCount, PDH_FMT_DOUBLE, NULL, &counterValue);
		//if (Status == ERROR_SUCCESS)
		//{
		//	Dbg("AvailableMemory:%.20gMB\n", counterValue.doubleValue);
		//}
		Status = PdhGetFormattedCounterValue(hcProcessTimeCount, PDH_FMT_DOUBLE, &CounterType, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.cpuLoad = (unsigned short)(counterValue.doubleValue + 0.5);
			//Dbg("CPURate:%d %u", (long)counterValue.doubleValue, counter.cpuLoad);
		}
		Status = PdhGetFormattedCounterValue(hcHandleCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.handleNum = (unsigned int)(counterValue.longValue);
			//Dbg("HandlesNum:%ld %u", counterValue.longValue, counter.handleNum);
		}
		Status = PdhGetFormattedCounterValue(hcThreadCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.threadNum = (unsigned short)(counterValue.longValue);
			//Dbg("ThreadsNum:%ld %u", counterValue.longValue, counter.threadNum);

		}
		Status = PdhGetFormattedCounterValue(hcProcessCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.procNum = (unsigned short)(counterValue.longValue);
			//Dbg("ProcessesNum:%ld %u", counterValue.longValue, counter.procNum);

		}
		Status = PdhGetFormattedCounterValue(hcElapsedTimeCount, PDH_FMT_LARGE, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			ULONGLONG ulSinceSeconds = counterValue.largeValue;
			ULONG days = 0, hours = 0, minutes = 0, seconds = 0;
			days = ULONG(ulSinceSeconds / DAY_DIV);
			ulSinceSeconds %= DAY_DIV;
			hours = ULONG(ulSinceSeconds / HOURS_DIV);
			ulSinceSeconds %= HOURS_DIV;
			minutes = ULONG(ulSinceSeconds / MINUS_DIV);
			ulSinceSeconds %= MINUS_DIV;
			seconds = ULONG(ulSinceSeconds);

			//Dbg("SystemElapseTime: %u:%02u:%02u:%02u", days, hours, minutes, seconds);

			FILETIME ftCurTime, ftStartTime;
			GetSystemTimeAsFileTime(&ftCurTime);
			ULARGE_INTEGER uliCurTime;
			uliCurTime.HighPart = ftCurTime.dwHighDateTime;
			uliCurTime.LowPart = ftCurTime.dwLowDateTime;
			uliCurTime.QuadPart -= counterValue.largeValue * 1e7;

			ftStartTime.dwHighDateTime = uliCurTime.HighPart;
			ftStartTime.dwLowDateTime = uliCurTime.LowPart;

			SYSTEMTIME stUTC, stLocal;

			FileTimeToSystemTime(&ftStartTime, &stUTC);

			SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
			sprintf_s(counter.osStartTime, 22, "%d-%02d-%02d %02d:%02d:%02d",
				stLocal.wYear, stLocal.wMonth, stLocal.wDay, stLocal.wHour, stLocal.wMinute, stLocal.wSecond);
			//Dbg("OSStartTime: %s", counter.osStartTime);
		}

	}while(false);

	//Status = PdhRemoveCounter(hcMemoryCount);
	Status = PdhRemoveCounter(hcHandleCount);
	Status = PdhRemoveCounter(hcThreadCount);
	Status = PdhRemoveCounter(hcProcessCount);
	Status = PdhRemoveCounter(hcElapsedTimeCount);

Cleanup:

	if (Query)
	{
		PdhCloseQuery(Query);
	}
	if(Status != ERROR_SUCCESS)
	{
		switch(Status)
		{
		case PDH_CSTATUS_BAD_COUNTERNAME :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The counter path could not be parsed or interpreted.");
			break;
		case PDH_CSTATUS_NO_COUNTER :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to find the specified counter on the computer or in the log file.");
			break;
		case PDH_CSTATUS_NO_COUNTERNAME  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The counter path is empty.");
			break;
		case PDH_CSTATUS_NO_MACHINE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The path did not contain a computer name, and function was unable to retrieve local computer name.");
			break;
		case PDH_CSTATUS_NO_OBJECT  :
			{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to find the specified object on the computer or in the log file.");
			if (!m_nLodCtrFlag || m_nLodCtrFlag == 2)
			{
				LodctrTask* task = new LodctrTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			}
			}
			break;
		case PDH_FUNCTION_NOT_FOUND  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to determine the calculation function to use for this counter.");
			break;
		case PDH_INVALID_ARGUMENT :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("One or more arguments are not valid.");
			break;
		case PDH_INVALID_HANDLE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The query handle is not valid.");
			break;
		case PDH_MEMORY_ALLOCATION_FAILURE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to allocate memory required to complete the function.");
			break;
		default :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Cannot figure the erroCode(0x%08x)(%d) in GetPerformCounter", Status, GetLastError());
			break;
		}
		return Error_Unexpect;
	}
	return Error_Succeed;
#else
	return Error_Succeed;
//oiltestlinux
#endif //RVC_OS_WIN
}
void HeartBeatConnection::OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
{
	string serviceCode = pRecvPkg->GetServiceCode();
	
	if (serviceCode.compare("HANDSHK") == 0 || serviceCode.compare("INSTRUC") == 0)
	{
		PkgRcvProcHandAndInstruc(pRecvPkg);
	}
	else if (serviceCode.compare("CARDACT") == 0)
	{
		PkgRcvProcCardActive(pRecvPkg);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unknown service code!");
	}
};
void HeartBeatConnection::SendHandShake()
{
	HandReq req = {0};
	//oiltest set default value
	CSimpleStringA warningLevel("w"),runState("O"),customerHandle("c"),callState("s"),
		localMaintain("l"),remoteMaintain("m"),termStage("U");
	strncpy(req.TerminalNo,m_TerminalNo.GetData(),m_TerminalNo.GetLength());
	m_pEntity->GetFunction()->GetSysVar("CustomerHandle",customerHandle);
	m_pEntity->GetFunction()->GetSysVar("CallState",callState);
	m_pEntity->GetFunction()->GetSysVar("TerminalStage",termStage);
	req.ip = GetLocalIP();
	req.WarningLevel = warningLevel[0];
	req.RunState = runState[0];
	req.CustomerHandle = customerHandle[0];
	req.CallState = callState[0];
	req.LocalMaintain = localMaintain[0];
	req.RemoteMaintain = remoteMaintain[0];
	req.TermStage = termStage[0];
	CSmartPointer<IPackage> pkt = CreateNewPackage("HANDSHK");
	pkt->AddStruct("FNTSTAT", false, false, (LPBYTE)&req, sizeof(HandReq));

	HandErrListReq errListReq;
	errListReq.warnLevel = m_pFSM->GetWarnLevel();
	errListReq.reserved1 = ' ';
	ZeroMemory(errListReq.errList, 512);

	pkt->AddStruct("ENTSTAT", false, false, (LPBYTE)&errListReq, sizeof(HandErrListReq));

	// [Josephus in 9:38:25 2016/4/23]
	TermianlCounter counter;
	ErrorCodeEnum erroCode = m_pFSM->GetPerformCounter(counter);
	if(erroCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get Terminal Performance Information failed !!!");
	}

	counter.serverIP = m_pFSM->m_dwServIP;
#ifdef RVC_OS_WIN
	const char* diskPath = m_pFSM->GetRunDiskPath();
	ULARGE_INTEGER uliFreeBytesAvailable;
	if(GetDiskFreeSpaceEx(diskPath, &uliFreeBytesAvailable, NULL, NULL))
	{
		counter.freeDisk = (unsigned int)(uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0);
		//Dbg("FreeDisk:%.2fMB, %u", uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0, counter.freeDisk);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetDiskFreeSpaceEx with %s failed failed 0x%x", diskPath, GetLastError());
	}
#else
	//oiltestlinux
	counter.freeDisk = 0;
#endif //RVC_OS_WIN
	pkt->AddStruct("CNTSTAT", false, false, (LPBYTE)&counter, sizeof(TermianlCounter));


	SendPackage(pkt);
	//delete pkt;
}

void HeartBeatConnection::SendCardActive(const int type,const int slot,unsigned long errCode,const char *termNo, const char *account, const int accSize, const char *data, const int dataSize,int findCard,int cardPos, unsigned long errCSCode)
{
	CSimpleStringA inParm = CSimpleStringA::Format("SendCardActive,type:%d, slot:%d, errCode:%d, fromTerm:%s, termNo:%s, findCard:%d, cardPos:%d, dataSize:%d,errCSCode:%d",
													type, slot, errCode, m_TerminalNo.GetData(), termNo, findCard, cardPos, dataSize, errCSCode);
	LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_SendCardActive_InParam, inParm.GetData());
	//TODO: 下面这两部分，绝大部分逻辑类似，为什么不把相同的部分抽出来？？？  [Gifur@2025821]
	//发起跨机调用包
	if (type == 0||type==10)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = type;
		req.slot = slot;
		
		strcpy_s(req.FromTerminalNo, sizeof(req.FromTerminalNo), m_TerminalNo.GetData());
		strcpy_s(req.Account, accSize, account);
		strcpy_s(req.TerminalNo, sizeof(req.TerminalNo), termNo);
		strcpy_s(req.Param2, dataSize, data);

		CSmartPointer<IPackage> pkt = CreateNewPackage("CARDACT");
		pkt->AddStruct("INSREQX", false, false, (LPBYTE)&req, sizeof(CardActiveReq));

		SendPackage(pkt);
	}
	//发送跨机调用返回包
	else if (type == 1 || type == 11)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = type;
		req.ErrCode = errCode;
		req.findCard = findCard;
		req.cardPos = cardPos;
		req.reserved1 = errCSCode;

		strcpy_s(req.FromTerminalNo, sizeof(req.FromTerminalNo), m_TerminalNo.GetData());
		strcpy_s(req.Account, accSize, account);
		strcpy_s(req.TerminalNo, sizeof(req.TerminalNo), termNo);
		strcpy_s(req.Param2, dataSize, data);

		CSmartPointer<IPackage> pkt = CreateNewPackage("CARDACT");
		pkt->AddStruct("INSREQX", false, false, (LPBYTE)&req, sizeof(CardActiveReq));

		SendPackage(pkt);
	}
}
void HeartBeatConnection::PkgRcvProcHandAndInstruc(const CSmartPointer<IPackage> &pRecvPkg)
{
	int nLen = pRecvPkg->GetStructLen("FNTHAND");
	if (nLen > 0) {
		Dbg("nLen %d", nLen);
		BYTE *pBuf = new BYTE[nLen+1];
		memset(pBuf, 0, nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("FNTHAND", pBuf, &nLen, &nArrayNum)) {
			Dbg("%s,%d,%d", pBuf, nLen, nArrayNum);
			HandAns* pAns = (HandAns*)pBuf;
			Dbg("hand recv %d events", nArrayNum);
			for (int i = 0; i < nArrayNum; ++i)
			{
				bool bKnownEvent = true;
				DWORD userEvtCode = 0;
				unsigned long ulTmp = (pAns + i)->EventCode;
				Dbg("event %d,param1 %s", ulTmp, (pAns + i)->param1);
				switch (ulTmp)
				{
				case INC_GLOBAL_SETTING_SYNC:
					userEvtCode = LOG_EVT_INC_GLOBAL_SETTING_SYNC;
					break;
				case INC_COMM_RECONNECT:
					userEvtCode = LOG_EVT_INC_COMM_RECONNECT;
					break;
				case INC_START_REMOTE_CONTROL:
					userEvtCode = LOG_EVT_INC_START_REMOTE_CONTROL;
					break;
				case INC_UPDATE_CHECK:
					userEvtCode = LOG_EVT_INC_UPDATE_CHECK;
					break;
				case INC_RECOVER_SERVICE:
					userEvtCode = LOG_EVT_INC_RECOVER_SERVICE;
					break;
				case INC_PAUSE_SERVICE:
					userEvtCode = LOG_EVT_INC_PAUSE_SERVICE;
					break;
				case INC_AREA_SERVICE_SWITCH:
					userEvtCode = LOG_EVT_INC_AREA_SERVICE_SWITCH;
					break;
				case INC_VERSION_ROLLBACK:
					userEvtCode = LOG_EVT_INC_VERSION_ROLLBACK;
					break;
				case INC_BRIDGE:
					userEvtCode = LOG_EVT_INC_BRIDGE;
					break;
				case INC_VEDIO_CONNECTING:
					userEvtCode = LOG_EVT_INC_VEDIO_CONNECTING;
					break;
				case INC_TRADE_MANAGER_NORMAL:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_NORMAL;
					break;
				case INC_TRADE_MANAGER_ON:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_ON;
					break;
				case INC_TRADE_MANAGER_OFF:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_OFF;
					break;
				case INC_DEVICE_LOCK_ON:
					userEvtCode = LOG_EVT_INC_DEVICE_LOCK_ON;
					break;
				case INC_DEVICE_UNLOCK:
					userEvtCode = LOG_EVT_INC_DEVICE_UNLOCK;
					break;
				case INC_DEVICE_KICK_OFF:
					userEvtCode = LOG_EVT_INC_DEVICE_KICK_OFF;
					break;
				default:
					bKnownEvent = false;
					Dbg("unknown ins %d", ulTmp);
					break;
				}
				if (bKnownEvent)
				{
					LogEvent(Severity_Middle, userEvtCode, (pAns + i)->param1);
				}
			}
		}
		else {
			Dbg("invalid handshakeans packet!");
			//OnDisconnect();
		}
		delete pBuf;
	}
}

void CHeartBeatFSM::ProcessCardActive(CardActiveReq* req)
{
	ProcessPreOnlineTask* ppTask = new ProcessPreOnlineTask(this, req);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(ppTask);
}

void CHeartBeatFSM::ProcessPreOnline(CardActiveReq* req)
{
	if (req->type == 0 || req->type == 10) {
		if (m_bCrossUseJS) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("心跳调用卡库跨机JS接口");
			LocalPreOnlineJS(req->slot, req->TerminalNo, req->FromTerminalNo, req->Account, req->Param2, req->type);
		}
		else {
			LocalPreOnline(req->slot, req->TerminalNo, req->FromTerminalNo, req->Account, req->Param2, req->type);
		}
	}
	else if (req->type == 1) {
		ReceivePreOnlineBack(req->ErrCode, req->Param2, req->findCard, req->cardPos, req->reserved1);
	}
#ifdef RVC_OS_WIN
	/** 特殊处理，很久以前  [Gifur@2025730]*/
	delete req;
#endif	
}

void HeartBeatConnection::PkgRcvProcCardActive(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	int nLen = pRecvPkg->GetStructLen("INSREQX");
	if (nLen > 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("nLen %d", nLen);
		BYTE *pBuf = new BYTE[nLen+1];
		memset(pBuf, 0, nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("INSREQX", pBuf, &nLen, &nArrayNum)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d,%d", pBuf, nLen, nArrayNum);
			CardActiveReq* pAns = (CardActiveReq*)pBuf;
			if (nArrayNum > 0)
			{
				CSimpleStringA inParam = CSimpleStringA::Format("PkgRcvProcCardActive, type %d, from term:%s, term:%s, errorCode:%d,userErrCode:%d, accLen:%d, param2Len:%d, findCard:%d,cardPos:%d",
					pAns->type, pAns->FromTerminalNo, pAns->TerminalNo, pAns->ErrCode, pAns->reserved1, strlen(pAns->Account), strlen(pAns->Param2), pAns->findCard, pAns->cardPos);
				if (pAns->ErrCode == Error_Succeed)
					LogWarn(Severity_Low, Error_Succeed, HeartBeat_UserErrorCode_PkgRcvProcCardActive_InParam, inParam.GetData());
				else
					LogWarn(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_PkgRcvProcCardActive_InParam, inParam.GetData());
				m_pFSM->ProcessCardActive(pAns);
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("invalid insreqx packet!");
		}
		/** 特殊处理，很久以前  [Gifur@2025730]*/
#ifdef RVC_OS_WIN
	//delete pBuf;
#else
	delete pBuf;
#endif			
	}
}

//ErrorCodeEnum CHeartBeatFSM::GetServerAddr(CSmartPointer<IConfigInfo> &spConfig, bool isCardStore)
//{
//	//卡库用新地址
//	if(isCardStore)
//	{
//		spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"ServerNew",m_servStr);
//
//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ServerNew=%s", m_servStr);
//		if (m_servStr.IsNullOrEmpty()) {
//			GetEntityBase()->GetFunction()->ShowFatalError("实体HeartBeat找不到对应的ServerNew配置，请检查集中配置");
//			return Error_Param;
//		}
//
//		if (!m_servStr.IsNullOrEmpty())
//		{
//			CAutoArray<CSimpleStringA> aaServ = m_servStr.Split(' ');
//			if (aaServ.GetCount() >= 2)
//			{
//				m_servIP = aaServ[0];
//				m_port = atoi(aaServ[1]);
//
//			}
//			else
//			{
//				GetEntityBase()->GetFunction()->ShowFatalError("实体HeartBeat找不到对应的配置，请检查集中配置");
//				return Error_Param;
//			}
//		}
//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d",(LPCTSTR)m_servIP,m_port);
//	}
//	else
//	{
//		spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"Server",m_servStr);
//		spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"Server_Backup",m_servStrB);
//		if (!m_servStr.IsNullOrEmpty())
//		{
//			CAutoArray<CSimpleStringA> aaServ = m_servStr.Split(' ');
//			if (aaServ.GetCount() >= 2)
//			{
//				m_servIP = aaServ[0];
//				m_port = atoi(aaServ[1]);
//
//			}
//			else
//			{
//				GetEntityBase()->GetFunction()->ShowFatalError("实体HeartBeat找不到对应的配置，请检查集中配置");
//				return Error_Param;
//			}
//		}
//		if (!m_servStrB.IsNullOrEmpty())
//		{
//			CAutoArray<CSimpleStringA> aaServB = m_servStrB.Split(' ');
//			if (aaServB.GetCount() >= 2)
//			{
//				m_servIPB = aaServB[0];
//				m_portB = atoi(aaServB[1]);
//
//			}
//			else
//			{
//				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("no backup(%s).",(LPCSTR)m_servStrB);
//				m_servIPB = m_servIP;
//				m_portB = m_port;
//			}
//		}
//
//		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d;%s,%d",(LPCTSTR)m_servIP,m_port,(LPCTSTR)m_servIPB,m_portB);
//	}
//
//	return Error_Succeed;
//}

ErrorCodeEnum CHeartBeatFSM::ParseServerAddr(bool isCardStore)
{
	//地址赋值
	CSimpleStringA servStrBackup = "";
	if (isCardStore){
		m_servStr = CARDISSUER_STORE_MAIN_SERVER;
		servStrBackup = CARDISSUER_STORE_BACKUP_SERVER;

	}else {
		m_servStr = CARDISSUER_STAND_MAIN_SERVER;
		servStrBackup = CARDISSUER_STAND_BACKUP_SERVER;
	}
	m_servStrBArr = servStrBackup.Split('|');

	if (m_servStr.IsNullOrEmpty()) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("实体HeartBeat配置的main_server值为空，请确认是否已设置正确，main_server=%s", m_servStr);
		return Error_Param;
	}
	else {
		CAutoArray<CSimpleStringA> aaServ = m_servStr.Split(' ');
		if (aaServ.GetCount() != 2){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("实体HeartBeat配置的main_server值无法解析，请确认格式是否正确，main_server=%s", m_servStr.GetData());
			return Error_Param;
		}
		else {
			CSimpleStringA servIP = aaServ[0];
			int port = atoi(aaServ[1]);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("main server: %s,%d", servIP.GetData(), port);
		}
	}
	

	for (int i = 0; i<m_servStrBArr.GetCount(); i++)
	{
		CSimpleStringA servStrB = m_servStrBArr[i];
		if (!servStrB.IsNullOrEmpty()) {
			CAutoArray<CSimpleStringA> aaServB = servStrB.Split(' ');
			if (aaServB.GetCount() != 2) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("实体HeartBeat配置的Backup_server值无法解析，请确认格式是否正确，Backup_server=%s", servStrB.GetData());
				return Error_Param;
			}
			else {
				CSimpleStringA servIP = aaServB[0];
				int port = atoi(aaServB[1]);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("backup server: %s,%d", servIP.GetData(), port);
			}
		}
	}
	return Error_Succeed;
}

bool CHeartBeatFSM::CheckCRASessionOrToConnect()
{
	if (m_pCRAClient != NULL && !m_pCRAClient->QuerySessionClosed())
		return true;
	else
	{
		ErrorCodeEnum eErr = Error_Unexpect;
		m_pCRAClient = new CardReadAdapterService_ClientBase(GetEntityBase());
		if (m_pCRAClient != NULL) {
			eErr = m_pCRAClient->Connect();
			if (eErr != Error_Succeed)
			{
				CSimpleStringA errMsg = CSimpleStringA::Format("connect to CardReadAdapter failed:%d(0x%x)", eErr, eErr);
				LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardReader_Failed, errMsg.GetData());
				return false;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("connect to CardReadAdapter suc.");
				return true;
			}
		}
		else
			return false;
	}
}

bool CHeartBeatFSM::CheckCISSessionOrToConnect()
{
	if (m_pCISClient != NULL && !m_pCISClient->QuerySessionClosed())
		return true;
	else
	{
		ErrorCodeEnum eErr = Error_Unexpect;
		m_pCISClient = new CardIssuerStore::CardIssuerStoreService_ClientBase(GetEntityBase());
		if (m_pCISClient != NULL) {
			eErr = m_pCISClient->Connect();
			if (eErr != Error_Succeed)
			{
				CSimpleStringA errMsg = CSimpleStringA::Format("connect to CardIssuerStore failed:%d(0x%x)", eErr, eErr);
				LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardReader_Failed, errMsg.GetData());
				return false;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("connect to CardIssuerStore succ.");
				return true;
			}
		}
		else {
			return false;
		}
	}
}