myvtm/Module/mod_selfchecker/mod_selfchecker.h

#ifndef __MOD_SELFCHECKER_H
#define __MOD_SELFCHECKER_H
#pragma once

#include "SpBase.h"
#include "SelfCheckerFSM.h"
#include "SelfChecker_server_g.h"
#include "AssistantChannel_client_g.h"
#include "chan_protocol.h"
using namespace SelfChecker;
using namespace AssistantChannel;

struct EntityProcessInfo
{
	int restartTimes;
	EntityProcessInfo(){restartTimes = 0;}
};
class CSelfCheckerEntity;
class SelfCheckerSession : public SelfCheckerService_ServerSessionBase
{
public:
	SelfCheckerSession(CSelfCheckerEntity *pEntity):m_pEntity(pEntity){}
	virtual ~SelfCheckerSession(){};
	virtual void Handle_RealCheck(SpReqAnsContext<SelfCheckerService_RealCheck_Req, SelfCheckerService_RealCheck_Ans>::Pointer ctx);
	virtual void Handle_GetEntityErrorList(SpReqAnsContext<SelfCheckerService_GetEntityErrorList_Req, SelfCheckerService_GetEntityErrorList_Ans>::Pointer ctx);
private:
	CSelfCheckerEntity *m_pEntity;
};
class AssistChannelSelfCheckerClient : public ChannelService_ClientBase
{
public:
	AssistChannelSelfCheckerClient(CSelfCheckerEntity *pEntity);
	virtual ~AssistChannelSelfCheckerClient(){}
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg,  CSmartPointer<IReleasable> pData);	
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData);
};


