myvtm/Module/mod_guiconsole/mod_GuiConsole.h

#pragma once
#include "GUIConsole_def_g.h"
#include "GUIConsole_server_g.h"
using namespace GUIConsole;
#include "SpBase.h"
#include "guiconsole_define.h"
#include <thread>
#include <condition_variable>
#include <mutex>
#include <chrono>

// 本地控制台 GUIConsole	0x508
class CGUIConsoleEntity;

class CGUIConsoleSession : public GUIConsoleService_ServerSessionBase
{
public:
	CGUIConsoleSession(CGUIConsoleEntity* pEntity) :m_pEntity(pEntity) {}
	virtual ~CGUIConsoleSession() {}

	virtual void Handle_OpenLogSender(SpReqAnsContext<GUIConsoleService_OpenLogSender_Req, GUIConsoleService_OpenLogSender_Ans>::Pointer ctx);

	virtual void Handle_CloseLogSender(SpReqAnsContext<GUIConsoleService_CloseLogSender_Req, GUIConsoleService_CloseLogSender_Ans>::Pointer ctx);

	virtual void Handle_OpenEntityMonitor(SpReqAnsContext<GUIConsoleService_OpenEntityMonitor_Req, GUIConsoleService_OpenEntityMonitor_Ans>::Pointer ctx);

	virtual void Handle_CloseEntityMonitor(SpReqAnsContext<GUIConsoleService_CloseEntityMonitor_Req, GUIConsoleService_CloseEntityMonitor_Ans>::Pointer ctx);

	virtual void Handle_OpenPerformanceSender(SpReqAnsContext<GUIConsoleService_OpenPerformanceSender_Req, GUIConsoleService_OpenPerformanceSender_Ans>::Pointer ctx);

	virtual void Handle_ClosePerformanceSender(SpReqAnsContext<GUIConsoleService_ClosePerformanceSender_Req, GUIConsoleService_ClosePerformanceSender_Ans>::Pointer ctx);

	virtual void Handle_VTMSystemControl(SpReqAnsContext<GUIConsoleService_VTMSystemControl_Req, GUIConsoleService_VTMSystemControl_Ans>::Pointer ctx);

	virtual void Handle_VTM_controlEntity(SpReqAnsContext<GUIConsoleService_VTM_controlEntity_Req, GUIConsoleService_VTM_controlEntity_Ans>::Pointer ctx);

	virtual void Handle_GetAllEntityList(SpReqAnsContext<GUIConsoleService_GetAllEntityList_Req, GUIConsoleService_GetAllEntityList_Ans>::Pointer ctx);

	virtual void Handle_GetBasicInformation(SpReqAnsContext<GUIConsoleService_GetBasicInformation_Req, GUIConsoleService_GetBasicInformation_Ans>::Pointer ctx);

	virtual void Handle_GetHelpInformationArr(SpReqAnsContext<GUIConsoleService_GetHelpInformationArr_Req, GUIConsoleService_GetHelpInformationArr_Ans>::Pointer ctx);

	virtual void Handle_GetHelpDetail(SpReqAnsContext<GUIConsoleService_GetHelpDetail_Req, GUIConsoleService_GetHelpDetail_Ans>::Pointer ctx);

	virtual void Handle_OpenCommonPage(SpReqAnsContext<GUIConsoleService_OpenCommonPage_Req, GUIConsoleService_OpenCommonPage_Ans>::Pointer ctx);

	virtual void Handle_CloseCommonPage(SpReqAnsContext<GUIConsoleService_CloseCommonPage_Req, GUIConsoleService_CloseCommonPage_Ans>::Pointer ctx);

	virtual void Handle_ReservedCall(SpReqAnsContext<GUIConsoleService_ReservedCall_Req, GUIConsoleService_ReservedCall_Ans>::Pointer ctx);
private:
	CGUIConsoleEntity* m_pEntity;
};

