myvtm/Module/mod_healthmanager/mod_healthmanager.h

#ifndef __MOD_HEALTHMANAGER_H
#define __MOD_HEALTHMANAGER_H

#include <map>
#include "SpBase.h"
#if defined(RVC_OS_LINUX)
#include "modVer.h"
#include "SpTest.h"
#endif
#include "HealthManagerFSM.h"
#include "EventCode.h"
#include "HealthManager_server_g.h"
using namespace HealthManager;

#include "UpgradeManager_client_g.h"

using namespace std;
using namespace UpgradeManager;


#include "GuardianBase.h"
typedef ErrorCodeEnum (*pfShakeHands)(WorkStateEnum &eState);

typedef ErrorCodeEnum (*pfPushUpdateTask)(const char *pszPackName);
typedef bool (*pfIsInstalling)();
typedef ErrorCodeEnum (*pfUpgradeRestart)(const DWORD dwParam1,const DWORD dwParam2);
typedef ErrorCodeEnum (*pfFrameworkQuit)(RebootTriggerEnum eReason);

#define DEPLOYSTATE_NOTINIT 0
#define DEPLOYSTATE_DONE 1
#define DEPLOYSTATE_FAILED 2

enum DealType
{
    Deal_Start = 1,
    Deal_Close,
    Deal_Pause,
    Deal_Continue,
    Deal_Kill,
    Deal_Test,
    Deal_Restart
};

struct ModuleRunInfo
{
	DWORD dwStart;
	int abnormalCount;
	bool bAbnormalBusy;
};
struct RestartModeInfo
{
	DWORD dwTimes;
	DWORD dwInternal;
};

#define MACSESION 6


#include <winpr/sysinfo.h>
static void GetLocalTimeRVC(SYSTEMTIME& stTime)
{
	GetLocalTime(&stTime);
}


class HealthManagerSession : public HealthManagerService_ServerSessionBase
{
public:
	HealthManagerSession(CHealthManagerEntity *pEntity):m_pEntity(pEntity){}
	virtual ~HealthManagerSession(){}
	virtual void Handle_EnterState(SpReqAnsContext<HealthManagerService_EnterState_Req, HealthManagerService_EnterState_Ans>::Pointer ctx);
	virtual void Handle_ExitState(SpReqAnsContext<HealthManagerService_ExitState_Req, HealthManagerService_ExitState_Ans>::Pointer ctx);
	virtual void Handle_DoEvent(SpReqAnsContext<HealthManagerService_DoEvent_Req, HealthManagerService_DoEvent_Ans>::Pointer ctx);
	virtual void Handle_RealCheck(SpReqAnsContext<HealthManagerService_RealCheck_Req, HealthManagerService_RealCheck_Ans>::Pointer ctx);
	virtual void Handle_GetNetworkState(SpReqAnsContext<HealthManagerService_GetNetworkState_Req, HealthManagerService_GetNetworkState_Ans>::Pointer ctx);
	virtual void Handle_QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx);
	virtual void Handle_ReadCenterConfigStr(SpReqAnsContext<HealthManagerService_ReadCenterConfigStr_Req, HealthManagerService_ReadCenterConfigStr_Ans>::Pointer ctx);
	virtual void Handle_GetAuthErrMsg(SpReqAnsContext<HealthManagerService_GetAuthErrMsg_Req, HealthManagerService_GetAuthErrMsg_Ans>::Pointer ctx);
	virtual void Handle_ControlTerminalLife(SpReqAnsContext<HealthManagerService_ControlTerminalLife_Req, HealthManagerService_ControlTerminalLife_Ans>::Pointer ctx);
	virtual void Handle_ControlEntityLife(SpReqAnsContext<HealthManagerService_ControlEntityLife_Req, HealthManagerService_ControlEntityLife_Ans>::Pointer ctx);
