/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
info.cpp
FILE HISTORY:
*/
#include "stdafx.h"
#include "infoi.h"
#include "rtrstr.h" // common router strings
#include "refresh.h"
#include "dvsview.h"
#include "machine.h"
#include "rtrutilp.h"
// Number of connections that we have made, this is used to
// generate the dwConnectionId
extern long s_cConnections;
DEBUG_DECLARE_INSTANCE_COUNTER(RefreshItem);
/*!--------------------------------------------------------------------------
RouterObjectRefreshTimerProc
-
Author: KennT
---------------------------------------------------------------------------*/
void RouterRefreshObjectTimerProc(LPARAM lParam, DWORD dwTime)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// The lParam passed in is a pointer to the RouterRefreshObject
// Call through on the RouterRefreshObject to start the query
// object
((RouterRefreshObject *)lParam)->ExecuteRefresh();
}
/*---------------------------------------------------------------------------
RouterRefreshObjectGroup implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(RouterRefreshObjectGroup);
RouterRefreshObjectGroup::~RouterRefreshObjectGroup()
{
POSITION p = NULL;
RouterRefreshObject* pObj = NULL;
for(p = m_list.GetHeadPosition(); p != NULL; )
{
pObj = m_list.GetNext(p);
Assert(pObj != NULL);
pObj->SetGroup(NULL);
pObj->Release();
}
m_list.RemoveAll();
DEBUG_DECREMENT_INSTANCE_COUNTER(RouterRefreshObjectGroup);
}
/*!--------------------------------------------------------------------------
RouterRefreshObjectGroup::Join
-
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObjectGroup::Join(RouterRefreshObject* pRefresh)
{
Assert(pRefresh);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_list.AddTail(pRefresh);
pRefresh->AddRef();
pRefresh->SetGroup(this);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObjectGroup::Leave
-
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObjectGroup::Leave(RouterRefreshObject* pRefresh)
{
POSITION p = m_list.Find(pRefresh);
if (p)
{
Assert(pRefresh == m_list.GetAt(p));
m_list.RemoveAt(p);
pRefresh->SetGroup(NULL);
pRefresh->Release();
}
return S_OK;
}
/*!--------------------------------------------------------------------------
RouterRefreshObjectGroup::Refresh
call each member in the group to DoRefresh
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObjectGroup::Refresh()
{
POSITION p = NULL;
RouterRefreshObject* pObj = NULL;
for(p = m_list.GetHeadPosition(); p != NULL; )
{
pObj = m_list.GetNext(p);
Assert(pObj != NULL);
pObj->DoRefresh();
}
return S_OK;
}
/*---------------------------------------------------------------------------
RouterRefreshObject implementation
---------------------------------------------------------------------------*/
IMPLEMENT_ADDREF_RELEASE(RouterRefreshObject);
DEBUG_DECLARE_INSTANCE_COUNTER(RouterRefreshObject);
STDMETHODIMP RouterRefreshObject::QueryInterface(REFIID iid,void **ppv)
{
*ppv = 0;
if (iid == IID_IUnknown)
*ppv = (IUnknown *) (IRouterRefresh *) this;
else if (iid == IID_IRouterRefresh)
*ppv = (IRouterRefresh *) this;
else if (iid == IID_IRouterRefreshModify)
*ppv = (IRouterRefreshModify *) this;
else
return ThreadHandler::QueryInterface(iid, ppv);
((IUnknown *) *ppv)->AddRef();
return hrOK;
}
RouterRefreshObject::RouterRefreshObject(HWND hWndSync)
: m_hWndSync(hWndSync),
m_dwSeconds(DEFAULT_REFRESH_INTERVAL),
m_iEventId(-1),
m_pRefreshGroup(NULL),
m_fStarted(FALSE),
m_fInRefresh(FALSE)
{
DEBUG_INCREMENT_INSTANCE_COUNTER(RouterRefreshObject);
InitializeCriticalSection(&m_critsec);
}
RouterRefreshObject::~RouterRefreshObject()
{
// Shut down the timer if its started
Stop();
DEBUG_DECREMENT_INSTANCE_COUNTER(RouterRefreshObject);
DeleteCriticalSection(&m_critsec);
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::GetRefreshInterval
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::GetRefreshInterval(DWORD *pdwSeconds)
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
if (pdwSeconds == NULL)
return E_INVALIDARG;
COM_PROTECT_TRY
{
if (pdwSeconds)
*pdwSeconds = m_dwSeconds;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::GetRefreshInterval
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::SetRefreshInterval(DWORD dwSeconds)
{
HRESULT hr = hrOK;
if (IsRefreshStarted() == hrOK)
{
Stop();
Start(dwSeconds);
}
else
{
RtrCriticalSection rtrCritSec(&m_critsec);
m_dwSeconds = dwSeconds;
}
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::IsInRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::IsInRefresh()
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
hr = (m_fInRefresh) ? hrOK : hrFalse;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::Refresh
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::Refresh()
{
if (m_pRefreshGroup)
{
return m_pRefreshGroup->Refresh();
}
else
{
return DoRefresh();
}
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::DoRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObject::DoRefresh()
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
// If we are in a refresh cycle, return hrOK
if (m_fInRefresh)
goto Error;
// If we are not in a refresh cycle, then we start one
ExecuteRefresh();
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::Start
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::Start(DWORD dwSeconds)
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
// If we are already started then end
if (m_fStarted)
goto Error;
// Start the timer going
m_fStarted = TRUE;
m_dwSeconds = dwSeconds;
m_iEventId = g_timerMgr.AllocateTimer(RouterRefreshObjectTimerProc,
(LPARAM) this,
dwSeconds * 1000);
if (m_iEventId == -1)
{
m_fStarted = FALSE;
hr = HRESULT_FROM_WIN32(::GetLastError());
}
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::Stop
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::Stop()
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
if (!m_fStarted)
{
Assert(m_iEventId == -1);
goto Error;
}
// Stop the timer
if (m_iEventId != -1)
g_timerMgr.FreeTimer(m_iEventId);
m_iEventId = -1;
ReleaseThreadHandler();
WaitForThreadToExit();
m_fStarted = FALSE;
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::IsRefreshStarted
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::IsRefreshStarted()
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
hr = m_fStarted ? hrOK : hrFalse;
Assert((m_fStarted == FALSE) || (m_iEventId != -1));
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::AdviseRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::AdviseRefresh(IRtrAdviseSink *pRtrAdviseSink,
LONG_PTR *pdwConnection,
LPARAM lUserParam)
{
Assert(pRtrAdviseSink);
Assert(pdwConnection);
RtrCriticalSection rtrCritSec(&m_critsec);
DWORD dwConnId;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
dwConnId = (DWORD) InterlockedIncrement(&s_cConnections);
CORg( m_AdviseList.AddConnection(pRtrAdviseSink, dwConnId, lUserParam) );
*pdwConnection = dwConnId;
COM_PROTECT_ERROR_LABEL;
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::AddRouter
-
Author: WeiJiang
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::AddRouterObject(REFIID riid, IUnknown *pUnk)
{
HRESULT hr = S_OK;
IRouterInfo * pRouterInfo;
if (riid != IID_IRouterInfo)
return E_NOINTERFACE;
pRouterInfo = reinterpret_cast<IRouterInfo *>(pUnk);
COM_PROTECT_TRY
{
CRouterInfoRefreshItem* pRefreshItem =
new CRouterInfoRefreshItem(pRouterInfo);
if (pRefreshItem)
{
// check for duplicates
if (S_FALSE == m_listElements.AddRefreshItem(pRefreshItem))
delete pRefreshItem;
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::RemoveRouterObject
-
Author: WeiJiang
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::RemoveRouterObject(REFIID riid, IUnknown *pUnk)
{
if (riid != IID_IRouterInfo)
return E_NOINTERFACE;
IRouterInfo * pRouterInfo = reinterpret_cast<IRouterInfo *>(pUnk);
CRouterInfoRefreshItem RefreshItem(pRouterInfo);
return m_listElements.RemoveRefreshItem(RefreshItem);
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::AddStatusNode
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObject::AddStatusNode(DomainStatusHandler* pStatusHandler, ITFSNode *pServerNode)
{
HRESULT hr = S_OK;
COM_PROTECT_TRY
{
CStatusNodeRefreshItem* pRefreshItem = new CStatusNodeRefreshItem(pStatusHandler, pServerNode);
if (pRefreshItem)
{
// Check for duplicates
if (S_FALSE == m_listElements.AddRefreshItem(pRefreshItem))
delete pRefreshItem;
}
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::RemoveRouter
-
Author: KennT
---------------------------------------------------------------------------*/
HRESULT RouterRefreshObject::RemoveStatusNode(ITFSNode *pServerNode)
{
CStatusNodeRefreshItem RefreshItem((DomainStatusHandler *)0x1, pServerNode);
return m_listElements.RemoveRefreshItem(RefreshItem);
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::NotifyRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::NotifyRefresh()
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
m_AdviseList.NotifyChange(ROUTER_REFRESH, 0, 0);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::UnadviseRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
STDMETHODIMP RouterRefreshObject::UnadviseRefresh(LONG_PTR dwConnection)
{
RtrCriticalSection rtrCritSec(&m_critsec);
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
hr = m_AdviseList.RemoveConnection(dwConnection);
}
COM_PROTECT_CATCH;
return hr;
}
/*!--------------------------------------------------------------------------
RouterRefreshObject::ExecuteRefresh
-
Author: KennT
---------------------------------------------------------------------------*/
void RouterRefreshObject::ExecuteRefresh()
{
SPITFSQueryObject spQuery;
RouterRefreshQueryObject * pQuery;
// Trace0("Refresh started\n");
if (m_fInRefresh)
return;
m_fInRefresh = TRUE;
// Create the Query Object
pQuery = new RouterRefreshQueryObject;
spQuery = pQuery;
pQuery->Init(&m_listElements);
// Need to start the background thread
Verify( StartBackgroundThread(NULL, m_hWndSync, spQuery) );
}
HRESULT RouterRefreshObject::OnNotifyError(LPARAM lParam)
{
return hrOK;
}
HRESULT RouterRefreshObject::OnNotifyHaveData(LPARAM lParam)
{
LONG_PTR RefreshItemKey = (LONG_PTR)lParam;
RouterRefreshQueryElement* pCur = NULL;
SPRouterRefreshQueryElement spPre;
HRESULT hr = S_OK;
// notify every one on the list, till lParam == Key of the refresh item
// enumerate and call TryNotify ...
if (RefreshItemKey)
{
do
{
pCur = m_listElements.Next(spPre);
if (pCur)
pCur->TryNotifyQueryResult();
spPre.Free();
spPre = pCur;
} while(pCur && pCur->GetRefreshItem()->GetKey() != RefreshItemKey);
}
return hrOK;
}
HRESULT RouterRefreshObject::OnNotifyExiting(LPARAM lParam)
{
// Trace0("RouterRefreshObject::OnNotifyExiting()\n");
// need to do the various actions at this point
// Merge the tree with the already existing tree
IRouterInfo* pRouter = (IRouterInfo*)lParam;
SPRouterRefreshQueryElement spPre;
RouterRefreshQueryElement* pCur = NULL;
HRESULT hr = S_OK;
// notify every one on the list, till lParam == IRouterInfo*
// enumerate and call TryNotify ...
do
{
pCur = m_listElements.Next(spPre);
if (pCur)
pCur->TryNotifyQueryResult();
spPre.Free();
spPre = pCur;
} while(pCur);
// Now notify all of the registered handlers
NotifyRefresh();
ReleaseThreadHandler();
WaitForThreadToExit();
m_fInRefresh = FALSE;
return hrOK;
}
/*!--------------------------------------------------------------------------
RtrRefreshTimerProc
This is used by the CTimerMgr as its callback proc. We then call
the Refresh code.
Author: KennT
---------------------------------------------------------------------------*/
void CALLBACK RtrRefreshTimerProc(HWND hWnd, UINT uMsg, UINT_PTR nIdEvent,
DWORD dwTime)
{
RtrCriticalSection rtrCritSec(&g_timerMgr.m_critsec);
CTimerDesc *pDesc = g_timerMgr.GetTimerDesc(nIdEvent);
if (pDesc)
{
(*(pDesc->refreshProc))(pDesc->lParam, dwTime);
}
}
/*---------------------------------------------------------------------------
Global variable: g_timerMgr
---------------------------------------------------------------------------*/
CTimerMgr g_timerMgr;
DEBUG_DECLARE_INSTANCE_COUNTER(CTimerMgr);
/*!--------------------------------------------------------------------------
CTimerMgr::CTimerMgr
-
Author: EricDav
---------------------------------------------------------------------------*/
CTimerMgr::CTimerMgr()
{
InitializeCriticalSection(&m_critsec);
}
/*!--------------------------------------------------------------------------
CTimerMgr::~CTimerMgr
-
Author: EricDav
---------------------------------------------------------------------------*/
CTimerMgr::~CTimerMgr()
{
CTimerDesc * pTimerDesc;
for (int i = GetUpperBound(); i >= 0; --i)
{
pTimerDesc = GetAt(i);
if (pTimerDesc->uTimerId != 0)
FreeTimer(i);
delete pTimerDesc;
}
DeleteCriticalSection(&m_critsec);
}
/*!--------------------------------------------------------------------------
CTimerMgr::AllocateTimer
-
Author: EricDav
---------------------------------------------------------------------------*/
int
CTimerMgr::AllocateTimer
(
REFRESHPROC RefreshProc,
LPARAM lParam,
UINT uTimerInterval
)
{
RtrCriticalSection rtrCritSec(&m_critsec);
CTimerDesc * pTimerDesc = NULL;
// look for an empty slot
for (int i = GetUpperBound(); i >= 0; --i)
{
pTimerDesc = GetAt(i);
if (pTimerDesc->uTimerId == 0)
break;
}
// did we find one? if not allocate one
if (i < 0)
{
pTimerDesc = new CTimerDesc;
pTimerDesc->lParam = 0;
pTimerDesc->uTimerInterval = 0;
pTimerDesc->refreshProc = NULL;
pTimerDesc->uTimerId = 0;
Add(pTimerDesc);
i = GetUpperBound();
}
pTimerDesc->uTimerId = SetTimer(NULL, 0, uTimerInterval, RtrRefreshTimerProc);
if (pTimerDesc->uTimerId == 0)
return -1;
pTimerDesc->lParam = lParam;
pTimerDesc->uTimerInterval = uTimerInterval;
pTimerDesc->refreshProc = RefreshProc;
return i;
}
/*!--------------------------------------------------------------------------
CTimerMgr::FreeTimer
-
Author: EricDav
---------------------------------------------------------------------------*/
void
CTimerMgr::FreeTimer
(
int uEventId
)
{
RtrCriticalSection rtrCritSec(&m_critsec);
CTimerDesc * pTimerDesc;
Assert(uEventId <= GetUpperBound());
if (uEventId > GetUpperBound())
return;
pTimerDesc = GetAt(uEventId);
::KillTimer(NULL, pTimerDesc->uTimerId);
pTimerDesc->lParam = 0;
pTimerDesc->uTimerId = 0;
pTimerDesc->uTimerInterval = 0;
pTimerDesc->refreshProc = NULL;
}
/*!--------------------------------------------------------------------------
CTimerMgr::GetTimerDesc
-
Author: EricDav
---------------------------------------------------------------------------*/
CTimerDesc *
CTimerMgr::GetTimerDesc
(
INT_PTR uTimerId
)
{
RtrCriticalSection rtrCritSec(&m_critsec);
CTimerDesc * pTimerDesc;
for (int i = GetUpperBound(); i >= 0; --i)
{
pTimerDesc = GetAt(i);
if (pTimerDesc->uTimerId == (UINT) uTimerId)
return pTimerDesc;
}
return NULL;
}
/*!--------------------------------------------------------------------------
CTimerMgr::ChangeInterval
-
Author: EricDav
---------------------------------------------------------------------------*/
void
CTimerMgr::ChangeInterval
(
int uEventId,
UINT uNewInterval
)
{
RtrCriticalSection rtrCritSec(&m_critsec);
Assert(uEventId <= GetUpperBound());
if (uEventId > GetUpperBound())
return;
CTimerDesc tempTimerDesc;
CTimerDesc * pTimerDesc;
pTimerDesc = GetAt(uEventId);
// kill the old timer
::KillTimer(NULL, pTimerDesc->uTimerId);
// set a new one with the new interval
pTimerDesc->uTimerId = ::SetTimer(NULL, 0, uNewInterval, RtrRefreshTimerProc);
}
/*---------------------------------------------------------------------------
RouterRefreshQueryObject implementation
---------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(RouterRefreshQueryObject);
RouterRefreshQueryObject::RouterRefreshQueryObject()
{
}
STDMETHODIMP RouterRefreshQueryObject::Execute()
{
// for each router info in the queue, run load
// after each load of router info, post message
// WM_HIDDENWND_INDEX_HAVEDATA
SPRouterRefreshQueryElement spPre;
RouterRefreshQueryElement* pCur = NULL;
HRESULT hr = S_OK;
// notify every one on the list, till lParam == IRouterInfo*
// enumerate and call TryNotify ...
Assert(m_plistElements);
do
{
pCur = m_plistElements->Next(spPre);
if (pCur)
pCur->DoQuery(m_hHiddenWnd, m_uMsgBase, m_spHandler);
spPre.Free();
spPre = pCur;
}while(pCur);
return hrFalse;
}
STDMETHODIMP RouterRefreshQueryObject::OnThreadExit()
{
::PostMessage(m_hHiddenWnd, m_uMsgBase + WM_HIDDENWND_INDEX_EXITING,
(WPARAM)(ITFSThreadHandler *)m_spHandler, 0);
// Trace0("Exiting RouterRefreshQueryObject::Execute()\n");
return hrOK;
}
//=========================================
// CRouterInfoRefreshItem implementation
//
DEBUG_DECLARE_INSTANCE_COUNTER(CRouterInfoRefreshItem);
/*!--------------------------------------------------------------------------
CRouterInfoRefreshItem::NotifyQueryResult
-
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT CRouterInfoRefreshItem::NotifyQueryResult()
{
// get the flag to see if need to notify, if not return S_FALSE
// TRACE(_T("\nAUTOREFRESH!!RouterInfoRefreshItem!!Merge on %8x\n"), GetKey());
// need to do the various actions at this point
// Merge the tree with the already existing tree
HRESULT hr = S_OK;
m_cs.Lock();
COM_PROTECT_TRY
{
hr = m_pRouter->Merge(m_spRouterNew);
m_spRouterNew->DoDisconnect();
}
COM_PROTECT_CATCH;
m_cs.Unlock();
return hr;
};
/*!--------------------------------------------------------------------------
CRouterInfoRefreshItem::DoQuery
-
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT CRouterInfoRefreshItem::DoQuery(HWND hwndHidden, UINT uMsgBase, ITFSThreadHandler* pHandler) // this happens in background worker thread
{
// TRACE(_T("\nAUTOREFRESH!!RouterInfoRefreshItem!!Do query on %8x\n"), GetKey());
// create new RouterInfo, if newRouterInfo is NULL
// Create the dummy router info
HRESULT hr = S_OK;
m_cs.Lock();
COM_PROTECT_TRY
{
if (!m_spRouterNew)
hr = CreateRouterInfo(&m_spRouterNew, NULL, m_pRouter->GetMachineName());
// do query on newRouterInfo
Assert(m_pRouter);
if (hr == S_OK)
{
TransferCredentials ( m_pRouter, m_spRouterNew );
m_pRouter->DoDisconnect();
hr = m_spRouterNew->Load(m_pRouter->GetMachineName(), NULL);
}
}
COM_PROTECT_CATCH;
m_cs.Unlock();
return hr;
};
//=========================================
// CMachineNodeDataRefreshItem implementation
DEBUG_DECLARE_INSTANCE_COUNTER(CStatusNodeRefreshItem);
CStatusNodeRefreshItem::CStatusNodeRefreshItem(DomainStatusHandler* pStatusHandler, ITFSNode *pServerNode)
: m_pNode(pServerNode) ,
m_pStatusHandler(pStatusHandler),
m_pData(NULL)
{
Assert(pStatusHandler);
Assert(pServerNode);
DMVNodeData *pData;
MachineNodeData *pMachineData;
pData = GET_DMVNODEDATA(m_pNode);
Assert(pData);
pMachineData = pData->m_spMachineData;
Assert(pMachineData);
m_strMachineName = pMachineData->m_stMachineName;
}
CStatusNodeRefreshItem::~CStatusNodeRefreshItem()
{
TerminateBlockingThread();
if (m_pData)
{
m_pData->Release();
m_pData = NULL;
}
};
HRESULT CStatusNodeRefreshItem::NotifyQueryResult()
{
// get the flag to see if need to notify, if not return S_FALSE
// TRACE(_T("\nAUTOREFRESH!!RouterInfoRefreshItem!!Sync node data on %8x\n"), GetKey());
HRESULT hr = S_OK;
m_cs.Lock();
COM_PROTECT_TRY
{
// set the new node data
DMVNodeData *pData;
pData = GET_DMVNODEDATA(m_pNode);
hr = pData->MergeMachineNodeData(m_pData);
if (hr == S_OK)
hr = m_pStatusHandler->UpdateSubItemUI(m_pNode);
}
COM_PROTECT_CATCH;
m_cs.Unlock();
// ssync on the node
return hr;
};
HRESULT CStatusNodeRefreshItem::DoQuery(HWND hwndHidden, UINT uMsgBase, ITFSThreadHandler* pHandler) // this happens in background worker thread
{
// TRACE(_T("\nAUTOREFRESH!!RouterInfoRefreshItem!!Do query on %8x\n"), GetKey());
// create a new machine node data, load informaiton,
HRESULT hr = S_OK;
m_cs.Lock();
COM_PROTECT_TRY
{
if (!m_pData)
{
m_pData = new MachineNodeData;
m_pData->Init(m_strMachineName);
}
m_pData->Load();
}
COM_PROTECT_CATCH;
m_cs.Unlock();
return hr;
};
//=========================================
// RouterRefreshQueryElement implementation
DEBUG_DECLARE_INSTANCE_COUNTER(RouterRefreshQueryElement);
HRESULT RouterRefreshQueryElement::SetRefreshItem(RefreshItem* pItem)
{
if (m_cs.Lock() == 0) return E_FAIL;
m_pItem = pItem;
m_cs.Unlock();
return S_OK;
};
RefreshItem* RouterRefreshQueryElement::GetRefreshItem()
{
RefreshItem* pItem;
m_cs.Lock();
pItem = m_pItem;
m_cs.Unlock();
return pItem;
};
/*!--------------------------------------------------------------------------
RouterRefreshQueryElement::TryNotifyQueryResult
to detect if the query done, yet to Notify
Author: WeiJiang
---------------------------------------------------------------------------*/
HRESULT RouterRefreshQueryElement::TryNotifyQueryResult()
{
HRESULT hr = S_OK;
RefreshItem* pItem = NULL;
// get the flag to see if need to notify, if not return S_FALSE
if (GetStatus() == RouterQuery_ToNotify)
{
// TRACE(_T("\nAUTOREFRESH!!TryNotifyQueryResult on %8x\n"), m_pItem->GetKey());
// need to do the various actions at this point
// Merge the tree with the already existing tree
pItem = GetRefreshItem();
}
if(pItem)
{
hr = pItem->NotifyQueryResult();
// after notify, set the flag, return S_OK
SetStatus(RouterQuery_NoAction);
}
return hr;
};
void RouterRefreshQueryElement::PostNotify(HWND hwndHidden, UINT uMsgBase, ITFSThreadHandler* pHandler) // this happens in background worker thread
{
// set ready to notify flag
SetStatus(RouterQuery_ToNotify);
// Post done to hidden window
::PostMessage(hwndHidden, uMsgBase + WM_HIDDENWND_INDEX_HAVEDATA,
(WPARAM)pHandler, (LPARAM)m_pItem->GetKey());
}
HRESULT RouterRefreshQueryElement::DoQuery(HWND hwndHidden, UINT uMsgBase, ITFSThreadHandler* pHandler) // this happens in background worker thread
{
HRESULT hr = S_OK;
// TRACE(_T("\nAUTOREFRESH!!Do query on %8x\n"), m_pItem->GetKey());
RefreshItem* pItem = GetRefreshItem();
COM_PROTECT_TRY
{
// asked to do query, do it anyway, no matter what's the status
// set blocking current thread, in case, this query blocks
pItem->SetBlockingThread(GetCurrentThread());
hr = pItem->DoQuery(hwndHidden, uMsgBase, pHandler);
if (hr == S_OK)
{
PostNotify(hwndHidden, uMsgBase, pHandler);
}
// it's not blocked, reset it
pItem->ResetBlockingThread();
}
COM_PROTECT_CATCH;
return hr;
};
RouterRefreshQueryElementList::~RouterRefreshQueryElementList()
{
POSITION p = NULL;
RouterRefreshQueryElement* pEle = NULL;
m_cs.Lock();
p = m_list.GetHeadPosition();
for(p = m_list.GetHeadPosition(); p != NULL; )
{
pEle = m_list.GetNext(p);
pEle->Release();
}
m_list.RemoveAll();
m_cs.Unlock();
}
HRESULT RouterRefreshQueryElementList::AddRefreshItem(RefreshItem* pItem) // no ref on IRouterInfo
{
POSITION p = NULL;
RouterRefreshQueryElement* pE = NULL;
HRESULT hr = S_OK;
m_cs.Lock();
try{
for (p = m_list.GetHeadPosition(); p != NULL; )
{
pE = m_list.GetNext(p);
// already added, so only addRef
if (pItem->GetKey() == pE->GetRefreshItem()->GetKey())
{
break;
}
}
if (p != NULL) // found
{
pE->AddRef();
hr = S_FALSE; // we are not keeping the pItem
}
else
{
CComObject<RouterRefreshQueryElement>* pEle = NULL;
hr = CComObject<RouterRefreshQueryElement>::CreateInstance(&pEle);
if ( FHrSucceeded(hr) )
{
Assert(pEle);
pEle->SetRefreshItem(pItem);
pEle->AddRef();
m_list.AddTail(pEle);
}
}
}
catch(CMemoryException&)
{
hr = E_OUTOFMEMORY;
}
catch(...)
{
m_cs.Unlock();
throw;
}
m_cs.Unlock();
return hr;
}
HRESULT RouterRefreshQueryElementList::RemoveRefreshItem(RefreshItem& Item) // no ref on IRouterInfo
{
HRESULT hr = hrOK;
POSITION p = NULL;
POSITION cp = NULL;
RouterRefreshQueryElement* pE = NULL;
m_cs.Lock();
try{
for(p = m_list.GetHeadPosition(); p != NULL; )
{
cp = p;
pE = m_list.GetNext(p);
if (Item.GetKey() == pE->GetRefreshItem()->GetKey()) // already added, will release on Ele object
{
break;
}
// This is not the one we are looking for.
cp = NULL;
}
if (cp != NULL) // found
{
pE->Release(); //remove from the refresh list
m_list.RemoveAt(cp);
}
else
hr = S_FALSE;
}
catch(...)
{
m_cs.Unlock();
throw;
}
m_cs.Unlock();
return hr;
}
RouterRefreshQueryElement* RouterRefreshQueryElementList::Next(RouterRefreshQueryElement* pEle) // AddRef on Ele Object
{
RouterRefreshQueryElement* pNext = NULL;
m_cs.Lock();
if (pEle == NULL)
{
if (m_list.GetCount() != 0) // asking for the first element
pNext = m_list.GetHead();
}
else
{
POSITION p;
// find the current one
for(p = m_list.GetHeadPosition(); p != NULL; )
{
if (pEle == m_list.GetNext(p))
{
if (p != NULL)
pNext = m_list.GetAt(p);
break;
}
}
}
m_cs.Unlock();
if (pNext)
pNext->AddRef();
return pNext;
}