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>

using namespace CardReadAdapter;
#include "EventCode.h"
#include "DeviceCrossHelper.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)

// 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) {
		m_bJBMachine = !sysInfo.strMachineType.Compare("RVC.IL", true);
		m_localDeviceNo = sysInfo.strTerminalID;
	}

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

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

	ErrorCodeEnum rc = GetServerAddr(spConfig, m_isCardStore);
	if (Error_Succeed != rc) {
		LogWarn(Severity_Middle, Error_NotConfig, LOG_EVT_HEARTBEAT_LACK_CENSETTINGS, "找不到对应的配置，请检查集中配置是否存在！");
        return rc;
	}
	
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(),"TestFlag",m_tmpTestFlag);
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "LongConnInterval", m_longConnInterval);
	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;
		}
	}
	
	//网络字节序
	//由于双活改造，改成固定ip，分行服务有处理
	//m_servIP = "99.1.100.215";
	m_dwServIP = inet_addr("99.1.100.215");
	//m_csServerIP = m_servIP;

	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;
	}
	CSimpleStringA temp="";
	spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(), "HandShakeUrl", temp);
	m_strHandShakeUrl = temp;
	//有心跳地址才启动心跳新线程
	if (!m_strHandShakeUrl.IsNullOrEmpty()) {
		NewHandShakeTask* task = new NewHandShakeTask(this);
		Error = this->GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		if (rc != 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(30000);
		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) 
	{
		//HeartBeatConnection* pHandShakeConn;
		m_pHandShakeConn = new HeartBeatConnection(m_pEntity, this);
		if (m_pHandShakeConn != NULL)
		{
			bool bConn = false;

			if(m_isCardStore)
			{
				bConn = m_pHandShakeConn->Connect(m_servIP, m_port, 3);
			}
			else
			{
				bConn = m_pHandShakeConn->ConnectFromCentralSetting();
			}
			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;
			}
		}
	}
	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())
			{
				FSMEvent *e = new FSMEvent(USER_EVT_START);
				PostEventFIFO(e);
				break;
			}
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState", "C");
			m_pHandShakeConn->SendHandShake();

			if(m_pHandShakeConn->IsConnectionOK() && !m_bAlarmed)
			{
				regex reg("((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])");
				if(regex_match(m_servIP.GetData(), reg))
				{
					CSimpleStringA msg = CSimpleStringA::Format("Branch server IP: %s, backup ip: %s", m_servIP.GetData(), m_servIPB.GetData());
					LogWarn(Severity_Low, Error_Succeed, LOG_EVT_CONNECT_BRANCH, msg);
				}
				else
				{
					CSimpleStringA msg = CSimpleStringA::Format("Center server url: %s", m_servIP.GetData());
					LogWarn(Severity_Low, Error_Succeed, LOG_EVT_CONNECT_CENTER, msg);
				}
				m_bAlarmed = true;
			}
			Sleep(m_longConnInterval);//修改成可配置的时间间隔
			//Sleep(20000);//oiltest
			if (m_tmpTestFlag)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("send spshell.exe restart event.");
				LogEvent(Severity_Middle, Event_Req_Framework_Restart, "spshell.exe restart");
			}
		}
	}
	return 0;
}

int CHeartBeatFSM::DoNewHandShake() {
	LOG_FUNCTION();
	int warnSum = 0;
	while (true)
	{
		if (warnSum == 50) {
			DbgWithLink(LOG_LEVEL_INFO, 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;

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


	//qTempReq.m_printDbg = true;

	if (!client->Post(qTempReq, qTempRet)) {
		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;//服务异常
	}
}


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);
	CSimpleStringA warningLevel("w"), runState("r"), customerHandle("c"), callState("s"),
		localMaintain("l"), remoteMaintain("m"), termStage("U");
	m_pEntity->GetFunction()->GetSysVar("RunState", runState);
	m_pEntity->GetFunction()->GetSysVar("CustomerHandle", customerHandle);
	m_pEntity->GetFunction()->GetSysVar("CallState", callState);
	m_pEntity->GetFunction()->GetSysVar("TerminalStage", termStage);
#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;
				}
			}
		}
	}
#endif //RVC_OS_WIN
	obj1["terminalNo"] = sysSInfo.strTerminalID.GetData();
