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 "\\"
#else
#include <signal.h>
#include "toolkit.h"
#include "path.h"
#include "fileutil.h"
#endif
#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 "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"
/*
#define LOG_EVT_BEGIN_CAMERA_CONFIG    0x21D00001
#define LOG_EVT_END_CAMERA_CONFIG      0x21D00002
*/

/*no use
#define MSG_EVT_STARTACTIVECAPTURE    0x31400001    //开始主动活体
#define MSG_EVT_STOPACTIVECAPTURE     0x31400002    //停止主动活体
#define LOG_EVT_SHOWACTIVECAPTUREMSG  0x31400003    //显示主动活体提示消息
#define CLIENT_MANAGER_PATH "c:\\Program Files\\CmbWinPad\\CmbWinPad.exe"
*/


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



namespace Chromium {

	void ChromiumSession::Handle_OpenBrowser(SpReqAnsContext<ChromiumSrv_OpenBrowser_Req, ChromiumSrv_OpenBrowser_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_pEntity->OpenBrowser(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)
	{
		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::OpenBrowser(SpReqAnsContext<ChromiumSrv_OpenBrowser_Req, ChromiumSrv_OpenBrowser_Ans>::Pointer ctx)
    {
        CSimpleStringA strUrl = ctx->Req.mainUrl;
        CSimpleStringA 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()));
        ErrorCodeEnum result = ret.first;
        DbgEx("open request browser page %s return %d", (LPCTSTR)strUrl, result);

        ctx->Answer(result);
}

	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

			FetchCustomMainUrl(strArgs);

			CModTools::get_mutable_instance().InitCModTools(this);
			CModTools::get_mutable_instance().killAllChromium();

			DoBrowserCacheClearJob();

#if (defined _WIN32 || defined _WIN64)
#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

			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;
						}
#if (defined _WIN32 || defined _WIN64)
#else
						m_runAd = m_runMain = true;
						m_runExtend = m_runLogin = m_withBrowser = m_withMin = 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_sysInfo.strMachineType.GetData(), webMaskKey.GetData(), webMaskStr.GetData(), m_runAd, m_runMain, m_runExtend, m_runLogin, m_withBrowser
						,m_withMin, m_withClose);
						
						if (m_withMin)
							CModTools::get_mutable_instance().setWithMin(m_withMin);
						if (m_withClose)
							CModTools::get_mutable_instance().setWithClose(m_withClose);
					}
					else
						DbgEx("can not find %s, use default", webMaskKey.GetData());
				}
				if (!m_runAd && !m_runMain && !m_runExtend && !m_withBrowser && !CModTools::get_mutable_instance().IsConfigWork())
				{
					DbgEx("can not open centerSetting, maybe fault");
					if (!(m_sysInfo.strMachineType.IsEndWith("PAD", true) || m_sysInfo.strMachineType.IsEndWith("Stand2S", true)))
					{
						m_withBrowser = true;
						DbgEx("since is %s, so m_withBrowser:%d", m_sysInfo.strMachineType.GetData(), m_withBrowser);
					}

				}
	#if (defined _WIN32 || defined _WIN64)
				if (!logProducer)
					logProducer = create_log_producer_storage("cefclient", "0", "");
	#endif

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

	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;

		//与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!"); //非必须
		}



		if (!m_withBrowser)
		{//有browser的时候不需要订阅这一堆
			Error = GetFunction()->SubscribeLog(m_uuidAccessAuth, this, Log_Event, Severity_None, Error_IgnoreAll, -1, "AccessAuthorization");
			if (Error != Error_Succeed)
				DbgEx("subscribe AccessAuthorization log failed!");
			else
				DbgEx("subscribe AccessAuthorization success!");


			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!");
		}


#if (defined _WIN32 || defined _WIN64)
		//未定义Log_Notify
