myvtm/Module/mod_chromium/mod_chromium.cpp

#include "stdafx.h"
#if (defined _WIN32 || defined _WIN64)
#include <Windows.h>
#include <WinUser.h>
#include <tchar.h>
#define SPLIT_SLASH_STR "\\"
#include "chromelink_export.h"
#pragma comment(lib, "cefControl.lib")
#else
#include <signal.h>
#endif
#include "fileutil.h"
#include "baseEx.h"
#include "CWebsocketServer.h"
#include "mod_chromium.h"
#include "base64.h"
#include "CModTools.h"
#include "cJSON.h"
#include "SpIni.h"
#include "CSocketClient.h"
#include "processControl.h"
#include <boost/chrono.hpp>
#include <boost/bind.hpp>
#include "../mod_upload/Upload_client_g.h"
#include <tuple>
#include <string>
#include <algorithm>
#include "EventCode.h"	
#ifdef OPEN_PERF
#include <gperftools/profiler.h>
#endif // OPEN_PERF
#include <boost/date_time/posix_time/posix_time.hpp>
//#include "../mod_CameraConfigManage/Event.h"
#include "../mod_ResourceWatcher/ResourceWatcher_msg_g.h"
#include "CommEntityUtil.hpp"


#define COMPKEY_TERMINATE ((UINT_PTR) 0)
#define COMPKEY_STATUS ((UINT_PTR) 1)
#define COMPKEY_JOBOBJECT ((UINT_PTR) 2)

void DbgByCefControl(const char * strMethod, const char* buf)
{
#if defined(_MSC_VER)
    doWithDebugModeData(strMethod, buf);
#endif //_MSC_VER
}



namespace Chromium {

	void ChromiumSession::Handle_OpenBrowser(SpReqAnsContext<ChromiumSrv_OpenBrowser_Req, ChromiumSrv_OpenBrowser_Ans>::Pointer ctx)
	{
		DbgToBeidou(ctx->link, __FUNCTION__)();
		m_pEntity->OpenBrowser(ctx);
	}

	void ChromiumSession::Handle_CloseBrowser(SpReqAnsContext<ChromiumSrv_CloseBrowser_Req, ChromiumSrv_CloseBrowser_Ans>::Pointer ctx)
	{
		DbgToBeidou(ctx->link, __FUNCTION__)();
		m_pEntity->CloseBrowser(ctx);
	}


	CChromiumEntity::CChromiumEntity() :m_pWsServer(NULL), m_iTcpBridgePort(4504), m_pTimerListener(NULL), m_strCustomMainUrl(true)
		, m_runAd(false), m_runMain(false), m_runExtend(false), m_runLogin(false), m_withBrowser(false), m_withMin(false), m_withClose(false)
		, m_withDebugMode(false), m_withMagic(false), m_withNoFileLog(false)
	{
		DbgEx("CChromiumEntity constructor");

		//boost::thread(boost::bind(&CChromiumEntity::CefClintNotify, this)).detach(); //后台自动运行

	}

	CChromiumEntity::~CChromiumEntity()
	{
		if (NULL != m_pWsServer)
		{
			delete m_pWsServer;
			m_pWsServer = NULL;
		}
		//DeleteCriticalSection(&g_csInvokFreeRDP);
	}


#if (defined _WIN32 || defined _WIN64)
	void CChromiumEntity::JobNotify() {
		TCHAR sz[2000] = _T("");
		BOOL fDone = FALSE;

		while (!fDone) {
			DWORD dwBytesXferred;
			ULONG_PTR CompKey;
			LPOVERLAPPED po;
			GetQueuedCompletionStatus(m_hIOCP, &dwBytesXferred, &CompKey, &po, INFINITE);

			fDone = (CompKey == COMPKEY_TERMINATE);

			if (CompKey == COMPKEY_JOBOBJECT) {
				switch (dwBytesXferred) {
				case JOB_OBJECT_MSG_END_OF_JOB_TIME:
					DbgEx("Job time limit reached");
					break;

				case JOB_OBJECT_MSG_END_OF_PROCESS_TIME:
					DbgEx("Job process (Id=%d) time limit reached", po);
					break;

				case JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT:
					DbgEx("Too many active processes in job");
					break;

				case JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO:
					DbgEx("Job contains no active processes");
					break;

				case JOB_OBJECT_MSG_NEW_PROCESS:
					DbgEx("New process (Id=%d) in Job", po);
					break;

				case JOB_OBJECT_MSG_EXIT_PROCESS:
					DbgEx("Process (Id=%d) terminated", po);
					break;

				case JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS:
					DbgEx("Process (Id=%d) terminated abnormally", po);
					break;

				case JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT:
					DbgEx("Process (Id=%d) exceeded memory limit", po);
					break;

				case JOB_OBJECT_MSG_JOB_MEMORY_LIMIT:
					DbgEx("Process (Id=%d) exceeded job memory limit", po);
					break;

				default:
					DbgEx("Unknown notification: %d", dwBytesXferred);
					break;
				}
				CompKey = 1;
			}
		}
	}
#endif