private:
	CHealthManagerEntity *m_pEntity;
};
class CHealthManagerEntity : public CEntityBase, public ILogListener, public IEntityStateListener, public ISysVarListener, public IBroadcastListener
	,public ITimerListener, public ICallbackListener
{
public:
	CHealthManagerEntity() :
		m_bWaitRestartPC(false)
		, m_bScreenLock(false)
		, m_bSayIdle(false), m_bGuardianRun(false), m_guardianCount(1), m_pUpgMgr(NULL)
		, m_bVerRollback(false), m_eRebootTrigger(RebootTrigger_Resource), m_eRebootWay(RebootWay_Unknown)
		, m_menuChoice(""), m_menuPre(""), m_netState("N"), m_bBrowserIdleFirst(true)
		, m_bInMainPage(false), m_stopSelfCheck(0)
		, m_bEnterMainPageEver(false),m_bHaveThrowMainPage(false)
		,m_bNeedAuthRetry(false), m_bNeedGuardianRestart(true), m_bNeedGuardian(true)
		, m_bToRestartByCenterSetting(false){}
	virtual ~CHealthManagerEntity() {}
	virtual const char *GetEntityName() const { return "HealthManager"; }
	const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum eErrCode = m_fsm.Init(this);
		if (eErrCode == Error_Succeed) {
            DoRestart();
		}

		GetFunction()->SubscribeLog(m_uuidUpdate,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"UpgradeManager");
		GetFunction()->SubscribeLog(m_uuidAccessAuth,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"AccessAuthorization");
		GetFunction()->SubscribeLog(m_uuidAccessAuth,this,Log_Error,Severity_Middle,Error_IgnoreAll,-1,"AccessAuthorization");

		GetFunction()->SubscribeLog(m_uuidFaceTracking,this,Log_Error,Severity_High,Error_IgnoreAll,-1,"FaceTracking");
		GetFunction()->SubscribeLog(m_uuidMediaController,this,Log_Error,Severity_High,Error_IgnoreAll,-1,"MediaController");

		GetFunction()->SubscribeLog(m_uuidRemoteController,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"RemoteController");
		GetFunction()->SubscribeLog(m_uuidGUIConsole,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"GUIConsole");
		GetFunction()->SubscribeLog(m_uuidHeartBeat,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"HeartBeat",false);
		GetFunction()->SubscribeLog(m_uuidCenterS, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "CenterSetting");
		GetFunction()->SubscribeLog(m_uuidPublic, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "Chromium");
		eErrCode = GetFunction()->SubscribeLog(m_uuidVtmLoader, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "VtmLoader");
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SubscribeLog VtmLoader eErrCode:%d", eErrCode);

		GetFunction()->RegistSysVarEvent("UIState", this);
		CSmartPointer<IEntityFunction> pFunc = GetFunction();
		CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
		eErrCode = pFuncPrivilege->RegistEntityStateEvent(NULL, this);
		if (eErrCode != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RegistEntityState failed(%d).", eErrCode);
			pTransactionContext->SendAnswer(eErrCode);
			return;
		}
		//UpgradeManager

#if defined(RVC_OS_WIN)
		GetFunction()->SubscribeLog(m_uuidPublic, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "PinPad");
		GetFunction()->SubscribeLog(m_uuid4SIPPhone, this, Log_Event, Severity_High, Error_IgnoreAll, -1, "SIPPhone");
#endif //RVC_OS_WIN

		pTransactionContext->SendAnswer(eErrCode) ;
	}

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

    virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
    {
        pTransactionContext->SendAnswer(Error_Succeed);
    }

    virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
    {
		LOG_FUNCTION();
		pTransactionContext->SendAnswer(Error_Succeed);
		m_fsm.QuitFrameworkAndSaveInfo(RebootTrigger_FrameUpgrade, RebootWay_Framework);
    }

	void EnterState(SpReqAnsContext<HealthManagerService_EnterState_Req, HealthManagerService_EnterState_Ans>::Pointer ctx)
	{
		if (ctx->Req.state == "M")
		{
			FSMEvent *pEvt = new FSMEvent(USER_EVT_MAITAIN);
			m_fsm.PostEventFIFO(pEvt);

		}
		ctx->Answer(Error_Succeed);
	}

	void ExitState(SpReqAnsContext<HealthManagerService_ExitState_Req, HealthManagerService_ExitState_Ans>::Pointer ctx)
	{
		if (ctx->Req.state == "M")
		{
			FSMEvent *pEvt = new FSMEvent(USER_EVT_MAITAIN_FINISHED);
			m_fsm.PostEventFIFO(pEvt);
		}
		ctx->Answer(Error_Succeed);
	}

	void DoEvent(SpReqAnsContext<HealthManagerService_DoEvent_Req, HealthManagerService_DoEvent_Ans>::Pointer ctx)
	{
		if (ctx->Req.code == Event_VtmLoader_EntityLoad_Finished || ctx->Req.code == Event_VtmLoader_EntityLoad_Failed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("receive %x,entityList:%s", ctx->Req.code,ctx->Req.entityList.GetData());
			if (!ctx->Req.entityList.IsNullOrEmpty())
				m_fsm.SetLoadEntityList(ctx->Req.entityList);
			FSMEvent* pEvt = new FSMEvent(USER_EVT_VTMLOADER_FINISHED);
			if (ctx->Req.code == Event_VtmLoader_EntityLoad_Finished)
			{
				pEvt->param1 = 0;
				//to get entity list
				if (!ctx->Req.entityList.IsNullOrEmpty())
				{
					m_activeEntity.Init(100);
					m_activeEntity = ctx->Req.entityList.Split('|');
					for (int i = 0; i < m_activeEntity.GetCount(); ++i)
					{
						m_modRunInfo[m_activeEntity[i]].abnormalCount = 0;
						m_modRunInfo[m_activeEntity[i]].bAbnormalBusy = false;
					}
				}
			}
			else
				pEvt->param1 = 1;
			m_fsm.PostEventFIFO(pEvt);
		}
		ctx->Answer(Error_Succeed);
	}


	void GetNetworkState(SpReqAnsContext<HealthManagerService_GetNetworkState_Req, HealthManagerService_GetNetworkState_Ans>::Pointer ctx)
	{
		ctx->Ans.netDeviceState = m_netState;
		ctx->Ans.reserved1 = m_fsm.QueryAccessAuthStatus();
		Dbg("current net state %s,auth state:%d", (LPCTSTR)m_netState, ctx->Ans.reserved1);
		ctx->Answer(Error_Succeed);
	}

	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/)
	{
		return new HealthManagerSession(this);
	}

	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return true;}

	int SystemRestart(bool bPeriod, bool bNow = false);
	int SystemShutdown(BOOL bReboot=FALSE);
	int FrameworkShutdown(bool bRestart=true);
	void QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx)
	{
		QueryHardwareInfoTask* pTask = new QueryHardwareInfoTask(&m_fsm);
		pTask->ctx = ctx;
		GetFunction()->PostThreadPoolTask(pTask);
	}
	void ReadCenterConfigStr(SpReqAnsContext<HealthManagerService_ReadCenterConfigStr_Req, HealthManagerService_ReadCenterConfigStr_Ans>::Pointer ctx);
	void GetAuthErrMsg(SpReqAnsContext<HealthManagerService_GetAuthErrMsg_Req, HealthManagerService_GetAuthErrMsg_Ans>::Pointer ctx);
	bool StartManagerDesktopPage(CSimpleStringA pageName);
	void WarnAndRestartFramwork();
	void ControlTerminalLife(SpReqAnsContext<HealthManagerService_ControlTerminalLife_Req, HealthManagerService_ControlTerminalLife_Ans>::Pointer ctx);
	void ControlEntityLife(SpReqAnsContext<HealthManagerService_ControlEntityLife_Req, HealthManagerService_ControlEntityLife_Ans>::Pointer ctx);
	void RealCheck(SpReqAnsContext<HealthManagerService_RealCheck_Req, HealthManagerService_RealCheck_Ans>::Pointer ctx);
	void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);
	ErrorCodeEnum ExceptionErrorProcess(const char* pszEntityName, ErrorCodeEnum eTestResult);
	ErrorCodeEnum CheckEntity(const char* pszEntityName, EntityTestEnum eTestType);
	void EntityLostProc(CSimpleStringA entityName);

	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, const linkContext &pLinkInfo);
	virtual void OnSysVarEvent(const char *pszKey,
		const char *pszValue, const char *pszOldValue, const char *pszEntityName);
	virtual void OnBroadcastEvent(CUUID SubID, const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer);
	virtual void OnTimeout(DWORD dwTimerID);

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

