wnmj-normal/Servers/服务器组件/内核引擎/AsynchronismEngine.cpp

#include "StdAfx.h"
#include "TraceService.h" // #include "EventService.h"
#include "AsynchronismEngine.h"

//////////////////////////////////////////////////////////////////////////
//宏定义

#define WM_ASYN_REQUEST					WM_USER+10						//异步请求

//////////////////////////////////////////////////////////////////////////

BEGIN_MESSAGE_MAP(CControlWnd, CWnd)
	ON_MESSAGE(WM_ASYN_REQUEST, OnAsynRequest)
END_MESSAGE_MAP()

//////////////////////////////////////////////////////////////////////////

//构造函数
CControlWnd::CControlWnd()
{
	m_pAsynchronismEngine = NULL;
}

//析构函数
CControlWnd::~CControlWnd()
{
}

//请求消息
HRESULT CControlWnd::OnAsynRequest(WPARAM wParam, LPARAM lParam)
{
	//效验变量
	ASSERT(m_pAsynchronismEngine != NULL);

	//获取参数
	WORD wRequestID = (WORD)wParam;
	IAsynchronismEngineSink * pIAsynchronismEngineSink = (IAsynchronismEngineSink *)lParam;

	//请求处理
	ASSERT(pIAsynchronismEngineSink != NULL);
	m_pAsynchronismEngine->OnAsynchronismRequest(wRequestID, pIAsynchronismEngineSink);

	return 0;
}

//////////////////////////////////////////////////////////////////////////

//构造函数
CMessageThread::CMessageThread()
{
	m_pAsynchronismEngine = NULL;
}

//析构函数
CMessageThread::~CMessageThread()
{
}

//运行函数
bool CMessageThread::OnEventThreadRun()
{
	MSG Message;
	if (GetMessage(&Message, NULL, 0, 0))
	{
		TranslateMessage(&Message);
		DispatchMessage(&Message);
		return true;
	}
	return false;
}

//停止线程
bool CMessageThread::StopThread(DWORD dwWaitSeconds)
{
	PostThreadMessage(WM_QUIT, 0, 0);
	return __super::ConcludeThread(dwWaitSeconds);
}

//中止线程
bool CMessageThread::TerminateThread(DWORD dwExitCode)
{
	PostThreadMessage(WM_QUIT, 0, 0);
	return __super::ConcludeThread(INFINITE);
}

//开始事件
bool CMessageThread::OnThreadStratEvent()
{
	ASSERT(m_pAsynchronismEngine != NULL);
	return m_pAsynchronismEngine->OnMessageThreadStart();
}

//停止事件
bool CMessageThread::OnThreadStopEvent()
{
	ASSERT(m_pAsynchronismEngine != NULL);
	return m_pAsynchronismEngine->OnMessageThreadStop();
}

//////////////////////////////////////////////////////////////////////////

//构造函数
CAsynchronismEngine::CAsynchronismEngine(void)
{
	//设置变量
	m_bService = false;
	memset(m_cbBuffer, 0, sizeof(m_cbBuffer));

	//设置组件
	m_ControlWnd.m_pAsynchronismEngine = this;
	m_MessageThread.m_pAsynchronismEngine = this;

	return;
}

//析构函数
CAsynchronismEngine::~CAsynchronismEngine(void)
{
}

//接口查询
void * CAsynchronismEngine::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(IAsynchronismEngine, Guid, dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(IAsynchronismEngine, Guid, dwQueryVer);
	return NULL;
}

//启动服务
bool CAsynchronismEngine::StartService()
{
	//启动线程
	if (m_MessageThread.StartThread() == false) return false;

	//设置变量
	m_bService = true;

	return true;
}

//停止服务
bool CAsynchronismEngine::ConcludeService()
{
	//设置变量
	m_bService = false;

	//停止线程
	m_MessageThread.ConcludeThread(INFINITE);

	//清理数据
	m_DataStorage.RemoveData(false);

	return true;
}

