689 lines
17 KiB
C++
689 lines
17 KiB
C++
|
//******************************************************************************
|
||
|
|
//
|
||
|
|
// AGGREG.CPP
|
||
|
|
//
|
||
|
|
// Copyright (C) 1996-1999 Microsoft Corporation
|
||
|
|
//
|
||
|
|
//******************************************************************************
|
||
|
|
|
||
|
|
#include "precomp.h"
|
||
|
|
#include "ess.h"
|
||
|
|
#include "aggreg.h"
|
||
|
|
|
||
|
|
IWbemClassObject* CEventAggregator::mstatic_pClass = NULL;
|
||
|
|
|
||
|
|
CEventAggregator::CEventAggregator(CEssNamespace* pNamespace,
|
||
|
|
CAbstractEventSink* pDest)
|
||
|
|
: COwnedEventSink(pDest), m_aProperties(NULL), m_pNamespace(pNamespace),
|
||
|
|
m_lNumProperties(0), m_pHavingTree(NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
CEventAggregator::~CEventAggregator()
|
||
|
|
{
|
||
|
|
delete [] m_aProperties;
|
||
|
|
delete m_pHavingTree;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::SetQueryExpression(CContextMetaData* pMeta,
|
||
|
|
QL_LEVEL_1_RPN_EXPRESSION* pExpr)
|
||
|
|
{
|
||
|
|
HRESULT hres = WBEM_S_NO_ERROR;
|
||
|
|
|
||
|
|
// Check that, if aggregation is required, tolerance is specified
|
||
|
|
// ==============================================================
|
||
|
|
|
||
|
|
if(!pExpr->bAggregated)
|
||
|
|
{
|
||
|
|
return WBEM_E_CRITICAL_ERROR; // internal error
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pExpr->bAggregated && pExpr->AggregationTolerance.m_bExact)
|
||
|
|
{
|
||
|
|
ERRORTRACE((LOG_ESS, "Event aggregation query specified GROUP BY, but "
|
||
|
|
"not GROUP WITHIN. This query is invalid and will not be acted "
|
||
|
|
"upon\n"));
|
||
|
|
return WBEM_E_MISSING_GROUP_WITHIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_fTolerance = pExpr->AggregationTolerance.m_fTolerance;
|
||
|
|
if(m_fTolerance < 0)
|
||
|
|
return WBEM_E_INVALID_PARAMETER;
|
||
|
|
|
||
|
|
// Check that all properties are valid
|
||
|
|
// ===================================
|
||
|
|
|
||
|
|
if(pExpr->bAggregateAll)
|
||
|
|
{
|
||
|
|
ERRORTRACE((LOG_ESS, "Aggregating based on all properties of an event "
|
||
|
|
"is not supported\n"));
|
||
|
|
return WBEM_E_MISSING_AGGREGATION_LIST;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get the class
|
||
|
|
// =============
|
||
|
|
|
||
|
|
_IWmiObject* pClass = NULL;
|
||
|
|
pMeta->GetClass(pExpr->bsClassName, &pClass);
|
||
|
|
if(pClass == NULL)
|
||
|
|
{
|
||
|
|
return WBEM_E_INVALID_CLASS;
|
||
|
|
}
|
||
|
|
CReleaseMe rm1(pClass);
|
||
|
|
|
||
|
|
// Allocate the array to hold property names
|
||
|
|
// =========================================
|
||
|
|
|
||
|
|
delete [] m_aProperties;
|
||
|
|
m_lNumProperties = pExpr->nNumAggregatedProperties;
|
||
|
|
m_aProperties = new CPropertyName[m_lNumProperties];
|
||
|
|
if(m_aProperties == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
int i;
|
||
|
|
for(i = 0; i < pExpr->nNumAggregatedProperties; i++)
|
||
|
|
{
|
||
|
|
CPropertyName& PropName = pExpr->pAggregatedPropertyNames[i];
|
||
|
|
|
||
|
|
// Check existence
|
||
|
|
// ===============
|
||
|
|
|
||
|
|
CIMTYPE ct;
|
||
|
|
if(FAILED(pClass->Get((LPWSTR)PropName.GetStringAt(0), 0, NULL,
|
||
|
|
&ct, NULL)))
|
||
|
|
{
|
||
|
|
ERRORTRACE((LOG_ESS, "Invalid aggregation property %S --- not a "
|
||
|
|
"member of class %S\n", (LPWSTR)PropName.GetStringAt(0),
|
||
|
|
pExpr->bsClassName));
|
||
|
|
|
||
|
|
return WBEM_E_INVALID_PROPERTY;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(PropName.GetNumElements() > 1 && ct != CIM_OBJECT)
|
||
|
|
{
|
||
|
|
return WBEM_E_PROPERTY_NOT_AN_OBJECT;
|
||
|
|
}
|
||
|
|
if(PropName.GetNumElements() == 1 && ct == CIM_OBJECT)
|
||
|
|
{
|
||
|
|
return WBEM_E_AGGREGATING_BY_OBJECT;
|
||
|
|
}
|
||
|
|
m_aProperties[i] = PropName;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initialize post-evaluator with the data from the HAVING clause
|
||
|
|
// ==============================================================
|
||
|
|
|
||
|
|
QL_LEVEL_1_RPN_EXPRESSION* pHavingExpr = _new QL_LEVEL_1_RPN_EXPRESSION;
|
||
|
|
if(pHavingExpr == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
pHavingExpr->SetClassName(L"__AggregateEvent");
|
||
|
|
|
||
|
|
for(i = 0; i < pExpr->nNumHavingTokens; i++)
|
||
|
|
{
|
||
|
|
pHavingExpr->AddToken(pExpr->pArrayOfHavingTokens[i]);
|
||
|
|
}
|
||
|
|
|
||
|
|
delete m_pHavingTree;
|
||
|
|
m_pHavingTree = new CEvalTree;
|
||
|
|
if(m_pHavingTree == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
hres = m_pHavingTree->CreateFromQuery(pMeta, pHavingExpr, 0, 0x7FFFFFFF);
|
||
|
|
delete pHavingExpr;
|
||
|
|
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::Initialize(IWbemServices* pNamespace)
|
||
|
|
{
|
||
|
|
return pNamespace->GetObject(L"__AggregateEvent", 0, GetCurrentEssContext(),
|
||
|
|
&mstatic_pClass, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::Shutdown()
|
||
|
|
{
|
||
|
|
if(mstatic_pClass)
|
||
|
|
mstatic_pClass->Release();
|
||
|
|
mstatic_pClass = NULL;
|
||
|
|
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::Indicate(long lNumEvents, IWbemEvent** apEvents,
|
||
|
|
CEventContext* pContext)
|
||
|
|
{
|
||
|
|
HRESULT hresGlobal = S_OK;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Note: we are going to lose the event's security context, but that is OK,
|
||
|
|
// since the security check has already been done.
|
||
|
|
//
|
||
|
|
|
||
|
|
for(long i = 0; i < lNumEvents; i++)
|
||
|
|
{
|
||
|
|
HRESULT hres = Process(apEvents[i]);
|
||
|
|
if(FAILED(hres))
|
||
|
|
hresGlobal = hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
return hresGlobal;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::Process(IWbemEvent* pEvent)
|
||
|
|
{
|
||
|
|
// Compute the event's aggregation vector
|
||
|
|
// ======================================
|
||
|
|
|
||
|
|
CVarVector* pvv = _new CVarVector;
|
||
|
|
if(pvv == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
HRESULT hres = ComputeAggregationVector(pEvent, *pvv);
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
delete pvv;
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add event to the right bucket, creating one if needed.
|
||
|
|
// THIS CALL ACQUIRES pvv!!!
|
||
|
|
// ======================================================
|
||
|
|
|
||
|
|
CBucket* pCreatedBucket = NULL;
|
||
|
|
hres = AddEventToBucket(pEvent, pvv, &pCreatedBucket);
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pCreatedBucket)
|
||
|
|
{
|
||
|
|
// Create a timer instruction to empty this bucket
|
||
|
|
// ===============================================
|
||
|
|
|
||
|
|
CBucketInstruction* pInst =
|
||
|
|
_new CBucketInstruction(this, pCreatedBucket, m_fTolerance);
|
||
|
|
if(pInst == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
pInst->AddRef();
|
||
|
|
hres = m_pNamespace->GetTimerGenerator().Set(pInst,
|
||
|
|
CWbemTime::GetZero());
|
||
|
|
pInst->Release();
|
||
|
|
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
ERRORTRACE((LOG_ESS, "Failed to schedule aggregation instruction %p"
|
||
|
|
"\n", pInst));
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::AddEventToBucket(IWbemEvent* pEvent,
|
||
|
|
ACQUIRE CVarVector* pvv, CBucket** ppCreatedBucket)
|
||
|
|
{
|
||
|
|
// Search for a matching bucket
|
||
|
|
// ============================
|
||
|
|
|
||
|
|
CInCritSec ics(&m_cs);
|
||
|
|
|
||
|
|
BOOL bFound = FALSE;
|
||
|
|
for(int i = 0; i < m_apBuckets.GetSize(); i++)
|
||
|
|
{
|
||
|
|
CBucket* pBucket = m_apBuckets[i];
|
||
|
|
if(pBucket->CompareTo(*pvv))
|
||
|
|
{
|
||
|
|
HRESULT hres = pBucket->AddEvent(pEvent);
|
||
|
|
delete pvv;
|
||
|
|
*ppCreatedBucket = NULL;
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Need a _new bucket
|
||
|
|
// ==================
|
||
|
|
|
||
|
|
CBucket* pBucket = _new CBucket(pEvent, pvv); // takes over pvv
|
||
|
|
if(pBucket == NULL)
|
||
|
|
{
|
||
|
|
delete pvv;
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(m_apBuckets.Add(pBucket) < 0)
|
||
|
|
{
|
||
|
|
delete pBucket;
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
*ppCreatedBucket = pBucket;
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::ComputeAggregationVector(
|
||
|
|
IN IWbemEvent* pEvent,
|
||
|
|
OUT CVarVector& vv)
|
||
|
|
{
|
||
|
|
HRESULT hres;
|
||
|
|
|
||
|
|
IWbemPropertySource* pPropSource = NULL;
|
||
|
|
if(FAILED(pEvent->QueryInterface(IID_IWbemPropertySource,
|
||
|
|
(void**)&pPropSource)))
|
||
|
|
{
|
||
|
|
return E_NOINTERFACE;
|
||
|
|
}
|
||
|
|
|
||
|
|
CReleaseMe rm1(pPropSource);
|
||
|
|
|
||
|
|
// Go through all the properties and add their values to the array
|
||
|
|
// ===============================================================
|
||
|
|
|
||
|
|
for(int i = 0; i < m_lNumProperties; i++)
|
||
|
|
{
|
||
|
|
CPropertyName& PropName = m_aProperties[i];
|
||
|
|
|
||
|
|
// Get the value
|
||
|
|
// =============
|
||
|
|
|
||
|
|
VARIANT v;
|
||
|
|
VariantInit(&v);
|
||
|
|
hres = pPropSource->GetPropertyValue(&PropName, 0, NULL, &v);
|
||
|
|
if(FAILED(hres))
|
||
|
|
return hres;
|
||
|
|
|
||
|
|
// Add it to the array
|
||
|
|
// ===================
|
||
|
|
|
||
|
|
CVar* pVar = _new CVar;
|
||
|
|
if(pVar == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
|
||
|
|
pVar->SetVariant(&v);
|
||
|
|
VariantClear(&v);
|
||
|
|
|
||
|
|
if(vv.Add(pVar) < 0) // ACQUIRES pVar
|
||
|
|
{
|
||
|
|
delete pVar;
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::PostponeDispatchFirstBucket()
|
||
|
|
{
|
||
|
|
HRESULT hres;
|
||
|
|
|
||
|
|
//
|
||
|
|
// Construct the aggregate event while locked
|
||
|
|
//
|
||
|
|
|
||
|
|
IWbemEvent* pAggEvent = NULL;
|
||
|
|
{
|
||
|
|
CInCritSec ics(&m_cs);
|
||
|
|
|
||
|
|
if(m_apBuckets.GetSize() == 0)
|
||
|
|
return WBEM_S_FALSE;
|
||
|
|
|
||
|
|
hres = m_apBuckets[0]->MakeAggregateEvent(&pAggEvent);
|
||
|
|
if(FAILED(hres))
|
||
|
|
return hres;
|
||
|
|
|
||
|
|
m_apBuckets.RemoveAt(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
CReleaseMe rm1(pAggEvent);
|
||
|
|
return FireEvent(pAggEvent, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::DispatchBucket(CBucket* pBucket)
|
||
|
|
{
|
||
|
|
// Search for the bucket
|
||
|
|
// =====================
|
||
|
|
|
||
|
|
IWbemEvent* pAggEvent = NULL;
|
||
|
|
{
|
||
|
|
CInCritSec ics(&m_cs);
|
||
|
|
|
||
|
|
BOOL bFound = FALSE;
|
||
|
|
for(int i = 0; i < m_apBuckets.GetSize(); i++)
|
||
|
|
{
|
||
|
|
if(m_apBuckets[i] == pBucket)
|
||
|
|
{
|
||
|
|
// Found it. Construct its event
|
||
|
|
// =============================
|
||
|
|
|
||
|
|
HRESULT hres = pBucket->MakeAggregateEvent(&pAggEvent);
|
||
|
|
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
ERRORTRACE((LOG_ESS, "Could not create an aggregate event: "
|
||
|
|
"%X\n", hres));
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Delete the bucket
|
||
|
|
// =================
|
||
|
|
|
||
|
|
m_apBuckets.RemoveAt(i);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pAggEvent == NULL)
|
||
|
|
{
|
||
|
|
// No bucket!
|
||
|
|
// ==========
|
||
|
|
|
||
|
|
return WBEM_E_CRITICAL_ERROR; // internal error
|
||
|
|
}
|
||
|
|
|
||
|
|
CReleaseMe rm1(pAggEvent);
|
||
|
|
|
||
|
|
//
|
||
|
|
// We can fire this event directly on this thread, as it is ours
|
||
|
|
//
|
||
|
|
|
||
|
|
return FireEvent(pAggEvent, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::FireEvent(IWbemClassObject* pAggEvent,
|
||
|
|
bool bRightNow)
|
||
|
|
{
|
||
|
|
// Constructed aggregate. Decorate it
|
||
|
|
// ==================================
|
||
|
|
|
||
|
|
m_pNamespace->DecorateObject(pAggEvent);
|
||
|
|
|
||
|
|
// Check HAVING query
|
||
|
|
// ==================
|
||
|
|
|
||
|
|
BOOL bResult;
|
||
|
|
CSortedArray aTrues;
|
||
|
|
IWbemObjectAccess* pAccess;
|
||
|
|
pAggEvent->QueryInterface(IID_IWbemObjectAccess, (void**)&pAccess);
|
||
|
|
if(FAILED(m_pHavingTree->Evaluate(pAccess, aTrues)))
|
||
|
|
{
|
||
|
|
bResult = FALSE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bResult = (aTrues.Size() > 0);
|
||
|
|
}
|
||
|
|
pAccess->Release();
|
||
|
|
|
||
|
|
if(bResult)
|
||
|
|
{
|
||
|
|
// Get destination pointer, protecting from Deactivation
|
||
|
|
// =====================================================
|
||
|
|
|
||
|
|
CAbstractEventSink* pDest = NULL;
|
||
|
|
{
|
||
|
|
CInCritSec ics(&m_cs);
|
||
|
|
pDest = m_pOwner;
|
||
|
|
if(pDest)
|
||
|
|
pDest->AddRef();
|
||
|
|
}
|
||
|
|
|
||
|
|
if(pDest)
|
||
|
|
{
|
||
|
|
if(bRightNow)
|
||
|
|
pDest->Indicate(1, &pAggEvent, NULL);
|
||
|
|
else
|
||
|
|
PostponeIndicate(pDest, pAggEvent);
|
||
|
|
|
||
|
|
pDest->Release();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::PostponeIndicate(CAbstractEventSink* pDest,
|
||
|
|
IWbemEvent* pEvent)
|
||
|
|
{
|
||
|
|
CPostponedList* pList = GetCurrentPostponedEventList();
|
||
|
|
if(pList == NULL)
|
||
|
|
return pDest->Indicate(1, &pEvent, NULL);
|
||
|
|
|
||
|
|
CPostponedIndicate* pReq = new CPostponedIndicate(pDest, pEvent);
|
||
|
|
if(pReq == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
return pList->AddRequest( m_pNamespace, pReq );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::Deactivate(bool bFire)
|
||
|
|
{
|
||
|
|
HRESULT hres;
|
||
|
|
|
||
|
|
//
|
||
|
|
// First remove all timer instructions that may still be scheduled.
|
||
|
|
// Timer instructions have a ref-count on us (and therefore our owner),
|
||
|
|
// so we may not disconnect until we are done
|
||
|
|
//
|
||
|
|
|
||
|
|
CAggregatorInstructionTest Test(this);
|
||
|
|
CTimerGenerator& Generator = m_pNamespace->GetTimerGenerator();
|
||
|
|
hres = Generator.Remove(&Test);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If requested, fire all buckets, albeit not right now
|
||
|
|
//
|
||
|
|
|
||
|
|
if(bFire)
|
||
|
|
PostponeFireAllBuckets();
|
||
|
|
|
||
|
|
Disconnect();
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::PostponeFireAllBuckets()
|
||
|
|
{
|
||
|
|
HRESULT hres;
|
||
|
|
while((hres = PostponeDispatchFirstBucket()) != S_FALSE);
|
||
|
|
|
||
|
|
if(FAILED(hres))
|
||
|
|
return hres;
|
||
|
|
else
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::CopyStateTo(CEventAggregator* pDest)
|
||
|
|
{
|
||
|
|
CInCritSec ics(&m_cs);
|
||
|
|
|
||
|
|
for(int i = 0; i < m_apBuckets.GetSize(); i++)
|
||
|
|
{
|
||
|
|
CBucket* pNewBucket = m_apBuckets[i]->Clone();
|
||
|
|
if(pNewBucket == NULL)
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
if(pDest->m_apBuckets.Add(pNewBucket) < 0)
|
||
|
|
{
|
||
|
|
delete pNewBucket;
|
||
|
|
return WBEM_E_OUT_OF_MEMORY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return S_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
CEventAggregator::CBucket::CBucket(IWbemEvent* pEvent,
|
||
|
|
CVarVector* pvvData)
|
||
|
|
: m_pvvData(pvvData), m_dwCount(1), m_pRepresentative(NULL)
|
||
|
|
{
|
||
|
|
pEvent->Clone(&m_pRepresentative);
|
||
|
|
}
|
||
|
|
|
||
|
|
CEventAggregator::CBucket::~CBucket()
|
||
|
|
{
|
||
|
|
delete m_pvvData;
|
||
|
|
if(m_pRepresentative)
|
||
|
|
m_pRepresentative->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL CEventAggregator::CBucket::CompareTo(CVarVector& vv)
|
||
|
|
{
|
||
|
|
return m_pvvData->CompareTo(vv, TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::CBucket::AddEvent(IWbemEvent* pEvent)
|
||
|
|
{
|
||
|
|
// Just increment the number of events in the bucket
|
||
|
|
// =================================================
|
||
|
|
|
||
|
|
m_dwCount++;
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::CBucket::MakeAggregateEvent(
|
||
|
|
IWbemClassObject** ppAggregateEvent) NOCS
|
||
|
|
{
|
||
|
|
HRESULT hres;
|
||
|
|
|
||
|
|
// Create an instance of the aggregate event class
|
||
|
|
// ===============================================
|
||
|
|
|
||
|
|
if(mstatic_pClass == NULL)
|
||
|
|
return WBEM_E_SHUTTING_DOWN;
|
||
|
|
|
||
|
|
IWbemClassObject* pAgg;
|
||
|
|
hres = mstatic_pClass->SpawnInstance(0, &pAgg);
|
||
|
|
if(FAILED(hres)) return hres;
|
||
|
|
|
||
|
|
// Fill in the number of events in the bucket
|
||
|
|
// ==========================================
|
||
|
|
|
||
|
|
VARIANT v;
|
||
|
|
VariantInit(&v);
|
||
|
|
V_VT(&v) = VT_I4;
|
||
|
|
V_I4(&v) = (long)m_dwCount;
|
||
|
|
|
||
|
|
hres = pAgg->Put(L"NumberOfEvents", 0, &v, NULL);
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
pAgg->Release();
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fill in the representative
|
||
|
|
// ==========================
|
||
|
|
|
||
|
|
V_VT(&v) = VT_EMBEDDED_OBJECT;
|
||
|
|
V_EMBEDDED_OBJECT(&v) = m_pRepresentative;
|
||
|
|
|
||
|
|
hres = pAgg->Put(L"Representative", 0, &v, NULL);
|
||
|
|
if(FAILED(hres))
|
||
|
|
{
|
||
|
|
pAgg->Release();
|
||
|
|
return hres;
|
||
|
|
}
|
||
|
|
|
||
|
|
*ppAggregateEvent = pAgg;
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
CEventAggregator::CBucket* CEventAggregator::CBucket::Clone()
|
||
|
|
{
|
||
|
|
CVarVector* pNewVv = new CVarVector(*m_pvvData);
|
||
|
|
if(pNewVv == NULL)
|
||
|
|
return NULL;
|
||
|
|
CBucket* pNewBucket = new CBucket(m_pRepresentative, pNewVv);
|
||
|
|
if(pNewBucket == NULL)
|
||
|
|
{
|
||
|
|
delete pNewVv;
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
pNewBucket->m_dwCount = m_dwCount;
|
||
|
|
return pNewBucket;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
CEventAggregator::CBucketInstruction::CBucketInstruction(
|
||
|
|
CEventAggregator* pAggregator, CBucket* pBucket, double fSTimeout)
|
||
|
|
: m_pAggregator(pAggregator), m_pBucket(pBucket), m_lRefCount(0)
|
||
|
|
{
|
||
|
|
m_Interval.SetMilliseconds(fSTimeout * 1000);
|
||
|
|
m_pAggregator->AddRef();
|
||
|
|
}
|
||
|
|
|
||
|
|
CEventAggregator::CBucketInstruction::~CBucketInstruction()
|
||
|
|
{
|
||
|
|
m_pAggregator->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
void CEventAggregator::CBucketInstruction::AddRef()
|
||
|
|
{
|
||
|
|
InterlockedIncrement(&m_lRefCount);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CEventAggregator::CBucketInstruction::Release()
|
||
|
|
{
|
||
|
|
if(InterlockedDecrement(&m_lRefCount) == 0)
|
||
|
|
delete this;
|
||
|
|
}
|
||
|
|
|
||
|
|
int CEventAggregator::CBucketInstruction::GetInstructionType()
|
||
|
|
{
|
||
|
|
return INSTTYPE_AGGREGATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
CWbemTime CEventAggregator::CBucketInstruction::GetNextFiringTime(
|
||
|
|
CWbemTime LastFiringTime, OUT long* plFiringCount) const
|
||
|
|
{
|
||
|
|
// Only fires once.
|
||
|
|
// ================
|
||
|
|
|
||
|
|
return CWbemTime::GetInfinity();
|
||
|
|
}
|
||
|
|
|
||
|
|
CWbemTime CEventAggregator::CBucketInstruction::GetFirstFiringTime() const
|
||
|
|
{
|
||
|
|
// In "interval" ms from now
|
||
|
|
// =========================
|
||
|
|
|
||
|
|
return CWbemTime::GetCurrentTime() + m_Interval;
|
||
|
|
}
|
||
|
|
|
||
|
|
HRESULT CEventAggregator::CBucketInstruction::Fire(long lNumTimes,
|
||
|
|
CWbemTime NextFiringTime)
|
||
|
|
{
|
||
|
|
m_pAggregator->DispatchBucket(m_pBucket);
|
||
|
|
return WBEM_S_NO_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
BOOL CEventAggregator::CAggregatorInstructionTest::
|
||
|
|
operator()(
|
||
|
|
CTimerInstruction* pToTest)
|
||
|
|
{
|
||
|
|
if(pToTest->GetInstructionType() == INSTTYPE_AGGREGATION)
|
||
|
|
{
|
||
|
|
CBucketInstruction* pInst = (CBucketInstruction*)pToTest;
|
||
|
|
return (pInst->GetAggregator() == m_pAgg);
|
||
|
|
}
|
||
|
|
else return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|