myvtm/Module/mod_ResourceWatcher/mod_ResourceWatcher.h

#pragma once

#include "modVer.h"
#include "SpTest.h"
#include "ResourceWatcherFSM.h"
#include "UOSTools.hpp"
#include "fileutil.h"
#include "../mod_UpgradeMgr/UpgradeManager_msg_g.h"

class ResourceWatcherEntity;

#define ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE 1
#define ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_INSTALLED_STATE 60 * 1000

#define ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE 3
#define ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE 30 * 1000

#define ENT_TIMERID_PROCESS_CHECK 66
#define ENT_TIMERINTERVAL_PROCESS_CHECK 10 * 1000

#define ENCODING (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING)  

class ResourceWatcherServiceSession : public ResourceWatcherService_ServerSessionBase
{
public:

	ResourceWatcherServiceSession(ResourceWatcherEntity* pEntity) : m_pEntity(pEntity) {}

	virtual ~ResourceWatcherServiceSession() {}

	virtual void Handle_Fetch(SpReqAnsContext<ResourceWatcherService_Fetch_Req,
		ResourceWatcherService_Fetch_Ans>::Pointer ctx);

	virtual void Handle_GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req,
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx);
	
	virtual void Handle_GetCardSwiper(SpReqAnsContext<ResourceWatcherService_GetCardSwiper_Req, ResourceWatcherService_GetCardSwiper_Ans>::Pointer ctx);

	virtual void Handle_GetCpuType(SpReqAnsContext<ResourceWatcherService_GetCpuType_Req, ResourceWatcherService_GetCpuType_Ans>::Pointer ctx);

	virtual void Handle_OperateFile(SpReqAnsContext<ResourceWatcherService_OperateFile_Req, ResourceWatcherService_OperateFile_Ans>::Pointer ctx);

	virtual void Handle_ExtractEventLog(SpReqAnsContext<ResourceWatcherService_ExtractEventLog_Req, ResourceWatcherService_ExtractEventLog_Ans>::Pointer ctx);

	virtual void Handle_BizLinkDetect(SpReqAnsContext<ResourceWatcherService_BizLinkDetect_Req, ResourceWatcherService_BizLinkDetect_Ans>::Pointer ctx);

	virtual void Handle_CheckNetType(SpReqAnsContext<ResourceWatcherService_CheckNetType_Req, ResourceWatcherService_CheckNetType_Ans>::Pointer ctx);

	virtual void Handle_GetBizLinks(SpReqAnsContext<ResourceWatcherService_GetBizLinks_Req, ResourceWatcherService_GetBizLinks_Ans>::Pointer ctx);

	virtual void Handle_GetThirdPartyInstallState(SpReqAnsContext<ResourceWatcherService_GetThirdPartyInstallState_Req, ResourceWatcherService_GetThirdPartyInstallState_Ans>::Pointer ctx);

	virtual void Handle_InstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req, ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_UninstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req, ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_RestartThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_RestartThirdPartyProgram_Req, ResourceWatcherService_RestartThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_ProcessDetectThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_ProcessDetectThirdPartyProgram_Req, ResourceWatcherService_ProcessDetectThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_FilesClean(SpReqAnsContext<ResourceWatcherService_FilesClean_Req, ResourceWatcherService_FilesClean_Ans>::Pointer ctx);
	
	//以下是uos专有 2023.3.8
	virtual void Handle_GetTerminalVersionList(SpReqAnsContext<ResourceWatcherService_GetTerminalVersionList_Req, ResourceWatcherService_GetTerminalVersionList_Ans>::Pointer ctx);

	virtual void Handle_ManipulateVersion(SpReqAnsContext<ResourceWatcherService_ManipulateVersion_Req, ResourceWatcherService_ManipulateVersion_Ans>::Pointer ctx);

	virtual void Handle_FetchSystemSnapshot(SpReqAnsContext<ResourceWatcherService_FetchSystemSnapshot_Req, ResourceWatcherService_FetchSystemSnapshot_Ans>::Pointer ctx);

	virtual void Handle_UpdateDNS(SpReqAnsContext<ResourceWatcherService_UpdateDNS_Req, ResourceWatcherService_UpdateDNS_Ans>::Pointer ctx);

	virtual void Handle_GetNetworkInfo(SpReqAnsContext<ResourceWatcherService_GetNetworkInfo_Req, ResourceWatcherService_GetNetworkInfo_Ans>::Pointer ctx);

