myvtm/Module/mod_selfchecker/SelfCheckerFSM.cpp

#include "stdafx.h"
#define WIN32_LEAN_AND_MEAN
#include <algorithm>
#include "SelfCheckerFSM.h"
#include "EventCode.h"
#pragma comment(lib,"user32.lib")
class	CSelfCheckerEntity;

const int MAX_AYSNC_TIMEOUT = 60000;
const int MAX_CHECK_TIME = 60000;
const int MAX_CPU_CHECK_TIME = 5000;
const int TIMER_ID_CHECK = 0;
const int TIMER_CPU_CHECK = 1;
const int THOUSAND = 1024;
const int MILLION = 1048576;



int ActionStrToInt(const char* pAction)
{
	int ret = 0;
	char x = *pAction;
	if (x >= '0' && x <= '9')
		return x - '0';
	else
		return 0;
}
DWORD GetRadixProduct(int times, int radix)
{
	DWORD dwRet = 1;
	if (times < 0 || (radix != 10 && radix != 16))
		return 0;
	else
	{
		for (int i = 0; i < times; i++)
			dwRet *= radix;
	}
	return dwRet;
}
DWORD CodeStrToInt(const char* pCode)
{
	CSimpleStringA csCode(pCode);
	csCode = csCode.Trim();
	int len = csCode.GetLength();
	if (len < 0 || len > 10)
	{
		return 0;
	}
	DWORD dwRet = 0;
	if (len > 2 && csCode[0] == '0' && (csCode[1] == 'x' || csCode[1] == 'X'))//"0x1234,0X12FF"
	{
		for (int i = 2; i < len; i++)
		{
			if (csCode[i] <= '9' && csCode[i] >= '0')
				dwRet += (csCode[i] - '0') * GetRadixProduct(len - i - 1, 16);
			else if (csCode[i] <= 'f' && csCode[i] >= 'a')
				dwRet += (csCode[i] - 'a' + 10) * GetRadixProduct(len - i - 1, 16);
			else if (csCode[i] <= 'F' && csCode[i] >= 'A')
				dwRet += (csCode[i] - 'A' + 10) * GetRadixProduct(len - i - 1, 16);
			else
				return 0;//because there is a invalid char,break process and return 0
		}
	}
	else//"768"
	{
		for (int i = 0; i < len; i++)
		{

			if (csCode[i] <= '9' && csCode[i] >= '0')
				dwRet += (csCode[i] - '0') * GetRadixProduct(len - i - 1, 10);
			else
				return 0;//because there is a invalid char,break process and return 0
		}
	}
	return dwRet;
}
ErrorCodeEnum CSelfCheckerFSM::OnInit()
{
	m_xIdlePre = m_xKernelPre = m_xUserPre = 0;
	ErrorCodeEnum errCode = Initial();
	if (errCode != Error_Succeed)
		return Error_IO;
	return Error_Succeed;
}
ErrorCodeEnum CSelfCheckerFSM::OnExit()
{
	return Error_Succeed;
}
void CSelfCheckerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	ErrorCodeEnum errCode;
	CAutoArray<WORD> tmpInstIDs;
	CAutoArray<CSimpleStringA> tmpNames;
	errCode = GetEntityBase()->GetFunction()->GetAllRegistedEntity(tmpNames, tmpInstIDs);
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get started entity failed.[%d]",errCode);
	}
	for (int i = 0; i < tmpNames.GetCount(); ++i)
	{
		ErrorCodeEnum eErr;
		CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
		CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
		CEntityRunInfo runInfo;
		eErr = pFunc->GetEntityRunInfo(tmpNames[i], runInfo);
		if (runInfo.eState != EntityState_NoStart
			|| tmpNames[i] == "Download" || tmpNames[i] == "UpgradeRun" || tmpNames[i] == "UpgradeManager")
		{
			m_allEntity.push_back(tmpNames[i]);
		}
	}
	FSMEvent* pEvt = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(pEvt);
}
void CSelfCheckerFSM::s0_on_exit()
{
}
unsigned int CSelfCheckerFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
void CSelfCheckerFSM::s1_on_entry()
{
	LOG_FUNCTION();
	void* pTmpData = NULL;
	ITimerListener* pListener = new TimerOutHelper<CSelfCheckerFSM>(this, &CSelfCheckerFSM::OnNormalWorkTimerout, pTmpData);
	GetEntityBase()->GetFunction()->SetTimer(TIMER_ID_CHECK, pListener, MAX_CHECK_TIME);

}
void CSelfCheckerFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CSelfCheckerFSM::s1_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	return 0;
}
void CSelfCheckerFSM::s2_on_entry()
{
	LOG_FUNCTION();
}
void CSelfCheckerFSM::s2_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CSelfCheckerFSM::s2_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	return 0;
}
void CSelfCheckerFSM::s3_on_entry()
{
	LOG_FUNCTION();
}
void CSelfCheckerFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CSelfCheckerFSM::s3_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	return 0;
}
int ch2int(char ch)
{
	if (ch >= '0' && ch <= '9')
		return ch - '0';
	else if (ch >= 'a' && ch <= 'f')
		return ch - 'a' + 10;
	else if (ch >= 'A' && ch <= 'F')
		return ch - 'A' + 10;

	return 0;
}
long hexstr2int(const char* str, int len)
{
	long result = 0;
	for (int i = 0; i < len; ++i)
	{
		result += (ch2int(str[i]) << ((len - i - 1) * 4));
	}
	return result;
}
bool StrEqualNoCase(const char* s1, const char* s2, int len)
{
	if (strlen(s1) != strlen(s2))
		return false;
	for (int i = 0; i < len; ++i)
	{
		if (toupper(s1[i]) != toupper(s2[i]))
			return false;
	}
	return true;
}
ErrorCodeEnum CSelfCheckerFSM::Initial()
{
	ErrorCodeEnum err;
	CSmartPointer<IConfigInfo> spCenConfig;
	err = GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCenConfig);
	if (err != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("open cfg file failed!");
		return Error_IO;
	}
	m_restartNormal = 2;
	m_restartSpecial = 5;
	m_maxOsRestart = 5;
	m_maxPowerRestart = 5;

	do {
		int value(0);
		spCenConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "RestartNormal", value);
		if (value != 0) m_restartNormal = value;
	} while (false);

	do {
		int value(0);
		spCenConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "RestartSpecial", value);
		if (value != 0) m_restartSpecial = value;
	} while (false);

	do {
		int value(0);
		spCenConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MaxOsRestart", value);
		if (value != 0) m_maxOsRestart = value;
	} while (false);

	do {
		int value(0);
		spCenConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MaxPowerRestart", value);
		if (value != 0) m_maxPowerRestart = value;
	} while (false);

	err = GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_sysInfo);
	if (err != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get System Static info failed(%d).",err);
		return Error_Unexpect;
	}

	m_activeEntity.push_back("Chromium");

	return Error_Succeed;
}

