myvtm/Module/mod_healthmanager/HealthManagerFSM.h

#ifndef __HEALTHMANAGER_FSM_H
#define __HEALTHMANAGER_FSM_H
#pragma once

#include "stdafx.h"
#include "SpFSM.h"
#include <map>
#include <vector>
using namespace std;

#include "HealthManager_msg_g.h"
#include "../mod_accessauth/AccessAuthorization_client_g.h"
#include "../mod_Initializer/Initializer_client_g.h"
#include "../mod_DeviceControl/DeviceControl_client_g.h"
#include "../mod_pinpad/PinPad_client_g.h"
#include "../mod_cardswiper/CardSwiper_msg_g.h"
using namespace AccessAuthorization;
using namespace Initializer;
using namespace DeviceControl;
using namespace PinPad;
using namespace CardSwiper;

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_WAIT_DEAMON_FINISHED,
	USER_EVT_COREBOOT_FINISHED,
	USER_EVT_SAFELOAD_FINISHED,
	USER_EVT_SAFELOAD_EXMINE_FINISHED,
	USER_EVT_OPERATING_FINISHED,
	USER_EVT_ACCESSAUTH_FINISHED,
	USER_EVT_MAITAIN,
	USER_EVT_MAITAIN_FINISHED,
	USER_EVT_ENTER_CUSTOMER_MANAGER,
	USER_EVT_SWITCH_BACK_TO_RVC,
};
enum LoadStage
{
	LOADSTAGE_UNKNOWN,
	LOADSTAGE_COREBOOT,
	LOADSTAGE_SAFELOAD,
	LOADSTAGE_OPERATING
};
enum EntityLoadFaultStage
{
	ENTITYLOAD_SAFELOADFAULT,
	ENTITYLOAD_OPERATINGFAULT,
};
enum EntityOption
{
	WATCHDOG,
	UPS,
	HEARTBEAT,
	SELFCHECKER
};
enum LoadingOpt
{
	LOADOPT_IGNORE,
	LOADOPT_ASYNC_VERIFY,
	LOADOPT_SYNC_VERIFY
};
enum LoadingResult
{
	LOADING_SUCCEED,
	LOADING_INIT,
	LOADING_FAILED,
	LOADING_TIMEOUT,
};
enum CustomerManagerState
{
	CM_INIT,
	CM_ENTER,
	CM_NOT_ENTER,
};
enum HealthManagerFSMState
{
	HM_FSM_INIT,
	HM_FSM_STATE_COREBOOT,
	HM_FSM_STATE_SAFELOAD,
	HM_FSM_STATE_OP,
	HM_FSM_STATE_IDLE,
	HM_FSM_STATE_FAULT,
	HM_FSM_STATE_MAINTAINING,
	HM_FSM_STATE_PREPAREOFF,
	HM_FSM_STATE_TERMINATING,
	HM_FSM_STATE_EXITTING,
	HM_FSM_STATE_SLEEP,
	HM_FSM_STATE_CMS,
};
struct callback_entry : public IReleasable
{
	virtual ~callback_entry() {}
	CSimpleStringA EntityName;
	union {
		void *pRawData;
		int state;
	};
	int op;
	ErrorCodeEnum ErrorResult;
};
struct EntityLoadInfo
{
	int initSn;
	int loadOpt;
	LoadingResult eResult;
};
struct EntityLoadFault
{
	CSimpleStringA name;
	int count;
};

extern unsigned long long GetTickCountRVC();

class	CHealthManagerEntity;