//插入请求
bool CAsynchronismEngine::InsertRequest(WORD wRequestID, void * const pBuffer, WORD wDataSize, IUnknownEx * pIUnknownEx)
{
	//效验状态
	ASSERT(wDataSize <= sizeof(m_cbBuffer));
	if (m_bService == false) return false;
	if (wDataSize > sizeof(m_cbBuffer)) return false;

	//查询接口
	IAsynchronismEngineSink * pIAsynchronismEngineSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IAsynchronismEngineSink);
	ASSERT(pIAsynchronismEngineSink != NULL);
	if (pIAsynchronismEngineSink == NULL) return false;

	//插入数据
	CWHDataLocker lcok(m_CriticalSection); // CWHDataLockerHandle ThreadLockHandle(&m_ThreadLock);
	if (m_DataStorage.InsertData(wRequestID, pBuffer, wDataSize) == false) return false;

	//投递消息
	PostMessage(m_ControlWnd.m_hWnd, WM_ASYN_REQUEST, wRequestID, (LPARAM)pIAsynchronismEngineSink);

	return true;
}

//队列负荷
bool CAsynchronismEngine::GetBurthenInfo( tagBurthenInfo & BurthenInfo )
{
	ASSERT(TRUE);ASSERT(FALSE);
	return true;
}

//注册钩子
bool CAsynchronismEngine::SetAsynchronismSink(IUnknownEx * pIUnknownEx)
{
	//获取接口
	IAsynchronismEngineSink * pIAsynchronismEngineSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IAsynchronismEngineSink);
	ASSERT(pIAsynchronismEngineSink != NULL);
	if (pIAsynchronismEngineSink == NULL) return false;

	//查找现存
	IAsynchronismEngineSink * pIAsynchronismEngineSinkTemp = NULL;
	for (INT_PTR i = 0; i < m_AsynchronismEngineSinkArray.GetCount(); i++)
	{
		pIAsynchronismEngineSinkTemp = m_AsynchronismEngineSinkArray[i];
		ASSERT(pIAsynchronismEngineSinkTemp != NULL);
		if (pIAsynchronismEngineSinkTemp == pIAsynchronismEngineSink) return false;
	}

	//注册钩子
	m_AsynchronismEngineSinkArray.Add(pIAsynchronismEngineSink);

	return true;
}

//投递数据
bool CAsynchronismEngine::PostAsynchronismData(WORD wIdentifier, VOID * pData, WORD wDataSize)
{
	//效验状态
	ASSERT(wDataSize <= sizeof(m_cbBuffer));
	if (m_bService == false) return false;
	if (wDataSize > sizeof(m_cbBuffer)) return false;

// 	//查询接口
// 	IAsynchronismEngineSink * pIAsynchronismEngineSink = QUERY_ME_INTERFACE(IAsynchronismEngineSink);
// 	ASSERT(pIAsynchronismEngineSink != NULL);
// 	if (pIAsynchronismEngineSink == NULL) return false;

	//插入数据
	CWHDataLocker lcok(m_CriticalSection); // CWHDataLockerHandle ThreadLockHandle(&m_ThreadLock);
	if (m_DataStorage.InsertData(wIdentifier, pData, wDataSize) == false) return false;

	//投递消息
	PostMessage(m_ControlWnd.m_hWnd, WM_ASYN_REQUEST, (WPARAM)pData, /*(LPARAM)pIAsynchronismEngineSink*/0);

	return true;
}

//投递数据
bool CAsynchronismEngine::PostAsynchronismData( WORD wIdentifier, tagDataBuffer DataBuffer[], WORD wDataCount )
{
	ASSERT(TRUE);ASSERT(FALSE);
	return true;
}

