myvtm/Module/mod_healthmanager/mod_healthmanager.h

#ifndef __MOD_HEALTHMANAGER_H
#define __MOD_HEALTHMANAGER_H

#include <map>
#include "SpBase.h"
#include "modVer.h"
#include "SpTest.h"
#include "HealthManagerFSM.h"
#include "EventCode.h"
#include "HealthManager_server_g.h"
using namespace HealthManager;

#include "WatchDog_client_g.h"
#include "Ups_client_g.h"
#include "UpsClass.h"
#include "InteractionContext_client_g.h"
#include "UpgradeManager_client_g.h"
#include "CardSwiper_client_g.h"

using namespace std;
using namespace WatchDog;
using namespace Ups;
using namespace InteractionContext;
using namespace UpgradeManager;
using namespace CardSwiper;


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

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

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

enum WatchDogOp
{
	WD_OP_START,
	WD_OP_STOP,
	WD_OP_REFRESH
};
enum ModuleReMode
{
	RESTART_MODE_DEFAULT,
	RESTART_MODE_LOW,
	RESTART_MODE_HIGH,
};
enum DealType
{
    Deal_Start = 1,
    Deal_Close,
    Deal_Pause,
    Deal_Continue,
    Deal_Kill,
    Deal_Test,
    Deal_Restart
};

struct ModuleRunInfo
{
	DWORD dwStart;
	int count;
};
struct RestartModeInfo
{
	DWORD dwTimes;
	DWORD dwInternal;
};
typedef CAutoArray<CSimpleStringA>  NetworkAddressesList;
#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_GetEntityCfgInfo(SpReqAnsContext<HealthManagerService_GetEntityCfgInfo_Req, HealthManagerService_GetEntityCfgInfo_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_ControlTerminalLife(SpReqAnsContext<HealthManagerService_ControlTerminalLife_Req, HealthManagerService_ControlTerminalLife_Ans>::Pointer ctx);
    virtual void Handle_DeployTerminal(SpReqAnsContext<HealthManagerService_DeployTerminal_Req, HealthManagerService_DeployTerminal_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 ISysVarListener, public IBroadcastListener
{
public:
	CHealthManagerEntity() :m_bInit(true), m_pWatchDogClient(NULL), m_bWatchDog(false), m_pUpsClient(NULL)
		, m_pSync(NULL), xxx(0), m_MCStart(0), m_bWaitRestartPC(false)
		, m_upsStateCount(0), m_bUpsWaitLock(false), m_bScreenLock(false), m_bToRestart(false)
		, m_upsNoElectorCount(0), m_bSayIdle(false), m_bGuardianRun(false), m_bHealthInit(false), m_pUpgMgr(NULL)
		, m_bVerRollback(false), m_eRebootTrigger(RebootTrigger_Unknown), m_eRebootWay(RebootWay_Unknown)
		, m_bGetUpsStateFlag(false), m_menuChoice(""), m_menuPre(""), m_netState("N"), m_bFisrtEnterMainPage(true)
		, m_bNeedToRestartPAD(false), m_preDay(99), m_bNeedToRestartIE(false), m_bInMainPage(false), m_maxRunDays(7)
		, m_bEnterMainPageEver(false), m_connectStatus(0), m_bAccessSuc(false), m_pfShake(NULL),m_pfUpgradeRestart(NULL){}
	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(Error_Succeed);

		int curStep(0);
		bool isNeedConfig = IsNotConfigMode(curStep);
		if (isNeedConfig) {
            m_fsm.SetConfigMode(true);
		} else {
			DoRestart();
        }
		eErrCode = m_fsm.Init(this);

		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_uuidInitializer,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"Initializer");
		GetFunction()->SubscribeLog(m_uuidInitializer,this,Log_Error,Severity_Middle,Error_IgnoreAll,-1,"Initializer");

		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_uuidSelfChecker,this,Log_Event,Severity_Middle,Error_IgnoreAll,-1,"SelfChecker");
		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");

		GetFunction()->RegistSysVarEvent("UIState", this);
		//UpgradeManager

#if defined(RVC_OS_WIN)
        GetFunction()->SubscribeLog(m_uuidMaintainWatch, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "MaintainWatcher");
        GetFunction()->SubscribeLog(m_uuidIE, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "IEBrowser");
        GetFunction()->SubscribeLog(m_uuidCardSwiper, this, Log_Error, Severity_Middle, Error_IgnoreAll, -1, "CardSwiper");
        GetFunction()->SubscribeLog(m_uuidPublic, this, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "systemcustomization");
		GetFunction()->SubscribeBroadcast("CardSwiper", "", this, m_uuidCardSwiper);