class CHealthManagerFSM : public FSMImpl<CHealthManagerFSM>,public ICallbackListener
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11};
	BEGIN_FSM_STATE(CHealthManagerFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"CoreBoot",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"SafeLoad",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"Loading",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"Operating",s4_on_entry,s4_on_exit,s4_on_event)
		FSM_STATE_ENTRY(s5,"Fault",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"Maintaining",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s7,"PrepareOff",s7_on_entry,s7_on_exit,s7_on_event)
		FSM_STATE_ENTRY(s8,"Terminating",s8_on_entry,s8_on_exit,s8_on_event)
		FSM_STATE_ENTRY(s9,"Exitting",s9_on_entry,s9_on_exit,s9_on_event)
		FSM_STATE_ENTRY(s10,"Sleep",s10_on_entry,s10_on_exit,s10_on_event)
		FSM_STATE_ENTRY(s11,"CustomerManager",s11_on_entry,s11_on_exit,s11_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CHealthManagerFSM,s0)
		FSM_RULE_ENTRY(s0,s1,USER_EVT_WAIT_DEAMON_FINISHED,0)
		//FSM_RULE_ENTRY(s0,s5,USER_EVT_WAIT_DEAMON_FINISHED,1)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_COREBOOT_FINISHED,0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_COREBOOT_FINISHED,1)
		FSM_RULE_ENTRY(s1,s5,USER_EVT_COREBOOT_FINISHED,2)
		FSM_RULE_ENTRY(s1,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s2,s3,USER_EVT_SAFELOAD_FINISHED,0)
		FSM_RULE_ENTRY(s2,s5,USER_EVT_SAFELOAD_FINISHED,2)
		FSM_RULE_ENTRY(s2,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		//FSM_RULE_ENTRY(s2,s4,USER_EVT_ACCESSAUTH_FINISHED,0)
		//FSM_RULE_ENTRY(s2,s5,USER_EVT_ACCESSAUTH_FINISHED,1)
		FSM_RULE_ENTRY(s3,s4,USER_EVT_OPERATING_FINISHED,0)
		FSM_RULE_ENTRY(s3,s5,USER_EVT_OPERATING_FINISHED,2)
		FSM_RULE_ENTRY(s3,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_ACCESSAUTH_FINISHED,1)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s4,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s5,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s5,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s7,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s7,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s8,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s8,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s9,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s9,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s10,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s10,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s6,s4,USER_EVT_MAITAIN_FINISHED,4)
		FSM_RULE_ENTRY(s6,s5,USER_EVT_MAITAIN_FINISHED,5)
		FSM_RULE_ENTRY(s6,s7,USER_EVT_MAITAIN_FINISHED,7)
		FSM_RULE_ENTRY(s6,s8,USER_EVT_MAITAIN_FINISHED,8)
		FSM_RULE_ENTRY(s6,s9,USER_EVT_MAITAIN_FINISHED,9)
		FSM_RULE_ENTRY(s6,s10,USER_EVT_MAITAIN_FINISHED,10)
		FSM_RULE_ENTRY(s11, s6, USER_EVT_MAITAIN, 0)
		FSM_RULE_ENTRY(s11,s2,USER_EVT_SWITCH_BACK_TO_RVC,2)
		FSM_RULE_ENTRY(s11,s3,USER_EVT_SWITCH_BACK_TO_RVC,3)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_SWITCH_BACK_TO_RVC,4)
		FSM_RULE_ENTRY(s11,s5,USER_EVT_SWITCH_BACK_TO_RVC,5)
		FSM_RULE_ENTRY(s11,s6,USER_EVT_SWITCH_BACK_TO_RVC,6)
		FSM_RULE_ENTRY(s11,s7,USER_EVT_SWITCH_BACK_TO_RVC,7)
		FSM_RULE_ENTRY(s11,s8,USER_EVT_SWITCH_BACK_TO_RVC,8)
		FSM_RULE_ENTRY(s11,s9,USER_EVT_SWITCH_BACK_TO_RVC,9)
		FSM_RULE_ENTRY(s11,s10,USER_EVT_SWITCH_BACK_TO_RVC,10)
	END_FSM_RULE()

	CHealthManagerFSM():m_eStage(LOADSTAGE_COREBOOT),m_SysState("I"),m_pACClient(NULL)
	,m_bAccessAuth(false),m_bACFailed(false),m_pInitClient(NULL),m_bInitSuc(false),m_bInitFail(false)
	, m_bIdleToMaintain(false), m_custMngerState(0), m_pDevCtrlClient(NULL), m_bHasAuthEver(false)
	, m_checkCode(""), m_accessAuthCheckMD5(0), m_havReceiveMD5OK(0), m_bFirstAccessAuth(true), m_bEverAuthSucWithDevice(false)
	, m_bIEBeforeHealth(false), m_hasCfgGpioInRootIni(false), m_csErrEntity(""){}
	~CHealthManagerFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* pEvt);
	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* pEvt);
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* pEvt);
	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* pEvt);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* pEvt);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* pEvt);
	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* pEvt);
	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* pEvt);
	void s8_on_entry();
	void s8_on_exit();
	unsigned int s8_on_event(FSMEvent* pEvt);
	void s9_on_entry();
	void s9_on_exit();
	unsigned int s9_on_event(FSMEvent* pEvt);
	void s10_on_entry();
	void s10_on_exit();
	unsigned int s10_on_event(FSMEvent* pEvt);
	void s11_on_entry();
	void s11_on_exit();
	unsigned int s11_on_event(FSMEvent* pEvt);

	ErrorCodeEnum Initial();
	int WaitDeamonFinish();
	int CoreBootDoWork();
	int SafeLoadDoWork();
	int OpLoadDoWork();
	int AccessAuthDoWork();
	int CheckLoadResult(LoadStage eStage);
	int CheckSafeLoadResult();
	int CheckOperatingResult();
	void SetAccessAuth(bool bResult=true);
	bool GetAccessAuthFlag(){return m_bAccessAuth;}
	void SetAccessFailedFlag(bool bValue = true) { m_bACFailed = bValue; }
	void SetInitSucFlag() {m_bInitSuc = true; m_bInitFail = false;}
	void SetInitFailFlag() {m_bInitFail = true; m_bInitSuc = false;}
	int StartPinPadEntity();
	int GetFSMState(){return m_fsmState;}
	void ToReAccessAuth(bool bEver=false);
	void SetCustomerMngerState(int iValue){m_custMngerState = iValue;}
	int GetCustomerMngerState(){return m_custMngerState;}
	int USBControl();
	CSimpleStringA GetEntityCfgInfo(CSimpleStringA name,int &loadOpt);
	CSimpleStringA GetUrlValue(){ return m_strURLValue; }
	void SetMD5OK(const int value){ m_havReceiveMD5OK = value; SetEvent(m_hMD5OKEvt); }
	int QueryAccessAuthStatus()
	{
		if (m_bAccessAuth)
			return 0;
		else
		{
			if (m_bHasAuthEver)
				return 1;
			else
				return 2;
		}
	}
	CSimpleStringA QueryCheckCode();
	CSimpleStringA QueryPinPadSM3DesInfo();
	void DeviceReConnect();
	bool IfIEBeforeHealth(){ return m_bIEBeforeHealth; }
	int QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay = RebootWay_Unknown);
	void PostProcessAfterUpgrade();
