myvtm/Module/mod_chromium/mod_chromium.cpp

#if (defined _WIN32 || defined _WIN64)
#include "stdafx.h"
#include <Windows.h>
#include <WinUser.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 "path.h"
#include "guitask/guitask.h"
#include "EventCode.h"
#include "../mod_upload/Upload_client_g.h"


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

#define LOG_EVT_SELFCHECK_ASSISTANTCHANNEL_IDLE		0x50500001  //协助通道重启
//#define EVENT_UKEY_PULLOUT  0x21000008		// 证书拔出	0x21000008	1	检测到维护证书拔出，用于驱动本地维护状态
#define LOG_EVT_BEGIN_CAMERA_CONFIG    0x21D00001
#define LOG_EVT_END_CAMERA_CONFIG      0x21D00002
#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"


namespace Chromium {

	CChromiumEntity::CChromiumEntity() :m_pWsServer(NULL), m_iTcpBridgePort(4504), m_pTimerListener(NULL)
	{
		DbgEx("CChromiumEntity constructor");

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

	}

	CChromiumEntity::~CChromiumEntity()
	{
		if (NULL != m_pWsServer)
		{
			free(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:
					Dbg("Job time limit reached");
					break;

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

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

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

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

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

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

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

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

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

	void CChromiumEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		GetFunction()->GetSystemStaticInfo(m_sysInfo);

		ErrorCodeEnum Error;
		Error = GetFunction()->StartTcpBridgeServer(m_iTcpBridgePort);
#if (defined _WIN32 || defined _WIN64)
		Error = GetFunction()->SubscribeBroadcast("IEBrowser", "CustomerCmd", this, m_uidBrowserListenser);
		if (Error != Error_Succeed) {
			LOG_TRACE("subscribe browser CustomerCmd failed!");
			pTransactionContext->SendAnswer(Error);
		}
		else
			LOG_TRACE("subscribe browser CustomerCmd success!");
#endif

		if (Error != Error_Succeed)
		{
			LOG_TRACE("start tcp bridge server failed!");
			pTransactionContext->SendAnswer(Error);
			return;
		}
		CModTools::get_mutable_instance().InitCModTools(this);
		CModTools::get_mutable_instance().killAllChromium();
		// 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();

		try {
			chromiumRpcTask::get_mutable_instance().openrpcServer(DEFAULT_CHROMIUM_RPCPORT);
			DbgEx("start rpcTask in port %d", DEFAULT_CHROMIUM_RPCPORT);
		}
		catch (...) {
			DbgEx("open rpcTask failed");
		}

		/*低柜
		//LOG_EVT_BEGIN_CAMERA_CONFIG, LOG_EVT_END_CAMERA_CONFIG
		Error = GetFunction()->SubscribeLog(m_uidCameraListener, this, Log_Event, Severity_None, Error_IgnoreAll, -1, "CameraConfigManage");
		if (Error != Error_Succeed)
			LOG_TRACE("subscribe Camera log failed!"); //非必须
			*/
		Error = GetFunction()->SubscribeLog(m_uuidAccessAuth, this, Log_Event, Severity_None, Error_IgnoreAll, -1, "AccessAuthorization");
		if (Error != Error_Succeed)
			LOG_TRACE("subscribe AccessAuthorization log failed!"); 
		else
			LOG_TRACE("subscribe AccessAuthorization success!");
		GetFunction()->SubscribeLog(m_uuidAccessAuth, this, Log_Error, Severity_None, Error_IgnoreAll, -1, "AccessAuthorization");

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

		generateBussinessLimitTimer();

		// 按照单屏方式
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	void CChromiumEntity::OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName)
	{
		if ((_strnicmp(pszKey, "UIState", strlen("UIState")) == 0))
		{
			if (_strnicmp(pszValue, "M", strlen("M")) == 0)
			{
				static bool firstEnter = true;
				if (firstEnter)
				{
					firstEnter = false;
					Dbg("first Enter main page");
				}
			}


		}
	}

	void CChromiumEntity::OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		if (m_pTimerListener != NULL)
		{
			GetFunction()->KillTimer(CHROMIUM_TIMER_ID);
			delete m_pTimerListener;
			m_pTimerListener = NULL;
		}
		GetFunction()->UnsubscribeBroadcast("IEBrowser");
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	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)
	{
		switch (dwUserCode)
		{
		case LOG_EVT_BEGIN_CAMERA_CONFIG:
		{
			auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::CameraConfig);
			Dbg("show Screen Camera config, open page cameraconfig, %d", openRet.first);
		}
			break;
		case LOG_EVT_END_CAMERA_CONFIG:
			Dbg("end show Screen Camera config, close page cameraconfig");
			CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::CameraConfig)._to_string());
			break;
		case EVENT_ACCESSAUTH_SUCCEED:
			Dbg("access auth success, open page mainurl");
			{
				CSystemRunInfo sysruninfo;
				GetFunction()->GetSystemRunInfo(sysruninfo);
				if (!(sysruninfo.dwBootOption & SystemBootOptionEnum::BootOption_Test))
					generateCefclientTimer();//非--test时，才会打开浏览器
			}
			break;
		case ERR_ACCESSAUTH_FAILED:
		case ERR_ACCESSAUTH_TIMEOUT:
		{
			auto openRet = CModTools::get_mutable_instance().StartChromiumBrowser(ERR_PAGE_REASON::breakdown);
			Dbg("access failed, open page breakdown, %d", openRet.first);
		}
			break;
		default:
			break;
		}
	}

	void CChromiumEntity::OnTerminalManage(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, HealthManager::TerminalManager& evt)
	{
		Dbg("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);
				Dbg("TerminalManagerState L, open page TerminalManagerOff, %d", openRet.first);
			}
			break;
		case 1:
			GetFunction()->SetSysVar("TerminalManagerState", "N", true);
			{
				Dbg("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);
				Dbg("TerminalManagerState K, open page TerminalManagerKickOut, %d", openRet.first);
			}
			break;
		case 99:
			GetFunction()->SetSysVar("TerminalManagerState", "N", true);
			{
				Dbg("TerminalManagerState N, try close TerminalManager");
				CModTools::get_mutable_instance().killChromiumByName((+PAGE_TYPE::TerminalManager)._to_string());
			}
			break;
		default:
			break;
		}
	}

	// 输入为北京时间 输出为北京时间戳
	int CChromiumEntity::StandardToStamp(const char* str_time, bool dateOnly)
	{
		Dbg("StandardToStamp str = %s", str_time);
		struct tm stm;
		int iY, iM, iD, iH, iMin, iS;

		// 检查有效性
		if ('-' != str_time[4] || '-' != str_time[7])
		{
			return 0;
		}

		memset(&stm, 0, sizeof(stm));
		iY = atoi(str_time);
		iM = atoi(str_time + 5);
		iD = atoi(str_time + 8);
		if (dateOnly)
		{
			iH = 0;
			iMin = 0;
			iS = 0;
		}
		else {
			iH = atoi(str_time + 11);
			iMin = atoi(str_time + 14);
			iS = atoi(str_time + 17);
		}

		stm.tm_year = iY - 1900;
		stm.tm_mon = iM - 1;
		stm.tm_mday = iD;
		stm.tm_hour = iH;
		stm.tm_min = iMin;
		stm.tm_sec = iS;

		/*printf("%d-%0d-%0d %0d:%0d:%0d\n", iY, iM, iD, iH, iMin, iS);*/   //标准时间格式例如：2016:08:02 12:12:30
		return (int)mktime(&stm);
	}

	TradeManageCodeEnum CChromiumEntity::CheckJobLimited() {
		/*if (!isOutsidePad())
		{
			return Undefined;
		}*/
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum BootTimeCfgError = GetFunction()->OpenConfig(Config_Run, spConfig);
		CSimpleStringA strLastRecordTime = "", strControl = "", strExpirationDate = "";
		time_t now = time(0);
		localtime(&now);
		ErrorCodeEnum errorRead = Error_Succeed;
		errorRead = spConfig->ReadConfigValue("Record", "LastRecordTime", strLastRecordTime);
		if (errorRead != Error_Succeed)
		{
			Dbg("Read Record LastRecordTime -> Failed! Maybe LastRecordTime not exist!");
			strLastRecordTime = "";
		}

		errorRead = spConfig->ReadConfigValue("Record", "Control", strControl);
		if (errorRead != Error_Succeed)
		{
			Dbg("Read Record Control -> Failed! Maybe Control not exist!");
			strControl = "";
		}

		errorRead = spConfig->ReadConfigValue("Record", "ExpirationDate", strExpirationDate);
		if (errorRead != Error_Succeed)
		{
			Dbg("Read Record ExpirationDate -> Failed! Maybe ExpirationDate not exist!");
			strExpirationDate = "";
		}
		if (strControl.Compare("on") == 0)
		{
			// 控制标识为on时，检查过期时间，过期时间之前都设置为启用
			if (strExpirationDate == "")
			{
				Dbg("CheckJobLimited -> on -> strExpirationDate=null ");
				CModTools::get_mutable_instance().setLimitReason("");
				return TradeManageCodeEnum::Trade;
			}
			int timestamp_expiration = StandardToStamp(strExpirationDate.Append(" 23:59:59"), false);

			if (now < timestamp_expiration)
			{
				// 过期之前都可以进行交易
				Dbg("CheckJobLimited -> on -> strExpirationDate>now ");
				CModTools::get_mutable_instance().setLimitReason("");
				return TradeManageCodeEnum::Trade;
			}
			else {
				// 过期之后 设置为normal
				Dbg("CheckJobLimited -> on -> strExpirationDate<now -> control to normal");
				spConfig->WriteConfigValue("Record", "Control", "normal");
				strControl = "normal";
				Dbg("过期之后 设置为normal");
			}
		}

		if (strControl.Compare("off") == 0)
		{
			// 展示交易暂停页面
			Dbg("CheckJobLimited -> off ");
			CModTools::get_mutable_instance().setLimitReason("disabled");
			return TradeManageCodeEnum::Disabled;
		}

		if (strControl.Compare("normal") == 0 || strControl.IsNullOrEmpty())
		{
			if (strLastRecordTime == "")
			{
				Dbg("CheckJobLimited -> normal -> strLastRecordTime=null ");
				CModTools::get_mutable_instance().setLimitReason("");
				return TradeManageCodeEnum::Trade;
			}
			int timestamp_lastRecordTime = StandardToStamp(strLastRecordTime, true);

			if (now < timestamp_lastRecordTime + 3600 * 24 * 2)
			{
				Dbg("CheckJobLimited -> normal -> now < lastRecordTime + 3600*24*2 ");
				CModTools::get_mutable_instance().setLimitReason("");
				return TradeManageCodeEnum::Trade;
			}
			else if (CheckTradeRecord()) {
				// 展示交易暂停页面
				Dbg("CheckJobLimited -> normal -> now < CheckTradeRecord = true ");
				CModTools::get_mutable_instance().setLimitReason("jobuncomplete");
				return TradeManageCodeEnum::JobUncomplete;
			}
		}
		// 理论上不会流转到这里来
		CModTools::get_mutable_instance().setLimitReason("");
		return TradeManageCodeEnum::Trade;
	}

	bool CChromiumEntity::CheckTradeRecord() {
		std::list<int> timeList;

		using namespace Upload;
		UploadService_ClientBase* pClient = new UploadService_ClientBase(this);
		auto rc = pClient->Connect();
		if (rc != Error_Succeed)
		{
			Dbg("connect to Upload entity fail: %d", rc);
		}
		else
		{
			UploadService_UploadDateList_Req req = {};
			UploadService_UploadDateList_Ans ans = {};

			rc = pClient->UploadDateList(req, ans, 10000);

			if (rc != Error_Succeed)
			{
				Dbg("UploadDateList fail from Upload: %d", rc);
			}
			else
			{
				Dbg("UploadDateList succeed from Upload");
				for (int i = 0; i < ans.uploadDateStr.GetCount(); ++i)
				{
					CSimpleStringA str = (CSimpleStringA)ans.uploadDateStr[i];
					int t = StandardToStamp(ans.uploadDateStr[i], true);
					timeList.push_back(t);
				}
			}

			pClient->SafeDelete();
			pClient = NULL;
		}

		// 比较时间戳 登记时间 <= 列表时间 < 今天 返回true
		time_t now = time(0);
		localtime(&now);
		now -= now % (3600 * 24);
		now -= 3600 * 8; //处理东八区问题
		CSmartPointer<IEntityFunction> spFunction = GetFunction();
		CSmartPointer<IConfigInfo> spConfig;
		ErrorCodeEnum BootTimeCfgError = spFunction->OpenConfig(Config_Run, spConfig);
		CSimpleStringA strLastRecordTime = "";
		ErrorCodeEnum errorRead = Error_Succeed;
		errorRead = spConfig->ReadConfigValue("Record", "LastRecordTime", strLastRecordTime);
		if (errorRead != Error_Succeed)
		{
			Dbg("Read Record LastRecordTime -> Failed! Maybe LastRecordTime not exist!");
			strLastRecordTime = "";
		}

		int timestamp_lastRecordTime = now;
		if (!strLastRecordTime.IsNullOrEmpty())
		{
			timestamp_lastRecordTime = StandardToStamp(strLastRecordTime, false);
		}
		for (std::list<int>::iterator it = timeList.begin(); it != timeList.end(); ++it)
		{
			if (timestamp_lastRecordTime <= *it && *it < now)
			{
				Dbg("CheckTradeRecord lastRecordTime=%d, time_list=%d, now=%d", timestamp_lastRecordTime, *it, now);
				return true;
			}
		}
		return false;
	}

	void CChromiumEntity::OnBusinessLimitTimerListener(void* pData)
	{
		Dbg("定时任务检查业务禁用");
		// 检查是否禁用业务
		//ShowLimitScreen();
		GetFunction()->ResetTimer(BROWSER_TIMER_ID, BROWSER_TIMER_INTERVAL);
	}

	void CChromiumEntity::CefClintNotify()
	{
#if(defined _WIN32 || defined _WIN64)
		while (1)
		{
			for (auto it = m_cefArr.begin(); it != m_cefArr.end(); it++)
			{

				if (WaitForSingleObject(std::get<1>(it->second), 10) != WAIT_OBJECT_0)	//process end
					DbgEx("cefclient.exe tag:%s job:%d, process:%d checkOpen", it->first.c_str(), std::get<0>(it->second), std::get<1>(it->second));
				else
				{
					DbgEx("cefclient.exe tag:%s job:%d, process:%d check Closed, try to restart", it->first.c_str(), std::get<0>(it->second), std::get<1>(it->second));
					auto info = it->first;
					auto cmdline = std::get<2>(it->second);//save the param

					TerminateJobObject(std::get<0>(it->second), 0);

					m_cefArr.erase(it->first);

					auto startRet = startProcessInJob(cmdline, "");
					if (std::get<0>(startRet))
						m_cefArr.insert(std::make_pair(info, std::make_tuple(std::get<1>(startRet), std::get<2>(startRet), cmdline)));
					break;
				}
			}
			boost::this_thread::sleep_for(boost::chrono::seconds(10));
		}
#endif
	}
