myvtm/Module/mod_guiconsole/mod_guiconsole.cpp

#include "mod_GuiConsole.h"
#include "publicFunExport.h"
#include <EventCode.h>
#include "GUIConsole_msg_g.h"
#include <chrono>
#include <fstream>
#include "modp_b64.h"



#ifdef RVC_OS_WIN
#include "..\mod_chromium\Chromium_client_g.h"
#include <Windows.h>

void openProcess(std::string cmdline)
{
	PROCESS_INFORMATION processInfo;
	STARTUPINFO startupInfo;
	::ZeroMemory(&startupInfo, sizeof(startupInfo));
	startupInfo.cb = sizeof(startupInfo);
	startupInfo.dwFlags = STARTF_USESHOWWINDOW;
	startupInfo.wShowWindow = SW_SHOW;
	::CreateProcess(NULL, const_cast<char*>(cmdline.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo);
}
#else
#include "../mod_chromium/Chromium_client_g.h" //启动浏览器接口
#include <unistd.h>
#include <cstdlib>
#endif // RVC_OS_WIN
#include <regex>




void CGUIConsoleEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(Error_Succeed);
}

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


void CGUIConsoleEntity::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)
{
	// 忽略GPIO事件
	if (dwUserCode == 0x2090000A || dwUserCode == 0x20900009)
		return;

	
	//did not open log sender
	if (!m_isOpenLogSender)
		return;
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OnLog %s %s", pszEntityName, pszMessage);
	if (pszMessage != NULL && strlen(pszMessage) > 2)
	{
		CSimpleStringA str = pszMessage;
		LogInfo msg;
		msg.sysError = dwSysError;
		msg.userCode = dwUserCode;
		msg.timeStr = GenerateTimeStr().c_str();
		msg.entityName = pszEntityName;
		msg.LogType = LogTypeEnumToString(eLogType).c_str();
		msg.message = str;
		msg.logLevel = eLevel;

		//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("OnLog %x from entity %s, msg : %s", dwUserCode, NULL == pszEntityName ? "" : pszEntityName, NULL == pszMessage ? "" : pszMessage);
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
	}
}

void CGUIConsoleEntity::OnEntityStateHook(const char* pszEntityName, const char* pszTriggerEntity, EntityStateEnum eState, EntityStateEnum eLastState)
{
	//did not open log sender
	if (m_isOpenLogSender)
	{
		LogInfo msg;
		if (eLastState == EntityState_Idle && eState != EntityState_Idle)
		{
			msg.sysError = ErrorCodeEnum::Error_Closed;
			msg.userCode = ErrorCodeEnum::Error_Closed;
			msg.message = CSimpleString::Format("%s实体异常，重新启动...", pszEntityName);
		}
		else
		{
			msg.sysError = ErrorCodeEnum::Error_Succeed;
			msg.userCode = ErrorCodeEnum::Error_Succeed;
			if (eState == EntityState_Starting)
				msg.message = CSimpleString::Format("正在启动实体%s...", pszEntityName);
			else if (eState == EntityState_Idle)
				msg.message = CSimpleString::Format("%s 实体启动成功", pszEntityName);
		}
		msg.logLevel = 1;
		msg.timeStr = GenerateTimeStr().c_str();
		msg.entityName = pszEntityName;
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
	}	

	if (m_isOpenEntityMonitor)
		PostEntityVary(pszEntityName);//if registered, while entity status changed, send to web
}


void CGUIConsoleEntity::OnTimeout(DWORD dwTimerID)
{
}

std::pair<DWORD, std::string> CGUIConsoleEntity::openLogSender(SpReqAnsContext<GUIConsoleService_OpenLogSender_Req, GUIConsoleService_OpenLogSender_Ans>::Pointer ctx)
{
	if ((__int64)m_logSubID != 0 && m_isOpenLogSender == true)
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not open again


	if ((__int64)m_logSubID != 0)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_AlreadyExist, WARN_GUICONSOLE_LOG_ALREADY_REGISTER, "openLogSender: already register");
		m_isOpenLogSender = true;
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_LOG_ALREADY_REGISTER, "openLogSender: already register");
	}
	else
	{
		auto logType = StringToLogTypeEnum(ctx->Req.LogType.GetData());
		//check valid input for this function
		if (logType != LogTypeEnum::Log_Ignore && logType != LogTypeEnum::Log_Event && logType != LogTypeEnum::Log_Warning && logType != LogTypeEnum::Log_Error)
		{
			LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NotSupport, WARN_GUICONSOLE_LOGSENDER_UNVAILD_INPUT,
				CSimpleString::Format("openLogSender: not valid input: %s, use default warning", ctx->Req.LogType.GetData()).GetData());
			m_sendLogType = LogTypeEnum::Log_Warning;
		}
		else
			m_sendLogType = logType;
		auto rc = GetFunction()->SubscribeLog(m_logSubID, this, (LogTypeEnum)m_sendLogType, Severity_None, Error_IgnoreAll, -1, NULL, false);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("openLogSender SubscribeLog %s %s", ctx->Req.LogType.GetData(), 
			(rc == ErrorCodeEnum::Error_Succeed ? "success" : "failed"));

		m_isOpenLogSender = (rc == ErrorCodeEnum::Error_Succeed);
		return std::pair<DWORD, std::string>(rc, "");
	}
	
	
}

std::pair<DWORD, std::string> CGUIConsoleEntity::closeLogSender()
{
	if ((__int64)m_logSubID == 0 && m_isOpenLogSender == false)
	{
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not close again
	}


	if ((__int64)m_logSubID == 0)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_AlreadyExist, WARN_GUICONSOLE_LOG_ALREADY_UNREGISTER, "closeLogSender: already unregister");
		m_isOpenLogSender = false;
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_LOG_ALREADY_UNREGISTER, "closeLogSender: already unregister");
	}
	else
	{
		auto rc = GetFunction()->UnsubscribeLog(m_logSubID);
		if(rc == ErrorCodeEnum::Error_Succeed)
			m_logSubID = 0;

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("closeLogSender UnsubscribeLog %s", (rc == ErrorCodeEnum::Error_Succeed ? "success" : "failed"));

		m_isOpenLogSender = !(rc == ErrorCodeEnum::Error_Succeed);
		return std::pair<DWORD, std::string>(rc, "");
	}
}

