myvtm/Module/mod_vtmloader/VtmLoaderFSM.h

#pragma once
#include "SpBase.h"
#include "SpFSM.h"
//#include "IHttpFunc.h"
#include "CommEntityUtil.hpp"
enum EvtType
{
	Event_NetworkCheck_Passed = EVT_USER + 1,		// 网络检查通过，包括网卡及到总行服务的连通性
	USER_EVT_COREBOOT_FINISHED,
	USER_EVT_SAFELOAD_FINISHED,
	USER_EVT_SAFELOAD_EXMINE_FINISHED,
	USER_EVT_OPERATING_FINISHED,
	USER_EVT_ACCESSAUTH_FINISHED,
};

enum LoadStage
{
	LOADSTAGE_UNKNOWN,
	LOADSTAGE_COREBOOT,
	LOADSTAGE_SAFELOAD,
	LOADSTAGE_OPERATING
};
enum EntityLoadFaultStage
{
	ENTITYLOAD_SAFELOADFAULT,
	ENTITYLOAD_OPERATINGFAULT,
};
enum EntityOption
{
	HEARTBEAT,
	SELFCHECKER
};
enum LoadingOpt
{
	LOADOPT_IGNORE,
	LOADOPT_ASYNC_VERIFY,
	LOADOPT_SYNC_VERIFY
};
enum LoadingResult
{
	LOADING_SUCCEED,
	LOADING_INIT,
	LOADING_FAILED,
	LOADING_TIMEOUT,
};
enum HttpAddrType
{
	HttpAddr_CenterSetting,
	HttpAddr_AccessAuth
};
enum HttpConnResult
{
	HttpConnResult_OK = 1,
	HttpConnResult_Failed
};
struct EntityLoadInfo
{
	int initSn;
	int loadOpt;
	LoadingResult eResult;
};
struct EntityLoadFault
{
	CSimpleStringA name;
	int count;
};
class CVtmLoaderEntity;

class CVtmLoaderFSM : public FSMImpl<CVtmLoaderFSM>, public IFSMStateHooker, public ICallbackListener
{
public:

	CVtmLoaderFSM();
	~CVtmLoaderFSM();

private:
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();
	virtual void OnStateTrans(int iSrcState, int iDstState);	

	enum{s0, s1, s2, s3, s4, s5};
	
	BEGIN_FSM_STATE(CVtmLoaderFSM)
		FSM_STATE_ENTRY(s0, "None",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)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CVtmLoaderFSM,s0)
		FSM_RULE_ENTRY(s0, s1, Event_NetworkCheck_Passed,0)
		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(s2, s3, USER_EVT_SAFELOAD_FINISHED, 0)
		FSM_RULE_ENTRY(s2, s5, USER_EVT_SAFELOAD_FINISHED, 2)
		FSM_RULE_ENTRY(s3, s4, USER_EVT_OPERATING_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s5, USER_EVT_OPERATING_FINISHED, 2)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_ACCESSAUTH_FINISHED, 1)
	END_FSM_RULE()
public:
	int m_refreshWaitSec, m_uploadLogInfo_waitSec;
	int NetWorkCheckAndGetSetting();
	bool GetConfig();
	bool DetectHttpActive();
	bool refreshToken();
	int EntityLoad();
	void NoticeEntityLoad(int evtCode);
	/*True: Legal; False: illegal*/
	BOOL DetectNetworkLegality(CSimpleStringA& strInfo);
	int CheckLoadResult(LoadStage eStage);
	int HttpConnCheck(CSimpleStringA csHttAddr, HttpAddrType eType);
	
private:
	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);

	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);
		
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);

	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);

	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);

	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);

	ErrorCodeEnum AsyncStartEntity(const char* entity_name, const char* cmdline, void* pData);
	void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);
	bool IsRootINIExist(CSimpleStringA& path);
	ErrorCodeEnum SubscribeEntitysEvents();
	void ShowEntityBootFailedAtFront(LPCTSTR lpcszEntityName, ErrorCodeEnum bootFailedResult, bool isBlock = true);
	void GetDns(string& dns);

private:
	CSystemStaticInfo m_sysInfo;
	CSimpleStringA m_strNetworkCheckUrl, m_csErrEntity, m_defaultSystemId;
	int m_sleepEnterOpMS, m_iCanIgnoreAddrDetect, m_iDetectInterval;
	ULLINT m_ullMaxAddrDetectTime, m_ullNetCardCost, m_ullNetDetectCost, m_ullGetConfigCost;
	int m_httpCheckResult[2];
	//DNS Settings
	CSimpleStringA m_strDefaultDNS;
	CSimpleStringA m_strBackupDNS;
	LoadStage m_eStage;
	vector<CSimpleStringA> m_vCoreBoot, m_vSafeLoad, m_vOperating;
	map<CSimpleStringA, EntityLoadInfo> m_coreBootOpt;
	map<CSimpleStringA, EntityLoadInfo> m_safeLoadOpt;
	map<CSimpleStringA, EntityLoadInfo> m_operatingOpt;
};

struct NetWorkCheckAndGetSettingTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	NetWorkCheckAndGetSettingTask(CVtmLoaderFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(Event_NetworkCheck_Passed);
		pEvt->param1 = fsm->NetWorkCheckAndGetSetting();
		fsm->PostEventFIFO(pEvt);
	}
};

struct NoticeEntityLoadTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	int evtCode;
	NoticeEntityLoadTask(CVtmLoaderFSM* f,int evtCode) : fsm(f),evtCode(evtCode) {}
	void Process()
	{
		fsm->NoticeEntityLoad(evtCode);
	}
};

struct HttpConnCheckTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	CSimpleStringA csHttAddr;
	HttpAddrType eType;
	HttpConnCheckTask(CVtmLoaderFSM* f,CSimpleStringA addr, HttpAddrType eType) : fsm(f),csHttAddr(addr),eType(eType) {}
	void Process()
	{
		fsm->HttpConnCheck(csHttAddr, eType);
	}
};