命名空间大写；

SATService/SATService/Global.cpp

@@ -21,7 +21,7 @@
 #pragma comment(lib, "SetupAPI.lib")
 
 
-namespace Global
+namespace GLOBAL
 {
 	STSATConfig g_stSATConfig;
 	//////////////////////////////////////////////////////////////////////////
@@ -44,7 +44,7 @@ namespace Global
 	TCHAR g_szDBPassWord[MAX_PATH];				// 数据库登录密码;
 	TCHAR g_szDBName[MAX_PATH];					// 数据库名称;	
 
-	CHAR g_szKeyPath[MAX_PATH];					// 加密狗USB位置;
+	std::string g_szIPAddress;
 
 	//////////////////////////////////////////////////////////////////////////
 	std::string g_strMacs;
@@ -1174,7 +1174,6 @@ namespace Global
 
 	std::string GetLocalAddress(int nType/*= MIB_IF_TYPE_ETHERNET*/)
 	{
-		std::string strAddress;
 		int nCardNo = 1;
 		// PIP_ADAPTER_INFO结构体指针存储本机网卡信息 
 		PIP_ADAPTER_INFO pIpAdapterInfo = new IP_ADAPTER_INFO();
@@ -1209,7 +1208,7 @@ namespace Global
 				IP_ADDR_STRING*pIpAddrString = &(pIpAdapterInfo->IpAddressList);
 				if ( pIpAdapterInfo->Type == nType )
 				{
-					strAddress = pIpAddrString->IpAddress.String;
+					g_szIPAddress = pIpAddrString->IpAddress.String;
 					break;
 				}
 #if 0
@@ -1245,7 +1244,7 @@ namespace Global
 			delete pIpAdapterInfo;
 		}
 
-		return strAddress;
+		return g_szIPAddress;
 	}
 
 	INT GetMacAddress()
@@ -1340,7 +1339,7 @@ namespace Global
 		for (; it != g_vtMac.end(); it++)
 		{
 			g_strMacs.append(it->szMacAddress);
-			g_strMacs.append("&");
+			break;
 		}
 #endif
 

SATService/SATService/Global.h

@@ -31,7 +31,7 @@ typedef string TString;
 typedef wstring TString;
 #endif
 