private:
	CHealthManagerFSM m_fsm;
	//the following is useless?just one var is ok? oiltmp
	CUUID m_uuidUpdate,m_uuidMediaController,m_uuidFaceTracking,m_uuidAccessAuth
		, m_uuidRemoteController, m_uuidGUIConsole, m_uuidHeartBeat, m_uuidIE, m_uuidCenterS, m_uuidVtmLoader;
	CUUID m_uuidPublic, m_uuid4SIPPhone;
	int m_stopSelfCheck;
	int m_restartHour, m_restartMinute, m_lastHour, m_guardianCount, m_maxAbnormalTimes;
	bool m_bWaitRestartPC, m_bScreenLock, m_bSayIdle
		, m_bGuardianRun, m_bVerRollback, m_bBrowserIdleFirst
		, m_bInMainPage, m_bEnterMainPageEver, m_bHaveThrowMainPage, m_bToRestartByCenterSetting;
	bool m_bNeedAuthRetry/*需要重试准入*/, m_bNeedGuardianRestart/*需要重启*/, m_bNeedGuardian;
	DWORD m_dwTimeOfAuthSuc;
	int m_maxWaitMainpageTime;
	ULONGLONG m_OSRunTicks;
	RebootTriggerEnum m_eRebootTrigger;
	RebootWayEnum m_eRebootWay;
	CSimpleStringA m_menuChoice,m_currentVer,m_menuPre,m_netState, m_versionEx;
	map<CSimpleStringA,ModuleRunInfo> m_modRunInfo;
	UpgradeMgrService_ClientBase *m_pUpgMgr;
	CAutoArray<CSimpleStringA> m_activeEntity;

	pfShakeHands m_pfShake;
	pfUpgradeRestart m_pfUpgradeRestart;
	CSystemStaticInfo m_sysStaticInfo;

	/** 启动限制配置读取以及监护模块初始化*/
	bool DoRestart();
	void OnCheckTimeTimeout();
	void OnSelfCheckTimeout();
	ErrorCodeEnum RestartModule(const char* pEntityName);
	void AfterWaitRestartPC();
	bool SaveCurrentVersion();
	bool SaveFrameStartTimeForUpgrade();
	//reture value:
	//0:no need guardian; 1:guardian is running; -1:guardian is not running
	int CheckGuardianIsRun(bool bStart=false);
	bool StopGuardian();
	bool StartGuardian();
	bool VersionRollBack(const char *pVerion);
	
	CSimpleStringA __ReadCenterConfigStr(CSimpleStringA key, CSimpleStringA entityName);

	bool IsTestMode();

	ErrorCodeEnum DealSpecifiedEntity(DealType type, LPCTSTR lpcszEntityName, LPCTSTR lpcszCmdline, bool bForce, CSimpleStringA& strErrMsg);
	void ToCalcRebootHourAndMinute(int restartBegin, int restartEnd);
};
#endif // __MOD_HEALTHMANAGER_H

struct FrameworkRestartTask : public ITaskSp
{
	CHealthManagerEntity* m_entity;
	FrameworkRestartTask(CHealthManagerEntity* entity) : m_entity(entity) {}
	void Process()
	{
		m_entity->WarnAndRestartFramwork();
	}
};

struct WarnPromptTask : public ITaskSp
{
	CHealthManagerEntity* m_entity;
	WarnPromptTask(CHealthManagerEntity* entity) : m_entity(entity) {}
	void Process()
	{
		m_entity->StartManagerDesktopPage("warnPrompt.html");
	}
};

struct EntityLostProcTask : public ITaskSp
{
	CHealthManagerEntity* pEntity;
	CSimpleStringA entityName;
	EntityLostProcTask(CHealthManagerEntity* entity,CSimpleStringA entityName) : pEntity(entity),entityName(entityName) {}
	void Process()
	{
		pEntity->EntityLostProc(entityName);
	}
};