private:
	ResourceWatcherEntity* m_pEntity;
};


struct CPUTestTask : public ITaskSp
{
    void Process()
    {
		while (true) {
			int cal = 123232323 + 23434324;
			double t = 334243.334 / 34343.2;
		}
    }
};

class ResourceWatcherEntity : public CEntityBase, public IBroadcastListener, public ITimerListener, public ISysVarListener
{
public:
	ResourceWatcherEntity():m_bInitMode(FALSE) {}
	virtual ~ResourceWatcherEntity() {}
	virtual const char* GetEntityName() const { return "ResourceWatcher"; }
    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

    ON_ENTITYT_TEST()

	virtual CServerSessionBase* OnNewSession(const char* , const char * )
	{
		LOG_FUNCTION();
		return new ResourceWatcherServiceSession(this);
	}

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();

		ErrorCodeEnum errorCode = Error_Succeed;
        CSimpleStringA strtermState;
        GetFunction()->GetSysVar("TerminalStage", strtermState);
        if (strtermState.IsStartWith("Z=")) {
            Dbg("aaa in config mode");
            m_bInitMode = TRUE;
        }

		errorCode = m_fsm.Init(this);
		if (errorCode == Error_Succeed) {

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

            CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
            CSystemStaticInfo staticInfo;
            spEntityFunction->GetSystemStaticInfo(staticInfo);
            if (!staticInfo.strMachineType.IsNullOrEmpty() && !staticInfo.strMachineType.Compare("RVC.Pad", true)) {
                errorCode = spEntityFunction->SubscribeBroadcast("CardSwiper", NULL, this, m_uiCardSwiperStatusListener);
                if (errorCode != Error_Succeed) {
                    LOG_TRACE("Subscribe CardSwiper evt failed 0x%x", errorCode);
				pTransactionContext->SendAnswer(errorCode);
				return;
                }
                Dbg("SubScribe CardSwiper status broadcast suc.");
            }
		}
		