std::pair<DWORD, std::string> CGUIConsoleEntity::openEntityMonitor(SpReqAnsContext<GUIConsoleService_OpenEntityMonitor_Req, GUIConsoleService_OpenEntityMonitor_Ans>::Pointer ctx)
{
	if (m_isOpenEntityMonitor && thread_entityMonitor != NULL)
	{
		m_entityMonitor_shouldwork = true;//broadcast entity arr immediately 
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not open again
	}

	m_isOpenEntityMonitor = true;
	if (ctx->Req.longestFrequence <= 1)
		m_longestEntityMonitor = 1;
	else
		m_longestEntityMonitor = ctx->Req.longestFrequence;
	if (ctx->Req.leastFrequence <= 1)
		m_leastEntityMonitor = 1;
	else
		m_leastEntityMonitor = ctx->Req.leastFrequence;

	m_entityMonitor_shouldwork = true;

	int rc_errorenum = ErrorCodeEnum::Error_Succeed;

	if (!GetFunction()->HasPrivilege())
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoPrivilege, WARN_GUICONSOLE_ENTITYMONITOR_NO_PRIVILEGE, "openEntityMonitor no privilige");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_ENTITYMONITOR_NO_PRIVILEGE, "");
	}
	

	auto entityMonitorSender = [this] {
		int rc_errorenum = ErrorCodeEnum::Error_Succeed;
		if (ErrorCodeEnum::Error_Succeed != (rc_errorenum = GetFunction()->GetPrivilegeFunction()->RegistEntityStateEvent(NULL, this)))
		{
			LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoPrivilege, WARN_GUICONSOLE_ENTITYMONITOR_REGISTER,
				CSimpleStringA::Format("openEntityMonitor RegistEntityStateEvent failed, %d", rc_errorenum));
		}
		while (m_isOpenEntityMonitor)
		{
			if(m_entityMonitor_shouldwork || (std::chrono::steady_clock::now() - m_entityMonitorlast_notify_time >= std::chrono::seconds(m_longestEntityMonitor)))
			{
				m_entityMonitorlast_notify_time = std::chrono::steady_clock::now();
				m_entityMonitor_shouldwork = false;
				EntityStatus cur;
				CAutoArray<EntityEntry> Entities;
				auto ret = GetAllEntity(Entities);
				if (ret.first != ErrorCodeEnum::Error_Succeed)
				{
					LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_AlreadyExist, WARN_GUICONSOLE_ENTITYMONITOR_GETINFO_FAILED,
						CSimpleStringA::Format("openEntityMonitor - GetAllEntity failed, %d", ret.first));
						continue;
				}
				cur.entityName.Init(Entities.GetCount());
				cur.status.Init(Entities.GetCount());
				cur.processId.Init(Entities.GetCount());
				cur.versionNo.Init(Entities.GetCount());
				cur.lastStartTime.Init(Entities.GetCount());

				for (int i = 0; i < Entities.GetCount(); ++i) {
					cur.entityName[i] = Entities[i].Name;
					cur.status[i] = EntityEntry::GetStateName(Entities[i].State);
					cur.processId[i] = std::to_string(Entities[i].Pid).c_str();
					cur.versionNo[i] = getRunVersion();
					cur.lastStartTime[i] = Entities[i].lastStartTime.ToTimeString();
				}

				SpSendBroadcast(GetFunction(), eMsg_EntityStatus, eMsgSig_EntityStatus, cur);
			}

			for (auto cur = std::chrono::milliseconds(0); cur < std::chrono::seconds(m_leastEntityMonitor); cur = cur + std::chrono::milliseconds(50))
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(50));
				if (!m_isOpenEntityMonitor)
					return;
			}
		}
	};

	if (thread_entityMonitor != NULL)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_AlreadyExist, WARN_GUICONSOLE_ENTITYMONITOR_EXISTED,
			"openEntityMonitor, thread_entityMonitor already existed");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_ENTITYMONITOR_EXISTED, "");
	}
	
	thread_entityMonitor = new std::thread(entityMonitorSender);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("openEntityMonitor create entityMonitor sender thread %s,  leastFrequence:%d, m_longestEntityMonitor:%d",
		(thread_entityMonitor != NULL ? "success" : "failed"), m_leastEntityMonitor, m_longestEntityMonitor);

	return std::pair<DWORD, std::string>(Error_Succeed, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::closeEntityMonitor()
{
	if (m_isOpenEntityMonitor == false && thread_entityMonitor == NULL)
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not close again

	m_isOpenEntityMonitor = false;

	int rc_errorenum = ErrorCodeEnum::Error_Succeed;

	if (!GetFunction()->HasPrivilege())
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoPrivilege, WARN_GUICONSOLE_ENTITYMONITOR_NO_PRIVILEGE, "closeEntityMonitor no privilige");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_ENTITYMONITOR_NO_PRIVILEGE, "");
	}
	if (ErrorCodeEnum::Error_Succeed != (rc_errorenum = GetFunction()->GetPrivilegeFunction()->UnregistEntityStateEvent(NULL)))
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoPrivilege, WARN_GUICONSOLE_ENTITYMONITOR_UNREGISTER,
			CSimpleStringA::Format("closeEntityMonitor unRegistEntityStateEvent failed, %d", rc_errorenum));
	}

	if (thread_entityMonitor == NULL)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NotExist, WARN_GUICONSOLE_ENTITYMONITOR_NOTEXISTED,
			"closeEntityMonitor, thread_entityMonitor not exist");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_ENTITYMONITOR_NOTEXISTED, "");
	}

	thread_entityMonitor->join();
	delete thread_entityMonitor;
	thread_entityMonitor = NULL;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("closeEntityMonitor close entityMonitor sender thread success");

	return std::pair<DWORD, std::string>(Error_Succeed, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::openPerformanceSender(SpReqAnsContext<GUIConsoleService_OpenPerformanceSender_Req, GUIConsoleService_OpenPerformanceSender_Ans>::Pointer ctx)
{
	if (m_isOpenPerformanceSender && thread_performanceSend != NULL)
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not open again


	m_isOpenPerformanceSender = true;
	if (ctx->Req.sendFrequence <= 1)
		m_performanceSenderFrequence = 1;
	else
		m_performanceSenderFrequence = ctx->Req.sendFrequence;

	auto performanceSender = [this] {
		while (m_isOpenPerformanceSender)
		{
			system_monitor_status curStatus;
			auto pullret = PollProcessList(m_performanceSenderFrequence, curStatus);

			PerformanceList dst;
			dst.NameArr.Init(curStatus.processList.size());
			dst.pidArr.Init(curStatus.processList.size());
			dst.cpuArr.Init(curStatus.processList.size());
			dst.memoryArr.Init(curStatus.processList.size());
			dst.cmdlineArr.Init(curStatus.processList.size());
			dst.handleNumArr.Init(curStatus.processList.size());
			for (int i = 0; i < curStatus.processList.size(); i++)
			{
				dst.NameArr[i] = curStatus.processList[i].ExeName;
				dst.pidArr[i] = curStatus.processList[i].ID;
				dst.cpuArr[i] = curStatus.processList[i].PercentProcessorTime;
				dst.memoryArr[i] = curStatus.processList[i].PercentMemory;
				dst.cmdlineArr[i] = "";
				dst.handleNumArr[i] = curStatus.processList[i].ThreadCount;
			}
			SpSendBroadcast(GetFunction(), eMsg_PerformanceList, eMsgSig_PerformanceList, dst);

			for (auto cur = std::chrono::milliseconds(0); cur < std::chrono::seconds(m_performanceSenderFrequence); cur = cur + std::chrono::milliseconds(50))
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(50));
				if (!m_isOpenPerformanceSender)
					return;
			}
		}
	};
	
	if (thread_performanceSend != NULL)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_AlreadyExist, WARN_GUICONSOLE_PERFORMANCE_EXISTED,
			"openPerformanceSender, thread_performanceSend already existed");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_PERFORMANCE_EXISTED, "");
	}

	thread_performanceSend = new std::thread(performanceSender);

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("openPerformanceSender create performance sender thread %s,  sendFrequence:%d",
		(thread_performanceSend != NULL ? "success" : "failed"), m_performanceSenderFrequence);

	return std::pair<DWORD, std::string>(Error_Succeed, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::closePerformanceSender()
{
	if (m_isOpenPerformanceSender == false && thread_performanceSend == NULL)
		return std::make_pair(ErrorCodeEnum::Error_Succeed, "");//should not close again


	m_isOpenPerformanceSender = false;
	if(thread_performanceSend == NULL)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NotExist, WARN_GUICONSOLE_PERFORMANCE_NOTEXISTED,
			"closePerformanceSender, thread_performanceSend not exist");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_PERFORMANCE_NOTEXISTED, "");
	}

	thread_performanceSend->join();
	delete thread_performanceSend;
	thread_performanceSend = NULL;

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("closePerformanceSender close performance sender thread success");

	return std::pair<DWORD, std::string>(Error_Succeed, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::VTMSystemControl(SpReqAnsContext<GUIConsoleService_VTMSystemControl_Req, GUIConsoleService_VTMSystemControl_Ans>::Pointer ctx)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege == NULL)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoPrivilege, WARN_GUICONSOLE_NO_PRIVILIGE, "VTMSystemControl no privilige");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_NO_PRIVILIGE, "");
	}
	LogInfo msg;
	msg.sysError = Error_Succeed;
	msg.userCode = Error_Succeed;
	msg.timeStr = GenerateTimeStr().c_str();
	msg.entityName = GetEntityName();
	msg.LogType = 1;
	

	DWORD rc = Error_Succeed;
	if (!ctx->Req.rebootFunction.Compare("RestartApp", true))
	{
		msg.message = "正在重启应用";
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
		rc = pFuncPrivilege->Reboot(RebootTrigger_ManualLocal, RebootWayEnum::RebootWay_Framework);
	}
	else if (!ctx->Req.rebootFunction.Compare("RestartOS", true))
	{
		msg.message = "正在重启系统";
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);

