basic_DriverPlatform-V3.1/DrvProc/DiosProc/DiosProc.cpp

// DiosProc.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <conio.h>
#include <stdio.h>
//#include "scf.h"
#include "CDI.h"
#include "LocalConfig.h"
#include "BusUnitClient.h"
#include "LogicClient.h"
#include "common_api.h"
#include "PacketAnalizer.h"
#include "ConsoleThread.h"

#include "AutoDmp.h"

#include <iostream>

#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

#include "ShareMemory_Client.h"

#include <chrono>

inline std::string CurrentDateTime()
{
	// 获取当前时间点
	auto now = std::chrono::system_clock::now();
	// 将时间长度转换为微秒数
	auto now_us = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch());
	// 再转成tm格式
	auto now_time_t = std::chrono::system_clock::to_time_t(now);
	auto now_tm = std::localtime(&now_time_t);

	// 可以直接输出到标准输出
	// std::cout << std::put_time(now_tm, "%Y-%m-%d %H:%M:%S.") << std::setfill('0') << std::setw(6) << now_us.count() % 1000000 << std::endl;

	// 格式化字符，年月日时分秒
	std::string now_time_str;
	char buf[64];
	std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", now_tm);
	now_time_str += buf;

	// 格式化微秒
	snprintf(buf, sizeof(buf), ".%06lld ", now_us.count() % 1000000);
	now_time_str += buf;

	//printf("%s\n", now_time_str.c_str());
	return now_time_str;
}

AutoDmp atdmp;

ConsoleThread g_ConsoleThread;


bool StartConsoleThreads(bool start)
{
	bool ret = true;

	g_ConsoleThread.SetName("ConsoleThread");
	if (start)
	{
		ret &= (g_ConsoleThread).StartThread();
	}
	else
	{
		(g_ConsoleThread).StopThread(100);
	}


	return ret;
}


bool WINAPI ConsoleHandler(DWORD msgType)
{
	if ((msgType == CTRL_CLOSE_EVENT) || 
		(msgType == CTRL_SHUTDOWN_EVENT))
	{
		printf("Close console window!\n");
		StartConsoleThreads(false);
		printf("StopThread Finished!\n");
		GetCommandDispathIF()->WaitExit(100, true);
		printf("WaitExit Finished!\n");

		Sleep(1000);
		/* Note: The system gives you very limited time to exit in this condition */
		return true;
	}

	/*
	Other messages:
	CTRL_BREAK_EVENT         Ctrl-Break pressed
	CTRL_LOGOFF_EVENT        User log off
	CTRL_SHUTDOWN_EVENT      System shutdown
	*/

	return false;
}

bool EntryCheck(int argc, _TCHAR* argv[])
{
	//only one driver exist
	if (argc < 2)
	{
		printf("not Driver exist.exit in 3sec\n");
		Sleep(3000);
		return false;
	}

	for (int idx = 1; idx < argc; idx++)
	{
		printf("Add DriverConfig:%s\n", argv[idx]);
		if (AddDriverConfig(argv[idx]) == false)
		{
			printf("DriverConfig File not Right.%s \nexit in 3sec\n", argv[1]);
			Sleep(3000);
			return false;

		}

	}

	return true;
}

class TestMqtt : public Dios_Thread
{
	dios_mqtt_connection* m_pConns;
	int m_nIndex;
	int m_nSendNum;
public:
	TestMqtt(dios_mqtt_connection* pConn, int nIndex, int nSendNum) {
		m_pConns = pConn; m_nIndex = nIndex;
		m_nSendNum = nSendNum;
	}
	~TestMqtt(){}


	bool Exec() override;
	//bool OnStartThread() override;
	//bool OnEndThread() override;
};

bool TestMqtt::Exec()
{
	int y = 0;
	for ( y= 0; y < m_nSendNum; y++)
	{
		char szTopic[256];
		char szContent[128];
		char szKey[32];
		//for (int z = 0; z < nConnNum; z++)
		{
			ResDataObject NotifyData;
			sprintf(szContent, "%d_%d_%s", y, m_nIndex, CurrentDateTime().c_str());
			sprintf(szTopic, "DIOS/TEST/Notify/%d/%d/TestV", GetCurrentProcessId(), m_nIndex);
			sprintf(szKey, "%d", GetTickCount());
			PacketAnalizer::MakeNotify(NotifyData, PACKET_CMD_UPDATE, szKey, szContent);
			//CmdFromLogicDev(&NotifyData);
			int ret = PublishAction(&NotifyData, szTopic, m_pConns);
			cout << "Send [" << szContent << "] to [" << szTopic << "] result " << ret << endl;

		}
	}
	std::wcout << "Send Over " << m_nIndex << " Count " << y << endl;
	return false;
}