class CGUIConsoleEntity : public CEntityBase, public ILogListener, public ITimerListener, IEntityStateListener, ICallbackListener
{
public:
	CGUIConsoleEntity();

	virtual ~CGUIConsoleEntity();
	virtual const char *GetEntityName() const { return "GUIConsole"; }
	const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }
	virtual bool IsService()const{return true;}

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

	void OnStarted() {}

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

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) ;
	

	std::pair<DWORD, std::string> openLogSender(SpReqAnsContext<GUIConsoleService_OpenLogSender_Req, GUIConsoleService_OpenLogSender_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> closeLogSender();
	std::pair<DWORD, std::string> openEntityMonitor(SpReqAnsContext<GUIConsoleService_OpenEntityMonitor_Req, GUIConsoleService_OpenEntityMonitor_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> closeEntityMonitor();
	std::pair<DWORD, std::string> openPerformanceSender(SpReqAnsContext<GUIConsoleService_OpenPerformanceSender_Req, GUIConsoleService_OpenPerformanceSender_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> closePerformanceSender();
	std::pair<DWORD, std::string> VTMSystemControl(SpReqAnsContext<GUIConsoleService_VTMSystemControl_Req, GUIConsoleService_VTMSystemControl_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> VTM_controlEntity(SpReqAnsContext<GUIConsoleService_VTM_controlEntity_Req, GUIConsoleService_VTM_controlEntity_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> GetBasicInformation(SpReqAnsContext<GUIConsoleService_GetBasicInformation_Req, GUIConsoleService_GetBasicInformation_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> GetHelpInformationArr(SpReqAnsContext<GUIConsoleService_GetHelpInformationArr_Req, GUIConsoleService_GetHelpInformationArr_Ans>::Pointer ctx);
	std::pair<DWORD, std::string> GetHelpDetail(SpReqAnsContext<GUIConsoleService_GetHelpDetail_Req, GUIConsoleService_GetHelpDetail_Ans>::Pointer ctx);
	CSimpleString getRunVersion();

private:
	// ILogListener
	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);

	//ITimerListener
	void OnTimeout(DWORD dwTimerID);

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

	void updateStartupEntity();


public:
	//Async
	ErrorCodeEnum AsyncStartEntity(const char* entity_name, const char* cmdline, void* pData);
	ErrorCodeEnum AsyncStopEntity(const char* entity_name, void* pData);
	ErrorCodeEnum AsyncPauseEntity(const char* entity_name, void* pData);
	ErrorCodeEnum AsyncContinueEntity(const char* entity_name, void* pData);
	ErrorCodeEnum AsyncTerminateEntity(const char* entity_name, void* pData);

	//sync
	int sync_StartEntity(const char* entity_name, const char* cmdline, void* pData);
	int sync_StopEntity(const char* entity_name, void* pData);
	int sync_PauseEntity(const char* entity_name, void* pData);
	int sync_ContinueEntity(const char* entity_name, void* pData);
	int sync_TerminateEntity(const char* entity_name, void* pData);
	int sync_OpenLog(const char* entity_name, void* pData);

	ErrorCodeEnum GetEntity(const char* entity_name, EntityEntry& e);
	std::pair<DWORD, std::string> GetAllEntity(CAutoArray<EntityEntry>& Entities);
	void PostEntityVary(const char* entity_name);
	//ICallbackListener
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);


private:
	bool m_isOpenLogSender, m_isOpenEntityMonitor, m_isOpenPerformanceSender;
	int m_performanceSenderFrequence, m_sendLogType;
	CUUID m_logSubID;
	std::thread *thread_performanceSend, *thread_entityMonitor;

	int m_longestEntityMonitor, m_leastEntityMonitor;
	bool m_entityMonitor_shouldwork;
	std::chrono::steady_clock::time_point m_entityMonitorlast_notify_time;
	std::vector<std::string> m_startupEntityArr;
};