#ifdef RVC_OS_WIN
	obj1["ip"] = (unsigned int)ip;
#else
	obj1["ip"] = 0;//默认不获取
#endif
	obj1["warningLevel"] = warningLevel.GetData();
	obj1["runState"] = runState.GetData();
	obj1["customerHandle"] = customerHandle.GetData();
	obj1["callState"] = callState.GetData();
	obj1["localMaintain"] = localMaintain.GetData();
	obj1["remoteMaintain"] = remoteMaintain.GetData();
	obj1["termStage"] = termStage.GetData();
	obj1["preTermStage"] = "";
	obj1["netState"] = "";
	obj1["preNetState"] = "";
	root["shakeHandVO"]=Json::Value(obj1);

	//写入shakeHandSystemInfo对象
	TermianlCounter counter;
	ErrorCodeEnum erroCode = GetPerformCounter(counter);
	if (erroCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get Terminal Performance Information failed !!!");
	}
	//Dbg("dwServIP 0x%x", counter.serverIP);
#ifdef RVC_OS_WIN
	const char* diskPath = GetRunDiskPath();
	ULARGE_INTEGER uliFreeBytesAvailable;
	if (GetDiskFreeSpaceEx(diskPath, &uliFreeBytesAvailable, NULL, NULL))
	{
		counter.freeDisk = (unsigned int)(uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0);
	}
	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
	obj2["serverIP"] = (unsigned int)m_dwServIP;
	obj2["totalMem"] = (int)counter.totalMem;
	obj2["freeMem"] = (int)counter.freeMem;
	obj2["procNum"] = (int)counter.procNum;
	obj2["threadNum"] = (int)counter.threadNum;;
	obj2["handleNum"] = (unsigned int)counter.handleNum;;
	obj2["freeDisk"] = (unsigned int)counter.freeDisk;
	obj2["osStartTime"] = CSimpleStringA::Format("%s",counter.osStartTime).GetData();
	obj2["cpuLoad"] = (int)counter.cpuLoad;
	root["shakeHandSystemInfo"]=Json::Value(obj2);

	//写入shakeHandErrorVO对象
	HandErrListReq errListReq;
	errListReq.warnLevel = GetWarnLevel();
	errListReq.reserved1 = ' ';
	ZeroMemory(errListReq.errList, 512);

	obj3["warnLevel"] = errListReq.warnLevel;
	string tmp_string(1, errListReq.reserved1);
	obj3["reserved1"] = tmp_string.c_str();
	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)
{
	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));
#ifdef RVC_OS_WIN
	itoa(slot, buf, 10);
#else
	_itoa(slot, buf, 10);
#endif	
	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 = "CardIssuer in use";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				m_pHandShakeConn->SendCardActive(1, 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, "CardIssuer in use");
			return;
		}
		else if (eErr == Error_DevNotAvailable)
		{
			errMsgData = "CardIssuer not available(open failed)";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				m_pHandShakeConn->SendCardActive(1, 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, "CardIssuer not available(open failed)");
			return;
		}
		else if (eErr == Error_TimeOut)
		{
			errMsgData = "CardIssuer process cost too long";
			if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
			{
				m_pHandShakeConn->SendCardActive(1, 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("RTA230W")("跨机时卡库处理耗时过长");
			LogError(Severity_Middle, Error_Unexpect, HeartBeat_UserErrorCode_CardIssuer_ProcessCostTooLong, "CardIssuer 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())
	{
		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);
	}
}
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
	//oilyang@20171122 数量太多，暂时去掉
	//LOG_FUNCTION();
	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.");
				//CSystemStaticInfo sysInfo;
				//if(GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo) == Error_Succeed)
				//{
				//	if(!sysInfo.strMachineType.Compare("RVC.PAD", true))
				//	{
				//		Dbg("Pad MachineType, abort lodctr operation.");
				//		break;
				//	}
				//}
				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
	//strcpy(req.TerminalNo,"75500000002");

	//Dbg("get sysvar");
	//oiltest set default value
	CSimpleStringA warningLevel("w"),runState("r"),customerHandle("c"),callState("s"),
		localMaintain("l"),remoteMaintain("m"),termStage("U");
	//m_pEntity->GetFunction()->GetSysVar("WarningLevel",warningLevel);

	strncpy(req.TerminalNo,m_TerminalNo.GetData(),m_TerminalNo.GetLength());
	m_pEntity->GetFunction()->GetSysVar("RunState",runState);
	m_pEntity->GetFunction()->GetSysVar("CustomerHandle",customerHandle);
	m_pEntity->GetFunction()->GetSysVar("CallState",callState);
	//m_pEntity->GetFunction()->GetSysVar("LocalMaintain",localMaintain);
	//m_pEntity->GetFunction()->GetSysVar("RemoteMaintain",remoteMaintain);
	m_pEntity->GetFunction()->GetSysVar("TerminalStage",termStage);
	//Dbg("ts[%s]",(LPCTSTR)termStage);
	//oiltest byteorder
#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;
				}
			}
		}
	}

	req.ip = ip;