#ifdef RVC_OS_WIN
		rc = pFuncPrivilege->Reboot(RebootTrigger_ManualLocal, RebootWayEnum::RebootWay_OS);
#else
		std::string cmdline = "sudo reboot";
		system(cmdline.c_str());
#endif
	}		
	else if (!ctx->Req.rebootFunction.Compare("ShutdownOS", true))
	{
		msg.message = "正在关闭系统";
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
#ifdef RVC_OS_WIN
		std::string cmdline = "shutdown -f -s -t 00";
		openProcess(cmdline);
#else
		std::string cmdline = "sudo shutdown --poweroff now";
		system(cmdline.c_str());
#endif

	}
	else if (!ctx->Req.rebootFunction.Compare("ExitApp", true))
	{
		msg.message = "正在退出应用";
		SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
		rc = pFuncPrivilege->Reboot(RebootTrigger_ManualLocal, RebootWayEnum::RebootWay_Framework);
	}
	else
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_NoDefine, WARN_GUICONSOLE_REBOOT_UNKNOWN_REASON, 
			CSimpleStringA::Format("VTMSystemControl receive unknown param %s, do nothing", ctx->Req.rebootFunction.GetData()).GetData());
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_REBOOT_UNKNOWN_REASON, "");
	}
	return std::pair<DWORD, std::string>(rc, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::VTM_controlEntity(SpReqAnsContext<GUIConsoleService_VTM_controlEntity_Req, GUIConsoleService_VTM_controlEntity_Ans>::Pointer ctx)
{
	auto control_thread = [this](SpReqAnsContext<GUIConsoleService_VTM_controlEntity_Req, GUIConsoleService_VTM_controlEntity_Ans>::Pointer ctx)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("VTM_controlEntity operate %s to %s", ctx->Req.operation.GetData(), ctx->Req.entityName.GetData());
		int ret = ErrorCodeEnum::Error_Succeed;
		if (!ctx->Req.operation.Compare("Start", true))
			ret = sync_StartEntity(ctx->Req.entityName, NULL, NULL);
		else if (!ctx->Req.operation.Compare("Stop", true))
			ret = sync_StopEntity(ctx->Req.entityName, NULL);
		else if (!ctx->Req.operation.Compare("Pause", true))
			ret = sync_PauseEntity(ctx->Req.entityName, NULL);
		else if (!ctx->Req.operation.Compare("Continue", true))
			ret = sync_ContinueEntity(ctx->Req.entityName, NULL);
		else if (!ctx->Req.operation.Compare("Terminate", true))
			ret = sync_TerminateEntity(ctx->Req.entityName, NULL);
		else if (!ctx->Req.operation.Compare("OpenLog", true))
			ret = sync_OpenLog(ctx->Req.entityName, NULL);

		if (m_isOpenLogSender)
		{
			LogInfo msg;
			msg.sysError = ret;
			msg.userCode = ret;
			msg.timeStr = GenerateTimeStr().c_str();
			msg.entityName = ctx->Req.entityName;
			if (ret == ErrorCodeEnum::Error_Succeed)
				msg.LogType = "Info";
			else
				msg.LogType = "Warning";
			msg.logLevel = 3;
			msg.message = CSimpleString::Format("%s %s %s, reason:%d", ctx->Req.entityName, ctx->Req.operation
				, (ret == ErrorCodeEnum::Error_Succeed ? "Success" : "Failed"), ret);
			SpSendBroadcast(GetFunction(), eMsg_LogInfo, eMsgSig_LogInfo, msg);
		}

		if (m_isOpenEntityMonitor && ctx->Req.operation.Compare("OpenLog", true))
		{
			PostEntityVary(ctx->Req.entityName);//if registered, while entity status changed, send to web
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		}
			

		if (ret == ErrorCodeEnum::Error_Succeed)
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		else
			ctx->Answer(ErrorCodeEnum::Error_Unexpect, ret);
	};

	std::thread(control_thread, ctx).detach();
	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
}