	void CChromiumEntity::CloseBrowser(SpReqAnsContext<ChromiumSrv_CloseBrowser_Req, ChromiumSrv_CloseBrowser_Ans>::Pointer ctx)
	{
		CSimpleString strType = ctx->Req.type;
		CSimpleString strNmae = ctx->Req.name;

		DbgToBeidou(ctx->link, "CloseBrowser")();

		if (!strType.Compare((+ERR_PAGE_REASON::OutsideRequest)._to_string(), true))
		{
			CModTools::get_mutable_instance().StopSingleChromiumBrowserByName((+ERR_PAGE_REASON::OutsideRequest)._to_string());
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		}			
		else if (!strType.Compare((+ERR_PAGE_REASON::SpecialPageFromOtherEntity)._to_string(), true))
		{
			CSimpleStringA dstBrowserName = strType + "_" + strNmae;
			CModTools::get_mutable_instance().StopSingleChromiumBrowserByName(dstBrowserName.GetData());
			ctx->Answer(ErrorCodeEnum::Error_Succeed);
		}
		else
		{
			ctx->Answer(ErrorCodeEnum::Error_NoTarget);
		}
	}

    void CChromiumEntity::OpenBrowser(SpReqAnsContext<ChromiumSrv_OpenBrowser_Req, ChromiumSrv_OpenBrowser_Ans>::Pointer ctx)
    {
		std::shared_ptr<void> CleanParamFun((void*)0, [&](void*) {
			CModTools::get_mutable_instance().SetSpecialPageParam("", "", "", 0);
			});
		CSimpleStringA strType = ctx->Req.type;

		DbgToBeidou(ctx->link, "OpenBrowser")();

		if (!strType.Compare((+ERR_PAGE_REASON::OutsideRequest)._to_string(), true))
		{
			CSimpleStringA strUrl = ctx->Req.mainUrl, strUrl2 = ctx->Req.viceUrl;
			if (strUrl.IsNullOrEmpty()) {
				ctx->Answer(Error_Param);
				return;
			}
			auto ret = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::OutsideRequest, std::make_tuple(strUrl.GetData(), strUrl2.GetData()));
			DbgEx("open OutsideRequest browser page %s return %d", (LPCTSTR)strUrl, ret.first);
			ctx->Answer(ret.first);
		}
		else if (!strType.Compare((+ERR_PAGE_REASON::SpecialPageFromOtherEntity)._to_string(), true))
		{
			CSimpleStringA strUrl = ctx->Req.mainUrl, strUrl2 = ctx->Req.viceUrl, sizeParam = ctx->Req.param1
				, pointParam = ctx->Req.param2, browserName = ctx->Req.name;
			CSimpleStringA dstBrowserName = strType + "_" + browserName;

			int browserTopZ = ctx->Req.top;

			CModTools::get_mutable_instance().SetSpecialPageParam(dstBrowserName.GetData(), sizeParam.GetData(), pointParam.GetData(), browserTopZ);
			//用一个临时变量解决，可能在高并发时有问题。
			auto ret = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::SpecialPageFromOtherEntity, 
				std::make_tuple(strUrl.GetData(), strUrl2.GetData()));
			