#else
	//oiltest
	req.ip = 0x0;
#endif //RVC_OS_WIN
	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 !!!");
	}
	else
	{
		//oilyang@20171122 数量太多，暂时去掉
		//Dbg("Get Terminal Performance Information suc");
	}
	//const char* szIP = m_pFSM->GetRealIP();
	//memset(tmp, 0, sizeof(tmp));
	//strcpy_s(tmp, 256, szIP);
	//Dbg("Calling gethostbyname with %s %s", tmp, szIP);
	//ent = gethostbyname(tmp);
	//ip = 0xffffffff;
	//if (ent == NULL)
	//{
	//	DWORD dwError = WSAGetLastError();
	//	if (dwError != 0)
	//	{
	//		if (dwError == WSAHOST_NOT_FOUND)
	//		{
	//			Dbg("Host not found");
	//		} else if (dwError == WSANO_DATA)
	//		{
	//			Dbg("No data record found");
	//		} else 
	//		{
	//			Dbg("Function failed with error: %ld", dwError);
	//		}
	//	}
	//	counter.serverIP = 0xffffffff;
	//} 
	//else 
	//{
	//	//unsigned long ulIP = ((struct in_addr*)ent->h_addr)->S_un.S_addr;
	//	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;
	//				// test for ip with S_addr [Josephus in 11:15:43 2016/4/22]
	//				unsigned long ulIP = in->S_un.S_addr;
	//				unsigned long ul2IP = inet_addr(tmp);
	//				Dbg("joseph-test2: ip=0x%x, ulIp=0x%x, ul2IP=0x%x", ip, ulIP, ul2IP);
	//				break;
	//			}
	//		}
	//	}
	//}

	counter.serverIP = m_pFSM->m_dwServIP;
	//Dbg("dwServIP 0x%x", counter.serverIP);
#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());
	//发起跨机调用包
	if (type == 0)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = 0;
		req.slot = slot;
#ifdef RVC_OS_WIN
		strncpy_s(req.FromTerminalNo, m_TerminalNo.GetData(), m_TerminalNo.GetLength());
		strncpy_s(req.Account, account, accSize);
		strncpy_s(req.TerminalNo, termNo, strlen(termNo));
		strncpy_s(req.Param2, data, dataSize);
#else
		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);
#endif //RVC_OS_WIN		
		CSmartPointer<IPackage> pkt = CreateNewPackage("CARDACT");
		pkt->AddStruct("INSREQX", false, false, (LPBYTE)&req, sizeof(CardActiveReq));

		SendPackage(pkt);
	}
	//发送跨机调用返回包
	else if (type == 1)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = 1;
		req.ErrCode = errCode;
		req.findCard = findCard;
		req.cardPos = cardPos;
		req.reserved1 = errCSCode;
#ifdef RVC_OS_WIN
		strncpy_s(req.FromTerminalNo, m_TerminalNo.GetData(), m_TerminalNo.GetLength());
		strncpy_s(req.Account, account, accSize);
		strncpy_s(req.TerminalNo, termNo, strlen(termNo));
		strncpy_s(req.Param2, data, dataSize);
#else
		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);
#endif //RVC_OS_WIN		
		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)
		LocalPreOnline(req->slot, req->TerminalNo, req->FromTerminalNo, req->Account, req->Param2);
	else if (req->type == 1)
		ReceivePreOnlineBack(req->ErrCode, req->Param2, req->findCard, req->cardPos, req->reserved1);
#ifdef RVC_OS_WIN
	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!");
		}
#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;
}
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;
	}
}