void CGUIConsoleEntity::updateStartupEntity()
{
	if (m_startupEntityArr.size() != 0)
		return;

	CSystemRunInfo sysRunInfo;
	if (ErrorCodeEnum::Error_Succeed !=  GetFunction()->GetSystemRunInfo(sysRunInfo))
		return;

	if (!sysRunInfo.bBasicCfgWork)
		return;


	CSystemStaticInfo m_terminalInfo;
	if (ErrorCodeEnum::Error_Succeed != GetFunction()->GetSystemStaticInfo(m_terminalInfo))
		return;


	CSmartPointer<IConfigInfo> spConfigCen, spRunCfg;
	GetFunction()->OpenConfig(Config_CenterSetting, spConfigCen);
	CSimpleStringA csCoreBootList(true), csSafeLoadList(true), csOperatingList(true), csKeyCB("CoreBootList."), csKeySL("SafeLoadList."), csKeyOp("OperatingList.");
	spConfigCen->ReadConfigValue("VtmLoader", (csKeyCB + m_terminalInfo.strMachineType).GetData(), csCoreBootList);
	spConfigCen->ReadConfigValue("VtmLoader", (csKeySL + m_terminalInfo.strMachineType).GetData(), csSafeLoadList);
	spConfigCen->ReadConfigValue("VtmLoader", (csKeyOp + m_terminalInfo.strMachineType).GetData(), csOperatingList);
	//"GuiConsole|Chromium|VtmLoader|";
	int nEntityCount = 3;
	auto booList =  csCoreBootList.Split('|');
	booList.Append(csSafeLoadList.Split('|'));
	booList.Append(csOperatingList.Split('|'));

	if (booList.GetCount() < 8)
		return;
	m_startupEntityArr.push_back("VtmLoader");
	m_startupEntityArr.push_back("Chromium");
	m_startupEntityArr.push_back("GUIConsole");
	for (int i = 0; i < booList.GetCount(); i++)
	{
		m_startupEntityArr.push_back(booList[i].SubString(0, booList[i].GetLength() - 2).GetData());
	}
		
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get effect entityNum:%d", m_startupEntityArr.size());
}

std::pair<DWORD, std::string> CGUIConsoleEntity::GetBasicInformation(SpReqAnsContext<GUIConsoleService_GetBasicInformation_Req, GUIConsoleService_GetBasicInformation_Ans>::Pointer ctx)
{
	//get idle entityNum;
	int idleNum = 0, totalNum = 0;
	CAutoArray<EntityEntry> Entities;
	auto ret = ErrorCodeEnum::Error_Succeed;
	auto entity_ret = GetAllEntity(Entities);
	if (ErrorCodeEnum::Error_Succeed != entity_ret.first)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_Unexpect, WARN_GUICONSOLE_BASICINFO_GETENTITY
			, CSimpleString::Format("GetBasicInformation-GetAllEntity get entity failed, %d", entity_ret.first).GetData());
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_BASICINFO_GETENTITY, "");
	}

	totalNum = Entities.GetCount();
	for (int i = 0; i < Entities.GetCount(); i++)
	{
		CSimpleString curState = EntityEntry::GetStateName(Entities[i].State);
		if (!curState.Compare("Idle", true))
			idleNum++;
	}

	ctx->Ans.total_entityNum = totalNum;
	ctx->Ans.Idle_entityNum = idleNum;

	CSystemStaticInfo m_terminalInfo;
	if (ErrorCodeEnum::Error_Succeed != (ret = GetFunction()->GetSystemStaticInfo(m_terminalInfo)))
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_Unexpect, WARN_GUICONSOLE_BASICINFO_SYSTEMINFO_FAILED
			, CSimpleString::Format("GetBasicInformation-GetSystemStaticInfo failed, %d", ret).GetData());
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_BASICINFO_SYSTEMINFO_FAILED, "");
	}
	ctx->Ans.terminalNo = m_terminalInfo.strTerminalID;
	ctx->Ans.machineType = m_terminalInfo.strMachineType;
	ctx->Ans.manufacturer = m_terminalInfo.strManufacturer;
	ctx->Ans.machineModel = m_terminalInfo.strMachineModel;
	ctx->Ans.versionNo = getRunVersion();
