myvtm/Module/mod_vtmloader/VtmLoaderFSM.h

#pragma once
#include "SpBase.h"
#include "SpFSM.h"
//#include "IHttpFunc.h"
#include "SpUtility.h"
#include "CommEntityUtil.hpp"
#include "VtmLoader_server_g.h"
using namespace VtmLoader;

enum EvtType
{
	USER_EVT_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,
	USER_EVT_CHECK_DEVICE_ENTITY,
	USER_EVT_SAVE_TERMINALNO,
	USER_EVT_DEALWITH_OLD_EVENT,
};

enum LoadStage
{
	LOADSTAGE_UNKNOWN,
	LOADSTAGE_COREBOOT,
	LOADSTAGE_SAFELOAD,
	LOADSTAGE_OPERATING
};
enum EntityLoadFaultStage
{
	ENTITYLOAD_SAFELOADFAULT,
	ENTITYLOAD_OPERATINGFAULT,
};
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, USER_EVT_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;
	CSimpleString m_verShowMsg;
	int NetWorkCheckAndGetSetting();
	bool GetConfig();
	bool VerifyVer();
	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);
	SP::Toolkit::CConditionVarPlus m_hWaitTerminalNoVar,m_hWaiDeviceEntityVar,m_hSaveTerminalNoVar;
	void SetTerminalNo(SpReqAnsContext<VtmLoaderService_SetTerminalNo_Req, VtmLoaderService_SetTerminalNo_Ans>::Pointer ctx)
	{
		if (ctx->Req.terminalNo.IsNullOrEmpty())
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Req.terminalNo is null or empty");
			ctx->Answer(Error_Param);
			return;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(VtmLoaderService_LogCode_SetTerminalNo)("set terminalNo to [%s]", ctx->Req.terminalNo.GetData());
		m_terminalNoFromWeb = ctx->Req.terminalNo;
		ctx->Answer(Error_Succeed);
		m_hWaitTerminalNoVar.Broadcast();
	}
	void NoticeAppReady(SpReqAnsContext<VtmLoaderService_NoticeAppReady_Req, VtmLoaderService_NoticeAppReady_Ans>::Pointer ctx) { }
	void CheckDeviceEntity(SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx);
	void SaveTerminalNo(SpReqAnsContext<VtmLoaderService_SaveTerminalNo_Req, VtmLoaderService_SaveTerminalNo_Ans>::Pointer ctx);
	void DealWithOldEvent(SpReqAnsContext<VtmLoaderService_DealWithOldEvent_Req, VtmLoaderService_DealWithOldEvent_Ans>::Pointer ctx);
	bool CheckConfigInfoInTestRoom();
	void SetVideoEntityOK() { m_bMediaControllerOK = true; }
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);
	void ToCheckIfInstalling();

private:
	CSystemStaticInfo m_sysInfo;
	CSimpleStringA m_strNetworkCheckUrl, m_csErrEntity, m_defaultSystemId, m_terminalNoFromWeb, m_csEntityList;
	int m_sleepEnterOpMS, m_iCanIgnoreAddrDetect, m_iDetectInterval, m_iNoCheckMachineModel;
	ULLINT m_ullMaxAddrDetectTime, m_ullNetCardCost, m_ullNetDetectCost, m_ullGetConfigCost, m_ullEntityLoadStart;
	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;

	bool m_bMediaControllerOK;

	bool RefreshDeviceConfig(SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx);
	void CheckDeviceBaseEntity(SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx, WORD wEntityID);
	void CheckEntityRestartIdle(SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx);
	void CheckVideo(SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx);
	
	
};
class CheckDeviceEntityEvent : public FSMEvent
{
public:
	CheckDeviceEntityEvent() : FSMEvent(USER_EVT_CHECK_DEVICE_ENTITY) {}
	~CheckDeviceEntityEvent() {}
	SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class SaveTerminalNoEvent : public FSMEvent
{
public:
	SaveTerminalNoEvent() : FSMEvent(USER_EVT_SAVE_TERMINALNO) {}
	~SaveTerminalNoEvent() {}
	SpReqAnsContext<VtmLoaderService_SaveTerminalNo_Req, VtmLoaderService_SaveTerminalNo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

class DealWithOldEvent_Event : public FSMEvent
{
public:
	DealWithOldEvent_Event() : FSMEvent(USER_EVT_DEALWITH_OLD_EVENT) {}
	~DealWithOldEvent_Event() {}
	SpReqAnsContext<VtmLoaderService_DealWithOldEvent_Req, VtmLoaderService_DealWithOldEvent_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

struct NetWorkCheckAndGetSettingTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	NetWorkCheckAndGetSettingTask(CVtmLoaderFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_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);
	}
};

struct CheckDeviceEntityTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	SpReqAnsContext<VtmLoaderService_CheckDeviceEntity_Req, VtmLoaderService_CheckDeviceEntity_Ans>::Pointer ctx;
	CheckDeviceEntityTask(CVtmLoaderFSM* f) : fsm(f){}
	void Process()
	{
		fsm->CheckDeviceEntity(ctx);
	}
};
struct SaveTerminalNoTask : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	SpReqAnsContext<VtmLoaderService_SaveTerminalNo_Req, VtmLoaderService_SaveTerminalNo_Ans>::Pointer ctx;
	SaveTerminalNoTask(CVtmLoaderFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->SaveTerminalNo(ctx);
	}
};

struct DealWithOldEvent_Task : public ITaskSp
{
	CVtmLoaderFSM* fsm;
	SpReqAnsContext<VtmLoaderService_DealWithOldEvent_Req, VtmLoaderService_DealWithOldEvent_Ans>::Pointer ctx;
	DealWithOldEvent_Task(CVtmLoaderFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->DealWithOldEvent(ctx);
	}
};