ErrorCodeEnum CSelfCheckerFSM::CheckEntity(const char* pszEntityName, EntityTestEnum eTestType, bool bNormalCheck)
{
	if (bNormalCheck)
	{
		//oilyang@20230426 ，常规自检时，针对"TerminalStage"做对应处理（自检分常规自检和即时自检）
		//"S"：准入服务告知准入不过，不再进行实体自检
		//非"A"：其他启动失败导致进关门页，不再对硬件以及其他没必要自检的实体进行自检
		CSimpleStringA tmpTerminalStage("");
		GetEntityBase()->GetFunction()->GetSysVar("TerminalStage", tmpTerminalStage);
		if (tmpTerminalStage.Compare("S") == 0)
			return Error_Succeed;
		else if (tmpTerminalStage.Compare("A") != 0)
		{
			//the hardward entity and some other entity no need to test
			if (_strnicmp("PinPad", pszEntityName, strlen("PinPad")) == 0 || _strnicmp("CardIssuer", pszEntityName, strlen("CardIssuer")) == 0
				|| _strnicmp("ContactlessCard", pszEntityName, strlen("ContactlessCard")) == 0
				|| _strnicmp("IDCertificate", pszEntityName, strlen("IDCertificate")) == 0
				|| _strnicmp("gpio", pszEntityName, strlen("gpio")) == 0 || _strnicmp("HSPScanner", pszEntityName, strlen("HSPScanner")) == 0
				|| _strnicmp("FingerPrint", pszEntityName, strlen("FingerPrint")) == 0
				)
				return Error_Succeed;
		}
	}
	//oilyang@20170926 no need to check by self.Let the HealthManager entity to do it.
	//oilyang@20231106 no need to check VtmLoader
	if (pszEntityName != NULL && (strnicmp(pszEntityName, GetEntityBase()->GetEntityName(), strlen(GetEntityBase()->GetEntityName())) == 0
		|| strnicmp(pszEntityName, "VtmLoader", strlen("VtmLoader")) == 0))
		return Error_Succeed;
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CSmartPointer<IAsynWaitSp> spWait;
	ErrorCodeEnum errCode;
	errCode = pFuncPrivilege->TestEntity(pszEntityName, eTestType, spWait);

	if (errCode == Error_Succeed)
	{
		callback_entry* entry = new callback_entry();
		entry->pRawData = NULL;
		entry->EntityName = pszEntityName;
		entry->ErrorResult = Error_Unexpect;
		entry->op = Test_ShakeHand;
		spWait->SetCallback(this, entry);
	}
	else
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Test %s,%d", pszEntityName, errCode);
	return errCode;
}
void CSelfCheckerFSM::OnNormalWorkTimerout(void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CSmartPointer<IAsynWaitSp> spWait;
	ErrorCodeEnum errCode;
	int activeEnCount = m_activeEntity.size();
	vector<CSimpleStringA>::iterator it;

	for (it = m_activeEntity.begin(); it != m_activeEntity.end(); ++it)
	{
		errCode = CheckEntity(*it, Test_ShakeHand);
		CEntityRunInfo runInfo;
		pFunc->GetEntityRunInfo(*it, runInfo);
		//CheckEntityResouce(*it, runInfo);
	}
	GetEntityBase()->GetFunction()->ResetTimer(TIMER_ID_CHECK, MAX_CHECK_TIME);
}