		pTransactionContext->SendAnswer(errorCode);
	}

	void OnStarted()
	{
		m_fsm.AfterInit();
		if (!m_bInitMode) {
            CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
            spEntityFunction->SetTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE,
                                       this, ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_INSTALLED_STATE);
			CSmartPointer<IConfigInfo> spCtSettingConfig;
			GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
			int procFlag = 0;
			spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "ProcDetectFlag4UOS", procFlag);
			if (procFlag > 0)
			{
				int tTime = 0;
				spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "ProcCheckTime", tTime);
				int fTime = ENT_TIMERINTERVAL_PROCESS_CHECK;
				if (tTime > ENT_TIMERINTERVAL_PROCESS_CHECK)
				{
					fTime = tTime;
				}
				spEntityFunction->SetTimer(ENT_TIMERID_PROCESS_CHECK, this, fTime);
			}
		}
	}

	/*ignore*/
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		OnTimeout(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE);
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*ignore*/
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*invoke fsm.onExit(), invoked when	entity will be closed*/
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,
		CSmartPointer<ITransactionContext>pTransactionContext)
	{
		ErrorCodeEnum errorCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(errorCode);
	}

	virtual void OnSelfTest(EntityTestEnum eTestType,
		CSmartPointer<ITransactionContext>pTransactionContext)
	{
		m_fsm.SelfTest(eTestType, pTransactionContext);
	}

	virtual bool IsService() const
	{
		return true;
	}

	virtual bool IsMultiThread() const
	{
		return false;
	}


	void Fetch(SpReqAnsContext<ResourceWatcherService_Fetch_Req,
		ResourceWatcherService_Fetch_Ans>::Pointer ctx)
	{
		FetchEvent* evt = new FetchEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}

	void GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req, 
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx)
	{
		ctx->Answer(Error_NotImpl);
	}

	void GetCSwiperStatus(SpReqAnsContext<ResourceWatcherService_GetCardSwiper_Req,
		ResourceWatcherService_GetCardSwiper_Ans>::Pointer ctx)
	{
		ctx->Ans.status = m_fsm.GetCardSwiperVal();
		ctx->Answer(Error_Succeed);
	}

	void GetCPUType(SpReqAnsContext<ResourceWatcherService_GetCpuType_Req, 
		ResourceWatcherService_GetCpuType_Ans>::Pointer ctx)
	{
		m_fsm.GetCpuType(ctx);
	}

	void BizLinkDetect(SpReqAnsContext<ResourceWatcherService_BizLinkDetect_Req,
		ResourceWatcherService_BizLinkDetect_Ans>::Pointer ctx)
	{
		m_fsm.BizLinkDetect(ctx);
	}

	void CheckNetType(SpReqAnsContext<ResourceWatcherService_CheckNetType_Req,
		ResourceWatcherService_CheckNetType_Ans>::Pointer ctx)
	{
		m_fsm.CheckNetType(ctx);
	}

	void GetBizLinks(SpReqAnsContext<ResourceWatcherService_GetBizLinks_Req,
		ResourceWatcherService_GetBizLinks_Ans>::Pointer ctx)
	{
		m_fsm.GetBizLinks(ctx);
	}

	void OperateFile(
		SpReqAnsContext<ResourceWatcherService_OperateFile_Req, 
		ResourceWatcherService_OperateFile_Ans>::Pointer ctx)
	{
		OperateFileEvent* evt = new OperateFileEvent();
		evt->m_ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}

	void RetrieveEventLog(SpReqAnsContext<ResourceWatcherService_ExtractEventLog_Req, 
		ResourceWatcherService_ExtractEventLog_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();

#if defined(RVC_OS_WIN)
		m_fsm.PostEventFIFO(new GetEventLogEvent(ctx));
#else
		ctx->Answer(Error_NotSupport);
#endif //RVC_OS_WIN
	}

	void GetThirdPartyInstallState(SpReqAnsContext<ResourceWatcherService_GetThirdPartyInstallState_Req,
		ResourceWatcherService_GetThirdPartyInstallState_Ans>::Pointer ctx);

	void InstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

	void UninstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
		ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	void RestartThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_RestartThirdPartyProgram_Req,
		ResourceWatcherService_RestartThirdPartyProgram_Ans>::Pointer ctx);

	void ProcessDetectThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_ProcessDetectThirdPartyProgram_Req,
		ResourceWatcherService_ProcessDetectThirdPartyProgram_Ans>::Pointer ctx);

    void FilesClean(SpReqAnsContext<ResourceWatcherService_FilesClean_Req, 
		ResourceWatcherService_FilesClean_Ans>::Pointer ctx);

	void UpdateDNS(SpReqAnsContext<ResourceWatcherService_UpdateDNS_Req, ResourceWatcherService_UpdateDNS_Ans>::Pointer ctx);

	void GetNetworkInfo(SpReqAnsContext<ResourceWatcherService_GetNetworkInfo_Req, ResourceWatcherService_GetNetworkInfo_Ans>::Pointer ctx);

	void FetchSystemSnapshot(SpReqAnsContext<ResourceWatcherService_FetchSystemSnapshot_Req, ResourceWatcherService_FetchSystemSnapshot_Ans>::Pointer ctx);

	void GetTerminalVersionList(SpReqAnsContext<ResourceWatcherService_GetTerminalVersionList_Req, ResourceWatcherService_GetTerminalVersionList_Ans>::Pointer ctx);

	void ManipulateVersion(SpReqAnsContext<ResourceWatcherService_ManipulateVersion_Req, ResourceWatcherService_ManipulateVersion_Ans>::Pointer ctx);

	void InstallSogou(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

    void UninstallSogou(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
					  ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	virtual void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName);

#if defined(_MSC_VER)
    SP_BEGIN_MSG_DISPATCH_MAP(ResourceWatcherEntity)
        SP_BEGIN_ENTITY_MSG("CardSwiper")
        SP_MSG_HANDLE_NS(CardSwiper, ConnectStatus, OnCardSwiperConnectStatus)
        SP_END_ENTITY_MSG()
        SP_END_MSG_DISPATCH_MAP()
#else
	virtual void OnBroadcastEvent(CUUID SubID, const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer)
	{

	}
#endif //_MSC_VER

private:
	void OnCardSwiperConnectStatus(const char* pszEntityName, DWORD dwMessageId,
		DWORD dwMessageSignature, CardSwiper::ConnectStatus& evt)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OnCardSwiperConnectStatus %d", evt.status);
		QueryCardSwiper cardswiperStatus;
		cardswiperStatus.status = evt.status;
		m_fsm.m_cardswiperStatus = evt.status;
		SpSendBroadcast(GetFunction(), SP_MSG_OF(QueryCardSwiper), SP_MSG_SIG_OF(QueryCardSwiper),
			cardswiperStatus);
	}

		ErrorCodeEnum DoCheckInstallStateJob();
		void OnTimeout(DWORD dwTimerID) 
		{
			if(dwTimerID == ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE) {

				CSimpleStringA strState;
				auto err = GetFunction()->GetSysVar("UIState",strState);
				/** 让进入首页之后才获取输入法信息 [Gifur@20211212]*/
				if(/*TRUE || */err == Error_Succeed && strState == "M") {

					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to check Sogou input install state...");
					if(Error_Succeed == DoCheckInstallStateJob()) {
						GetFunction()->KillTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE);

						GetFunction()->SetTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE,
                                 this, ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE);
					}
				} else {
					Dbg("Get UIState result: %s, %s", SpStrError(err), strState.GetData());
				}
            } else if (dwTimerID == ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE) {

                DoCheckSogouProcessStatus();

            } else if (dwTimerID == ENT_TIMERID_PROCESS_CHECK) {

                CheckProcessStatus();

            } else {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkonwn timer id: %u", dwTimerID);
            }
		}

		void DoCheckSogouProcessStatus();
		std::string DoCheckCertainProcessStatus(const CAutoArray<CSimpleStringA>& pName);
		ErrorCodeEnum GetSogouPkgDirPath(CSimpleStringA& strPkgPath);
		ErrorCodeEnum UnzipPack(const char* unZipPackName);
		ErrorCodeEnum GetUnzipTempDir(CSimpleStringA& strUnzipDir);
		ErrorCodeEnum ConfigMonitorSetting(const UOS::MonitorInfo& config);
		std::vector<std::string> GetUserNameList(bool bExcludeRoot = false);
		ErrorCodeEnum RunShellScript(LPCTSTR cmdline);

		/// <summary>
		/// 通过集中配置检测指定进程是否存在
		/// </summary>
		void CheckProcessStatus();


private:
	ResourceWatcherFSM m_fsm;
	CUUID m_uiCardSwiperStatusListener;
	BOOL m_bInitMode;
};

struct InstallSogouTask : public ITaskSp
{
	SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx;

	ResourceWatcherEntity* m_pEntity;
	InstallSogouTask(ResourceWatcherEntity* entity) :m_pEntity(entity) {}
	void Process()
	{
		m_pEntity->InstallSogou(ctx);
	}
};

struct UninstallSogouTask : public ITaskSp
{
    SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
        ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx;

    ResourceWatcherEntity* m_pEntity;
	UninstallSogouTask(ResourceWatcherEntity* entity) :m_pEntity(entity) {}
    void Process()
    {
        m_pEntity->UninstallSogou(ctx);
    }
};