class CSelfCheckerEntity : public CEntityBase,public IEntityLifeListener,public IEntityStateListener
	,public ILogListener
{
public:
	CSelfCheckerEntity():m_bIEIdle(false),m_pAssChanClient(NULL){ }
	virtual ~CSelfCheckerEntity() {}
	virtual const char *GetEntityName() const { return "SelfChecker"; }
	
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		LOG_FUNCTION();
		ErrorCodeEnum errCode = Error_Succeed;
		m_fsm.Init(this);
		CSmartPointer<IEntityFunction> pFunc = GetFunction();
		CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
		if (pFuncPrivilege != NULL) {
			errCode = pFuncPrivilege->RegistEntityLifeEvent(this); // NULL to register for all
			if (errCode != Error_Succeed)
			{
				Dbg("RegistEntityLife failed(%d).",errCode);
				pTransactionContext->SendAnswer(errCode);
				return;
			}
		} else {
			errCode = Error_NoPrivilege;
			Dbg("NoPrivilege");
			pTransactionContext->SendAnswer(errCode);
			return;
		}
		errCode = pFuncPrivilege->RegistEntityStateEvent(NULL,this);
		if (errCode != Error_Succeed)
		{
			Dbg("RegistEntityState failed(%d).",errCode);
			pTransactionContext->SendAnswer(errCode);
			return;
		}
		Dbg("regist entity event ok.");
		GetFunction()->SubscribeLog(m_uuidCardIsuuer,this,Log_Error,Severity_High,Error_IgnoreAll,-1,NULL,false);
		GetFunction()->SubscribeLog(m_uuidCardSwiper,this,Log_Event,Severity_High,Error_IgnoreAll,-1,"CardSwiper",false);
		GetFunction()->SubscribeLog(m_uuidCardSwiper, this, Log_Error, Severity_Middle, Error_IgnoreAll, -1, "CardSwiper");
		//GetFunction()->SubscribeLog(m_uuidPinPad,this,Log_Error,Severity_High,Error_IgnoreAll,-1,"PinPad",false);
		//GetFunction()->SubscribeLog(m_uuidIDCertificate,this,Log_Error,Severity_High,Error_IgnoreAll,-1,"IDCertificate",false);
		//GetFunction()->SubscribeLog(m_uuidMedia,this,Log_Error,Severity_High,Error_IgnoreAll,-1,"MediaController",false);
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum eCfg = pFunc->OpenConfig(Config_Software, spConfig);
		if (eCfg != Error_Succeed) {
			Dbg("open cfg file failed()!",eCfg);
		}
		else
		{
			spConfig->ReadConfigValue("init","QueryStateEntity",m_csQueryStateEntity);
		}
		auto list = m_csQueryStateEntity.Split(',');
		for (int i = 0; i < list.GetCount(); ++i)
		{
			CSimpleStringA entity = list[i];
			m_vQueryStateEntity.push_back(entity);
		}
		//ConnectToAssistChannel();
		//ConnectToHealthManager();
		pTransactionContext->SendAnswer(errCode);
	}

	
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		pTransactionContext->SendAnswer(Error_Succeed); 
	}

	virtual void OnCreated(const char *pszEntityName,ErrorCodeEnum eOnStartErrorCode,const char *pszCallerEntity);
	virtual void OnClosed(const char *pszEntityName,EntityCloseCauseEnum eCloseCause,ErrorCodeEnum eOnCloseErrorCode,const char *pszCallerEntity);
	virtual void OnException(const char *pszEntityName,const char *pszFunctionName,EntityStateEnum eState,EntityStateEnum eLastState,ErrorCodeEnum eErrorCode);

	virtual void OnEntityStateHook(const char *pszEntityName,const char *pszTriggerEntity,EntityStateEnum eState,EntityStateEnum eLastState);
	virtual void OnUserStateHook(const char *pszEntityName,DWORD dwState,DWORD dwLastState);
	virtual void OnCeateConnection(const char *pszCallerEntity,const char *pszServiceEntity);
	virtual void OnCloseConnection(const char *pszCallerEntity,const char *pszServiceEntity);

	//int GetActiveCount(){return m_activeEntity.size();}
	ErrorCodeEnum GetLiveEntityList(CAutoArray<CSimpleString> &LiveEntitys);
	ErrorCodeEnum GetEntityTestCode(const char *pszEntityName,ErrorCodeEnum &LastTestError, TestActionEnum &eLastAction);
	ErrorCodeEnum ExamineEntity(const char *pszEntityName);

	bool GetIEIdleFlag() {return m_bIEIdle;}
	void RealCheck(SpReqAnsContext<SelfCheckerService_RealCheck_Req, SelfCheckerService_RealCheck_Ans>::Pointer ctx);
	void GetEntityErrorList(SpReqAnsContext<SelfCheckerService_GetEntityErrorList_Req, SelfCheckerService_GetEntityErrorList_Ans>::Pointer ctx);
	virtual void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID,const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError,const DWORD dwUserCode,const DWORD dwEntityInstanceID, const WORD wEntityDevelID, 
		const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName,const char *pszMessage);
	ErrorCodeEnum MsgPushedByAssChannel(const int type,const int sub_type,const char *pszEntityName="",const char *msg="");
	ErrorCodeEnum GetEntityStatusStr(CSimpleStringA &result);
	ErrorCodeEnum ConnectToAssistChannel();
	//ErrorCodeEnum ConnectToHealthManager();

	//ErrorCodeEnum AddEntity(vector<CSimpleStringA> &entityVec,const char *pszEntityName);
	//ErrorCodeEnum RemoveEntity(vector<CSimpleStringA> &entityVec,const char *pszEntityName);
	//ErrorCodeEnum CheckEntity();
	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/)
	{
		return new SelfCheckerSession(this);
	}
	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return true;}
private:
	CSelfCheckerFSM m_fsm;
	map<CSimpleStringA,EntityProcessInfo> m_entityProcInfo;
	bool m_bIEIdle;
	CUUID m_uuidCardIsuuer,m_uuidCardSwiper,m_uuidPinPad,m_uuidIDCertificate,m_uuidMedia;
	AssistChannelSelfCheckerClient *m_pAssChanClient;
	CSimpleStringA m_csQueryStateEntity;
	vector<CSimpleStringA> m_vQueryStateEntity;
	ErrorCodeEnum RestartModule(const char* pEntityName);
};
AssistChannelSelfCheckerClient::AssistChannelSelfCheckerClient(CSelfCheckerEntity *pEntity):ChannelService_ClientBase(pEntity)
{

}

#endif // __MOD_SELFCHECKER_H