void CSelfCheckerFSM::DoOnCreated(const char* pszEntityName, ErrorCodeEnum eOnStartErrorCode, const char* pszCallerEntity)
{
}
void CSelfCheckerFSM::DoOnClosed(const char* pszEntityName, EntityCloseCauseEnum eCloseCause, ErrorCodeEnum eOnCloseErrorCode, const char* pszCallerEntity)
{
}
void CSelfCheckerFSM::DoOnException(const char* pszEntityName, const char* pszFunctionName, EntityStateEnum eState, EntityStateEnum eLastState, ErrorCodeEnum eErrorCode)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OnException:%s,%s,%d,%d,%d", pszEntityName, pszFunctionName, eState, eLastState, eErrorCode);
}
void CSelfCheckerFSM::OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp)
{
	CSmartPointer<ICallbackListener> spCallback;
	CSmartPointer<IReleasable> pData;
	pAsynWaitSp->GetCallback(spCallback, pData);
	//LOG_ASSERT(pData);
	callback_entry* entry = dynamic_cast<callback_entry*>((IReleasable*)pData.GetRawPointer());
	entry->ErrorResult = pAsynWaitSp->AsyncGetAnswer();
	callback_entry* new_entry = new callback_entry();

	new_entry->EntityName = entry->EntityName;
	new_entry->ErrorResult = entry->ErrorResult;
	new_entry->op = entry->op;
	new_entry->state = entry->state;
	m_entRunInfo[new_entry->EntityName].eTest = new_entry->ErrorResult; //add test result oilyang 20150616
	
	if (new_entry->op == Test_ShakeHand && new_entry->ErrorResult != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("oiltmp shakehand %s turns out %s, entity state: %s", (LPCTSTR)new_entry->EntityName, SpStrError(new_entry->ErrorResult), SpStrEntityState((EntityStateEnum)new_entry->state));
	}
	if (new_entry->ErrorResult != Error_Succeed)
	{
		ErrorCodeEnum eErr;
		CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
		CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
		if (_strnicmp("MediaController", (const char*)new_entry->EntityName, strlen("MediaController")) == 0
			&& !m_bEverInMainPage)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("On loading stage,don't process MediaController exception.");
		}
		else
			Proc((const char*)new_entry->EntityName, ProcType_Shake, new_entry->ErrorResult);
	}
	else
	{
		CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum eErr = spEntityFunction->OpenConfig(Config_Run, spConfig);
		if (eErr != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("open run cfg file failed!");
			return;
		}
		spConfig->WriteConfigValueInt(new_entry->EntityName, "OsRestart", 0);
		spConfig->WriteConfigValueInt(new_entry->EntityName, "PowerRestart", 0);
	}
}