#ifdef DEVOPS_ON_ST /*DevOps流水线编译，ST环境*/
	ctx->Ans.Env = "ST";
#elif defined(DEVOPS_ON_UAT)/*DevOps流水线编译，UAT环境*/
	ctx->Ans.Env = "UAT";
#elif defined(DEVOPS_ON_PRD)/*DevOps流水线编译，PRD环境*/
	ctx->Ans.Env = "PRD";
#else/*本地编译等非DevOps环境编译的版本*/
	ctx->Ans.Env = "DEV";
#endif
	
	CSystemRunInfo sysRunInfo;
	if (ErrorCodeEnum::Error_Succeed != (ret = GetFunction()->GetSystemRunInfo(sysRunInfo)))
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, ErrorCodeEnum::Error_Unexpect, WARN_GUICONSOLE_BASICINFO_RUNINFO_FAILED
			, CSimpleString::Format("GetBasicInformation-GetSystemRunInfo failed, %d", ret).GetData());
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_BASICINFO_RUNINFO_FAILED, "");
	}
	ctx->Ans.vtm_startupTime = sysRunInfo.tmStart.ToTimeString();
	ctx->Ans.basicconfig_status = sysRunInfo.bBasicCfgWork;
	ctx->Ans.errmsg_status = sysRunInfo.bErrCfgWork;

	if (m_startupEntityArr.size() > 0)
		ctx->Ans.total_entityNum = m_startupEntityArr.size();

	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
}

std::pair<DWORD, std::string> CGUIConsoleEntity::GetHelpInformationArr(SpReqAnsContext<GUIConsoleService_GetHelpInformationArr_Req, GUIConsoleService_GetHelpInformationArr_Ans>::Pointer ctx)
{
	std::map<std::string, std::string> helpArr;
	helpArr.insert(std::make_pair("runcfg", "root配置"));
	helpArr.insert(std::make_pair("centercfg", "集中配置"));
	helpArr.insert(std::make_pair("shellcfg", "shell配置"));
	ctx->Ans.titleArr.Init(helpArr.size());
	ctx->Ans.cn_titleArr.Init(helpArr.size());
	int pos = 0;
	for(auto it : helpArr)
	{
		ctx->Ans.titleArr[pos] = it.first.c_str();
		ctx->Ans.cn_titleArr[pos] = it.second.c_str();
		pos++;
	}
	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
}
#if(defined _WIN32 || defined _WIN64)
std::string string_to_utf8(const std::string& str) {
	int wcLen = MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);
	if (wcLen > 0) {
		wchar_t* pwBuf = new wchar_t[wcLen + 1];
		if (pwBuf == NULL) {
			return std::string();
		}

		memset(pwBuf, 0, sizeof(wchar_t) * (wcLen + 1));
		wcLen = MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, pwBuf, wcLen);
		if (wcLen <= 0) {
			delete[] pwBuf;
			return std::string();
		}

		std::wstring modifyStr = pwBuf;


		int ucLen = WideCharToMultiByte(CP_UTF8, 0, pwBuf, -1, NULL, 0, NULL, NULL);
		//DbgEx("ucLen = %d", ucLen);
		if (ucLen < 0) {
			delete[] pwBuf;
			return std::string();
		}

		char* pBuf = new char[ucLen + 1];
		if (pBuf == NULL) {
			delete[]pwBuf;
			return std::string();
		}
		memset(pBuf, 0, sizeof(char) * (ucLen + 1));
		ucLen = WideCharToMultiByte(CP_UTF8, 0, pwBuf, -1, pBuf, ucLen, NULL, NULL);
		if (ucLen <= 0) {
			delete[] pwBuf;
			delete[] pBuf;
			return std::string();
		}

		std::string retStr(pBuf);
		//DbgEx("string_to_utf8 return: %s", retStr.c_str());

		if (pwBuf) {
			delete[] pwBuf;
			pwBuf = NULL;
		}
		if (pBuf) {
			delete[] pBuf;
			pBuf = NULL;
		}

		return retStr;
	}
	return std::string();
}
#endif



std::pair<DWORD, std::string> CGUIConsoleEntity::GetHelpDetail(SpReqAnsContext<GUIConsoleService_GetHelpDetail_Req, GUIConsoleService_GetHelpDetail_Ans>::Pointer ctx)
{
	CSimpleString tilte = ctx->Req.title;
	CSmartPointer<IConfigInfo> spConfig;
	
	if (tilte.Compare("runcfg", true) == 0)
	{
		ctx->Ans.subtitle = "root配置";
		ErrorCodeEnum erroCode = GetFunction()->OpenConfig(Config_Root, spConfig);
		if (!IS_SUCCEED(erroCode))
			return std::pair<DWORD, std::string>(WARN_GUICONSOLE_HELP_ROOT_FAILED, "");
	}
	else if (tilte.Compare("centercfg", true) == 0)
	{
		ctx->Ans.subtitle = "集中配置";
		ErrorCodeEnum erroCode = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
		if (!IS_SUCCEED(erroCode))
			return std::pair<DWORD, std::string>(WARN_GUICONSOLE_HELP_CENTER_FAILED, "");
	}
	else if (tilte.Compare("shellcfg", true) == 0)
	{
		ctx->Ans.subtitle = "shell配置";
		ErrorCodeEnum erroCode = GetFunction()->OpenConfig(Config_Shell, spConfig);
		if (!IS_SUCCEED(erroCode))
			return std::pair<DWORD, std::string>(WARN_GUICONSOLE_HELP_SHELL_FAILED, "");
	}

	CAutoArray<CSimpleStringA> arrSections, arrKeys;

	CSimpleStringA dstStr;
	dstStr.Append("# ").Append(ctx->Ans.subtitle).Append("\n");
	dstStr += "| moudle | name | value |\n";//table header
	dstStr += "-----|------|-----\n";//sperate

	if (Error_Succeed != spConfig->ReadAllSections(arrSections))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Read all sections failed.");
		return std::pair<DWORD, std::string>(WARN_GUICONSOLE_HELP_GETSECTION_FAILED, "");
	}

	for (int i = 0; i < arrSections.GetCount(); ++i)
	{
		spConfig->ReadAllKeys(arrSections[i].GetData(), arrKeys);
		for (int j = 0; j < arrKeys.GetCount(); ++j)
		{
			CSimpleStringA value, tmp;
			spConfig->ReadConfigValue(arrSections[i].GetData(), arrKeys[j].GetData(), value);

			tmp = CSimpleStringA::Format("{\"moudle\":\"%s\", \"name\":\"%s\", \"value\":\"%s\"}",
				arrSections[i].GetData(), arrKeys[j].GetData(), value.GetData());
			std::string result = value.GetData();
			std::string::size_type pos = 0;
			while ((pos = result.find("|", pos)) != std::string::npos) {
				result.replace(pos, 1, "\\|");
				pos += 2; // 跳过新插入的"\\"
			}

			dstStr.Append("| ").Append(arrSections[i]).Append(" | ").Append(arrKeys[j]).Append(" | ").Append(result.c_str()).Append(" |\n");
		}
	}