-namespace Global
+namespace GLOBAL
 {
 	typedef struct __ST_SAT_CFG__ 
 	{
@@ -86,7 +86,7 @@ namespace Global
 	extern TCHAR g_szFna[_MAX_FNAME];
 	extern TCHAR g_szExt[_MAX_EXT];
 
-
+	extern std::string g_szIPAddress;
 
 	//////////////////////////////////////////////////////////////////////////
 	// Íø¿¨ÀàÐÍ;

SATService/SATService/SATDevices.cpp

@@ -4,7 +4,7 @@
 bool CSATDevices::s_bEnableAndroid = true;
 ULONGLONG CSATDevices::s_ulEraseDuration = 30000;
 ThreadSection CSATDevices::s_ThreadSection;
-std::vector<STDevice> CSATDevices::s_vtDevices;
+std::vector<SATDEV::STDevice> CSATDevices::s_vtDevices;
 
 void Split(vector<std::string>& vtLine, std::string strLines, const std::string strSplit)
 {
@@ -87,19 +87,18 @@ CSATDevices::CSATDevices(void)
 
 CSATDevices::~CSATDevices(void)
 {
+	EndofWork();
 }
 
 void CSATDevices::StartWork()
 {
 	m_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-	if ( m_hEvent == NULL )
-	{
+	if ( m_hEvent == NULL ) {
 		return;
 	}
 
 	m_hWorkThread = CreateThread(NULL, 0, WorkThread, this, 0, NULL);
-	if ( m_hWorkThread == NULL)
-	{
+	if ( m_hWorkThread == NULL) {
 		SetEvent(m_hEvent);
 		CloseHandle(m_hEvent);
 		CloseHandle(m_hWorkThread);
@@ -138,7 +137,7 @@ DWORD CSATDevices::WorkThread(LPVOID lpVoid)
 			continue;
 
 		// 刷新当前设备列表;
-		std::vector<STDevice> vtDevices;
+		std::vector<SATDEV::STDevice> vtDevices;
 #ifdef _DEBUG
 		printf("GetCurrentDevices\n");
 #endif
@@ -146,9 +145,9 @@ DWORD CSATDevices::WorkThread(LPVOID lpVoid)
 		GetCurrentDevices(vtDevices);
 
 		// 遍历设备列表是否有下线设备;
-		std::vector<STDevice>::iterator it = s_vtDevices.begin();
+		std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 		for ( ;it != s_vtDevices.end(); ) {
-			if ( it->nType == Virtual ) {
+			if ( it->nType == SATDEV::Virtual ) {
 				it++;
 				continue;
 			}
@@ -161,19 +160,19 @@ DWORD CSATDevices::WorkThread(LPVOID lpVoid)
 					// 移除设备(需要线程加锁);
 					it = s_vtDevices.erase(it);
 				} else {
-					if ( it->nType == Reticle ) {
-						if ( it->nStatus == Offline ) {
+					if ( it->nType == SATDEV::Reticle ) {
+						if ( it->nStatus == SATDEV::Offline ) {
 							// offline只能reconnect才能重连;
 							std::string str = "adb reconnect ";
 							str.append(it->strName);
 							WinExec(str.c_str(), SW_HIDE);
 						} 
-						else if ( it->nStatus == Dropline ) {
+						else if ( it->nStatus == SATDEV::Dropline ) {
 							std::string str = "adb connect ";
 							str.append(it->strName);
 							WinExec(str.c_str(), SW_HIDE);
 						}
-					} else if ( it->nType == Usb ) {
+					} else if ( it->nType == SATDEV::Usb ) {
 						// 如果是usb的话,可能要kill-server,再全部重连接;
 						WinExec("adb kill-server", SW_HIDE);
 						// 重连所有;
@@ -196,11 +195,11 @@ void CSATDevices::DelDevices(std::string name)
 {
 	std::string str;
 	AutoThreadSection ats(&s_ThreadSection);
-	std::vector<STDevice>::iterator it = s_vtDevices.begin();
+	std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 	for(; it != s_vtDevices.end(); it++ ) {
 		if ( _tcscmp(it->strName.c_str(), name.c_str()) == 0 ) {
 			// usb设备没办法删除,此处忽略;
-			if ( it->nType != Usb) {
+			if ( it->nType != SATDEV::Usb) {
 				// 只有网络设备才能删除;
 				str = "adb disconnect ";
 				str.append(name);
@@ -214,12 +213,12 @@ void CSATDevices::DelDevices(std::string name)
 
 void CSATDevices::AddReticleDevices(std::string ip)
 {
-	STDevice stDevice;
-	stDevice.nType = Reticle;
+	SATDEV::STDevice stDevice;
+	stDevice.nType = SATDEV::Reticle;
 	stDevice.strName = ip;
 	stDevice.ulOfflineTime = 0;
-	stDevice.nStatus = Online;
-	stDevice.nUsageState = Idle;
+	stDevice.nStatus = SATDEV::Online;
+	stDevice.nUsageState = SATDEV::Idle;
 
 	AutoThreadSection ats(&s_ThreadSection);
 	if (!IsDeviceExist(stDevice))
@@ -228,22 +227,22 @@ void CSATDevices::AddReticleDevices(std::string ip)
 
 void CSATDevices::AddVirtualDevices(std::string name)
 {
-	STDevice stDevice;
-	stDevice.nType = Virtual;
+	SATDEV::STDevice stDevice;
+	stDevice.nType = SATDEV::Virtual;
 	stDevice.strName = name;
 	stDevice.ulOfflineTime = 0;
-	stDevice.nStatus = Online;
-	stDevice.nUsageState = Idle;
+	stDevice.nStatus = SATDEV::Online;
+	stDevice.nUsageState = SATDEV::Idle;
 
 	AutoThreadSection ats(&s_ThreadSection);
 	if (!IsDeviceExist(stDevice))
 		s_vtDevices.push_back(stDevice);
 }
 
-bool CSATDevices::IsDeviceExist(STDevice &stDevice)
+bool CSATDevices::IsDeviceExist(SATDEV::STDevice &stDevice)
 {
 	bool bExist = false;
-	std::vector<STDevice>::iterator it = s_vtDevices.begin();
+	std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 	for(; it != s_vtDevices.end(); it++ ) {
 		if ( _tcscmp(it->strName.c_str(), stDevice.strName.c_str()) == 0 ) {
 			bExist = true;
@@ -254,17 +253,17 @@ bool CSATDevices::IsDeviceExist(STDevice &stDevice)
 	return bExist;
 }
 
-bool CSATDevices::IsDevicesOffline(STDevice &stDevice, std::vector<STDevice> &vtDevices )
+bool CSATDevices::IsDevicesOffline(SATDEV::STDevice &stDevice, std::vector<SATDEV::STDevice> &vtDevices )
 {
 	bool bOffline = true;
 	// 在当前设备列表查询;
-	std::vector<STDevice>::iterator it = vtDevices.begin();
+	std::vector<SATDEV::STDevice>::iterator it = vtDevices.begin();
 	for(; it != vtDevices.end(); it++ ) {
 		if ( _tcscmp(it->strName.c_str(), stDevice.strName.c_str()) == 0 ) {
 			// 同步状态;
 			stDevice.nStatus = it->nStatus;
 			// 设备是否offline或dropline;
-			if ( it->nStatus != Offline && it->nStatus != Dropline)
+			if ( it->nStatus != SATDEV::Offline && it->nStatus != SATDEV::Dropline)
 				bOffline = false;
 			break;
 		}
@@ -273,14 +272,14 @@ bool CSATDevices::IsDevicesOffline(STDevice &stDevice, std::vector<STDevice> &vt
 	if ( bOffline ) {
 		if ( stDevice.ulOfflineTime == 0 ) {
 			// 首次检测到离线;
-			if ( stDevice.nStatus != Offline )
-				stDevice.nStatus = Dropline;
+			if ( stDevice.nStatus != SATDEV::Offline )
+				stDevice.nStatus = SATDEV::Dropline;
 			stDevice.ulOfflineTime = GetTickCount64();
 		}
 	} else {
 		// 若重新连接,重置离线时间;
 		if ( stDevice.ulOfflineTime ) {
-			stDevice.nStatus = Online;
+			stDevice.nStatus = SATDEV::Online;
 			stDevice.ulOfflineTime = 0;
 		}
 	}	
@@ -288,10 +287,10 @@ bool CSATDevices::IsDevicesOffline(STDevice &stDevice, std::vector<STDevice> &vt
 	return bOffline;
 }
 
-bool CSATDevices::IsNewDevices(STDevice &stDevice)
+bool CSATDevices::IsNewDevices(SATDEV::STDevice &stDevice)
 {
 	bool bNewDevices = true;
-	std::vector<STDevice>::iterator it = s_vtDevices.begin();
+	std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 	for(; it != s_vtDevices.end(); it++ ) {
 		if ( _tcscmp(it->strName.c_str(), stDevice.strName.c_str()) == 0 ) {
 			bNewDevices = false;
@@ -308,7 +307,7 @@ bool CSATDevices::IsNewDevices(STDevice &stDevice)
 	return bNewDevices;
 }
 
-void CSATDevices::GetCurrentDevices(std::vector<STDevice> &vtDevices)
+void CSATDevices::GetCurrentDevices(std::vector<SATDEV::STDevice> &vtDevices)
 {
 	std::string strLines = ExecuteCMD("adb devices");
 	std::vector<std::string> vtLine;
@@ -316,18 +315,18 @@ void CSATDevices::GetCurrentDevices(std::vector<STDevice> &vtDevices)
 	int npos = -1;
 	// offline设备也要加入,不区分usb或reticle;
 	for ( std::vector<std::string>::iterator it = vtLine.begin(); it != vtLine.end(); it++ ) {
-		STDevice stDevice;
+		SATDEV::STDevice stDevice;
 		// 设备类型;
 		if ( it->find(":5555") == std::string::npos )
-			stDevice.nType = Usb;
+			stDevice.nType = SATDEV::Usb;
 		else
-			stDevice.nType = Reticle;
+			stDevice.nType = SATDEV::Reticle;
 		stDevice.ulOfflineTime = 0;
 		// 设备状态;
 		if ( (npos = it->find("	device")) != std::string::npos )
-			stDevice.nStatus = Online;
+			stDevice.nStatus = SATDEV::Online;
 		else if ( (npos = it->find("	offline")) != std::string::npos )
-			stDevice.nStatus = Offline;
+			stDevice.nStatus = SATDEV::Offline;
 		// 获取设备名;
 		stDevice.strName = it->substr(0, npos);
 		// 新设备否（一般用于usb设备）
@@ -340,9 +339,9 @@ void CSATDevices::GetCurrentDevices(std::vector<STDevice> &vtDevices)
 void CSATDevices::ReConnectAllDevices()
 {
 	std::string str;
-	std::vector<STDevice>::iterator it = s_vtDevices.begin();
+	std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 	for ( ;it != s_vtDevices.end(); it++ ) {
-		if ( it->nType == Reticle ) {
+		if ( it->nType == SATDEV::Reticle ) {
 			str = "adb connect ";
 			str.append(it->strName);
 			WinExec(str.c_str(), SW_HIDE);
@@ -350,12 +349,12 @@ void CSATDevices::ReConnectAllDevices()
 	}
 }
 
-int CSATDevices::AttachDeviceName2Buffer(SATProtocol::Device (&pbuff)[30])
+int CSATDevices::AttachDeviceName2Buffer(SATPROTO::Device (&pbuff)[30])
 {
 	int count = 0;
 	if ( pbuff ) {
 		std::string str;
-		std::vector<STDevice>::iterator it = s_vtDevices.begin();
+		std::vector<SATDEV::STDevice>::iterator it = s_vtDevices.begin();
 		for ( ;it != s_vtDevices.end(); it++ ) {
 			pbuff[count].nType = it->nType;
 			pbuff[count].nStatus = it->nStatus;

SATService/SATService/SATDevices.h

@@ -6,45 +6,49 @@
 #include "CritSection.h"
 #include "SATProtocol.h"
 
-enum DEVICE_TYPE{
-	Virtual,
-	Usb,
-	Reticle
-};
-
-enum DEVICE_STATUS{
-	Online,
-	Offline,
-	Dropline
-};
-
-enum DEVICE_USAGE_STATUS{
-	Idle,
-	InUse
-};
-
-typedef struct __DEVICE__
-{
-	int 			nType;			// 0=虚拟, 1=usb, 2=网线;
-	std::string 	strName;		// 设备名称(IP:端口号);
-	// 离线时刻：超过指定时长删除该设备,线程实时刷新离线时刻;
-	ULONGLONG		ulOfflineTime;
-	int				nStatus;		// 设备状态：0=在线,1=offline, 2=掉线(drop line);
-	int				nUsageState;	// 设备使用状态：0=空闲,1=使用;
-}STDevice, *pSTDevice;
-
-// 安卓设备adb连接：USB连接、网线连接;
-typedef struct __DEVICE_INFO__ 
-{
-	STDevice		dev;
-	//////////////////////////////////////////////////////////////////////////
-	// 附加项;
-	int				nStatus;		// 设备状态：0表示空闲,1表示繁忙;
-	std::string		strSoftVersion;	// 软件版本;
-	std::string		strModel;		// 软件模型;
-	std::string		strHardVersion;	// 硬件版本;
-	std::string		strManu;		// 软件菜单;		
-}STDeviceInfo, *pSTDeviceInfo;
+namespace SATDEV{
+	// 设备类型;
+	enum DEVICE_TYPE{
+		Virtual,
+		Usb,
+		Reticle
+	};
+
+	// 设备状态;
+	enum DEVICE_STATUS{
+		Online,
+		Offline,
+		Dropline
+	};
+
+	// 设备使用状态;
+	enum DEVICE_USAGE_STATUS{
+		Idle,
+		InUse
+	};
+
+	// 设备信息;
+	typedef struct __DEVICE__ {
+		int 			nType;			// 0=虚拟, 1=usb, 2=网线;
+		std::string 	strName;		// 设备名称(IP:端口号);
+		// 离线时刻：超过指定时长删除该设备,线程实时刷新离线时刻;
+		ULONGLONG		ulOfflineTime;
+		int				nStatus;		// 设备状态：0=在线,1=offline, 2=掉线(drop line);
+		int				nUsageState;	// 设备使用状态：0=空闲,1=使用;
+	}STDevice, *pSTDevice;
+
+	// 安卓设备adb连接：USB连接、网线连接;
+	typedef struct __DEVICE_INFO__  {
+		STDevice		dev;
+		//////////////////////////////////////////////////////////////////////////
+		// 附加项;
+		int				nStatus;		// 设备状态：0表示空闲,1表示繁忙;
+		std::string		strSoftVersion;	// 软件版本;
+		std::string		strModel;		// 软件模型;
+		std::string		strHardVersion;	// 硬件版本;
+		std::string		strManu;		// 软件菜单;		
+	}STDeviceInfo, *pSTDeviceInfo;
+}
 
 class CSATDevices
 {
@@ -77,7 +81,7 @@ protected:
 	// 线程锁;
 	static ThreadSection s_ThreadSection;
 	// 安卓设备列表;
-	static std::vector<STDevice> s_vtDevices;	
+	static std::vector<SATDEV::STDevice> s_vtDevices;	
 
 	// 其他接口;
 public:
@@ -85,29 +89,28 @@ public:
 	void StartWork();
 	// 工作结束函数;
 	void EndofWork();
-
 	// 工作线程;
 	static DWORD WINAPI WorkThread(LPVOID lpVoid);
 
-
+	const std::vector<SATDEV::STDevice>& GetDeviceList() const {return s_vtDevices;};
 	// 删除设备;
 	static void DelDevices(std::string name);
 	// 添加网线连接设备;
 	static void AddReticleDevices(std::string ip);
 	static void AddVirtualDevices(std::string name);
 	// 设备是否存在;
-	static bool IsDeviceExist(STDevice &stDevice);
+	static bool IsDeviceExist(SATDEV::STDevice &stDevice);
 	// 设备是否下线;
-	static bool IsDevicesOffline(STDevice &stDevice, std::vector<STDevice> &vtDevices);
+	static bool IsDevicesOffline(SATDEV::STDevice &stDevice, std::vector<SATDEV::STDevice> &vtDevices);
 	// 是否新设备;
-	static bool IsNewDevices(STDevice &stDevice);
+	static bool IsNewDevices(SATDEV::STDevice &stDevice);
 	// 获取当前设备列表;
-	static void GetCurrentDevices(std::vector<STDevice> &vtDevices);
+	static void GetCurrentDevices(std::vector<SATDEV::STDevice> &vtDevices);
 	// 重连所有设备;
 	static void ReConnectAllDevices();
 
 	// 附加设备名到缓存中;
-	static int AttachDeviceName2Buffer(SATProtocol::Device (&pbuff)[30]);
+	static int AttachDeviceName2Buffer(SATPROTO::Device (&pbuff)[30]);
 
 };
 

SATService/SATService/SATExecutor.cpp

@@ -2,7 +2,6 @@
 #include "SATExecutor.h"
 #include "ScriptExecutor.h"
 #include "CharEncoding.h"
-#include "SATDevices.h"
 
 CSATExecutor::CSATExecutor(void)
 {
@@ -17,10 +16,10 @@ CSATExecutor::~CSATExecutor(void)
 {
 }
 
-bool CSATExecutor::IsTaskExist(SATParameters::STTask &task)
+bool CSATExecutor::IsTaskExist(SATHTTP::STTask &task)
 {
 	bool found = false;
-	std::list<SATParameters::STTask>::iterator it = m_vtTask.begin();
+	std::list<SATHTTP::STTask>::iterator it = m_vtTask.begin();
 	for ( ; it != m_vtTask.end(); it++ ) {
 		// 不要使用nTaskId,这个值没啥用;
 		if ( it->Id == task.Id ) {
@@ -32,9 +31,9 @@ bool CSATExecutor::IsTaskExist(SATParameters::STTask &task)
 	return found;
 }
 
-SATParameters::STTask* CSATExecutor::IsThereATaskInProcess()
+SATHTTP::STTask* CSATExecutor::IsThereATaskInProcess()
 {
-	std::list<SATParameters::STTask>::iterator it = m_vtTask.begin();
+	std::list<SATHTTP::STTask>::iterator it = m_vtTask.begin();
 	for ( ; it != m_vtTask.end(); it++ ) {
 		if ( it->_nExecutionState == 1 ) {
 			return &(*it);
@@ -44,9 +43,9 @@ SATParameters::STTask* CSATExecutor::IsThereATaskInProcess()
 	return NULL;
 }
 
-SATParameters::STTask* CSATExecutor::GetFreeTask()
+SATHTTP::STTask* CSATExecutor::GetFreeTask()
 {
-	std::list<SATParameters::STTask>::iterator it = m_vtTask.begin();
+	std::list<SATHTTP::STTask>::iterator it = m_vtTask.begin();
 	for ( ; it != m_vtTask.end(); it++ ) {
 		if ( it->_nExecutionState == 0 ) {
 			return &(*it);
@@ -56,9 +55,9 @@ SATParameters::STTask* CSATExecutor::GetFreeTask()
 	return NULL;
 }
 
-SATParameters::STCase* CSATExecutor::IsCaseScriptProcess(std::vector<SATParameters::STCase> &vtCases)
+SATHTTP::STCase* CSATExecutor::IsCaseScriptProcess(std::vector<SATHTTP::STCase> &vtCases)
 {
-	std::vector<SATParameters::STCase>::iterator it = vtCases.begin();
+	std::vector<SATHTTP::STCase>::iterator it = vtCases.begin();
 	for ( ; it != vtCases.end(); it++) {
 		if ( it->_nExecutionState == 1 ) {
 			return &(*it);
@@ -68,9 +67,9 @@ SATParameters::STCase* CSATExecutor::IsCaseScriptProcess(std::vector<SATParamete
 	return NULL;
 }
 
-SATParameters::STCase* CSATExecutor::GetFreeCaseScript(std::vector<SATParameters::STCase> &vtCases)
+SATHTTP::STCase* CSATExecutor::GetFreeCaseScript(std::vector<SATHTTP::STCase> &vtCases)
 {
-	std::vector<SATParameters::STCase>::iterator it = vtCases.begin();
+	std::vector<SATHTTP::STCase>::iterator it = vtCases.begin();
 	for ( ; it != vtCases.end(); it++) {
 		if ( it->_nExecutionState == 0 ) {
 			return &(*it);
@@ -80,9 +79,9 @@ SATParameters::STCase* CSATExecutor::GetFreeCaseScript(std::vector<SATParameters
 	return NULL;
 }
 
-SATParameters::STCase* CSATExecutor::ExecuteFreeCaseScript(SATParameters::STTask* pTask)
+SATHTTP::STCase* CSATExecutor::ExecuteFreeCaseScript(SATHTTP::STTask* pTask)
 {
-	SATParameters::STCase* pCase = GetFreeCaseScript(pTask->Job.vtCases);
+	SATHTTP::STCase* pCase = GetFreeCaseScript(pTask->Job.vtCases);
 	if (pCase) {		
 		if ( !pCase->_pExcutor ) {
 			CScriptExecutor *pExcutor = new CScriptExecutor(); 
@@ -114,15 +113,21 @@ SATParameters::STCase* CSATExecutor::ExecuteFreeCaseScript(SATParameters::STTask
 	return pCase;
 }
 
+void CSATExecutor::AddDevices(SATDEV::STDevice &stDevice)
+{
+	
+}
+
 bool CSATExecutor::Login(std::string user, std::string password, std::string actuator, bool bLogin /*= true*/)
 {
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!executeLogin.action");
 	// 填充数据;
 	m_stLoginReq.strUserName = user;
+	m_stLoginReq.strPassword = password;
 	m_stLoginReq.strStatus = bLogin ? "0" : "1";   // 0表示登录;
 	m_stLoginReq.strDeleteStatus = "";
-	m_stLoginReq.strIP = Global::GetLocalAddress();//"10.118.158.175";
+	m_stLoginReq.strIP = GLOBAL::g_szIPAddress;
 	m_stLoginReq.strStorage = "";
 	if ( bLogin ) {
 		m_stLoginReq.strDisconnectTime = "";
@@ -133,20 +138,15 @@ bool CSATExecutor::Login(std::string user, std::string password, std::string act
 	}
 	// 执行器名称;
 	m_stLoginReq.strExecuteName = m_strActuatorName = actuator;
-	if ( Global::g_vtMac.size() )
-		m_stLoginReq.strMAC = Global::g_vtMac[0].szMacAddress; // 取第一个MAC地址;
-	else
-		m_stLoginReq.strMAC = "";
-	
-	m_stLoginReq.strPassword = password;
+	// 执行器PC物理地址;
+	m_stLoginReq.strMAC = GLOBAL::g_strMacs;	
 	m_stLoginReq.strCPU = "";
 
-	if ( ::Login(url, m_stLoginReq, m_stLoginResp) )
-	{
+	if ( ::Login(url, m_stLoginReq, m_stLoginResp) ) {
 #ifdef _DEBUG
 	OutputDebugString("登录成功\n");
 #endif
-		Global::WriteTextLog("登录成功");
+		GLOBAL::WriteTextLog("登录成功");
 		m_bLogin = TRUE;
 		return true;
 	}
@@ -154,7 +154,7 @@ bool CSATExecutor::Login(std::string user, std::string password, std::string act
 #ifdef _DEBUG
 	OutputDebugString("登录失败\n");
 #endif
-	Global::WriteTextLog("登录失败");
+	GLOBAL::WriteTextLog("登录失败");
 
 	return false;
 }
@@ -166,7 +166,7 @@ bool CSATExecutor::Logout(std::string user, std::string password)
 
 bool CSATExecutor::UpdateDevice()
 {
-	SATParameters::STDevice stDevice;
+	SATHTTP::STDevice stDevice;
 	stDevice.strStatus = "0";	// 0表示设备空闲; 1表示设备忙碌
 	stDevice.strDeviceSerial = "192.168.1.119:5555";
 	stDevice.strHardwareVersion = "SATHardwareVersion";
@@ -185,9 +185,9 @@ bool CSATExecutor::UpdateDevice()
 	stDevice.strLastTimeConnected = "2019-12-16 10:16:01";
 	stDevice.strElectric = "";
 
-	SATParameters::STUpdateDeviceReq stUpdateDeviceReq;
-	SATParameters::STUpdateDeviceResp stUpdateDeviceResp;
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	SATHTTP::STUpdateDeviceReq stUpdateDeviceReq;
+	SATHTTP::STUpdateDeviceResp stUpdateDeviceResp;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!updateDeviceMessage.action");
 	
 	stUpdateDeviceReq.strStatus = "0";
@@ -196,8 +196,8 @@ bool CSATExecutor::UpdateDevice()
 	stUpdateDeviceReq.strStorage = "228092536KB";
 	stUpdateDeviceReq.strRunnerName = "SAT-Admin";
 	//stUpdateDeviceReq.strMAC = "40:16:7e:23:10:53";
-	if ( Global::g_vtMac.size() )
-		stUpdateDeviceReq.strMAC = Global::g_vtMac[0].szMacAddress; // 取第一个MAC地址;
+	if ( GLOBAL::g_vtMac.size() )
+		stUpdateDeviceReq.strMAC = GLOBAL::g_vtMac[0].szMacAddress; // 取第一个MAC地址;
 	else
 		stUpdateDeviceReq.strMAC = "";
 	stUpdateDeviceReq.strReportType = "1";
@@ -215,14 +215,14 @@ bool CSATExecutor::UpdateDevice()
 	return true;
 }
 
-bool CSATExecutor::NotifyTaskStart(SATParameters::STTask* pTask)
+bool CSATExecutor::NotifyTaskStart(SATHTTP::STTask* pTask)
 {
 	if ( !pTask )
 		return false;
 
-	SATParameters::STNotifyJobStartReq stNotifyJobStartReq;
-	SATParameters::STNotifyJobStartResp stNotifyJobStartResp;
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	SATHTTP::STNotifyJobStartReq stNotifyJobStartReq;
+	SATHTTP::STNotifyJobStartResp stNotifyJobStartResp;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResult.action");
 
 	TCHAR szValue[36] = {0};
@@ -258,14 +258,14 @@ bool CSATExecutor::NotifyTaskStart(SATParameters::STTask* pTask)
 	return false;
 }
 
-bool CSATExecutor::UploadCaseImg(SATParameters::STTask* pTask, SATParameters::STCase *pCase, std::string img)
+bool CSATExecutor::UploadCaseImg(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase, std::string img)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!saveResultImg.action");
 
-	SATParameters::STSaveImgReq stSaveImgReq;
-	SATParameters::STSaveImgResp stSaveImgResp;
+	SATHTTP::STSaveImgReq stSaveImgReq;
+	SATHTTP::STSaveImgResp stSaveImgResp;
 
 	stSaveImgReq.strCaseId = pCase->strId;
 	stSaveImgReq.strCaseRepeat = "0";
@@ -295,14 +295,14 @@ bool CSATExecutor::UploadCaseImg(SATParameters::STTask* pTask, SATParameters::ST
 	return false;
 }
 
-bool CSATExecutor::UploadCaseLog(SATParameters::STTask* pTask, SATParameters::STCase *pCase)
+bool CSATExecutor::UploadCaseLog(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!saveCaseOrTaskLog.action");
 
-	SATParameters::STSaveLogReq stSaveLogReq;
-	SATParameters::STSaveLogResp stSaveLogResp;
+	SATHTTP::STSaveLogReq stSaveLogReq;
+	SATHTTP::STSaveLogResp stSaveLogResp;
 
 	stSaveLogReq.strCaseId = pCase->strId;
 	// 执行ID;
@@ -323,14 +323,14 @@ bool CSATExecutor::UploadCaseLog(SATParameters::STTask* pTask, SATParameters::ST
 	return false;
 }
 
-bool CSATExecutor::ReportCaseItemFinish(SATParameters::STTask* pTask, SATParameters::STCase *pCase, STCaseItem &caseItem)
+bool CSATExecutor::ReportCaseItemFinish(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase, STCaseItem &caseItem)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResultList.action");
 
-	SATParameters::STJobProcessReq stJobProcessReq;
-	SATParameters::STJobProcessResp stJobProcessResp;
+	SATHTTP::STJobProcessReq stJobProcessReq;
+	SATHTTP::STJobProcessResp stJobProcessResp;
 
 	stJobProcessReq.strResultState = caseItem.result ? "1" : "0";
 	stJobProcessReq.strCaseScene = "";
@@ -416,14 +416,14 @@ bool CSATExecutor::ReportCaseItemFinish(SATParameters::STTask* pTask, SATParamet
 	return false;
 }
 
-bool CSATExecutor::ReportCaseFinish(SATParameters::STTask* pTask, SATParameters::STCase *pCase)
+bool CSATExecutor::ReportCaseFinish(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResultList.action");
 
-	SATParameters::STJobProcessReq stJobProcessReq;
-	SATParameters::STJobProcessResp stJobProcessResp;
+	SATHTTP::STJobProcessReq stJobProcessReq;
+	SATHTTP::STJobProcessResp stJobProcessResp;
 
 	// 上报用例结果：0表示脚本成功执行,	1表示脚本出错或超时;
 	if ( pCase->_nExecutionState == 2 )
@@ -493,7 +493,7 @@ bool CSATExecutor::ReportCaseFinish(SATParameters::STTask* pTask, SATParameters:
 	return false;
 }
 
-bool CSATExecutor::ReportCaseResult(SATParameters::STTask* pTask, SATParameters::STCase *pCase)
+bool CSATExecutor::ReportCaseResult(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase)
 {
 	// 获取xml文件内容;
 	std::string xmlpath = "D:\\SAT\\results\\detail\\";
@@ -506,10 +506,10 @@ bool CSATExecutor::ReportCaseResult(SATParameters::STTask* pTask, SATParameters:
 	
 	int nIndex = 1;
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResultList.action");
-	SATParameters::STJobProcessReq stJobProcessReq;
-	SATParameters::STJobProcessResp stJobProcessResp;
+	SATHTTP::STJobProcessReq stJobProcessReq;
+	SATHTTP::STJobProcessResp stJobProcessResp;
 	// 遍历所有用例测试项;
 	std::vector<STCaseItem>::iterator it = vtCaseItem.begin();
 	for (; it != vtCaseItem.end(); it++ )
@@ -527,14 +527,14 @@ bool CSATExecutor::ReportCaseResult(SATParameters::STTask* pTask, SATParameters:
 	return true;
 }
 
-bool CSATExecutor::UploadTaskLog(SATParameters::STTask* pTask)
+bool CSATExecutor::UploadTaskLog(SATHTTP::STTask* pTask)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!saveCaseOrTaskLog.action");
 
-	SATParameters::STSaveLogReq stSaveLogReq;
-	SATParameters::STSaveLogResp stSaveLogResp;
+	SATHTTP::STSaveLogReq stSaveLogReq;
+	SATHTTP::STSaveLogResp stSaveLogResp;
 
 	stSaveLogReq.strCaseId = "";
 	// 执行ID;
@@ -555,14 +555,14 @@ bool CSATExecutor::UploadTaskLog(SATParameters::STTask* pTask)
 	return false;
 }
 
-bool CSATExecutor::ReportTaskStart(SATParameters::STTask* pTask)
+bool CSATExecutor::ReportTaskStart(SATHTTP::STTask* pTask)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResultList.action");
 
-	SATParameters::STJobProcessReq stJobProcessReq;
-	SATParameters::STJobProcessResp stJobProcessResp;
+	SATHTTP::STJobProcessReq stJobProcessReq;
+	SATHTTP::STJobProcessResp stJobProcessResp;
 
 	// 需要处理###
 	stJobProcessReq.strResultState = "";	// 脚本执行中,认为fail;
@@ -627,14 +627,14 @@ bool CSATExecutor::ReportTaskStart(SATParameters::STTask* pTask)
 	return false;
 }
 
-bool CSATExecutor::ReportTaskFinish(SATParameters::STTask* pTask)
+bool CSATExecutor::ReportTaskFinish(SATHTTP::STTask* pTask)
 {
 	TCHAR szValue[MAX_PATH] = {0};
-	std::string url = Global::g_stSATConfig.szExecuteServer;
+	std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 	url.append("/ajaxInteractiveManage!setResultList.action");
 
-	SATParameters::STJobProcessReq stJobProcessReq;
-	SATParameters::STJobProcessResp stJobProcessResp;
+	SATHTTP::STJobProcessReq stJobProcessReq;
+	SATHTTP::STJobProcessResp stJobProcessResp;
 
 	// 需要处理###
 	stJobProcessReq.strResultState = "0";	// 脚本执行中,认为fail;
@@ -703,8 +703,7 @@ bool CSATExecutor::GetCaseXMLResult(std::string xmlpath, std::vector<STCaseItem>
 {
 	// 解析xml;
 	tinyxml2::XMLDocument doc;
-	if (tinyxml2::XML_SUCCESS != doc.LoadFile(xmlpath.c_str()) )
-	{
+	if (tinyxml2::XML_SUCCESS != doc.LoadFile(xmlpath.c_str()) ) {
 		return false;
 	}
 
@@ -716,14 +715,11 @@ bool CSATExecutor::GetCaseXMLResult(std::string xmlpath, std::vector<STCaseItem>
 		return false;
 	
 	tinyxml2::XMLElement *pXmlElent = pXmlRoot->FirstChildElement();
-	while (pXmlElent)
-	{
-		if (_tcsicmp(pXmlElent->Value(), _T("item")) == 0)
-		{
+	while (pXmlElent) {
+		if (_tcsicmp(pXmlElent->Value(), _T("item")) == 0) {
 			STCaseItem cItem;
 			tinyxml2::XMLElement *pItem = pXmlElent->FirstChildElement();
-			while (pItem)
-			{
+			while (pItem) {
 				if (_tcsicmp(pItem->Value(), _T("name")) == 0)
 				{
 					cItem.name = pItem->GetText();
@@ -766,22 +762,19 @@ bool CSATExecutor::GetCaseXMLResult(std::string xmlpath, std::vector<STCaseItem>
 void CSATExecutor::StartWork()
 {
 	m_hEventHearbeat = CreateEvent(NULL, TRUE, FALSE, NULL);
-	if ( m_hEventHearbeat == NULL )
-	{
+	if ( m_hEventHearbeat == NULL ) {
 		_tprintf_s(_T("创建事件失败\n"));
 		return;
 	}
 
 	m_hEventExcuteScript = CreateEvent(NULL, TRUE, FALSE, NULL);
-	if ( m_hEventExcuteScript == NULL )
-	{
+	if ( m_hEventExcuteScript == NULL ) {
 		_tprintf_s(_T("创建事件失败2\n"));
 		return;
 	}
 
 	m_hThreadHearbeat = CreateThread(NULL, 0, HearbeatThread, this, 0, NULL);
-	if ( m_hThreadHearbeat == NULL)
-	{
+	if ( m_hThreadHearbeat == NULL) {
 		SetEvent(m_hEventHearbeat);
 		SetEvent(m_hEventExcuteScript);
 		CloseHandle(m_hEventHearbeat);
@@ -793,8 +786,7 @@ void CSATExecutor::StartWork()
 	}
 
 	m_hThreadExcuteScript = CreateThread(NULL, 0, ExecuteScriptThread, this, 0, NULL);
-	if ( m_hThreadExcuteScript == NULL )
-	{
+	if ( m_hThreadExcuteScript == NULL ) {
 		SetEvent(m_hEventHearbeat);
 		SetEvent(m_hEventExcuteScript);
 		CloseHandle(m_hEventHearbeat);
@@ -812,7 +804,41 @@ void CSATExecutor::StartWork()
 
 void CSATExecutor::EndofWork()
 {
+	//////////////////////////////////////////////////////////////////////////
+	// 设置事件有信号;
+	if ( m_hEventHearbeat )
+		SetEvent(m_hEventHearbeat);
 
+	// 等待线程结束;
+	if ( m_hThreadHearbeat ) {
+		WaitForSingleObject(m_hThreadHearbeat, INFINITE);
+		CloseHandle(m_hThreadHearbeat);
+		m_hThreadHearbeat = NULL;
+	}
+
+	// 关闭事件句柄;
+	if ( m_hEventHearbeat ) {
+		CloseHandle(m_hEventHearbeat);
+		m_hEventHearbeat = NULL;
+	}
+
+	//////////////////////////////////////////////////////////////////////////
+	// 设置事件有信号;
+	if ( m_hEventExcuteScript )
+		SetEvent(m_hEventExcuteScript);
+
+	// 等待线程结束;
+	if ( m_hThreadExcuteScript ) {
+		WaitForSingleObject(m_hThreadExcuteScript, INFINITE);
+		CloseHandle(m_hThreadExcuteScript);
+		m_hThreadExcuteScript = NULL;
+	}
+
+	// 关闭事件句柄;
+	if ( m_hEventExcuteScript ) {
+		CloseHandle(m_hEventExcuteScript);
+		m_hEventExcuteScript = NULL;
+	}
 }
 
 DWORD CSATExecutor::HearbeatThread(LPVOID lpVoid)
@@ -824,9 +850,9 @@ DWORD CSATExecutor::HearbeatThread(LPVOID lpVoid)
 		// 没有登录成功,不查询;
 		if ( !that->m_bLogin ) continue;
 		
-		SATParameters::STHeartbeatReq stHeartbeatReq;
-		SATParameters::STHeartbeatResp stHeartbeatResp;
-		std::string url = Global::g_stSATConfig.szExecuteServer;
+		SATHTTP::STHeartbeatReq stHeartbeatReq;
+		SATHTTP::STHeartbeatResp stHeartbeatResp;
+		std::string url = GLOBAL::g_stSATConfig.szExecuteServer;
 		url.append("/ajaxInteractiveManage!executeHeartbeat.action");
 
 		stHeartbeatReq.strUserName = that->m_stLoginReq.strUserName;
@@ -836,20 +862,20 @@ DWORD CSATExecutor::HearbeatThread(LPVOID lpVoid)
 #ifdef _DEBUG
 			OutputDebugString("心跳查询成功\n");
 #endif
-			Global::WriteTextLog("心跳查询成功");
-			std::vector<SATParameters::STTask>::iterator it = stHeartbeatResp.vtTask.begin();
+			GLOBAL::WriteTextLog("心跳查询成功");
+			std::vector<SATHTTP::STTask>::iterator it = stHeartbeatResp.vtTask.begin();
 			for ( ; it != stHeartbeatResp.vtTask.end(); it++ ) {
 				if (!that->IsTaskExist(*it)) {
 					// 将任务压入队列中;
 					AutoThreadSection ats(&that->m_csTask);
 					// 同时下载任务;
-					std::string host = Global::g_stSATConfig.szCaseServer;
+					std::string host = GLOBAL::g_stSATConfig.szCaseServer;
 					std::string url = host + "/ajaxInteractiveManage!getCaseFileListUrl.action";
-					std::vector<SATParameters::STCase>::iterator _case = it->Job.vtCases.begin();
+					std::vector<SATHTTP::STCase>::iterator _case = it->Job.vtCases.begin();
 					for ( int i = 1; _case != it->Job.vtCases.end(); _case++) {
 						_case->_nCaseStep = i++;
-						SATParameters::STScriptUrlResp stScriptUrlResp;
-						if ( DownloadScript(url, _case->strId, Global::g_stSATConfig.szScriptDir, stScriptUrlResp) ) {
+						SATHTTP::STScriptUrlResp stScriptUrlResp;
+						if ( DownloadScript(url, _case->strId, GLOBAL::g_stSATConfig.szScriptDir, stScriptUrlResp) ) {
 							_case->_strFileDir = stScriptUrlResp._strFileDir;
 							_case->_strFileName = stScriptUrlResp._strFileName;
 							_case->_strScriptPath = stScriptUrlResp._strScripFile;
@@ -885,14 +911,14 @@ DWORD CSATExecutor::ExecuteScriptThread(LPVOID lpVoid)
 
 	do {
 		// 是否有任务在执行;
-		SATParameters::STTask *pTask = that->IsThereATaskInProcess();
+		SATHTTP::STTask *pTask = that->IsThereATaskInProcess();
 		if ( pTask ) {// 有任务在执行中;
 			if ( pTask->_bConcurrent ) {// 并发;
 
 			}
 			else {// 串行;
 				// 是否有脚本用例在执行;
-				SATParameters::STCase* pCase = that->IsCaseScriptProcess(pTask->Job.vtCases);
+				SATHTTP::STCase* pCase = that->IsCaseScriptProcess(pTask->Job.vtCases);
 				if ( pCase ) {
 					CScriptExecutor *pExcutor = (CScriptExecutor*)pCase->_pExcutor;
 					if ( pExcutor ) {
@@ -934,7 +960,7 @@ DWORD CSATExecutor::ExecuteScriptThread(LPVOID lpVoid)
 				// 是否支持并发;
 				if ( pTask->_bConcurrent ) {
 					// 暂时全部一起并发;
-					std::vector<SATParameters::STCase>::iterator _case = pTask->Job.vtCases.begin();
+					std::vector<SATHTTP::STCase>::iterator _case = pTask->Job.vtCases.begin();
 					for ( ; _case != pTask->Job.vtCases.end(); _case++) {
 						if (!_case->_pExcutor) {					
 							CScriptExecutor *pExcutor = new CScriptExecutor();
@@ -953,7 +979,7 @@ DWORD CSATExecutor::ExecuteScriptThread(LPVOID lpVoid)
 				}
 				else {
 					// 是否有用例脚本在执行;
-					SATParameters::STCase* pCase = that->IsCaseScriptProcess(pTask->Job.vtCases);
+					SATHTTP::STCase* pCase = that->IsCaseScriptProcess(pTask->Job.vtCases);
 					if ( !pCase ) {
 						// 执行空闲用例脚本;
 						that->ExecuteFreeCaseScript(pTask);
@@ -966,12 +992,6 @@ DWORD CSATExecutor::ExecuteScriptThread(LPVOID lpVoid)
 				// 通知SAT服务器,脚本开始;
 				that->ReportTaskStart(pTask);
 			}	
-#ifdef _DEBUG
-			else
-			{
-				OutputDebugString("无任务可执行\n");
-			}
-#endif
 		}
 	} while ( WaitForSingleObject(that->m_hEventExcuteScript, 10000) == WAIT_TIMEOUT );
 

SATService/SATService/SATExecutor.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include "CritSection.h"
+#include "SATDevices.h"
 
 // 用例xml;
 typedef struct __ST_CASEITEM__
@@ -48,54 +49,61 @@ protected:
 	BOOL	m_bLogin;
 
 	ThreadSection	m_csTask;
-	std::list<SATParameters::STTask> m_vtTask;
-	std::vector<SATParameters::STDevice> m_vtDevice;
-	SATParameters::STLoginReq	m_stLoginReq;
-	SATParameters::STLoginResp	m_stLoginResp;
+	std::list<SATHTTP::STTask> m_vtTask;
+	std::vector<SATHTTP::STDevice> m_vtDevice;
+	SATHTTP::STLoginReq	m_stLoginReq;
+	SATHTTP::STLoginResp	m_stLoginResp;
 	// 执行器名称;
 	std::string m_strActuatorName;
 
 	// 任务是否存在;
-	bool IsTaskExist(SATParameters::STTask &task);
+	bool IsTaskExist(SATHTTP::STTask &task);
 	// 是否有任务在执行;
-	SATParameters::STTask* IsThereATaskInProcess();
+	SATHTTP::STTask* IsThereATaskInProcess();
 	// 提取未执行的任务;
-	SATParameters::STTask* GetFreeTask();
+	SATHTTP::STTask* GetFreeTask();
 	// 是否有用例脚本在执行;
-	SATParameters::STCase* IsCaseScriptProcess(std::vector<SATParameters::STCase> &vtCases);
+	SATHTTP::STCase* IsCaseScriptProcess(std::vector<SATHTTP::STCase> &vtCases);
 	// 提取未执行的用例;
-	SATParameters::STCase* GetFreeCaseScript(std::vector<SATParameters::STCase> &vtCases);
-
+	SATHTTP::STCase* GetFreeCaseScript(std::vector<SATHTTP::STCase> &vtCases);
 	// 执行空闲新用例;
-	SATParameters::STCase* ExecuteFreeCaseScript(SATParameters::STTask* pTask);
+	SATHTTP::STCase* ExecuteFreeCaseScript(SATHTTP::STTask* pTask);
+	// 添加设备;
+	void AddDevices(SATDEV::STDevice &stDevice);
+	// 删除设备;
+	void DelDevices(SATDEV::STDevice &stDevice);
+	// 同步设备;
+	void SynchDevices(SATDEV::STDevice &stDevice);
+
+
 public:
 	// 登录;
 	bool Login(std::string user, std::string password, std::string actuator, bool bLogin = true);
 	// 登出;
 	bool Logout(std::string user, std::string password);
-	const SATParameters::STLoginResp *GetLoginResp() const{ return &m_stLoginResp;};
+	const SATHTTP::STLoginResp *GetLoginResp() const{ return &m_stLoginResp;};
 	// 设置执行器名称;
 	void SetActuatorName(const char *pszActuator){ if (pszActuator) m_strActuatorName = pszActuator;};
 	// 更新设备信息;
 	bool UpdateDevice();
 	// 通知SAT任务开始;
-	bool NotifyTaskStart(SATParameters::STTask* pTask);
+	bool NotifyTaskStart(SATHTTP::STTask* pTask);
 	// 上传用例图片;
-	bool UploadCaseImg(SATParameters::STTask* pTask, SATParameters::STCase *pCase, std::string img);
+	bool UploadCaseImg(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase, std::string img);
 	// 上传用例结果;
-	bool UploadCaseLog(SATParameters::STTask* pTask, SATParameters::STCase *pCase);
+	bool UploadCaseLog(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase);
 	// 上报用例测试项完成;
-	bool ReportCaseItemFinish(SATParameters::STTask* pTask, SATParameters::STCase *pCase, STCaseItem &caseItem);
+	bool ReportCaseItemFinish(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase, STCaseItem &caseItem);
 	// 上报用例完成;
-	bool ReportCaseFinish(SATParameters::STTask* pTask, SATParameters::STCase *pCase);
+	bool ReportCaseFinish(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase);
 	// 上报用例结果;
-	bool ReportCaseResult(SATParameters::STTask* pTask, SATParameters::STCase *pCase);
+	bool ReportCaseResult(SATHTTP::STTask* pTask, SATHTTP::STCase *pCase);
 	// 上传任务结果;
-	bool UploadTaskLog(SATParameters::STTask* pTask);
+	bool UploadTaskLog(SATHTTP::STTask* pTask);
 	// 上报任务开始;
-	bool ReportTaskStart(SATParameters::STTask* pTask);
+	bool ReportTaskStart(SATHTTP::STTask* pTask);
 	// 上报任务完成;
-	bool ReportTaskFinish(SATParameters::STTask* pTask);
+	bool ReportTaskFinish(SATHTTP::STTask* pTask);
 	// 获取用例xml结果;
 	bool GetCaseXMLResult(std::string xmlpath, std::vector<STCaseItem> &vtCaseItem);
 	// 其他接口;

SATService/SATService/SATProtocol.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-namespace SATProtocol{
+namespace SATPROTO{
 	//////////////////////////////////////////////////////////////////////////
 	// žßĚĺĐ­ŇéÖ¸Áî;
 	enum ProtocolCMD {

SATService/SATService/SATService.cpp

@@ -41,11 +41,11 @@ void CALLBACK WorkStart()
 // 工作结束回调函数;
 void CALLBACK WorkEndof()
 {
-	Global::WriteTextLog("SATService goto end");
+	GLOBAL::WriteTextLog("SATService goto end");
 	CSATTCPServer::GetInstance()->Stop();
 	CSATTCPServer::GetInstance()->UnloadSocketLib();
 	CMainProcess::GetInstance()->EndofWork();
-	Global::WriteTextLog("SATService work end!");
+	GLOBAL::WriteTextLog("SATService work end!");
 }
 
 
@@ -68,9 +68,10 @@ int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
 	else
 	{
 		// TODO: 在此处为应用程序的行为编写代码。
-		Global::GetIniInfo();
-		Global::GetMacAddress();
-		Global::WriteTextLog("SATService goto start");
+		GLOBAL::GetIniInfo();
+		GLOBAL::GetMacAddress();
+		GLOBAL::GetLocalAddress();
+		GLOBAL::WriteTextLog("SATService goto start");
 #ifdef _DEBUG
 
 #if 0
@@ -110,9 +111,9 @@ int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
 		TCHAR szDir[_MAX_DIR] = { 0 };
 		TCHAR szFna[_MAX_FNAME] = { 0 };
 		TCHAR szExt[_MAX_EXT] = { 0 };
-		_tsplitpath_s(Global::g_szCurModuleFileName, szDrive, szDir, szFna, szExt);
+		_tsplitpath_s(GLOBAL::g_szCurModuleFileName, szDrive, szDir, szFna, szExt);
 		_stprintf_s(szExeName, _T("%s%s"), szFna, szExt);
-		if ( Global::FindProcessCount(szExeName) > 1)
+		if ( GLOBAL::FindProcessCount(szExeName) > 1)
 		{// 进程计数大于1,退出;
 			return 0;
 		}

SATService/SATService/SATTCPServer.cpp

@@ -715,35 +715,35 @@ void CSATTCPServer::_ShowMessage(const CString szFormat,...) const
 	strMessage.FormatV(szFormat,arglist);
 	va_end(arglist);
 
-	Global::WriteTextLog(strMessage);
+	GLOBAL::WriteTextLog(strMessage);
 }
 
-#define PAK_LEN sizeof(SATProtocol::DataHeader)
+#define PAK_LEN sizeof(SATPROTO::DataHeader)
 void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONTEXT* pIoContext)
 {
 #ifdef _DEBUG
 	OutputDebugString("有数据返回\n");
 #endif
-	Global::WriteTextLog("有数据返回");
+	GLOBAL::WriteTextLog("有数据返回");
 	// 小于包头;
-	SATProtocol::DataHeader* phead = NULL;
+	SATPROTO::DataHeader* phead = NULL;
 	if (pSocketContext->lastData.size() == 0)
 	{
 		// 不足包头;
 		if (PAK_LEN > pIoContext->m_Overlapped.InternalHigh)
 		{
 			OutputDebugString("A：不足包头;\n");
-			Global::WriteTextLog("A：不足包头");
+			GLOBAL::WriteTextLog("A：不足包头");
 			pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh);
 		}
 		else
 		{
 			// 包头充足;
-			phead = (SATProtocol::DataHeader*)pIoContext->m_wsaBuf.buf;
+			phead = (SATPROTO::DataHeader*)pIoContext->m_wsaBuf.buf;
 			if ( !CheckDataHeader(phead) )
 			{
 				OutputDebugString("A：包头损坏;\n");
-				Global::WriteTextLog("A：包头损坏");
+				GLOBAL::WriteTextLog("A：包头损坏");
 				return;
 			}
 
@@ -751,23 +751,23 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 			if (phead->len == pIoContext->m_Overlapped.InternalHigh)
 			{
 				OutputDebugString("A：完整的包;\n");
-				Global::WriteTextLog("A：完整的包");
-				_TaskProcess(pIoContext, (SATProtocol::Package*)pIoContext->m_wsaBuf.buf);
+				GLOBAL::WriteTextLog("A：完整的包");
+				_TaskProcess(pIoContext, (SATPROTO::Package*)pIoContext->m_wsaBuf.buf);
 			}
 			// 小包;
 			else if (phead->len > pIoContext->m_Overlapped.InternalHigh)
 			{
 				OutputDebugString("A：小包;\n");
-				Global::WriteTextLog("A：小包");
+				GLOBAL::WriteTextLog("A：小包");
 				pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh);
 			}
 			// 超包;
 			else if (phead->len < pIoContext->m_Overlapped.InternalHigh)
 			{
 				OutputDebugString("A：超包;\n");
-				Global::WriteTextLog("A：超包");
+				GLOBAL::WriteTextLog("A：超包");
 				pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf + phead->len, pIoContext->m_Overlapped.InternalHigh - phead->len);
-				_TaskProcess(pIoContext, (SATProtocol::Package*)pIoContext->m_wsaBuf.buf);
+				_TaskProcess(pIoContext, (SATPROTO::Package*)pIoContext->m_wsaBuf.buf);
 			}
 		}
 	}
@@ -776,11 +776,11 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 		int lastlen = pIoContext->m_Overlapped.InternalHigh;
 		if (pSocketContext->lastData.size() >= PAK_LEN)
 		{
-			phead = (SATProtocol::DataHeader*)pSocketContext->lastData.data();
+			phead = (SATPROTO::DataHeader*)pSocketContext->lastData.data();
 			if ( !CheckDataHeader(phead) )
 			{
 				OutputDebugString("C：包头损坏;\n");
-				Global::WriteTextLog("C：包头损坏");
+				GLOBAL::WriteTextLog("C：包头损坏");
 				pSocketContext->lastData.clear();
 				return;
 			}
@@ -790,9 +790,9 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 				if ( phead->len <= pSocketContext->lastData.size() )
 				{
 					OutputDebugString("C：超包;\n");
-					Global::WriteTextLog("C：超包");
+					GLOBAL::WriteTextLog("C：超包");
 					// 完整包;
-					_TaskProcess(pIoContext, (SATProtocol::Package*)pSocketContext->lastData.substr(0, phead->len).data());
+					_TaskProcess(pIoContext, (SATPROTO::Package*)pSocketContext->lastData.substr(0, phead->len).data());
 
 					pSocketContext->lastData = pSocketContext->lastData.substr(phead->len);
 					pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh);
@@ -800,11 +800,11 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 				else
 				{
 					OutputDebugString("D：超包;\n");
-					Global::WriteTextLog("D：超包");
+					GLOBAL::WriteTextLog("D：超包");
 					lastlen = pSocketContext->lastData.size() + pIoContext->m_Overlapped.InternalHigh - phead->len;
 					pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh - lastlen);
 					// 完整包;
-					_TaskProcess(pIoContext, (SATProtocol::Package*)pSocketContext->lastData.data());
+					_TaskProcess(pIoContext, (SATPROTO::Package*)pSocketContext->lastData.data());
 					// 剩余包;
 					pSocketContext->lastData.clear();
 					if (lastlen)
@@ -814,7 +814,7 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 			else
 			{
 				OutputDebugString("C：仍不足一个包;\n");
-				Global::WriteTextLog("C：仍不足一个包");
+				GLOBAL::WriteTextLog("C：仍不足一个包");
 				pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh);
 			}
 		}
@@ -826,18 +826,18 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 			if ( diflen > pIoContext->m_Overlapped.InternalHigh )
 			{
 				OutputDebugString("B：仍不足一个包头;\n");
-				Global::WriteTextLog("B：仍不足一个包头");
+				GLOBAL::WriteTextLog("B：仍不足一个包头");
 				pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, pIoContext->m_Overlapped.InternalHigh);
 			}
 			else
 			{
 				// 拼成完整包头;
 				pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf, diflen);
-				phead = (SATProtocol::DataHeader*)pSocketContext->lastData.data();
+				phead = (SATPROTO::DataHeader*)pSocketContext->lastData.data();
 				if ( !CheckDataHeader(phead) )
 				{
 					OutputDebugString("B：包头损坏;\n");
-					Global::WriteTextLog("B：包头损坏");
+					GLOBAL::WriteTextLog("B：包头损坏");
 					pSocketContext->lastData.clear();
 					return;
 				}
@@ -846,26 +846,26 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 				if ( phead->len == PAK_LEN + pIoContext->m_Overlapped.InternalHigh - diflen )
 				{
 					OutputDebugString("B：完整包;\n");
-					Global::WriteTextLog("B：完整包");
+					GLOBAL::WriteTextLog("B：完整包");
 					pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf + diflen, pIoContext->m_Overlapped.InternalHigh - diflen);
-					_TaskProcess(pIoContext, (SATProtocol::Package*)pSocketContext->lastData.data());
+					_TaskProcess(pIoContext, (SATPROTO::Package*)pSocketContext->lastData.data());
 					pSocketContext->lastData.clear();
 				}
 				// 小包;
 				else if ( phead->len > PAK_LEN + pIoContext->m_Overlapped.InternalHigh - diflen)
 				{
 					OutputDebugString("B：小包;\n");
-					Global::WriteTextLog("B：小包");
+					GLOBAL::WriteTextLog("B：小包");
 					pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf + diflen, pIoContext->m_Overlapped.InternalHigh - diflen);
 				}
 				// 超包;
 				else if (phead->len < PAK_LEN + pIoContext->m_Overlapped.InternalHigh - diflen)
 				{
 					OutputDebugString("B：超包;\n");
-					Global::WriteTextLog("B：超包");
+					GLOBAL::WriteTextLog("B：超包");
 					// 组完成包;
 					pSocketContext->lastData.append(pIoContext->m_wsaBuf.buf + diflen, phead->len - PAK_LEN);
-					_TaskProcess(pIoContext, (SATProtocol::Package*)pSocketContext->lastData.data());
+					_TaskProcess(pIoContext, (SATPROTO::Package*)pSocketContext->lastData.data());
 					pSocketContext->lastData.clear();
 					int last = pIoContext->m_Overlapped.InternalHigh - diflen - phead->len + PAK_LEN;
 					if (last)
@@ -878,33 +878,33 @@ void CSATTCPServer::_RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONT
 	}
 }
 
-void CSATTCPServer::_TaskProcess(PER_IO_CONTEXT* pIoContext, SATProtocol::Package* pak)
+void CSATTCPServer::_TaskProcess(PER_IO_CONTEXT* pIoContext, SATPROTO::Package* pak)
 {
 #ifdef _DEBUG
 	OutputDebugString("\n########成功获取数据########\n\n");
 #endif
-	Global::WriteTextLog("成功获取数据");
+	GLOBAL::WriteTextLog("成功获取数据");
 
-	SATProtocol::DataHeader *pHeader = &pak->header;
+	SATPROTO::DataHeader *pHeader = &pak->header;
 	if ( !pHeader ) 
 		return;
 
 	if ( pHeader->protocol == 0xAA ) {
 		switch ( pHeader->cmd  ) 
 		{
-			case SATProtocol::CMD_LOGIN:
-			case SATProtocol::CMD_LOGOUT:
+			case SATPROTO::CMD_LOGIN:
+			case SATPROTO::CMD_LOGOUT:
 				{
 					// 登录;
-					SATProtocol::UserInfo *pLogin = (SATProtocol::UserInfo*)pak->buf;
-					Global::WriteTextLog(_T("User=%s, psw=%s"), pLogin->szUserName, pLogin->szPassword);
+					SATPROTO::UserInfo *pLogin = (SATPROTO::UserInfo*)pak->buf;
+					GLOBAL::WriteTextLog(_T("User=%s, psw=%s"), pLogin->szUserName, pLogin->szPassword);
 					bool bRet = CSATExecutor::GetInstance()->Login(pLogin->szUserName, pLogin->szPassword, pLogin->szActuatorName, !pHeader->cmd);
 
 					// 计算数据包长度;
-					long len = sizeof(SATProtocol::DataHeader)+sizeof(SATProtocol::LoginResp);
+					long len = sizeof(SATPROTO::DataHeader)+sizeof(SATPROTO::LoginResp);
 					byte *pbuff = new byte[len];
 					memset(pbuff, 0, len);
-					SATProtocol::Package *pSendPak = (SATProtocol::Package *)pbuff;
+					SATPROTO::Package *pSendPak = (SATPROTO::Package *)pbuff;
 					pSendPak->header.protocol = 0xAA;
 					pSendPak->header.cmd = pHeader->cmd;
 					pSendPak->header.len = len;
@@ -916,8 +916,8 @@ void CSATTCPServer::_TaskProcess(PER_IO_CONTEXT* pIoContext, SATProtocol::Packag
 					_stprintf_s(szMessage, _T("登录……"));
 					memcpy(pSendPak->buf + sizeof(bool), szMessage, MAX_PATH);
 #else
-					const SATParameters::STLoginResp *pstLoginResp = CSATExecutor::GetInstance()->GetLoginResp();
-					SATProtocol::LoginResp *pLoginResp = (SATProtocol::LoginResp*)(pbuff+sizeof(SATProtocol::DataHeader));
+					const SATHTTP::STLoginResp *pstLoginResp = CSATExecutor::GetInstance()->GetLoginResp();
+					SATPROTO::LoginResp *pLoginResp = (SATPROTO::LoginResp*)(pbuff+sizeof(SATPROTO::DataHeader));
 					pLoginResp->bStatus = bRet;
 					memset(pLoginResp->szMessage, 0, MAX_PATH);
 					//_stprintf_s(pLoginResp->szMessage, _T("%s"), pstLoginResp->strMessage.c_str());
@@ -933,36 +933,36 @@ void CSATTCPServer::_TaskProcess(PER_IO_CONTEXT* pIoContext, SATProtocol::Packag
 					pbuff = NULL;
 				}
 				break;
-			case SATProtocol::CMD_ADD_DEVICE:
-			case SATProtocol::CMD_DEL_DEVICE:
+			case SATPROTO::CMD_ADD_DEVICE:
+			case SATPROTO::CMD_DEL_DEVICE:
 				{
 					std::string ip = (char*)pak->buf;
-					if (pHeader->cmd == SATProtocol::CMD_DEL_DEVICE ) 
+					if (pHeader->cmd == SATPROTO::CMD_DEL_DEVICE ) 
 						CSATDevices::DelDevices(ip);
 					else 
 						CSATDevices::AddReticleDevices(ip);
 
-					SATProtocol::DataHeader header;
+					SATPROTO::DataHeader header;
 					header.cmd = pHeader->cmd;
-					header.len = sizeof(SATProtocol::DataHeader);
+					header.len = sizeof(SATPROTO::DataHeader);
 					header.protocol = 0xAA;
 
-					send(pIoContext->m_sockAccept, (const char*)&header, sizeof(SATProtocol::DataHeader), 0);
+					send(pIoContext->m_sockAccept, (const char*)&header, sizeof(SATPROTO::DataHeader), 0);
 				}
 				break;
-			case SATProtocol::CMD_QUERY_DEVICES:
+			case SATPROTO::CMD_QUERY_DEVICES:
 				{
 					// 计算数据包长度;
-					long len = sizeof(SATProtocol::DataHeader)+sizeof(SATProtocol::DeviceResp);
+					long len = sizeof(SATPROTO::DataHeader)+sizeof(SATPROTO::DeviceResp);
 					byte *pbuff = new byte[len];
 					memset(pbuff, 0, len);
-					SATProtocol::Package *pSendPak = (SATProtocol::Package *)pbuff;
+					SATPROTO::Package *pSendPak = (SATPROTO::Package *)pbuff;
 					pSendPak->header.protocol = 0xAA;
 					pSendPak->header.cmd = pHeader->cmd;
 					pSendPak->header.len = len;
 					// 转换pak->buf为结构体;
-					SATProtocol::DeviceResp *pDevResp = (SATProtocol::DeviceResp*)(pbuff+sizeof(SATProtocol::DataHeader));
-					memset(pDevResp->ssDevs, 0, 30*sizeof(SATProtocol::Device));
+					SATPROTO::DeviceResp *pDevResp = (SATPROTO::DeviceResp*)(pbuff+sizeof(SATPROTO::DataHeader));
+					memset(pDevResp->ssDevs, 0, 30*sizeof(SATPROTO::Device));
 					// 获取设备列表;
 					pDevResp->nSize = CSATDevices::AttachDeviceName2Buffer(pDevResp->ssDevs);
 
@@ -980,7 +980,7 @@ void CSATTCPServer::_TaskProcess(PER_IO_CONTEXT* pIoContext, SATProtocol::Packag
 	}
 }
 
-bool CSATTCPServer::CheckDataHeader(SATProtocol::DataHeader* header)
+bool CSATTCPServer::CheckDataHeader(SATPROTO::DataHeader* header)
 {
 	if ( header->protocol != 0xAA )
 		return false;

SATService/SATService/SATTCPServer.h

@@ -246,8 +246,8 @@ protected:
 	void _ShowMessage( const CString szFormat,...) const;
 
 	void _RecvProcess(PER_SOCKET_CONTEXT* pSocketContext, PER_IO_CONTEXT* pIoContext);
-	void _TaskProcess(PER_IO_CONTEXT* pIoContext, SATProtocol::Package *pak);
-	bool CheckDataHeader(SATProtocol::DataHeader* header);
+	void _TaskProcess(PER_IO_CONTEXT* pIoContext, SATPROTO::Package *pak);
+	bool CheckDataHeader(SATPROTO::DataHeader* header);
 private:
 
 	HANDLE                       m_hShutdownEvent;              // 用来通知线程系统退出的事件，为了能够更好的退出线程

SATService/SATService/ScriptExecutor.cpp

@@ -107,7 +107,7 @@ DWORD CScriptExecutor::_LogExportThread(LPVOID lpParam)
 				continue;
 
 			that->m_ulStartTickCount = GetTickCount64();
-			Global::WritePythonLog(that->m_szLogPath, chBuf);
+			GLOBAL::WritePythonLog(that->m_szLogPath, chBuf);
 			memset(chBuf, 0, BUFSIZE);
 		} while (!that->m_bStopLogExport);
 	}
@@ -124,7 +124,7 @@ DWORD CScriptExecutor::_LogExportThread(LPVOID lpParam)
 				continue;
 
 			that->m_ulStartTickCount = GetTickCount64();
-			Global::WritePythonLog(that->m_szLogPath, chBuf);
+			GLOBAL::WritePythonLog(that->m_szLogPath, chBuf);
 			memset(chBuf, 0, BUFSIZE);
 		} while (!that->m_bStopLogExport);
 	}
@@ -998,7 +998,7 @@ bool CScriptExecutor::InitScript(std::string strScript, std::string strLogPath,
 	if (!PathFileExists(strLogPath.c_str()))
 	{
 		// ´´½¨Â·¾¶;
-		if (!Global::MKDIR(strLogPath.c_str()))
+		if (!GLOBAL::MKDIR(strLogPath.c_str()))
 		{
 			printf("Error:´´½¨Ä¿Â¼Ê§°Ü\n");
 			return false;