int CSelfCheckerFSM::AddEntityState(const char* pszEntityName, EntityStateEnum eState)
{
	if (eState == EntityState_Starting)
	{
		m_entRunInfo[pszEntityName].bGetLoadOpt = false;
		m_entRunInfo[pszEntityName].bRestarting = false;
		m_entRunInfo[pszEntityName].loadOpt = 99;
		m_entRunInfo[pszEntityName].eState = eState;
		m_entRunInfo[pszEntityName].eTest = Error_Succeed;
	}
	else
		m_entRunInfo[pszEntityName].eState = eState;
	if (eState == EntityState_Idle)
	{
		m_entRunInfo[pszEntityName].eTest = Error_Succeed;
		m_entRunInfo[pszEntityName].memoryHighCount = 0;
	}
	m_entRunInfo[pszEntityName].cpuRatio = 0;
	return 0;
}
int CSelfCheckerFSM::Proc(string entity, ProcType eType, DWORD dwCode, const char* pszMessage)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("using default process...entity:%s,eType:%d,dwCode:%x,msg:%s", entity.c_str(), eType, dwCode, pszMessage);

	if (eType == ProcType_Shake && (dwCode == Error_TimeOut || dwCode == Error_Unexpect || dwCode == Error_InvalidState))
		ExceptionErrorProcess(eType, entity.c_str(), ACTION_ENTITY_RESTART, true);
	else if (eType == ProcType_Warn)
		ExceptionErrorProcess(eType, entity.c_str(), dwCode, true, pszMessage);
	else
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("What's this:type:%d,receive code:%x,msg:%s, from entity %s.", eType, dwCode, pszMessage, entity.c_str());
	return -1;
}