#if(defined _WIN32 || defined _WIN64)
	dstStr = string_to_utf8(dstStr.GetData()).c_str();
#endif
	int base64Len = modp_b64_encode_len(dstStr.GetLength());
	char *base64Data = (char*)malloc(sizeof(char) * base64Len);
	modp_b64_encode(base64Data, (const char*)dstStr.GetData(), dstStr.GetLength());


	ctx->Ans.detail = base64Data;

	if (base64Data)
		free(base64Data);
	

	return std::pair<DWORD, std::string>(ErrorCodeEnum::Error_Succeed, "");
}

CGUIConsoleEntity::CGUIConsoleEntity()
	:m_isOpenLogSender(false), m_isOpenEntityMonitor(false), m_isOpenPerformanceSender(false),
	m_sendLogType(LogTypeEnum::Log_Warning), thread_performanceSend(NULL), thread_entityMonitor(NULL),
	m_longestEntityMonitor(60), m_leastEntityMonitor(2)
{
}

CGUIConsoleEntity::~CGUIConsoleEntity()
{
	m_isOpenPerformanceSender = false;
	m_isOpenEntityMonitor = false;
	m_isOpenLogSender = false;
	if (thread_performanceSend)
	{
		thread_performanceSend->detach();
		delete thread_performanceSend;
		thread_performanceSend = NULL;
	}

	if (thread_entityMonitor)
	{
		thread_entityMonitor->detach();
		delete thread_entityMonitor;
		thread_entityMonitor = NULL;
	}
}