private:
	
	virtual ErrorCodeEnum AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData);
	virtual ErrorCodeEnum AsyncStopEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncPauseEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncContinueEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncTerminateEntity(const char *entity_name, void *pData);
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);
	int DoInitialization();
	void ToCheckUPS();
	void ToLogWarnTermAboutInfo();

	void ShowEntityBootFailedAtFront(LPCTSTR lpcszEntityName, ErrorCodeEnum bootFailedResult, bool isBlock = true);

private:
	LoadStage m_eStage;
	CSimpleStringA m_SysState,m_strURL,m_strURLValue,m_checkCode,m_csErrEntity;
	map<int,int> m_enOpt;//entity option
	vector<CSimpleStringA> m_vCoreBoot,m_vSafeLoad,m_vOperating,m_vAllCfgEntity;
	map<CSimpleStringA,EntityLoadInfo> m_coreBootOpt;
	map<CSimpleStringA,EntityLoadInfo> m_safeLoadOpt;
	map<CSimpleStringA,EntityLoadInfo> m_operatingOpt;
	map<CSimpleStringA,EntityLoadFault> m_safeLoadFault;
	map<CSimpleStringA,EntityLoadFault> m_operatingFault;
	int m_devCfgNum, m_AccessAuthTries, m_InitTries, m_fsmState, m_stateBeforeMaintain, m_custMngerState, m_preFsmState, m_accessAuthCheckMD5
		,m_havReceiveMD5OK;
	AccessAuthService_ClientBase *m_pACClient;
	InitializerService_ClientBase *m_pInitClient;
	bool m_bAccessAuth,m_bACFailed,m_bInitSuc,m_bInitFail,m_bIdleToMaintain,m_bHasAuthEver,m_bFirstAccessAuth,m_bEverAuthSucWithDevice
		,m_bIEBeforeHealth, m_hasCfgGpioInRootIni;
	DWORD m_AccessAuthTimeout,m_InitializationTimeout;
	DeviceControlService_ClientBase *m_pDevCtrlClient;
	HANDLE m_hMD5OKEvt;
	CSystemStaticInfo m_sysInfo;
	//CHealthManagerEntity *m_pEntity;
};
struct WaitDeamonFinishTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WaitDeamonFinishTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_WAIT_DEAMON_FINISHED);
		e->param1 = fsm->WaitDeamonFinish();
		fsm->PostEventFIFO(e);
	}
};
struct CoreBootTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	CoreBootTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_COREBOOT_FINISHED);
		e->param1 = fsm->CoreBootDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct SafeLoadTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	SafeLoadTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
		e->param1 = fsm->SafeLoadDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct OpLoadTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	OpLoadTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
		e->param1 = fsm->OpLoadDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct AccessAuthTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	AccessAuthTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_ACCESSAUTH_FINISHED);
		e->param1 = fsm->AccessAuthDoWork();
		fsm->PostEventFIFO(e);
	}
};
#endif // __HEALTHMANAGER_FSM_H