ErrorCodeEnum CSelfCheckerFSM::ExceptionErrorProcess(ProcType eType, const char* pszEntityName, DWORD dwAction, bool bDefault, const char* pszMessage)
{
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CSmartPointer<IAsynWaitSp> spWait;
	ErrorCodeEnum eErrCode = Error_Unexpect;
	switch (dwAction)
	{
	case ACTION_EXAMINE:
		break;
	case ACTION_RESET:
		break;
	case ACTION_CLOSE:
		eErrCode = pFuncPrivilege->CloseEntity(pszEntityName, spWait);
		if (eErrCode == Error_Succeed)
		{
		}
		break;
	case ACTION_ENTITY_RESTART:
	{
		if (m_entCfgInfo[pszEntityName].bWaitRestart)
		{
			if (!bDefault)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("waiting restart...");
				break;
			}
		}
		//if (m_entRunInfo[pszEntityName].loadOpt == 99)
		//{
		   // DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("not configure? name:[%s]", pszEntityName);
		   // break;
		//}
		//oilyang@20200407 if being restarted by selfchecker,break
		if (m_entRunInfo[pszEntityName].bRestarting)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s is being restarted by selfchecker.", pszEntityName);
			break;
		}
		//oilyang@20240313 comment all of the following, to see the behaving in the future
		//oilyang@20200403
		//for fwb test,PinPad&CardSwiper can't be stop immediately
		//huchen@20210220,SIPPhone can't be stop immediately
		//if (_strnicmp("PinPad", pszEntityName, strlen("PinPad")) == 0
		//	|| _strnicmp("CardSwiper", pszEntityName, strlen("CardSwiper")) == 0
		//	//oilyang@20210220 for huchen add SIPPhone
		//	|| _strnicmp("SIPPhone", pszEntityName, strlen("SIPPhone")) == 0
		//	|| _strnicmp("IDCertificate", pszEntityName, strlen("IDCertificate")) == 0
		//	|| _strnicmp("FingerPrint", pszEntityName, strlen("FingerPrint")) == 0
		//	|| _strnicmp("DeviceControl", pszEntityName, strlen("DeviceControl")) == 0)
		//	eErrCode = pFuncPrivilege->TerminateEntity(pszEntityName, spWait);
		//else
			eErrCode = pFuncPrivilege->StopEntity(pszEntityName, spWait);
		if (eErrCode == Error_Succeed)
		{
			eErrCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
			if (eErrCode != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("spwait stop %s failed: %s.", pszEntityName, SpStrError(eErrCode));
				eErrCode = pFuncPrivilege->TerminateEntity(pszEntityName, spWait);
				eErrCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
				if (eErrCode != Error_Succeed)
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("spwait terminate %s failed: %s.", pszEntityName, SpStrError(eErrCode));
					break;
				}
			}
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Stop %s failed(%d).", pszEntityName, eErrCode);
			break;
		}
		Sleep(2000);
		eErrCode = pFuncPrivilege->StartEntity(pszEntityName, NULL, spWait);
		if (eErrCode == Error_Succeed)
		{
			eErrCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
			if (eErrCode != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("spwait start %s failed(%d).", pszEntityName, eErrCode);
				break;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start entity %s suc.", pszEntityName);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("(re)Start %s failed(%d).", pszEntityName, eErrCode);
			break;
		}
	}
	break;
	default:
		break;
	}
	return eErrCode;
}
void CSelfCheckerFSM::SetEverEnterMainPageFlag(bool bValue)
{
	m_bEverInMainPage = bValue;
}
void CSelfCheckerFSM::GetEntityList(CSimpleStringA csList)
{


	CAutoArray<CSimpleStringA> arrStageList;
	arrStageList.Init(64);
	arrStageList = csList.Split('|');
	for (int i = 0; i < arrStageList.GetCount(); ++i)
	{
		CAutoArray<CSimpleStringA> arrEntity;
		arrEntity.Init(2);
		arrEntity = arrStageList[i].Split('=');
		if (arrEntity.GetCount() < 2)
			break;
		//去重，防止前面已经加载了
		if (find(m_activeEntity.begin(), m_activeEntity.end(), arrEntity[0].GetData()) != m_activeEntity.end())
			continue;
		m_activeEntity.push_back(arrEntity[0]);
		m_entRunInfo[arrEntity[0]].bGetLoadOpt = true;
		if (arrEntity[1].Compare("1") == 0)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s config with loadopt 1", arrEntity[0].GetData());
			m_entRunInfo[arrEntity[0]].loadOpt = 1;
		}
		else if (arrEntity[1].Compare("2") == 0)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s config with loadopt 2", arrEntity[0].GetData());
			m_entRunInfo[arrEntity[0]].loadOpt = 2;
		}
		else
			m_entRunInfo[arrEntity[0]].loadOpt = 0;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_activeEntity has %d entity", m_activeEntity.size());
}