//取消注册
bool CAsynchronismEngine::UnRegisterAsynchronismEngineSink(IUnknownEx * pIUnknownEx)
{
	//获取接口
	IAsynchronismEngineSink * pIAsynchronismEngineSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IAsynchronismEngineSink);
	ASSERT(pIAsynchronismEngineSink != NULL);
	if (pIAsynchronismEngineSink == NULL) return false;

	//删除钩子
	IAsynchronismEngineSink * pIAsynchronismEngineSinkTemp = NULL;
	for (INT_PTR i = 0; i < m_AsynchronismEngineSinkArray.GetCount(); i++)
	{
		pIAsynchronismEngineSinkTemp = m_AsynchronismEngineSinkArray[i];
		ASSERT(pIAsynchronismEngineSinkTemp != NULL);
		if (pIAsynchronismEngineSinkTemp == pIAsynchronismEngineSink)
		{
			m_AsynchronismEngineSinkArray.RemoveAt(i);
			return true;
		}
	}

	return false;
}

//线程启动
bool CAsynchronismEngine::OnMessageThreadStart()
{
	//创建窗口
	if (m_ControlWnd.m_hWnd == NULL)
		m_ControlWnd.Create(NULL, NULL, WS_CHILD, CRect(0, 0, 0, 0), CWnd::GetDesktopWindow(), 10);

	//事件通知
	bool bSuccsee = true;
	IAsynchronismEngineSink * pIAsynchronismEngineSink = NULL;
	for (INT_PTR i = 0; i < m_AsynchronismEngineSinkArray.GetCount(); i++)
	{
		pIAsynchronismEngineSink = m_AsynchronismEngineSinkArray[i];
		ASSERT(pIAsynchronismEngineSink != NULL);
		try
		{
			if (!pIAsynchronismEngineSink->OnAsynchronismEngineStart())
			{
				bSuccsee = false;
			}
		}
		catch (...)
		{
			bSuccsee = false;
		}
	}

	return bSuccsee;
}

//线程停止
bool CAsynchronismEngine::OnMessageThreadStop()
{
	//关闭窗口
	m_ControlWnd.DestroyWindow();

	//事件通知
	bool bSuccsee = true;
	IAsynchronismEngineSink * pIAsynchronismEngineSink = NULL;
	for (INT_PTR i = 0; i < m_AsynchronismEngineSinkArray.GetCount(); i++)
	{
		pIAsynchronismEngineSink = m_AsynchronismEngineSinkArray[i];
		ASSERT(pIAsynchronismEngineSink != NULL);
		try
		{
			if (!pIAsynchronismEngineSink->OnAsynchronismEngineConclude())
			{
				bSuccsee = false;
			}
		}
		catch (...)
		{
			bSuccsee = false;
		}
	}

	return bSuccsee;
}

//异步请求
void CAsynchronismEngine::OnAsynchronismRequest(WORD wRequestID, IAsynchronismEngineSink * pIAsynchronismEngineSink)
{
	//锁定资源
	CWHDataLocker lcok(m_CriticalSection);

	//提取数据
	tagDataHead DataHead;
	if (m_DataStorage.DistillData(DataHead, m_cbBuffer, sizeof(m_cbBuffer)))
	{
		//消息处理
		try
		{
			ASSERT(DataHead.wIdentifier == wRequestID);
			pIAsynchronismEngineSink->OnAsynchronismEngineData(wRequestID, m_cbBuffer, DataHead.wDataSize);
		}
		catch (...)
		{

		}
	}


	return;
}

//////////////////////////////////////////////////////////////////////////

//建立对象函数
extern "C" __declspec(dllexport) void * CreateAsynchronismEngine(const GUID & Guid, DWORD dwInterfaceVer)
{
	//建立对象
	CAsynchronismEngine * pAsynchronismEngine = NULL;
	try
	{
		pAsynchronismEngine = new CAsynchronismEngine();
		if (pAsynchronismEngine == NULL) throw TEXT("创建失败");
		void * pObject = pAsynchronismEngine->QueryInterface(Guid, dwInterfaceVer);
		if (pObject == NULL) throw TEXT("接口查询失败");
		return pObject;
	}
	catch (...) {}

	//清理对象
	SafeDelete(pAsynchronismEngine);
	return NULL;
}

//////////////////////////////////////////////////////////////////////////