void CGUIConsoleSession::Handle_OpenLogSender(SpReqAnsContext<GUIConsoleService_OpenLogSender_Req, GUIConsoleService_OpenLogSender_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->openLogSender(ctx);
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_CloseLogSender(SpReqAnsContext<GUIConsoleService_CloseLogSender_Req, GUIConsoleService_CloseLogSender_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->closeLogSender();
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_OpenEntityMonitor(SpReqAnsContext<GUIConsoleService_OpenEntityMonitor_Req, GUIConsoleService_OpenEntityMonitor_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->openEntityMonitor(ctx);
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_CloseEntityMonitor(SpReqAnsContext<GUIConsoleService_CloseEntityMonitor_Req, GUIConsoleService_CloseEntityMonitor_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->closeEntityMonitor();
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_OpenPerformanceSender(SpReqAnsContext<GUIConsoleService_OpenPerformanceSender_Req, GUIConsoleService_OpenPerformanceSender_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->openPerformanceSender(ctx);
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_ClosePerformanceSender(SpReqAnsContext<GUIConsoleService_ClosePerformanceSender_Req, GUIConsoleService_ClosePerformanceSender_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->closePerformanceSender();
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_VTMSystemControl(SpReqAnsContext<GUIConsoleService_VTMSystemControl_Req, GUIConsoleService_VTMSystemControl_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->VTMSystemControl(ctx);
	ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
}

void CGUIConsoleSession::Handle_VTM_controlEntity(SpReqAnsContext<GUIConsoleService_VTM_controlEntity_Req, GUIConsoleService_VTM_controlEntity_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->VTM_controlEntity(ctx);
}

void CGUIConsoleSession::Handle_GetAllEntityList(SpReqAnsContext<GUIConsoleService_GetAllEntityList_Req, GUIConsoleService_GetAllEntityList_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	CAutoArray<EntityEntry> Entities;
	auto ret = m_pEntity->GetAllEntity(Entities);
	if (ret.first != ErrorCodeEnum::Error_Succeed)
	{
		ctx->Answer((ErrorCodeEnum)ret.first, (ErrorCodeEnum)ret.first);
		return;
	}
	ctx->Ans.entityName.Init(Entities.GetCount());
	ctx->Ans.status.Init(Entities.GetCount());
	ctx->Ans.processId.Init(Entities.GetCount());
	ctx->Ans.versionNo.Init(Entities.GetCount());
	ctx->Ans.lastStartTime.Init(Entities.GetCount());

	for (int i = 0; i < Entities.GetCount(); ++i) {
		ctx->Ans.entityName[i] = Entities[i].Name;
		ctx->Ans.status[i] = EntityEntry::GetStateName(Entities[i].State);
		ctx->Ans.processId[i] = std::to_string(Entities[i].Pid).c_str();
		ctx->Ans.versionNo[i] = m_pEntity->getRunVersion();
		ctx->Ans.lastStartTime[i] = Entities[i].lastStartTime.ToTimeString();
	}
	ctx->Answer(Error_Succeed);
}

void CGUIConsoleSession::Handle_GetBasicInformation(SpReqAnsContext<GUIConsoleService_GetBasicInformation_Req, GUIConsoleService_GetBasicInformation_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	auto ret = m_pEntity->GetBasicInformation(ctx);
	ctx->Answer((ErrorCodeEnum)ret.first, ret.first);
}

void CGUIConsoleSession::Handle_GetHelpInformationArr(SpReqAnsContext<GUIConsoleService_GetHelpInformationArr_Req, GUIConsoleService_GetHelpInformationArr_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->GetHelpInformationArr(ctx);
	ctx->Answer(ErrorCodeEnum::Error_Succeed);
}

void CGUIConsoleSession::Handle_GetHelpDetail(SpReqAnsContext<GUIConsoleService_GetHelpDetail_Req, GUIConsoleService_GetHelpDetail_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	m_pEntity->GetHelpDetail(ctx);
	ctx->Answer(ErrorCodeEnum::Error_Succeed);
}

void CGUIConsoleSession::Handle_OpenCommonPage(SpReqAnsContext<GUIConsoleService_OpenCommonPage_Req, GUIConsoleService_OpenCommonPage_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	

	Chromium::ChromiumSrv_ClientBase* chromiumClient = new Chromium::ChromiumSrv_ClientBase(m_pEntity);
	ErrorCodeEnum error = chromiumClient->Connect();
	if (error == Error_Succeed)
	{

		Chromium::ChromiumSrv_OpenCommonPage_Req req;
		Chromium::ChromiumSrv_OpenCommonPage_Ans  ans;
		req.title = ctx->Req.title;
		req.url = ctx->Req.url;
		req.width = ctx->Req.width;
		req.height = ctx->Req.height;
		req.point_x = ctx->Req.point_x;
		req.point_y = ctx->Req.point_y;
		req.top = ctx->Req.top;



		error = (*chromiumClient)(EntityResource::getLink().upgradeLink())->OpenCommonPage(req, ans, 10000);
		chromiumClient->GetFunction()->CloseSession();

		if (error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start common chromium page [%s] failed.", ctx->Req.url.GetData());
			ctx->Answer(error, error);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Start common chromium page [%s] success.", ctx->Req.url.GetData());
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		}
	}
	else
		ctx->Answer(ErrorCodeEnum::Error_Unexpect);

}

void CGUIConsoleSession::Handle_CloseCommonPage(SpReqAnsContext<GUIConsoleService_CloseCommonPage_Req, GUIConsoleService_CloseCommonPage_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgToBeidou(ctx->link, __FUNCTION__)();
	Chromium::ChromiumSrv_ClientBase* chromiumClient = new Chromium::ChromiumSrv_ClientBase(m_pEntity);
	ErrorCodeEnum error = chromiumClient->Connect();
	if (error == Error_Succeed)
	{
		Chromium::ChromiumSrv_CloseCommonPage_Req req;
		Chromium::ChromiumSrv_CloseCommonPage_Ans ans;
		req.title = ctx->Req.title;

		error = (*chromiumClient)(EntityResource::getLink().upgradeLink())->CloseCommonPage(req, ans, 10000);
		chromiumClient->GetFunction()->CloseSession();

		if (error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("close common chromium page [%s] failed.", ctx->Req.title.GetData());
			ctx->Answer(error, error);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("close common chromium page [%s] success.", ctx->Req.title.GetData());
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		}
	}
	else
		ctx->Answer(ErrorCodeEnum::Error_Unexpect);
}

CSimpleString CGUIConsoleEntity::getRunVersion()
{
	static CSimpleStringA activeVer;
	if(activeVer.GetLength() == 0)
		GetFunction()->GetRunningVersion(activeVer);
	return activeVer;
}

ErrorCodeEnum CGUIConsoleEntity::AsyncStartEntity(const char* entity_name, const char* cmdline, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StartEntity(entity_name, cmdline, spWait);
		if (Error == Error_Succeed) {
			callback_entry* entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_START_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum CGUIConsoleEntity::AsyncStopEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StopEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry* entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_STOP_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}
ErrorCodeEnum CGUIConsoleEntity::AsyncPauseEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->PauseEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry* entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_PAUSE_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}
ErrorCodeEnum CGUIConsoleEntity::AsyncContinueEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->ContinueEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry* entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_CONTINUE_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}
ErrorCodeEnum CGUIConsoleEntity::AsyncTerminateEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->TerminateEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry* entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_TERMINATE_ENTITY;
			spWait->SetCallback(this, entry);
		}
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

#define MAX_SYNC_TIMEOUT 20000

int CGUIConsoleEntity::sync_StartEntity(const char* entity_name, const char* cmdline, void* pData)
{	
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StartEntity(entity_name, cmdline, spWait);
		if (Error == Error_Succeed)
			Error = spWait->WaitAnswer(MAX_SYNC_TIMEOUT);
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

int CGUIConsoleEntity::sync_StopEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StopEntity(entity_name, spWait);
		if (Error == Error_Succeed)
			Error = spWait->WaitAnswer(MAX_SYNC_TIMEOUT);
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

int CGUIConsoleEntity::sync_PauseEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->PauseEntity(entity_name, spWait);
		if (Error == Error_Succeed)
			Error = spWait->WaitAnswer(MAX_SYNC_TIMEOUT);
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

int CGUIConsoleEntity::sync_ContinueEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->ContinueEntity(entity_name, spWait);
		if (Error == Error_Succeed)
			Error = spWait->WaitAnswer(MAX_SYNC_TIMEOUT);
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

int CGUIConsoleEntity::sync_TerminateEntity(const char* entity_name, void* pData)
{
	CSmartPointer<IEntityFunction> pFunc = GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->TerminateEntity(entity_name, spWait);
		if (Error == Error_Succeed)
			Error = spWait->WaitAnswer(MAX_SYNC_TIMEOUT);
		return Error;
	}
	else {
		return Error_NoPrivilege;
	}
}

int CGUIConsoleEntity::sync_OpenLog(const char* entity_name, void* pData)
{
	auto fileExist = [](const char* path) ->bool {
		fstream f2;
		f2.open(path);
		if (!f2)
		{
			f2.close();
			return false;
		}
		else
		{
			f2.close();
			return true;
		}
	};

	ErrorCodeEnum ret = ErrorCodeEnum::Error_Succeed;
	CEntityLogInfo cur;
	if (ErrorCodeEnum::Error_Succeed != (ret = GetFunction()->GetEntityLogPath(entity_name, cur)))
		return ret;

	if(!fileExist(cur.strLogPath))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s not exist", cur.strLogPath.GetData());
		return WARN_GUICONSOLE_ENTITYCONTROL_LOG_NOTEXIST;
	}
		

	// 使用记事本打开文件
#ifdef _WIN32
	// Windows 上使用 ShellExecute 打开文件
	std::string command = std::string("notepad.exe ") + cur.strLogPath.GetData();
	openProcess(command);
#else
	// Linux 上使用 xdg-open 打开文件
	//std::string command = std::string("gedit ") + cur.strLogPath.GetData();
	//std::string command = std::string("sudo xdg-open ") + cur.strLogPath.GetData();
	std::string command = std::string("sudo deepin-editor ") + cur.strLogPath.GetData() + std::string(" &");
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s ", command.c_str());
	system(command.c_str());
#endif
	
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s ", command.c_str());
	return ErrorCodeEnum::Error_Succeed;
}

ErrorCodeEnum CGUIConsoleEntity::GetEntity(const char* entity_name, EntityEntry& e)
{
	CSmartPointer<IEntityFunction> spFunc = GetFunction();
	LOG_ASSERT(spFunc != NULL);
	CEntityStaticInfo StaticInfo;
	CEntityRunInfo RunInfo;
	ErrorCodeEnum Error = spFunc->GetEntityStaticInfo(entity_name, StaticInfo);
	if (Error == Error_Succeed) {
		Error = spFunc->GetEntityRunInfo(entity_name, RunInfo);
		if (Error == Error_Succeed) {
			e.Name = entity_name;
			e.Id = RunInfo.dwEntityInstanceID;
			e.ModuleName = _GetFileName(StaticInfo.strSpFileName);
			e.State = RunInfo.eState;
			e.Type = StaticInfo.bStartedByShell ? 0 : 1;
			e.Pid = (int)RunInfo.dwProcessID;
			e.DevelopID = (int)StaticInfo.wEntityDevelopID;
			e.DebugLevel = RunInfo.eDebugLevel;
			e.lastStartTime = RunInfo.tmLastStart;
		}
	}
	return Error;
}

void CGUIConsoleEntity::PostEntityVary(const char* entity_name)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("PostEntityVary %s ", entity_name);

	m_entityMonitor_shouldwork = true;

	/*
	EntityStatus cur;
	cur.entityName = entity_name;
	cur.status = EntityEntry::GetStateName(ret.State);
	cur.processId = std::to_string(ret.Pid).c_str();
	cur.versionNo = getRunVersion();
	cur.lastStartTime = ret.lastStartTime.ToTimeString();
	SpSendBroadcast(GetFunction(), eMsg_EntityStatus, eMsgSig_EntityStatus, cur);
	*/
}


std::pair<DWORD, std::string> CGUIConsoleEntity::GetAllEntity(CAutoArray<EntityEntry>& Entities)
{
	CSimpleString ErrInfo;
	ErrorCodeEnum Error = ErrorCodeEnum::Error_Succeed;
	updateStartupEntity();
	if (m_startupEntityArr.size() != 0)
	{
		ErrInfo = CSimpleStringA::Format("From EntityArr size:%d, ", m_startupEntityArr.size());
		Entities.Init(m_startupEntityArr.size());
		for (int i = 0; i < m_startupEntityArr.size(); i++)
		{
			Error = GetEntity(m_startupEntityArr[i].c_str(), Entities[i]);
			if (Error != Error_Succeed)
				ErrInfo += CSimpleString::Format("|%s %d|", m_startupEntityArr[i].c_str(), Error);
		}
	}
	else
	{
		CSmartPointer<IEntityFunction> spFunc = GetFunction();
		CAutoArray<CSimpleStringA> strEntityNames;
		CAutoArray<WORD> wDevelopIDs;
		Error = spFunc->GetAllRegistedEntity(strEntityNames, wDevelopIDs);
		ErrInfo = CSimpleStringA::Format("From GetAllRegistedEntity size:%d, ", strEntityNames.GetCount());
		if (Error_Succeed != Error)
		{
			LogWarn(SeverityLevelEnum::Severity_Middle, Error, WARN_GUICONSOLE_GETALLENTITY_REGISTERED, "GetAllEntity-GetAllRegistedEntity failed");
			return std::make_pair(WARN_GUICONSOLE_GETALLENTITY_REGISTERED, "");
		}

		Entities.Init(strEntityNames.GetCount());
		for (int i = 0; i < strEntityNames.GetCount(); ++i) {
			Error = GetEntity(strEntityNames[i], Entities[i]);
			if (Error != Error_Succeed)
				ErrInfo += CSimpleString::Format("|%s %d|", strEntityNames[i].GetData(), Error);
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(ErrInfo.GetData());
	/*
	if (ErrInfo.GetLength() > 0)
	{
		LogWarn(SeverityLevelEnum::Severity_Middle, Error, WARN_GUICONSOLE_GETALLENTITY_GETENTITY, ErrInfo.GetData());
		return std::make_pair(WARN_GUICONSOLE_GETALLENTITY_GETENTITY, "");
	}
	*/
	return std::make_pair(ErrorCodeEnum::Error_Succeed, "");
}

void CGUIConsoleEntity::OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp)
{
	CSmartPointer<ICallbackListener> spCallback;
	CSmartPointer<IReleasable> pData;
	pAsynWaitSp->GetCallback(spCallback, pData);
	LOG_ASSERT(pData.GetRawPointer() != NULL);
	callback_entry* entry = static_cast<callback_entry*>((IReleasable*)pData.GetRawPointer());
	entry->ErrorResult = pAsynWaitSp->AsyncGetAnswer();
	if(m_isOpenEntityMonitor)
		PostEntityVary(entry->EntityName);//if registered, while entity status changed, send to web
}




SP_BEGIN_ENTITY_MAP()
SP_ENTITY(CGUIConsoleEntity)
SP_END_ENTITY_MAP()