#else
		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

		return true;
}

	bool CChromiumEntity::OnPreStart_openWeb(CAutoArray<CSimpleStringA>& strArgs, CSmartPointer<ITransactionContext>& pTransactionContext)
	{
		//generateBussinessLimitTimer();
		if (m_runAd) openAdPage();
		if (m_runExtend) openExtendPage();

		if (m_runMain)
		{
			//openMainPage(); return true;
			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 ('X' == t_terminalState[0])
				{
					DbgEx("do not begin accessAuth, terminalStage X, do nothing.");
				}
				else if (!m_withBrowser)
				{
					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
				openMainPage();

		}

		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)) {
			return;
		}
		if (!IsConfigMode()) {
			if (!OnPreStart_register(strArgs, pTransactionContext)) {
				return;
			}
			if (!OnPreStart_openWeb(strArgs, pTransactionContext)) {
				return;
			}
		}
		
		pTransactionContext->SendAnswer(Error_Succeed);
	}

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

	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);
		if ((strnicmp(pszKey, "UIState", strlen("UIState")) == 0))
		{
			if (strnicmp(pszValue, "M", strlen("M")) == 0)
			{
				static bool firstEnter = true;
				if (firstEnter)
				{
					firstEnter = false;
					DbgEx("first Enter main page");
					m_firstStartMain.unlock();
				}
				GetFunction()->UnregistSysVarEvent("UIState");
			}
		}
		else if (0 == CSimpleStringA("TerminalStage").Compare(pszKey, true))
		{
			if (0 == CSimpleStringA("A").Compare(pszValue, true))
			{
				if(CModTools::get_mutable_instance().IsConfigWork())//url正常时才关闭
				{
					CModTools::get_mutable_instance().StopChromiumBrowser(ERR_PAGE_REASON::breakdown);
					openMainPage();
					//DbgEx("UnregistSysVarEvent TerminalStage %s", Error_Succeed == GetFunction()->UnregistSysVarEvent("TerminalStage") ? "success" : "fail");
				}				
			}
			else if (0 == CSimpleStringA("X").Compare(pszValue, true))
				DbgEx("TerminalStage X, do nothing.");
			else
			{
				if (!m_withBrowser)
				{
					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 (0 == CSimpleStringA("CardStoreInUse").Compare(pszKey, true) && CheckIsCardStore())
		{
			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);
		}

	}

	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)
    {
        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_High, 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_High, Error_Debug, LOG_EVT_CHROMIUM_DETECT_CUSTOM_FULTURE_URL_FROM_CONFIG,
							CSimpleStringA::Format("从本地维护桌面获取自定义链接：%s", m_strCustomMainUrl.GetData()));
				}
			}
		}
    }

#if (defined _WIN32 || defined _WIN64)
	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)
#else
	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)
#endif
	{
		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
		switch (dwUserCode)
		{
		case LOG_EVT_BEGIN_CAMERA_CONFIG://no use
		{
			auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::CameraConfig,
				std::tuple < std::string, std::string>(m_sysInfo.strTerminalID.GetData(), generateTimeStr()));
			DbgEx("show Screen Camera config, open page cameraconfig %s, %d", Error_Succeed == openRet.first ? "success" : "fail", openRet.second);
		}
		break;
		case LOG_EVT_END_CAMERA_CONFIG://no use
			DbgEx("end show Screen Camera config, close page cameraconfig");
			CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::CameraConfig)._to_string());
			break;
		default:
			break;
		}
	}

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

#if (defined _WIN32 || defined _WIN64)
	void CChromiumEntity::OnCustomerCmd(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, IEBrowser::CustomerCmd& evt)
	{
		DbgEx("OnCustomerCmd %s", evt.cmdStr);
	}
#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()
    {
        LOG_FUNCTION();

        CSmartPointer<IConfigInfo> spConfig;
        ErrorCodeEnum err = GetFunction()->OpenConfig(Config_Run, 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" };

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

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

                }
            }

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

    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()

}