			DbgEx("open %s browser page %s return %d", dstBrowserName.GetData(), (LPCTSTR)strUrl, ret.first);
			ctx->Answer(ret.first);
		}
		else
			ctx->Answer(ErrorCodeEnum::Error_NoTarget);
	}

	void CChromiumEntity::OnPaused() {
#ifdef OPEN_PERF
		ProfilerStop();//停止性能分析
#endif // OPEN_PERF
	}

	void CChromiumEntity::OnPreStart_Init(CAutoArray<CSimpleStringA>& strArgs, CSmartPointer<ITransactionContext>& pTransactionContext) {
#ifdef OPEN_PERF
		auto profStr = CSimpleString::Format("chromiumAnalyze_%s.prof", generateTimeStr(true).c_str());
		std::thread([](std::string str) {
			ProfilerStart(str.c_str());//开启性能分析
			DbgEx("Generate chromiumAnalyze, %s", str.c_str());
			}, profStr.GetData()).detach();
#endif // OPEN_PERF
#if (defined _WIN32 || defined _WIN64)
			CModTools::get_mutable_instance().InitCModTools(this);
			//CModTools::get_mutable_instance().killAllChromium();
			//shell启动过程，已经进行了cef的kill操作。这里可能会把启动时间延长很多
#else
			FetchCustomMainUrl(strArgs);
			CModTools::get_mutable_instance().InitCModTools(this);
			CModTools::get_mutable_instance().killAllChromium();
			DoBrowserCacheClearJob();
#endif

#if (defined _WIN32 || defined _WIN64)
			//SetUnhandledExceptionFilter(&printSEG);
#else
			CSimpleStringA strDbgPath;
			GetFunction()->GetPath("Dbg", strDbgPath);
			set_traceback_path(strDbgPath.GetData());
			boost::thread([]() {
				for (auto i = 1; i < 28; i++)
				{
					if (SIGTERM == i)
						signal(i, [](int signum)->void {
						DbgEx("receive signal:%d, closeChromium", signum);
						CModTools::get_mutable_instance().killAllChromiumByThread(3);
						CWebsocketServer::stopServer();
						signal(signum, SIG_DFL);
						raise(signum);

							});
					else if (SIGSEGV == i || SIGABRT == i)
						signal(i, &seg_signal_handler);
					else if (SIGPROF == i || SIGALRM == i || SIGVTALRM == i)
						continue;
					else
						signal(i, &normal_signal_handle);
				}

				}).detach();
#endif

#if (defined _WIN32 || defined _WIN64)
				const int ArgsCount = strArgs.GetCount();
				LOG_TRACE("strArgs.GetCount() = %d", ArgsCount);
				for (int i = 0; i < ArgsCount; ++i) {
					DbgEx("strArgs[%d] = %s", i, strArgs[i].GetData());
				}
				if (ArgsCount == 1) {
					m_strCustomMainUrl = strArgs[0];
					DbgEx("Get custom main ulr: %s", m_strCustomMainUrl.GetData());
				}
				else if (ArgsCount == 2)
				{
					m_strCustomMainUrl = strArgs[0];
					m_strCustomAdUrl = strArgs[1];
					DbgEx("Get custom main url: %s, ad url: %s", m_strCustomMainUrl.GetData(), m_strCustomAdUrl.GetData());
				}
#endif

				GetFunction()->GetSystemStaticInfo(m_sysInfo);
				if (!IsConfigMode()) {
				CSmartPointer<IConfigInfo> spConfig;
				if (Error_Succeed == GetFunction()->OpenConfig(Config_CenterSetting, spConfig))//特别坑，这个OpenConfig返回一直都是success
				{
					auto webMaskKey = CSimpleString::Format("WebMask_%s", m_sysInfo.strMachineType.GetData());
					CSimpleString webMaskStr;
					if (Error_Succeed == spConfig->ReadConfigValue("Chromium", webMaskKey.GetData(), webMaskStr))
					{
						auto maskArr = webMaskStr.Split('|');
						for (int i = 0; i < maskArr.GetCount(); i++)
						{
							auto trimStr = maskArr[i].Trim();
							if (!trimStr.Compare("ad", true))
								m_runAd = true;
							else if (!trimStr.Compare("main", true))
								m_runMain = true;
							else if (!trimStr.Compare("extend", true))
								m_runExtend = true;
							else if (!trimStr.Compare("login", true))
								m_runLogin = true;
							else if (!trimStr.Compare("with_browser", true))
								m_withBrowser = true;
							else if (!trimStr.Compare("with_min", true))
								m_withMin = true;
							else if (!trimStr.Compare("with_close", true))
								m_withClose = true;
							else if (!trimStr.Compare("with_debugmode", true))
								m_withDebugMode = true;
							else if (!trimStr.Compare("with_magic", true))
								m_withMagic = true;
							else if (!trimStr.Compare("with_nofilelog", true))
								m_withNoFileLog = true;
						}
#if (defined _WIN32 || defined _WIN64)
						if (m_withDebugMode)
							CModTools::get_mutable_instance().setWithDebugMode(m_withDebugMode);
#else
						//对于UOS来说，没有最小化和关闭按钮
						m_withMin = false;
						m_withClose = false;
#endif
						DbgEx("MachineType: %s, find %s, readStr:%s, m_runAd:%d, m_runMain:%d, m_runExtend:%d, m_runLogin:%d, \
							m_withBrowser:%d, with_min:%d, with_close:%d, m_withDebugMode:%d, m_withMagic:%d, m_withNoFileLog:%d",
							m_sysInfo.strMachineType.GetData(), webMaskKey.GetData(), webMaskStr.GetData(), m_runAd, m_runMain, m_runExtend, m_runLogin, m_withBrowser
						,m_withMin, m_withClose, m_withDebugMode, m_withMagic, m_withNoFileLog);
						
						if (m_withMin)
							CModTools::get_mutable_instance().setWithMin(m_withMin);
						if (m_withClose)
							CModTools::get_mutable_instance().setWithClose(m_withClose);
						
						g_logToFile = !m_withNoFileLog;


						int forceCacheClean = false;
						if (Error_Succeed == spConfig->ReadConfigValueInt("Chromium", "forceCacheClean", forceCacheClean) && forceCacheClean)
						{
							DbgEx("forceCacheClean, call OnOnBrowserCacheClean");
							ResourceWatcher::BrowserCacheClean evt;
							evt.needClean = 1;
							OnBrowserCacheClean(NULL, 0, 0, evt);
						}

					}
					else
						DbgEx("can not find %s, use default", webMaskKey.GetData());
				}
				if (!m_runAd && !m_runMain && !m_runExtend && !m_withBrowser)
				{
					DbgEx("can not open centerSetting, maybe fault");
				}
#if (defined _WIN32 || defined _WIN64)
				if (!logProducer)
					logProducer = create_log_producer_storage("cefclient_logger", "0", "");
#else
				CSimpleString dbgPath;
				GetFunction()->GetPath("Dbg", dbgPath);
				std::string dstDbgPath = dbgPath.GetData();
				dstDbgPath.append(SPLIT_SLASH_STR).append("mod_chromium");
				if (InitFileLogger(dstDbgPath))
					DbgToFileLogger("================");
				else
					DbgEx("[ERROR]logger init failed!");

#endif
				CSimpleString translatePath;
				GetFunction()->GetPath("Cfg", translatePath);
				translatePath.Append(CSimpleStringA(SPLIT_SLASH_STR) + "UserCodeToMsgTip.ini");

				InitTranslateFile(translatePath.GetData());

				if (m_withMagic)
				{
					std::string magicStr = CModTools::get_mutable_instance().getMagicStr();
					boost::thread(boost::bind(SaveCefclientLog, magicStr)).detach();
				}				

				boost::thread(boost::bind(&CChromiumEntity::DoWithSysVarEvent, this)).detach();//用于处理sysvar，避免由于阻塞动作，导致实体卡住，lost
		}
	}

	bool CChromiumEntity::OnPreStart_socketStart(CAutoArray<CSimpleStringA>& strArgs, CSmartPointer<ITransactionContext>& pTransactionContext)
	{
		ErrorCodeEnum Error;
		if (Error_Succeed != (Error = GetFunction()->StartTcpBridgeServer(m_iTcpBridgePort)))
		{
			DbgEx("start tcp bridge server failed!");
			pTransactionContext->SendAnswer(Error);
			return false;
		}
		// load all struct define xml & start websocket server
		CSimpleStringA strStructPath;
		GetFunction()->GetPath("Base", strStructPath);
		strStructPath.Append(CSimpleStringA(SPLIT_SLASH_STR) + "res" + SPLIT_SLASH_STR + "StructConfig" + SPLIT_SLASH_STR);
		DbgEx("find struct config files in path %s", strStructPath.GetData());
		m_pWsServer = new CWebsocketServer(strStructPath, this);
		m_pWsServer->run();

		return true;
	}

	bool CChromiumEntity::OnPreStart_register(CAutoArray<CSimpleStringA>& strArgs, CSmartPointer<ITransactionContext>& pTransactionContext)
	{
		ErrorCodeEnum Error;

#if defined(RVC_OS_LINUX)
        Error = GetFunction()->SubscribeLog(m_uuidAllFault, this, Log_Notify, Severity_High, Error_IgnoreAll, -2, NULL, false);
        if (Error_Succeed == Error) {
            this->GetFunction()->GetPrivilegeFunction()->RefreshFrameworkState(FrameworkState_NotDisturb);
        } else {
            DbgEx("subscribe log for notify failed! %s", SpStrError(Error));
        }
#endif //RVC_OS_LINUX

		//与browser进行交互所必须，移除browser的机型不需要订阅browser相关
		if (m_withBrowser)
		{
			if (Error_Succeed != (Error = GetFunction()->SubscribeBroadcast("IEBrowser", "CustomerCmd", this, m_uidBrowserListenser))) {
				DbgEx("subscribe browser CustomerCmd failed!");
				pTransactionContext->SendAnswer(Error);
			}
			else
				DbgEx("subscribe browser CustomerCmd success!");

			if (Error_Succeed != (Error = GetFunction()->SubscribeLog(m_uidCameraListener, this, Log_Event, Severity_None, Error_IgnoreAll, -1, "CameraConfigManage")))
				DbgEx("subscribe Camera log failed!"); //非必须
		} else {//有browser的时候不需要订阅这一堆
			DbgEx("subscribe AccessAuthorization %s, %d",
				Error_Succeed == (Error = GetFunction()->SubscribeLog(m_uuidAccessAuth, this, Log_Event, Severity_None, Error_IgnoreAll, -1, "AccessAuthorization")) ? "success" : "failed", Error);

			DbgEx("subscribe ResourceWatcher %s, %d", 
				Error_Succeed == (Error = GetFunction()->SubscribeBroadcast("ResourceWatcher", NULL, this, m_uuidResourceWatch)) ? "success" : "failed", Error);


			if (Error_Succeed != GetFunction()->RegistSysVarEvent("UIState", this))
				DbgEx("RegistSysVarEvent UIState failed!");
			if (Error_Succeed != GetFunction()->RegistSysVarEvent("TerminalStage", this))
				DbgEx("RegistSysVarEvent TerminalStage failed!");
			if (Error_Succeed != GetFunction()->RegistSysVarEvent("EntryPermit", this))
				DbgEx("RegistSysVarEvent EntryPermit failed!");
			if (Error_Succeed != GetFunction()->RegistSysVarEvent("SessionID", this))
				DbgEx("RegistSysVarEvent SessionID failed!");
			if (Error_Succeed != GetFunction()->RegistSysVarEvent("CustomerID", this))
				DbgEx("RegistSysVarEvent CustomerID failed!");
			if (Error_Succeed != GetFunction()->RegistSysVarEvent("CardStoreInUse", this))
				DbgEx("RegistSysVarEvent CardStoreInUse failed!");
		}

		return true;
}

	bool CChromiumEntity::OnPreStart_openWeb()
	{
		if (m_runExtend)
			openExtendPage();

		if (!m_runMain)//不启动页面
			return true;

		do
		{
			CSimpleStringA t_EntryPermit, t_terminalState;
			GetFunction()->GetSysVar("EntryPermit", t_EntryPermit);
			GetFunction()->GetSysVar("TerminalStage", t_terminalState);
			/** Z开头标识终端配种模式 [Gifur@20211017]*/
		    if ('A' != t_terminalState[0] &&  'Z' != t_terminalState[0])
			{
				if (m_withBrowser)
					break;//run IEBrowser
				if ('X' == t_terminalState[0])
				{
					DbgEx("do not begin accessAuth, terminalStage X, do nothing.");
					break;
				}
				else if ('S' == t_terminalState[0])
				{
					auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::warnPrompt,
						std::tuple <std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
					DbgEx("access failed, open page warnPrompt %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
				}
				else
				{
					auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::breakdown,
						std::tuple <std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
					DbgEx("access failed, open page breakdown %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
				}
			}
			else
			{
				if (m_runAd) openAdPage();
				openMainPage();
#if (defined _WIN32 || defined _WIN64)
				if (m_withDebugMode)
					getNetworkInfo(L"127.0.0.1:9222", L"", &DbgByCefControl);
#endif
			}
		} while (false);
		


		return true;
	}

	void CChromiumEntity::openMainPage()
	{
#if (defined _WIN32 || defined _WIN64)
		generateCefclientTimer();
#else
		CSystemRunInfo sysruninfo;
		GetFunction()->GetSystemRunInfo(sysruninfo);
		if (!(sysruninfo.dwBootOption & SystemBootOptionEnum::BootOption_Test))
			generateCefclientTimer();//非--test时，才会打开浏览器
#endif
	}

	void CChromiumEntity::openAdPage()
	{
		auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::Ad);
		DbgEx("open page Ad %s, pid:%d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
	}
	void CChromiumEntity::openExtendPage()
	{
		auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::extend);
		DbgEx("open page extend %s， pid:%d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
	}

	void CChromiumEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		OnPreStart_Init(strArgs, pTransactionContext);//初始化部分， perf ，killchromium， signal, get custom url
		if (!OnPreStart_socketStart(strArgs, pTransactionContext)) {//OnPreStart_socketStart()->new CWebsocketServer(strStructPath, this) 时间过长
			return;
		}
		if (!IsConfigMode()) {
			if (!OnPreStart_register(strArgs, pTransactionContext)) {
				return;
			}
			//if contain default setting, then oepn web by setting
#if (defined _WIN32 || defined _WIN64)
			if (strArgs.GetCount())
			{
				if (!m_strCustomMainUrl.IsNullOrEmpty())
					openMainPage();
				if (!m_strCustomAdUrl.IsNullOrEmpty())
					openAdPage();
				return;
			}
#endif
			if (!OnPreStart_openWeb()) {
				return;
			}
		}
		
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	bool CChromiumEntity::CheckIsCardStore() {
		return m_sysInfo.strMachineType.IsEndWith("CardStore", true) || m_sysInfo.strMachineType.IsEndWith("CardPrinter", true);
	}

	void CChromiumEntity::DoWithSysVarEvent()
	{
		while (true)
		{
			if (m_eventArr.empty())
			{
				boost::this_thread::sleep_for(boost::chrono::microseconds(100));
				continue;
			}

			m_eventContorl.lock();
			SYS_EVENT_PARAM curEvent = m_eventArr.front();
			m_eventArr.pop_front();
			m_eventContorl.unlock();
			if ((strnicmp(curEvent.key.c_str(), "UIState", strlen("UIState")) == 0))
			{
				if (strnicmp(curEvent.value.c_str(), "M", strlen("M")) == 0)
				{
					static bool firstEnter = true;
					if (firstEnter)
					{
						firstEnter = false;
						DbgEx("first Enter main page");
						m_firstStartMain.unlock();
						LogWarn(Severity_Low, Error_Debug, LOG_SLV_CHROMIUM_OPENSUCCESS,
							CSimpleStringA::Format("Chromium Enter main page success, %s", CModTools::get_mutable_instance().getFultureUrl().GetData()));
					}
					GetFunction()->UnregistSysVarEvent("UIState");
				}
			}
			/** 该事件有变化才会触发错误页 [Gifur@2022324]*/
			else if (0 == CSimpleStringA("TerminalStage").Compare(curEvent.key.c_str(), true))
			{
				if (0 == CSimpleStringA("A").Compare(curEvent.value.c_str(), true))
				{
					if (CModTools::get_mutable_instance().IsConfigWork())//url正常时才关闭
					{
						if (m_runAd) openAdPage();
						openMainPage();
						CModTools::get_mutable_instance().StopChromiumBrowser(ERR_PAGE_REASON::breakdown);
						
						//DbgEx("UnregistSysVarEvent TerminalStage %s", Error_Succeed == GetFunction()->UnregistSysVarEvent("TerminalStage") ? "success" : "fail");
					}
				}
				else if (0 == CSimpleStringA("X").Compare(curEvent.value.c_str(), true))
					DbgEx("TerminalStage X, do nothing.");
				else
				{
					if (!m_withBrowser)
					{
						auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(
							0 == CSimpleStringA("S").Compare(curEvent.value.c_str(), true) ? ERR_PAGE_REASON::warnPrompt : ERR_PAGE_REASON::breakdown,
							std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
						DbgEx("access failed, open err page %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
						CModTools::get_mutable_instance().StopChromiumBrowser(ERR_PAGE_REASON::main);						
					}
				}

			}
			else if (0 == CSimpleStringA("CardStoreInUse").Compare(curEvent.key.c_str(), true) && CheckIsCardStore())
			{
				if (0 == CSimpleStringA("Y").Compare(curEvent.value.c_str(), true))
				{
					auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::CardStoreIsBusy,
						std::tuple <std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
					DbgEx("CardStoreIsBusy, open page CardStoreIsBusy %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
				}
				else
					CModTools::get_mutable_instance().StopChromiumBrowser(ERR_PAGE_REASON::CardStoreIsBusy);
			}
		}
		
	}

	void CChromiumEntity::OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName)
	{
		DbgEx("OnSysVarEvent %s, old->new:%s->%s", pszKey, pszOldValue, pszValue);
		SYS_EVENT_PARAM curEvent;
		curEvent.key = pszKey;
		curEvent.value = pszValue;
		curEvent.oldValue = pszOldValue;
		curEvent.entityName = pszEntityName;
		boost::unique_lock<boost::mutex> eventArrLock(m_eventContorl);
		m_eventArr.push_back(curEvent);

	}

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

	void CChromiumEntity::exitClean()
	{
		static bool isExit = false;
		if (!isExit)
		{
			isExit = true;
			CModTools::get_mutable_instance().killAllChromiumByThread(3);
			delete m_pWsServer;
			if (m_pTimerListener != NULL)
			{
				GetFunction()->KillTimer(CHROMIUM_TIMER_ID);
				delete m_pTimerListener;
				m_pTimerListener = NULL;
			}
			GetFunction()->UnsubscribeBroadcast("IEBrowser");
		}
	}

	/** 查看启动顺序发现集中配置实体启动在本实体之前，无法调用集中配置的接口，随将实现搬到这里来 [Gifur@2021124]*/
    void CChromiumEntity::FetchCustomMainUrl(CAutoArray<CSimpleStringA>& strArgs)
    {
#if (defined _WIN32 || defined _WIN64)
#else
        const int ArgsCount = strArgs.GetCount();
        LOG_TRACE("strArgs.GetCount() = %d", ArgsCount);
        for (int i = 0; i < ArgsCount; ++i) {
            DbgEx("strArgs[%d] = %s", i, strArgs[i].GetData());
        }
        if (ArgsCount == 1) {
            m_strCustomMainUrl = strArgs[0];
            DbgEx("Get custom main url: %s", m_strCustomMainUrl.GetData());
			if (!m_strCustomMainUrl.IsNullOrEmpty()) {
                LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_DETECT_CUSTOM_FULTURE_URL_FROM_START,
						CSimpleStringA::Format("从模块入参获取自定义链接：%s", m_strCustomMainUrl.GetData()));
			}
		} else {
            CSmartPointer<IConfigInfo> pConfig;
            GetFunction()->OpenConfig(Config_Cache, pConfig);
            int cnt(0), currentUsing(0);
            pConfig->ReadConfigValueInt("CustomWebUrl", "Count", cnt);
            pConfig->ReadConfigValueInt("CustomWebUrl", "Current", currentUsing);
			if (cnt > 0 && currentUsing > 0) {
				CSimpleStringA strAdUrl(true);
                CSimpleStringA strSection = CSimpleStringA::Format("CustomWebUrl%d", currentUsing);
                pConfig->ReadConfigValue(strSection, "FultureUrl", m_strCustomMainUrl);
                pConfig->ReadConfigValue(strSection, "AdUrl", strAdUrl);
				if (!m_strCustomMainUrl.IsNullOrEmpty()) {
                    LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_DETECT_CUSTOM_FULTURE_URL_FROM_CONFIG,
							CSimpleStringA::Format("从本地维护桌面获取自定义链接：%s", m_strCustomMainUrl.GetData()));
				}
			}
		}
#endif
    }

	void CChromiumEntity::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)
	{
		DbgEx("OnLog %x from entity %s, msg : %s", dwUserCode, NULL == pszEntityName ? "" : pszEntityName, NULL == pszMessage ? "" : pszMessage);
#if (defined _WIN32 || defined _WIN64)
		//No Log_Notify
#else
		if (Log_Notify == eLogType)
		{
			try {
				cJSON* pJson = cJSON_Parse(pszMessage);
				auto notifyReason = cJSON_GetObjectItem(pJson, "reason")->valuestring;
				auto notifymsg = cJSON_GetObjectItem(pJson, "errmsg")->valuestring;
				auto notiryRebootTime = cJSON_GetObjectItem(pJson, "rebootTime")->valuestring;
				auto notifyPool = m_pWsServer->getNotifyPool();
				if (notifyPool.size() > 0)
				{
					for (auto it : notifyPool)
					{
						DbgEx("Log_Notify err, notifyPool to %d, %d", it.first, it.second);
						m_pWsServer->do_send_notifyMsg(it.first, it.second, notifyReason, notifymsg, notiryRebootTime, dwSysError, dwUserCode);
					}
				}
				else
				{
					auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::ErrNotify, { m_sysInfo.strTerminalID.GetData(), generateTimeStr() }, { notifyReason, notifymsg, notiryRebootTime, dwSysError, dwUserCode });
					DbgEx("Log_Notify err, open page %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
				}
			}
			catch (std::exception& e) {
				DbgEx("Log_Notify err, %s", e.what());
			}
			return;
	}
#endif
	}

	void CChromiumEntity::OnTerminalManage(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, HealthManager::TerminalManager& evt)
	{
		DbgEx("OnTerminalManage : evt.op = %d", evt.op);
		switch (evt.op)
		{
		case 0:
			GetFunction()->SetSysVar("TerminalManagerState", "L", true);
			{
				auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::TerminalManagerOff,
					std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
				DbgEx("TerminalManagerState L, open page TerminalManagerOff %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
			}
			break;
		case 1:
			GetFunction()->SetSysVar("TerminalManagerState", "N", true);
			{
				DbgEx("TerminalManagerState N, try close TerminalManager");
				CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::TerminalManager)._to_string());
			}
			break;
		case 2:
			GetFunction()->SetSysVar("TerminalManagerState", "K", true);
			{
				auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::TerminalManagerKickOut,
					std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
				DbgEx("TerminalManagerState K, open page TerminalManagerKickOut %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
			}
			break;
		case 99:
			GetFunction()->SetSysVar("TerminalManagerState", "N", true);
			{
				DbgEx("TerminalManagerState N, try close TerminalManager");
				CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::TerminalManager)._to_string());
			}
			break;
		default:
			break;
		}
	}



	void CChromiumEntity::OnBusinessLimitTimerListener(void* pData)
	{
		DbgEx("定时任务检查业务禁用");
		// 检查是否禁用业务,做交易限制的检查
		TradeManageCodeEnum jobLimit = CModTools::get_mutable_instance().CheckJobLimited();

		DbgEx("ShowLimitScreen : TradeManageCodeEnum=%s", jobLimit._to_string());


		switch (jobLimit) {
		case TradeManageCodeEnum::Trade:
			CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::TradeManager)._to_string());
			break;
		case TradeManageCodeEnum::Disabled:
		{
			auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::disabled,
				std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
			DbgEx("TradeManageCodeEnum Disabled, open page %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
		}
		break;
		case TradeManageCodeEnum::JobUncomplete:
		{
			auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::jobuncomplete,
				std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
			DbgEx("TradeManageCodeEnum JobUncomplete, open page %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
		}
		break;
		default:
			break;
		}

		GetFunction()->ResetTimer(BROWSER_TIMER_ID, BROWSER_TIMER_INTERVAL);
	}

	void CChromiumEntity::OnBrowserCacheClean(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, ResourceWatcher::BrowserCacheClean& evt)
	{
		DbgEx("OnOnBrowserCacheClean, needClean:%d", evt.needClean);
		ErrorCodeEnum error = Error_Succeed;
		if (!evt.needClean)
			return;

		CSimpleString tmpCacheDir;
		if (Error_Succeed != (error = GetFunction()->GetPath("Temp", tmpCacheDir)) || tmpCacheDir.GetLength() == 0)
		{
			DbgEx("OnBrowserCacheClean get cache path err, %d", error);
			return;
		}
#if (defined _WIN32 || defined _WIN64)
		CModTools::get_mutable_instance().lockGuard();
		auto tmpArr = find_files(tmpCacheDir.GetData(), "cefCache*", true);
		std::shared_ptr<std::vector<std::string>> tmpDirArr(new std::vector<std::string>());
		for each (auto it in tmpArr)
			tmpDirArr.get()->push_back(it);

		auto runCacheClean = [](std::shared_ptr<std::vector<std::string>> p) ->void {
			CModTools::get_mutable_instance().StopChromiumBrowser(ERR_PAGE_REASON::breakdown, true);//close all tab
			for each (auto it in *p.get())
			{
				LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_BROWSER_CACHE_CLEAER, CSimpleStringA::Format("clear chromium browser cache %s %s", it.c_str(),
					RemoveDirRecursive(it.c_str()) ? "success" : "fail"));
			}
		};

		boost::thread CacheCleanThread(runCacheClean, tmpDirArr);
		CacheCleanThread.timed_join(boost::posix_time::microseconds(10000));

		CModTools::get_mutable_instance().unlockGuard();
