You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
509 lines
13 KiB
509 lines
13 KiB
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
queryobj.cpp
|
|
Implementation for nodes in the MMC
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "queryobj.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CBackgroundThread
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
DEBUG_DECLARE_INSTANCE_COUNTER(CBackgroundThread);
|
|
|
|
CBackgroundThread::CBackgroundThread()
|
|
{
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(CBackgroundThread);
|
|
|
|
m_bAutoDelete = TRUE;
|
|
::InitializeCriticalSection(&m_cs);
|
|
}
|
|
|
|
CBackgroundThread::~CBackgroundThread()
|
|
{
|
|
DEBUG_DECREMENT_INSTANCE_COUNTER(CBackgroundThread);
|
|
|
|
// Trace0("CBackgroundThread::~CBackgroundThread()\n");
|
|
::DeleteCriticalSection(&m_cs);
|
|
m_spQuery.Release();
|
|
}
|
|
|
|
void
|
|
CBackgroundThread::SetQueryObj(ITFSQueryObject *pQuery)
|
|
{
|
|
Assert(pQuery != NULL);
|
|
m_spQuery.Set(pQuery);
|
|
}
|
|
|
|
BOOL CBackgroundThread::Start()
|
|
{
|
|
// NOTE::: ericdav 10/23/97
|
|
// the thread is initially suspended so we can duplicate the handle
|
|
// if the query object exits very quickly, the background thread object
|
|
// may be destroyed before we can duplicate the handle. Right after
|
|
// we duplicate the handle, it is started.
|
|
return CreateThread(CREATE_SUSPENDED);
|
|
}
|
|
|
|
int
|
|
CBackgroundThread::Run()
|
|
{
|
|
DWORD dwRet;
|
|
DWORD dwData;
|
|
BOOL fAbort = FALSE;
|
|
|
|
Assert(m_spQuery);
|
|
// Trace0("CBackgroundThread::Run() started\n");
|
|
|
|
for (;;)
|
|
{
|
|
try
|
|
{
|
|
if (m_spQuery->Execute() != hrOK)
|
|
break;
|
|
}
|
|
catch(...)
|
|
{
|
|
// Trace1("%x Caught an exception while executing CQuerObj!\n",
|
|
// GetCurrentThreadId());
|
|
fAbort = TRUE;
|
|
}
|
|
|
|
//$ Review: kennt
|
|
// Should we sleep a little while at this point? especially
|
|
// since the thread has given us some data to process.
|
|
|
|
// Check to see if the abort flag is set
|
|
if (fAbort || FHrOK(m_spQuery->FCheckForAbort()))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Notify the query object that we are exiting
|
|
if (fAbort || FHrOK(m_spQuery->FCheckForAbort()))
|
|
m_spQuery->OnEventAbort();
|
|
else
|
|
m_spQuery->OnThreadExit();
|
|
|
|
m_spQuery->DoCleanup();
|
|
|
|
Trace2("handle=%X id=%X CBackgroundThread::Run() terminated\n",
|
|
m_hThread, m_nThreadID);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CQueryObject implementation
|
|
---------------------------------------------------------------------------*/
|
|
DEBUG_DECLARE_INSTANCE_COUNTER(CQueryObject);
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CQueryObject::CQueryObject
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
CQueryObject::CQueryObject()
|
|
{
|
|
DEBUG_INCREMENT_INSTANCE_COUNTER(CQueryObject);
|
|
|
|
m_cRef = 1;
|
|
m_hEventAbort = NULL;
|
|
::InitializeCriticalSection(&m_cs);
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CQueryObject::~CQueryObject
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
CQueryObject::~CQueryObject()
|
|
{
|
|
DEBUG_DECREMENT_INSTANCE_COUNTER(CQueryObject);
|
|
|
|
Assert(m_cRef == 0);
|
|
::DeleteCriticalSection(&m_cs);
|
|
::CloseHandle(m_hEventAbort);
|
|
m_hEventAbort = 0;
|
|
// Trace1("%X CQueryObject::~CQueryObject()\n", GetCurrentThreadId());
|
|
}
|
|
|
|
IMPLEMENT_ADDREF_RELEASE(CQueryObject)
|
|
|
|
STDMETHODIMP CQueryObject::QueryInterface(REFIID riid, LPVOID *ppv)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
// Is the pointer bad?
|
|
if (ppv == NULL)
|
|
return E_INVALIDARG;
|
|
|
|
// Place NULL in *ppv in case of failure
|
|
*ppv = NULL;
|
|
|
|
// This is the non-delegating IUnknown implementation
|
|
if (riid == IID_IUnknown)
|
|
*ppv = (LPVOID) this;
|
|
else if (riid == IID_ITFSQueryObject)
|
|
*ppv = (ITFSQueryObject *) this;
|
|
|
|
// If we're going to return an interface, AddRef it first
|
|
if (*ppv)
|
|
{
|
|
((LPUNKNOWN) *ppv)->AddRef();
|
|
return hrOK;
|
|
}
|
|
else
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CQueryObject::Init
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CQueryObject::Init(ITFSThreadHandler *pHandler, HWND hwndHidden, UINT uMsgBase)
|
|
{
|
|
Assert(m_spHandler == NULL);
|
|
m_spHandler.Set(pHandler);
|
|
|
|
m_hHiddenWnd = hwndHidden;
|
|
m_uMsgBase = uMsgBase;
|
|
|
|
m_hEventAbort = ::CreateEvent(NULL,
|
|
TRUE /*bManualReset*/,
|
|
FALSE /*signalled*/,
|
|
NULL);
|
|
if (m_hEventAbort == NULL)
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
else
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CQueryObject::SetAbortEvent
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CQueryObject::SetAbortEvent()
|
|
{
|
|
// Trace1("%X Signalling CQueryObject abort event.\n", GetCurrentThreadId());
|
|
Assert(m_hEventAbort);
|
|
|
|
::SetEvent(m_hEventAbort);
|
|
|
|
OnEventAbort();
|
|
|
|
// flush out the message queue in case something is wait to be processed
|
|
MSG msg;
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CQueryObject::FCheckForAbort
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CQueryObject::FCheckForAbort()
|
|
{
|
|
// Assert(m_hEventAbort);
|
|
|
|
// we may not be running as a background thread, but somebody may have
|
|
// created this object to do somework... In which case this isn't valid,
|
|
// and just return ok
|
|
if (!m_hEventAbort)
|
|
return hrOK;
|
|
|
|
DWORD dwRet = WaitForSingleObjectEx(m_hEventAbort, 0, FALSE);
|
|
#ifdef DEBUG
|
|
// if (dwRet == WAIT_OBJECT_0)
|
|
// Trace1("%X CQueryObject() detects an abort event!\n", GetCurrentThreadId());
|
|
#endif
|
|
return dwRet == WAIT_OBJECT_0 ? hrOK : hrFalse;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CNodeQueryObject implementation
|
|
---------------------------------------------------------------------------*/
|
|
|
|
CNodeQueryObject::~CNodeQueryObject()
|
|
{
|
|
// Trace2("%X CNodeQueryObject::~CNodeQueryObject has %d objects\n",
|
|
// GetCurrentThreadId(), m_dataQueue.GetCount());
|
|
Assert(m_dataQueue.IsEmpty());
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::AddToQueue
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
BOOL CNodeQueryObject::AddToQueue(ITFSNode *pNode)
|
|
{
|
|
BOOL bSleep = FALSE;
|
|
|
|
Lock();
|
|
//::Sleep(1000);
|
|
LPQUEUEDATA pQData = new QUEUEDATA;
|
|
|
|
pQData->Type = QDATA_PNODE;
|
|
pQData->Data = reinterpret_cast<LPARAM>(pNode);
|
|
|
|
BOOL bRes = NULL != m_dataQueue.AddTail(pQData);
|
|
pNode->AddRef();
|
|
|
|
if (IsQueueFull())
|
|
{
|
|
bSleep = TRUE;
|
|
}
|
|
Unlock();
|
|
|
|
// We have too much data, we've posted a notification to the node
|
|
// so we can go to sleep here.
|
|
|
|
// Note the danger here! The code calling has to be aware that a
|
|
// context switch will occur here (as well as not locking the data
|
|
// structures).
|
|
if (bSleep)
|
|
{
|
|
PostHaveData((LPARAM) (CNodeQueryObject *) this);
|
|
::Sleep(0);
|
|
}
|
|
|
|
return bRes;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::AddToQueue
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
BOOL CNodeQueryObject::AddToQueue(LPARAM Data, LPARAM Type)
|
|
{
|
|
BOOL bSleep = FALSE;
|
|
|
|
Lock();
|
|
//::Sleep(1000);
|
|
LPQUEUEDATA pQData = new QUEUEDATA;
|
|
|
|
pQData->Data = Data;
|
|
pQData->Type = Type;
|
|
|
|
BOOL bRes = NULL != m_dataQueue.AddTail(pQData);
|
|
|
|
if (IsQueueFull())
|
|
{
|
|
bSleep = TRUE;
|
|
}
|
|
Unlock();
|
|
|
|
// We have too much data, we've posted a notification to the node
|
|
// so we can go to sleep here.
|
|
|
|
// Note the danger here! The code calling has to be aware that a
|
|
// context switch will occur here (as well as not locking the data
|
|
// structures).
|
|
if (bSleep)
|
|
{
|
|
PostHaveData((LPARAM) (CNodeQueryObject *) this);
|
|
::Sleep(0);
|
|
}
|
|
|
|
return bRes;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::RemoveFromQueue
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
LPQUEUEDATA
|
|
CNodeQueryObject::RemoveFromQueue()
|
|
{
|
|
Lock();
|
|
LPQUEUEDATA pQD = m_dataQueue.IsEmpty() ? NULL : m_dataQueue.RemoveHead();
|
|
Unlock();
|
|
return pQD;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::IsQueueEmpty
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
BOOL
|
|
CNodeQueryObject::IsQueueEmpty()
|
|
{
|
|
Lock();
|
|
BOOL bRes = m_dataQueue.IsEmpty();
|
|
Unlock();
|
|
return bRes;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::IsQueueFull
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
BOOL CNodeQueryObject::IsQueueFull()
|
|
{
|
|
Lock();
|
|
BOOL bRes = m_dataQueue.GetCount() >= m_nQueueCountMax;
|
|
Unlock();
|
|
return bRes;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::OnThreadExit
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CNodeQueryObject::OnThreadExit()
|
|
{
|
|
BOOL fSomethingInQueue = FALSE;
|
|
|
|
Lock();
|
|
fSomethingInQueue = (m_dataQueue.GetCount() > 0);
|
|
Unlock();
|
|
|
|
// If there's anything in the queue, post
|
|
if (fSomethingInQueue)
|
|
{
|
|
PostHaveData((LPARAM) (CNodeQueryObject *) this);
|
|
::Sleep(0);
|
|
}
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::OnEventAbort
|
|
-
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CNodeQueryObject::OnEventAbort()
|
|
{
|
|
// Trace2("%X CNodeQueryObject::OnEventAbort Q has %d nodes.\n", GetCurrentThreadId(), m_dataQueue.GetCount());
|
|
Lock();
|
|
while (!m_dataQueue.IsEmpty())
|
|
{
|
|
LPQUEUEDATA pQD = m_dataQueue.RemoveHead();
|
|
if (pQD->Type == QDATA_PNODE)
|
|
{
|
|
SPITFSNode spNode;
|
|
spNode = reinterpret_cast<ITFSNode *>(pQD->Data);
|
|
}
|
|
else
|
|
{
|
|
// give the query object a chance to clean up this data
|
|
OnEventAbort(pQD->Data, pQD->Type);
|
|
}
|
|
|
|
delete pQD;
|
|
}
|
|
|
|
Unlock();
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::OnCleanup
|
|
DO NOT override this function. It provides a last cleanup
|
|
mechanism for the query object. If you need notification
|
|
that a thread is exiting, then override the OnThreadExit call.
|
|
Author: EricDav
|
|
---------------------------------------------------------------------------*/
|
|
STDMETHODIMP CNodeQueryObject::DoCleanup()
|
|
{
|
|
PostMessageToComponentData(WM_HIDDENWND_INDEX_EXITING, (LPARAM) (CNodeQueryObject *) this);
|
|
|
|
m_spQuery.Release();
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
/*!--------------------------------------------------------------------------
|
|
CNodeQueryObject::PostMessageToComponentData
|
|
Posts a message to the hidden window to get back on the main
|
|
MMC thread.
|
|
Author: KennT
|
|
---------------------------------------------------------------------------*/
|
|
BOOL
|
|
CNodeQueryObject::PostMessageToComponentData(UINT uIndex, LPARAM lParam)
|
|
{
|
|
// Assert(m_spHandler);
|
|
// Assert(m_hHiddenWnd != NULL);
|
|
// Assert(::IsWindow(m_hHiddenWnd));
|
|
|
|
//$ Review: kennt, if the hidden window is bogus, should we still post
|
|
// to it? This could happen if our ComponentData went away but we were
|
|
// still in our loop, posting away (we haven't had a chance to get the
|
|
// abort signal).
|
|
|
|
// maybe something like
|
|
|
|
if (!m_hHiddenWnd)
|
|
return 0;
|
|
|
|
if (!::IsWindow(m_hHiddenWnd))
|
|
{
|
|
// Trace2("%X The Hidden window is GONE, tried to send %08x.\n",
|
|
// GetCurrentThreadId(), m_uMsgBase+uIndex);
|
|
m_hHiddenWnd = NULL;
|
|
return 0;
|
|
}
|
|
|
|
//Trace2("%X CBackgroundThread::PostMessageToComponentData(%08x)\n", GetCurrentThreadId(), m_uMsgBase+uIndex);
|
|
|
|
if (!m_spHandler)
|
|
{
|
|
// Trace0("PostMessageToCompData - m_spHandler == NULL, NOT posting a message\n");
|
|
return 0;
|
|
}
|
|
|
|
return ::PostMessage(m_hHiddenWnd, m_uMsgBase + uIndex,
|
|
(WPARAM)(ITFSThreadHandler *)m_spHandler, lParam);
|
|
}
|
|
|
|
/*---------------------------------------------------------------------------
|
|
CNodeTimerQueryObject implementation
|
|
---------------------------------------------------------------------------*/
|
|
HRESULT
|
|
CNodeTimerQueryObject::Execute()
|
|
{
|
|
|
|
while (WaitForSingleObjectEx(m_hEventAbort, GetTimerInterval(), FALSE) != WAIT_OBJECT_0)
|
|
{
|
|
// we timed out. Post a message to the ComponentData...
|
|
AddToQueue(NULL, QDATA_TIMER);
|
|
}
|
|
|
|
// Trace0("CNodeTimerQueryObject::Execute - got abort event, exiting.\n");
|
|
|
|
return hrFalse;
|
|
}
|