myvtm/Module/mod_accessauth/AccessAuthFSM.h

#pragma once

#include "SpBase.h"
#include "SpFSM.h"
#include "Blob.h"
#include "AccessAuthConn.h"
#include "AccessAuthErrorCode.h"
class MyMutex;
class CAccessAuthFSM : public FSMImpl<CAccessAuthFSM>, public IFSMStateHooker
{
public:	
	struct ReportStateEvent : public FSMEvent
	{
		ReportStateEvent(char cNewStage, DWORD dwNewStageTime, char cOldStage, DWORD dwOldStageTime):
			FSMEvent(Event_ReportStage), cNewStage(cNewStage), dwNewStageTime(dwNewStageTime),
			cOldStage(cOldStage), dwOldStageTime(dwOldStageTime)
		{}

		char cNewStage;
		char cOldStage;
		DWORD dwNewStageTime;
		DWORD dwOldStageTime;
	};

	CAccessAuthFSM();
	virtual ~CAccessAuthFSM();

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

	enum{s1, s2, s3, s4, s5, s6, s7};

	enum
	{
		Event_StartRegist = EVT_USER+1,
		Event_StartReregist,	
		Event_ConnectionOK,
		Event_EndSyncTime,
		Event_UpdateWKSucc,
		Event_IgnoreUpdateWK,
		Event_UpdateWKFail,
		Event_ReqTokenSucc,
		Event_ReqTokenFail,
		Event_ReqTokenCancel,
		Event_StartUnregist,
		Event_LostTrust,
		Event_StateTimeout,		// 临时状态超时
		Event_ReportStage,
		Event_CheckMD5Succ,
		Event_CheckMD5Fail,
		Event_InitFinishOK,
		Event_SyncTimeFailed  //同步时间失败
	};

	BEGIN_FSM_STATE(CAccessAuthFSM)
		FSM_STATE_ENTRY(s1, "Isolate",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2, "Checking",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3, "Failure",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4, "Cancel", s4_on_entry, s4_on_exit, s4_on_event)
		FSM_STATE_ENTRY(s5, "Login", s5_on_entry, s5_on_exit, s5_on_event)
		FSM_STATE_ENTRY(s6, "Leaving", s6_on_entry, s6_on_exit, s6_on_event)
		FSM_STATE_ENTRY(s7, "LostTrust", s7_on_entry, s7_on_exit, s7_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CAccessAuthFSM,s1)
		FSM_RULE_ENTRY_ANY(s1, s2, Event_StartRegist)
		//FSM_RULE_ENTRY_ANY(s2, s3, Event_UpdateWKFail)
		FSM_RULE_ENTRY_ANY(s2, s3, Event_ReqTokenFail)
		FSM_RULE_ENTRY_ANY(s2, s3, Event_CheckMD5Fail)		
		FSM_RULE_ENTRY_ANY(s2, s4, Event_ReqTokenCancel)
		FSM_RULE_ENTRY_ANY(s2, s5, Event_ReqTokenSucc)
		FSM_RULE_ENTRY_ANY(s2, s3, Event_SyncTimeFailed)
		FSM_RULE_ENTRY_ANY(s3, s2, Event_StartRegist)
		FSM_RULE_ENTRY_ANY(s4, s1, Event_StateTimeout)
		FSM_RULE_ENTRY_ANY(s5, s6, Event_StartUnregist)			
		FSM_RULE_ENTRY_ANY(s5, s2, Event_StartReregist)
		FSM_RULE_ENTRY_ANY(s5, s2, Event_StartRegist)
		FSM_RULE_ENTRY_ANY(s5, s7, Event_LostTrust)
		FSM_RULE_ENTRY_ANY(s6, s1, Event_StateTimeout)
		FSM_RULE_ENTRY_ANY(s7, s1, Event_StateTimeout)		
	END_FSM_RULE()

	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);

	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* event);

	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* event);

public:
	DWORD InitDevice(SpReqAnsContext<AccessAuthService_InitDev_Req, AccessAuthService_InitDev_Ans>::Pointer &ctx);
	DWORD SyncTime();
	int m_finishAccess;

private:
	ErrorCodeEnum SetSysVar(const CSimpleStringA &newVal);
	ErrorCodeEnum SecureClientConnect();
	ErrorCodeEnum SecureClientRelease();

	ErrorCodeEnum LoadCenterConfig();
	CAccessAuthConn *m_pConnection;

	int m_nExitReason;
	int m_nExitWay;
	int m_nCheckMD5;

	
};
class MyMutex {
public:
	explicit MyMutex(std::_Mutex* pm):mut(pm) {
		mut->_Lock();
	}
	~MyMutex() {
		mut->_Unlock();
	}
private:
	std::_Mutex* mut;
};