#if (defined _WIN32 || defined _WIN64)
	void CChromiumEntity::OnCustomerCmd(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, IEBrowser::CustomerCmd& evt)
	{
		DbgEx("OnCustomerCmd %s", evt.cmdStr);
		static std::pair<int, std::string> historyChromium;
		auto jsDeletor = [](cJSON* p) {
			cJSON_Delete(p);
		};
		std::unique_ptr<cJSON, decltype(jsDeletor)> cmdJs(cJSON_Parse(evt.cmdStr), jsDeletor);
		auto cmdStr = cJSON_GetObjectItem(cmdJs.get(), "command")->valuestring;

		auto chromiumCLoseInJob = [&](std::string closeJob) -> bool {
			auto it = m_cefArr.find(closeJob);
			if (m_cefArr.end() != it)
			{
				TerminateJobObject(std::get<0>(it->second), 0);
				m_cefArr.erase(closeJob);
				return true;
			}
			else
			{
				DbgEx("m_cefArr can not find %s", closeJob.c_str());
				return false;
			}
		};

		if (!strcmp(cmdStr, "ChromiumStart"))
		{
			auto info = cJSON_GetObjectItem(cmdJs.get(), "info")->valuestring;
			auto fullscreen = cJSON_GetObjectItem(cmdJs.get(), "fullscreen")->valueint;
			auto top = cJSON_GetObjectItem(cmdJs.get(), "top")->valueint;
			// 感觉应当通过FreeRDP来启动Chromium，不应该自己管理
			// 需要保存启动的chromium的句柄值或者进程Id，通过该进程Id来获取句柄管理chromium运行
			// 因为有多个chromium，此时对每一个H5页面，都保存连接。并无法感知到某一个chromium的连接都不存在来重启chromium

			chromiumCLoseInJob(info);

			CSmartPointer<IConfigInfo> spCerConfig;
			GetFunction()->OpenConfig(Config_CenterSetting, spCerConfig);

			CSimpleString UserMgrUrlFulture;
			SpIniMappingTable table;
			// clean cache every time
			table.AddEntryString(GetEntityName(), "UserMgrUrlFulture", UserMgrUrlFulture, "");
			if (Error_Succeed != table.Load(spCerConfig))
			{
				DbgEx("load UserMgrUrlFulture failed");
				return;
			}

			CSimpleStringA strChromiumPath;
			GetFunction()->GetPath("Base", strChromiumPath);
			strChromiumPath.Append("\\bin\\Chromium\\");

			auto checkHttpThread = boost::async(boost::bind(checkHttpThreadFun, UserMgrUrlFulture.GetData()));
			checkHttpThread.wait_for(boost::chrono::seconds(1));

			Dbg("%s http check %s", UserMgrUrlFulture.GetData(), (checkHttpThread.is_ready() && checkHttpThread.get()) ? "sucess" : "failed");

			CSimpleStringA cachePath;
			GetFunction()->GetPath("Temp", cachePath);
			cachePath.Append("\\cefCache");

			CSimpleStringA strCmdLine = "";
			strCmdLine.Append(strChromiumPath).Append("cefclient.exe --url=").Append(UserMgrUrlFulture);
			strCmdLine.Append(" --hide-controls=true --cache-path=").Append(cachePath);
			strCmdLine.Append(" --logExtend=").Append(info).Append(" --top=").Append(std::to_string((LONGLONG)top).c_str());
			if (fullscreen)
				strCmdLine.Append(" --fullscreen");

			DbgEx("ChromiumStart cmdline : %s", strCmdLine);



			//control cefclient throught job
			auto startRet = startProcessInJob(strCmdLine.GetData(), "");
			if (std::get<0>(startRet))
				m_cefArr.insert(std::make_pair(info, std::make_tuple(std::get<1>(startRet), std::get<2>(startRet), strCmdLine.GetData())));
			else
				DbgEx("startProcessInJob failed!");
		}
		else if (!strcmp(cmdStr, "ChromiumClose"))
		{
			auto info = cJSON_GetObjectItem(cmdJs.get(), "info")->valuestring;



			chromiumCLoseInJob(info);
		}
	}
#endif

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

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


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


		//基于Desk2S功能判断，当当前并未启动cefclient时，对cefclient.exe进行清理
		if (0 == m_cefArr.size())
			DbgEx("kill chromium %s", CModTools::get_mutable_instance().killAllChromium() ? "success" : "fail");

		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();
							//modTools.StartChromiumBrowser();
							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()

}