#else
		//uos 由于无guard，需要重启整个chromium实体
		CModTools::get_mutable_instance().killAllChromium();
		auto tmpDirArr = find_files(tmpCacheDir.GetData(), "cefCache*", true);
		auto uosTmpDirArr = find_files(tmpCacheDir.GetData(), "UOSBrowser*", true);
		std::for_each(uosTmpDirArr.begin(), uosTmpDirArr.end(), [&](std::string tmp) {
			tmpDirArr.push_back(tmp);
			});//insert uosTmpDirArr into tmpDirArr

		for (auto it = tmpDirArr.begin(); it != tmpDirArr.end(); it++)
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_BROWSER_CACHE_CLEAER, CSimpleStringA::Format("clear chromium browser cache %s %s", it->c_str(),
				RemoveDirRecursive(it->c_str()) ? "success" : "fail"));

		if (m_pTimerListener != NULL)
		{
			GetFunction()->KillTimer(CHROMIUM_TIMER_ID);
			delete m_pTimerListener;
			m_pTimerListener = NULL;
		}
		OnPreStart_openWeb();//重新调用open web

#endif 
	}
	void CChromiumEntity::generateCefclientTimer()
	{
		if (nullptr == m_pTimerListener)
		{
			m_pTimerListener = new TimerOutHelper<CChromiumEntity>(this, &CChromiumEntity::OnTaskTimerListener, NULL, false);
			GetFunction()->SetTimer(CHROMIUM_TIMER_ID, m_pTimerListener, 2000);	//间隔执行时间
		}

	}

	void CChromiumEntity::generateBussinessLimitTimer() {
		DbgEx("Start BusinessLimitTimer");
		pBusinessLimitTimerListener = new TimerOutHelper<CChromiumEntity>(this, &CChromiumEntity::OnBusinessLimitTimerListener, NULL, false);
		GetFunction()->SetTimer(BROWSER_TIMER_ID, pBusinessLimitTimerListener, 5000);
	}

	int CChromiumEntity::getBrowserStartTimes() {
		CAutoArray<CSimpleStringA> t_names;
		CAutoArray<int> t_Idx;
		CAutoArray<CEntityStartInfo> t_Infos;
		GetFunction()->GetAllEntityStartInfo(t_names, t_Idx, t_Infos);
		for (int i = 0; i < t_names.GetCount(); i++)
		{
			if (t_names[i] == GetEntityName())
				return t_Infos[i].startTimes;
		}
		return -1;
	}

	void CChromiumEntity::checkUrlStartTime() {
		std::string startTimeStr = boost::posix_time::to_iso_extended_string(boost::posix_time::microsec_clock::local_time());
		int pos = startTimeStr.find('T');
		startTimeStr.replace(pos, 1, std::string(" "));
		pos = startTimeStr.find('.');
		startTimeStr.replace(pos, 1, std::string(":"));
		auto urlStartTime = boost::posix_time::microsec_clock::universal_time();
		while (!m_firstStartMain.try_lock_for(boost::chrono::seconds(30)))
			Dbg("wait 30s, but slv did not start");
		auto urlEndTime = boost::posix_time::microsec_clock::universal_time();
		auto timeDuration = urlEndTime - urlStartTime;
		Dbg("slv start at %s, used %d ms", startTimeStr.c_str(), timeDuration.total_milliseconds());
		if (1 == getBrowserStartTimes())
		{
			auto generateAlarmJson = [](CSimpleString entityName, CSimpleString startTime, int cost) ->CSimpleString {
				return CSimpleString::Format("[{\"name\":\"%s\",\"time\":\"%s\",\"cost\":%d}]", entityName.GetData(), startTime.GetData(), cost);
			};
			LogWarn(Severity_Low, Error_Debug, LOG_TRACE_ENTITY_START_TIME, generateAlarmJson("slv", startTimeStr.c_str(), timeDuration.total_milliseconds()).GetData());
		}
		m_firstStartMain.unlock();
	};

    void CChromiumEntity::DoBrowserCacheClearJob()
    {
#if (defined _WIN32 || defined _WIN64)
#else
        LOG_FUNCTION();

        CSmartPointer<IConfigInfo> spConfig;
        ErrorCodeEnum err = GetFunction()->OpenConfig(Config_Cache, spConfig);
        CSimpleStringA str(true);
        err = spConfig->ReadConfigValue("Browser", "CacheClear", str);
        if (str.Compare("true", true) == 0) {

            BOOL bSucc(FALSE);
            CSimpleStringA strCachePath;
            GetFunction()->GetPath("Temp", strCachePath);
            if (!strCachePath.IsNullOrEmpty()) {

                bSucc = TRUE;

                const char* cacheDirs[] = { "cefCache", "cefCache_Ad", "cefCache_breakdown","cefCache_ErrNotify", "cefCache_main"
                    , "UOSBrowser_Ad", "UOSBrowser_main"
					, "UOSBrowserConfig_Ad", "UOSBrowserConfig_main"
                , "UOSBrowser2_Ad", "UOSBrowser2_main"
                    , "UOSBrowserConfig2_Ad", "UOSBrowserConfig2_main" };
				const int cacheDirsLength = (5 + 4 + 4);

                for (int i = 0; i < cacheDirsLength; ++i) {
                    CSimpleStringA strcefCachePath(strCachePath);
                    strcefCachePath += SPLIT_SLASH_STR;
                    strcefCachePath += cacheDirs[i];

                    if (ExistsDirA(strcefCachePath)) {
                        RemoveDirRecursiveA(strcefCachePath);
                        LogWarn(Severity_Low, Error_Debug, LOG_EVT_CHROMIUM_BROWSER_CACHE_CLEAER,
                                CSimpleStringA::Format("clear chromium browser cache: %s", strcefCachePath.GetData()));
                    }
                }
            }

            if (bSucc) {
                spConfig->WriteConfigValue("Browser", "CacheClear", NULL);
            }
        }
#endif
    }

    void CChromiumEntity::OnTaskTimerListener(void* pData)
	{
		static int max_restartTime = 3;
		DbgEx("OnTaskTimerListener");
		if (max_restartTime == 0)
		{
			DbgEx("max_restartTime == 0, do not restart chromium");
			GetFunction()->KillTimer(CHROMIUM_TIMER_ID);
			return;
		}

		static bool t_firstStartMain = true;
		if (t_firstStartMain)
		{
			t_firstStartMain = false;
			m_firstStartMain.lock();
			boost::thread(boost::bind(&CChromiumEntity::checkUrlStartTime, this)).detach();
		}

		auto rc = CModTools::get_mutable_instance().StartChromiumBrowser();
		max_restartTime--;
		DbgEx("TaskTimerListen, startChromiumBrowser, rc:%d, pid:%d", rc.first, rc.second);
		if (0 == rc.first)
			GetFunction()->KillTimer(CHROMIUM_TIMER_ID);

#if (defined _WIN32 || defined _WIN64)
		if (rc.first == Error_Succeed && rc.second != 0)
		{

			HANDLE defaultProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, rc.second);
			if (defaultProcess == nullptr)
			{
				DbgEx("OnTaskTimerListener, openProcess failed");
				return;
			}
			auto ret = assigntoJob(defaultProcess, rc.second);
			if (!ret.first)
				DbgEx("OnTaskTimerListener, assigntoJob failed");
			else
			{
				auto monitorThread = [&](HANDLE job, HANDLE process) {
					while (1)
					{
						if (WaitForSingleObject(process, 10) != WAIT_OBJECT_0)	//process end
							DbgEx("default cefclient.exe job:%d, process:%d checkOpen", job, process);
						else
						{
							DbgEx("default cefclient.exe job:%d, process:%d check Closed, try to restart", job, process);

							TerminateJobObject(job, 0);
							max_restartTime--;
							generateCefclientTimer();
							break;
						}
						boost::this_thread::sleep_for(boost::chrono::seconds(10));
					}
				};
				if (ret.second != nullptr && defaultProcess != nullptr)
					boost::thread(monitorThread, ret.second, defaultProcess).detach();

			}

		}


		if (Error_Succeed != rc.first)
		{
			DbgEx("OnTaskTimerListener will be called after %d secs, rest restart time %d", 15, max_restartTime);
			if (max_restartTime)
				GetFunction()->ResetTimer(CHROMIUM_TIMER_ID, 15000);
		}
		else {
			DbgEx("OnTaskTimerListener rc = succeed");
			GetFunction()->KillTimer(CHROMIUM_TIMER_ID);
		}
#endif
	}

	SP_BEGIN_ENTITY_MAP()
		SP_ENTITY(CChromiumEntity)
		SP_END_ENTITY_MAP()

}