int _tmain(int argc, _TCHAR* argv[])
{
	printf("Main Thread:%d\n", GetCurrentThreadId());
	std::cout << "Main " << argc << endl;
	for (size_t i = 0; i < argc; i++)
	{
		cout << "param " << i << " : " << argv[i] << std::endl;
	}
	if (argc > 1)
	{
		if (strcmp(argv[1], "test") == 0)
		{
			char szName[20][256];

			int nConnNum = 5;
			int nSendNum = 10;
			if (argc > 2)
				nConnNum = atoi(argv[2]);
			if (argc > 3)
				nSendNum = atoi(argv[3]);
			if (nConnNum > 20)
				nConnNum = 20;
			dios_mqtt_connection** pConns = new dios_mqtt_connection * [nConnNum];
			TestMqtt** pTests = new TestMqtt * [nConnNum];
			for (int x = 0; x < nConnNum; x++)
			{
				sprintf(szName[x], "TEST_MQTT_Client_%d_%d", x, GetCurrentProcessId());
				pConns[x] = NewConnection(szName[x], [szName,x](ResDataObject* rsp, const  char* topic, void* conn_void) {
					dios_mqtt_connection* conn = (dios_mqtt_connection*)conn_void;
					std::cout << "Server [" << szName[x] << "] " << CurrentDateTime() << "Get Msg from " << topic << /*" Msg Body " << rsp->encode() <<*/ endl;

					if (PacketAnalizer::GetPacketType(rsp) == PACKET_TYPE_RES)
					{
						//check cmd
						if ((PacketAnalizer::GetPacketCmd(rsp) == PACKET_CMD_OPEN) /*&& 	(PacketAnalizer::GetPacketKey(rsp) == realPath)*/)
						{
							//std::cout << "\n\n-----------" << CurrentDateTime() << "LogicClient::Open OK [" << m_strClientName << "] try open path:" << realPath << endl << endl;

							//ret = ProcessOpenResponse(*rsp);


							//if (m_bNeedNotify) {
							string notifyTopic = "DIOS/Tetst/";
							notifyTopic += "/Notify/#";
							SubscribeTopic(conn, notifyTopic.c_str());
							//}
						}
						else
						{
							std::cout << szName[x] << CurrentDateTime() << "Try Conn callback  get unkown packet pointer [" << (UINT64)conn << endl;
							std::cout << "Unkown Packet: cmd [" << PacketAnalizer::GetPacketCmd(rsp) << "] packet key: " << PacketAnalizer::GetPacketKey(rsp) << "" << endl;
							//if (m_pPacketArrivedCallbackFunc != nullptr)
							//{
							//	m_pPacketArrivedCallbackFunc(rsp, topic, conn);
							//}
							//else
							//{
							//	m_pPacketReceivedQue->Lock();
							//	m_pPacketReceivedQue->InQueue(*rsp);
							//	//SetEvent(m_NotifyEvent);//notify to user
							//	SetEvent(m_ResponseEvent);
							//	m_pPacketReceivedQue->UnLock();
							//}
						}
					}
					else
					{

					}

					});
				pTests[x] = new TestMqtt(pConns[x], x , nSendNum);
				char szTopic[256];
				sprintf(szTopic, "DIOS/TEST/CLIENT/C%06d", GetCurrentProcessId());
				SubscribeTopic(pConns[x], szTopic);
				//SubscribeTopic(pConns[x], "DIOS/TEST/Action/#", true);
			}



			std::cout << "Waiting quit..." << endl;
			while (1)
			{
				int c = getchar();
				switch (c)
				{
				case 's':
				{

						for (int z = 0; z < nConnNum; z++)
						{
							pTests[z]->StartThread(false);
						}
				}
				break;
				case 'x':
				{
					for (int x = 0; x < nConnNum; x++)
					{
						cout << "Try ResetConnection" << x << endl;
						ResetConnection(pConns[x]);
						//Sleep(2500);
						cout << "ResetConnection Over" << x << endl;
					}				
				}
				break;
				case 'q':
				{
					break;
				}
				}
				if (c == 'q')
					break;
				std::cout << "Please Input Command " << endl;
				Sleep(10);
			}
			for (int x = 0; x < nConnNum; x++)
			{
				CloseConnection(pConns[x]);
			}
			delete[] pConns;
			std::cout << "Hello World!\n";
			return 0;
		}
	}
	
	bool status = true;

	//这里把多个 通OEMDriver的 xml一起启动
	if (EntryCheck(argc, argv) == false)
	{
		return false;
	}

	if (GetCommandDispathIF()->InitAs(DIOS_PROC_MASTER, (UINT64)GetCurrentProcessId()))
	{
		if (SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleHandler, true))
		{
			//WaitSomeInfo("Driver init Done.Press Any Key to show All Driver List\n", 1000);

			//1. do the bus test
			//Sleep(3000);
			{
				LogicClient buClient("diosproc_exe", "", "", false);
				if (buClient.Open((const char*)getRootpath(), ALL_ACCESS) == RET_SUCCEED)
				{
					//buClient.ExitDriverProc();
					buClient.Close();
					//DWORD count = buClient.GetDeviceCount();
					//for (DWORD i = 0; i < count; i++)
					//{
					//	UINT64 ProcId, Addr;
					//	ResDataObject DevType,devpath, MachineId;
					//	buClient.GetDeviceDescript(i, devpath, DevType, MachineId, ProcId, Addr);
					//	printf("path:%s\nProc:%I64u\nAddr:%I64u\n", (const char*)devpath, ProcId, Addr);
					//	LogicClient DevClient("diosproc_exe_temp","diosproc");
					//	if (DevClient.Open((const char*)devpath, ALL_ACCESS) >= RET_SUCCEED)
					//	{
					//		DevClient.Close();
					//		printf("Open Succeed\n");
					//	}
					//	else
					//	{
					//		printf("Open Failed\n");
					//	}
					//}

					status = true;
				}
				else
				{
					status = false;
				}
			}
			
			//start work
			if (status)
			{

				if (StartConsoleThreads(true))
				{
					printf("Done Init Channel.going to sleep...\n");
					while (1){
						if (GetCommandDispathIF()->WaitExit(500) == true)
						{
							StartConsoleThreads(false);
							return 1;
						}
					}
				}
			}

			printf("Can't Start Console Thread.Exit in 3sec\n");
			Sleep(3000);

			return 0;


		}

	}
	return 0;
}
//int _tmain(int argc, _TCHAR* argv[])
//{
//	printf("Main Thread:%d\n", GetCurrentThreadId());
//	if (GetCommandDispathIF()->InitAs(true, (UINT64)GetCurrentProcessId()))
//	{
//		if (SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleHandler, true))
//		{
//			//1. do the bus test
//			BusUnitClient buClient;
//			if (buClient.Open(getRootpath().c_str(), ALL_ACCESS) == RET_SUCCEED)
//			{
//				buClient.Close();
//				DWORD count = buClient.GetDeviceCount();
//				for (DWORD i = 0; i < count; i++)
//				{
//					UINT64 ProcId, Addr;
//					ResDataObject devpath;
//					buClient.GetDeviceDescript(i, devpath, ProcId, Addr);
//					printf("path:%s\nProc:%I64u\nAddr:%I64u\n", (const char*)devpath, ProcId, Addr);
//				}
//			}
//
//			//1. do the Wheel test
//			DWORD loop = 8;
//			CommonLogicClient WheelClient;
//			HANDLE notifyhandle = WheelClient.GetNotifyHandle();
//			if (WheelClient.Open("/diosAlpha/Major/Minor/Ecom/AbstractSeq/1234/{4E4206DA-DA34-4E71-7F42-97E0ABFF3F81}",
//				ALL_ACCESS) == RET_SUCCEED)
//			{
//				while (loop--)
//				{
//					ResDataObject Request,Response;
//					WheelClient.Action("OpenLogicDevice", Request, Response);
//					WheelClient.Action("GetSEQResource", Request, Response);
//					WheelClient.Action("FrameInState", Request, Response);
//					//bool status = false;
//					//PACKET_CMD cmd;
//					//ResDataObject data;
//					//WheelClient.StartRoll();
//					////Notify
//					//cmd = PACKET_CMD_NONE;
//					//printf("Wait for a notify\n");
//					//while (cmd == PACKET_CMD_NONE)
//					//{
//					//	WaitForSingleObject(notifyhandle, INFINITE);
//					//	while (WheelClient.IsDataArrived())
//					//	{
//					//		cmd = WheelClient.ReadCmd(data);
//					//		printf("cmd:%d\n", cmd);
//					//		if (cmd == PACKET_CMD_UPDATE)
//					//		{
//					//			//got update notify
//					//			WheelClient.GetLocalStatus(status);
//					//			printf("current status :%d\n", status);
//					//		}
//					//	}
//					//}
//
//					//WheelClient.StopRoll();
//					////Notify
//					//cmd = PACKET_CMD_NONE;
//					//printf("Wait for a notify\n");
//					//while (cmd == PACKET_CMD_NONE)
//					//{
//					//	WaitForSingleObject(notifyhandle, INFINITE);
//					//	while (WheelClient.IsDataArrived())
//					//	{
//					//		cmd = WheelClient.ReadCmd(data);
//					//		printf("cmd:%d\n", cmd);
//					//		if (cmd == PACKET_CMD_UPDATE)
//					//		{
//					//			//got update notify
//					//			WheelClient.GetLocalStatus(status);
//					//			printf("current status :%d\n", status);
//					//		}
//					//	}
//					//}
//
//				}
//
//				WheelClient.Close();
//			}
//
//			//printf("Press Ctrl-C or [x] to close...\n");
//			while (1){ Sleep(2000); }
//		}
//
//	}
//	return 0;
//}