#endif //RVC_OS_WIN

		pTransactionContext->SendAnswer(eErrCode) ;
	}

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

	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)
	{
	}

	void GetEntityCfgInfo(SpReqAnsContext<HealthManagerService_GetEntityCfgInfo_Req, HealthManagerService_GetEntityCfgInfo_Ans>::Pointer ctx)
	{
		ctx->Ans.reserved2 = m_fsm.GetEntityCfgInfo(ctx->Req.name,ctx->Ans.loadOpt);
		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;}

	bool DoWatchDog(WatchDogOp eOp);
	int SystemRestart(bool bPeriod,bool bUpsImmediately,bool bNow=false);
	int SystemShutdown(BOOL bReboot=FALSE);
	ErrorCodeEnum  SystemShutdownThroughUPS(DWORD msPreShutdown = 5, DWORD msPreRestart = 5);
	int FrameworkShutdown(bool bRestart=true);
	int GetNetDeviceState();
	int UpdateSiteChangeFlag();
	int UpdateSiteToRuncfg(bool bWriteSite=true,bool bClearSiteFlag = false);
	int WriteSiteToRootIni();
	void QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx);
	void ReadCenterConfigStr(SpReqAnsContext<HealthManagerService_ReadCenterConfigStr_Req, HealthManagerService_ReadCenterConfigStr_Ans>::Pointer ctx);
	void ControlTerminalLife(SpReqAnsContext<HealthManagerService_ControlTerminalLife_Req, HealthManagerService_ControlTerminalLife_Ans>::Pointer ctx);
    void ControlEntityLife(SpReqAnsContext<HealthManagerService_ControlEntityLife_Req, HealthManagerService_ControlEntityLife_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);
	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);

    void DeployTerminal(SpReqAnsContext<HealthManagerService_DeployTerminal_Req, HealthManagerService_DeployTerminal_Ans>::Pointer ctx);
	/*!
	 * @brief 判断是否为未配置模式
	 * @param[out] 如果为未配置模式，stepMode 等于 0 为从头开始配置，其他为阶段性配置，详情见 DeployStep_* 定义
	 * @return : true: 为未配置模式，false：正常模式
	 */
	bool IsNotConfigMode(int& stepMode);

private:

	CHealthManagerFSM m_fsm;
	//the following is useless?just one var is ok? oiltmp
	CUUID m_uuidUpdate,m_uuidMediaController,m_uuidFaceTracking,m_uuidAccessAuth,m_uuidInitializer,m_uuidSelfChecker
		, m_uuidRemoteController, m_uuidGUIConsole, m_uuidHeartBeat, m_uuidMaintainWatch, m_uuidIE, m_uuidCenterS;
	CUUID m_uuidCardSwiper,m_uuidPublic;
	int m_devCfgNum,m_connectStatus;
	int m_restartHour, m_restartMinute, m_lastHour, m_restartTimes, m_maxRestartTimes, m_preDay, m_dayNum, m_maxRunDays;
	bool m_bInit,m_bWatchDog,m_bWaitRestartPC,m_bUpsWaitLock,m_bScreenLock,m_bToRestart,m_testFlag,m_bSayIdle
		, m_bGuardianRun, m_bHealthInit, m_bVerRollback, m_bFisrtEnterMainPage, m_bNeedToRestartPAD,m_bNeedToRestartIE
		, m_bInMainPage, m_bEnterMainPageEver,m_bAccessSuc;
	DWORD m_wDayOfWeek,m_MCStart,m_MCEnd;
	int xxx,m_upsStateCount,m_upsNoElectorCount;
	RebootTriggerEnum m_eRebootTrigger;
	RebootWayEnum m_eRebootWay;
	CSimpleStringA m_menuChoice,m_currentVer,m_menuPre,m_netState;
	map<CSimpleStringA,ModuleRunInfo> m_modRunInfo;
	map<CSimpleStringA,ModuleReMode> m_modCfgInfo;
	map<ModuleReMode,RestartModeInfo> m_restartMode;
	WatchDogService_ClientBase *m_pWatchDogClient;
	UpsService_ClientBase *m_pUpsClient;
	SyncService_ClientBase *m_pSync;
	UpgradeMgrService_ClientBase *m_pUpgMgr;

	pfShakeHands m_pfShake;
	pfUpgradeRestart m_pfUpgradeRestart;
	bool m_bGetUpsStateFlag;
	CSystemStaticInfo m_sysStaticInfo;

	/** 启动限制配置读取以及监护模块初始化*/
	bool DoRestart();
	void OnCheckTimeTimeout();
	void OnWatchDogTimeout();
	ErrorCodeEnum RestartModule(const char* pEntityName);
	void AfterWaitRestartPC();
	void UpsSupplyLockScreen();
	int ConnectUps();
	void SplitModuleNames(CSimpleStringA csLine,ModuleReMode eMode);
	bool SaveCurrentVersion();
	bool SaveFrameStartTimeForUpgrade();
	bool CheckGuardianIsRun(bool bStart=false);
	bool StopGuardian();
	bool StartGuardian();
	bool VersionRollBack(const char *pVerion);
	//int QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger = RebootTrigger_Unknown,RebootWayEnum eWay = RebootWay_Unknown);
	void ReadMachineDataBySyncSerivce();
	int RestartIE();
	void GetINETMacAddresses(NetworkAddressesList &macList, NetworkAddressesList &ipList);
	CSimpleStringA __ReadCenterConfigStr(CSimpleStringA key, CSimpleStringA entityName);

	bool IsTestMode();

	ErrorCodeEnum GetTmpRootFilePath(CSimpleStringA& rootPath, CSimpleStringA& rootTmpPath);
	ErrorCodeEnum GetGuidePageUrlWithStep(int whichStep, CSimpleStringA& strUrl);

	ErrorCodeEnum TellChromiumOpenGuidePage(const CSimpleStringA& pageUrl);

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