able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/hmonitor/hmagent/datacltr.cpp

6216 lines
156 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//***************************************************************************
//
// DATACLTR.CPP
//
// Module: HEALTHMON SERVER AGENT
//
// Purpose: CDataCollector class to do WMI instance collection.
//
// Copyright (c)1999 Microsoft Corporation, All Rights Reserved
//
//***************************************************************************
#include <tchar.h>
#include "datacltr.h"
#include "datagrp.h"
#include "system.h"
extern CSystem* g_pSystem;
extern CSystem* g_pStartupSystem;
extern LPTSTR conditionLocStr[10];
extern LPTSTR stateLocStr[9];
// STATIC DATA
NSLIST CDataCollector::mg_nsList;
//STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC STATIC
void CDataCollector::DETerminationCleanup(void)
{
NSSTRUCT *pns;
int iSize;
int i;
// Since this is a global shared array, we need to do this
// in a static function.
iSize = mg_nsList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<mg_nsList.size());
pns = &mg_nsList[i];
pns->pIWbemServices->Release();
pns->pIWbemServices = NULL;
if (pns->szTargetNamespace)
{
delete [] pns->szTargetNamespace;
pns->szTargetNamespace = NULL;
}
if (pns->szLocal)
{
delete [] pns->szLocal;
pns->szLocal = NULL;
}
}
if (g_pDataCollectorEventSink != NULL)
{
g_pDataCollectorEventSink->Release();
g_pDataCollectorEventSink = NULL;
}
if (g_pDataCollectorPerInstanceEventSink != NULL)
{
g_pDataCollectorPerInstanceEventSink->Release();
g_pDataCollectorPerInstanceEventSink = NULL;
}
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CDataCollector::CDataCollector()
{
MY_OUTPUT(L"ENTER ***** CDataCollector...", 4);
Init();
m_hmStatusType = HMSTATUS_DATACOLLECTOR;
m_bValidLoad = FALSE;
MY_OUTPUT(L"EXIT ***** CDataCollector...", 4);
}
CDataCollector::~CDataCollector()
{
MY_OUTPUT(L"ENTER ***** ~CDataCollector...", 4);
g_pStartupSystem->RemovePointerFromMasterList(this);
m_bValidLoad = TRUE;
Cleanup(FALSE);
if (m_szGUID)
{
delete [] m_szGUID;
m_szGUID = NULL;
}
if (m_szParentObjPath)
{
delete [] m_szParentObjPath;
m_szParentObjPath = NULL;
}
MY_OUTPUT(L"EXIT ***** ~CDataCollector...", 4);
}
// get polling interval in milliseconds.
long CDataCollector::GetCollectionIntervalMultiple()
{
return m_lCollectionIntervalMultiple;
}
//
// We keep a global static list of pointers to namespaces, so we can share them
// and be more efficient about it. Each time a new one comes in, we add it to the
// list.
//
HRESULT CDataCollector::fillInNamespacePointer(void)
{
HRESULT hRetRes = S_OK;
int i;
int iSize;
BSTR bsNamespace = NULL;
BSTR bsLocal = NULL;
BOOL bFound = FALSE;
NSSTRUCT ns;
NSSTRUCT *pns;
IWbemLocator *pLocator = NULL;
IWbemServices *pService = NULL;
ns.szTargetNamespace = NULL;
ns.szLocal = NULL;
MY_OUTPUT(L"ENTER ***** fillInNamespacePointer...", 4);
hRetRes = CoCreateInstance(CLSID_WbemAdministrativeLocator, NULL,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID*) &pLocator);
if (FAILED(hRetRes))
{
MY_HRESASSERT(hRetRes);
return hRetRes;
}
MY_ASSERT(pLocator);
// We already have apointer to the local Healthmon namespace
if (!_wcsicmp(m_szTargetNamespace, L"healthmon"))
{
m_pIWbemServices = g_pIWbemServices;
}
else
{
iSize = mg_nsList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<mg_nsList.size());
pns = &mg_nsList[i];
if (!_wcsicmp(m_szTargetNamespace, pns->szTargetNamespace) && !_wcsicmp(m_szLocal, pns->szLocal))
{
m_pIWbemServices = pns->pIWbemServices;
bFound = TRUE;
break;
}
}
if (bFound == FALSE)
{
bsNamespace = SysAllocString(m_szTargetNamespace);
MY_ASSERT(bsNamespace); if (!bsNamespace) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if (_wcsicmp(m_szLocal, L""))
{
bsLocal = SysAllocString(m_szLocal);
MY_ASSERT(bsLocal); if (!bsLocal) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
}
hRetRes = pLocator->ConnectServer(bsNamespace,
NULL,
NULL,
bsLocal,
0L,
NULL,
NULL,
&pService);
if (FAILED(hRetRes))
{
hRetRes = hRetRes;
m_pIWbemServices = NULL;
if (hRetRes != WBEM_E_INVALID_NAMESPACE) MY_HRESASSERT(hRetRes);
MY_OUTPUT2(L"Failed to connect to namespace=%s", m_szTargetNamespace, 4);
}
else
{
// Store one in the static array
m_pIWbemServices = pService;
ns.szTargetNamespace = new TCHAR[wcslen(m_szTargetNamespace)+1];
MY_ASSERT(ns.szTargetNamespace); if (!ns.szTargetNamespace) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(ns.szTargetNamespace , m_szTargetNamespace);
ns.szLocal = new TCHAR[wcslen(m_szLocal)+1];
MY_ASSERT(ns.szLocal); if (!ns.szLocal) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(ns.szLocal , m_szLocal);
ns.pIWbemServices = pService;
mg_nsList.push_back(ns);
}
SysFreeString(bsNamespace);
bsNamespace = NULL;
if (bsLocal)
{
SysFreeString(bsLocal);
bsLocal = NULL;
}
}
}
if (pLocator)
{
pLocator->Release();
pLocator = NULL;
}
MY_OUTPUT(L"EXIT ***** fillInNamespacePointer...", 4);
return hRetRes;
error:
MY_ASSERT(FALSE);
if (bsNamespace)
SysFreeString(bsNamespace);
if (bsLocal)
SysFreeString(bsLocal);
if (ns.szTargetNamespace)
delete [] ns.szTargetNamespace;
if (ns.szLocal)
delete [] ns.szLocal;
if (pLocator)
pLocator->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return FALSE;
}
//
// Load a single DataCollector, and everything under it.
//
HRESULT CDataCollector::LoadInstanceFromMOF(IWbemClassObject* pObj, CDataGroup *pParentDG, LPTSTR pszParentObjPath, BOOL bModifyPass/*FALSE*/)
{
GUID guid;
int i, iSize;
CThreshold* pThreshold;
LPTSTR pszTemp;
LPTSTR pszStr;
HRESULT hRetRes = S_OK;
//XXXXX
//static count = 0;
MY_OUTPUT(L"ENTER ***** CDataCollector::LoadInstanceFromMOF...", 4);
// Make sure that the Thresholds are loaded properly first
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
// return WBEM_E_INVALID_OBJECT;
return S_OK;
}
m_bValidLoad = TRUE;
Cleanup(bModifyPass);
if (bModifyPass == FALSE)
{
// This is the first initial read in of this
// Get the GUID property
// If this fails we will actually not go through with the creation of this object.
if (m_szGUID)
{
delete [] m_szGUID;
m_szGUID = NULL;
}
hRetRes = GetStrProperty(pObj, L"GUID", &m_szGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
m_szParentObjPath = new TCHAR[wcslen(pszParentObjPath)+1];
MY_ASSERT(m_szParentObjPath); if (!m_szParentObjPath) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(m_szParentObjPath, pszParentObjPath);
m_pParentDG = pParentDG;
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, m_szStatusGUID, 100);
hRetRes = g_pStartupSystem->AddPointerToMasterList(this);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else
{
m_lIntervalCount = -1;
}
MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4);
// Get the Name. If it is NULL or rather blank, then we use the qualifier
hRetRes = GetStrProperty(pObj, L"Name", &m_szName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
// Get the Description. If it is NULL then we use the qualifier
hRetRes = GetStrProperty(pObj, L"Description", &m_szDescription);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetStrProperty(pObj, L"TargetNamespace", &m_szTargetNamespace);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetStrProperty(pObj, L"Local", &m_szLocal);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
InitContext(pObj);
hRetRes = GetUint32Property(pObj, L"CollectionIntervalMsecs", &m_lCollectionIntervalMultiple);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
m_lCollectionIntervalMultiple /= 1000;
hRetRes = GetUint32Property(pObj, L"CollectionTimeOut", &m_lCollectionTimeOut);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (m_lCollectionIntervalMultiple < m_lCollectionTimeOut)
{
m_lCollectionTimeOut = m_lCollectionIntervalMultiple;
}
hRetRes = GetUint32Property(pObj, L"StatisticsWindowSize", &m_lStatisticsWindowSize);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetUint8Property(pObj, L"ActiveDays", &m_iActiveDays);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
// The time format looks as follows "********0600**.******+***"; hh is hours and mm is minutes
// All else is ignored.
hRetRes = GetStrProperty(pObj, L"BeginTime", &pszTemp);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pszStr = wcschr(pszTemp, '.');
if (pszStr)
{
// Back up to look at the minute
pszStr -= 2;
*pszStr = '\0';
pszStr -= 2;
m_lBeginMinuteTime= _wtol(pszStr);
// Back up to look at the hour
*pszStr = '\0';
pszStr -= 2;
m_lBeginHourTime= _wtol(pszStr);
}
else
{
//XXXBad format, default to something
m_lBeginMinuteTime= -1;
m_lBeginHourTime= -1;
}
delete [] pszTemp;
hRetRes = GetStrProperty(pObj, L"EndTime", &pszTemp);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pszStr = wcschr(pszTemp, '.');
if (pszStr)
{
// Back up to look at the minute
pszStr -= 2;
*pszStr = '\0';
pszStr -= 2;
m_lEndMinuteTime= _wtol(pszStr);
// Back up to look at the hour
*pszStr = '\0';
pszStr -= 2;
m_lEndHourTime= _wtol(pszStr);
}
else
{
//XXXBad format, default to something
m_lEndMinuteTime= -1;
m_lEndHourTime= -1;
}
delete [] pszTemp;
hRetRes = GetStrProperty(pObj, L"TypeGUID", &m_szTypeGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetBoolProperty(pObj, L"RequireReset", &m_bRequireReset);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetBoolProperty(pObj, L"Enabled", &m_bEnabled);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetStrProperty(pObj, L"Message", &m_szMessage);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetStrProperty(pObj, L"ResetMessage", &m_szResetMessage);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
//
// Now load all the Thresholds that are children of this one.
//
if (bModifyPass == FALSE)
{
if (m_bEnabled==FALSE || m_pParentDG->m_bEnabled==FALSE || m_pParentDG->m_bParentEnabled==FALSE)
{
if (m_pParentDG->m_bEnabled==FALSE || m_pParentDG->m_bParentEnabled==FALSE)
m_bParentEnabled = FALSE;
// Since our parent is disabled, we will not be able to get into
// our OnAgentInterval function and send the disabled status later.
SetCurrState(HM_DISABLED);
FireEvent(TRUE);
}
hRetRes = InternalizeThresholds();
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else
{
//
// Set our state to enabled, or disabled and transfer to the child thresholds
//
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentEnabledFlag(FALSE);
}
}
else
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentEnabledFlag(TRUE);
}
}
}
// Setup what is needed to track statistics on each property listed
// (Need to do this after the Thresholds are read in, because we may
// need to insert some properties that were not in the list)
hRetRes = InitPropertyStatus(pObj);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
//
// Do any initialization stuff now
//
// Get the pointer to the namespace used in this DataCollector
hRetRes = fillInNamespacePointer();
if (hRetRes != WBEM_E_INVALID_NAMESPACE)
{
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
m_ulErrorCode = 0;
m_ulErrorCodePrev = MAX_ULONG;
m_bValidLoad = TRUE;
//XXXXX
#ifdef SAVE
//static count = 0;
if (count==3 || count==4 || count==5 || count==6 || count==11)
{
count++;
hRetRes = WBEM_E_OUT_OF_MEMORY;
goto error;
}
else
{
count++;
}
#endif
MY_OUTPUT(L"EXIT ***** CDataCollector::LoadInstanceFromMOF...", 4);
return S_OK;
error:
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
HRESULT CDataCollector::InternalizeThresholds(void)
{
TCHAR szTemp[1024];
HRESULT hRetRes = S_OK;
ULONG uReturned;
BSTR Language = NULL;
BSTR Query = NULL;
IWbemClassObject *pObj = NULL;
IEnumWbemClassObject *pEnum = NULL;
LPTSTR pszTempGUID = NULL;
MY_OUTPUT(L"ENTER ***** CDataCollector::InternalizeThresholds...", 4);
// Just loop through all top level Thresholds associated with the DataCollector.
// Call a method of each, and have the Threshold load itself.
Language = SysAllocString(L"WQL");
MY_ASSERT(Language); if (!Language) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(szTemp, L"ASSOCIATORS OF {MicrosoftHM_DataCollectorConfiguration.GUID=\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"} WHERE ResultClass=MicrosoftHM_ThresholdConfiguration");
Query = SysAllocString(szTemp);
MY_ASSERT(Query); if (!Query) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
// Issue query
hRetRes = g_pIWbemServices->ExecQuery(Language, Query, WBEM_FLAG_FORWARD_ONLY, 0, &pEnum);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
SysFreeString(Query);
Query = NULL;
SysFreeString(Language);
Language = NULL;
// Retrieve objects in result set
while (TRUE)
{
pObj = NULL;
uReturned = 0;
hRetRes = pEnum->Next(0, 1, &pObj, &uReturned);
MY_ASSERT(hRetRes==S_OK || hRetRes==WBEM_S_FALSE);
if (hRetRes!=S_OK && hRetRes!=WBEM_S_FALSE)
{
MY_HRESASSERT(hRetRes);
pEnum->Release();
pEnum = NULL;
return hRetRes;
}
if (uReturned == 0)
{
break;
}
// See if this is already read in. Need to prevent endless loop, circular references.
hRetRes = GetStrProperty(pObj, L"GUID", &pszTempGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (!g_pStartupSystem->FindPointerFromGUIDInMasterList(pszTempGUID))
{
//
// Create the internal class to represent the Threshold
//
CThreshold* pThreshold = new CThreshold;
MY_ASSERT(pThreshold); if (!pThreshold) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if (m_deType == HM_PGDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PMDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PQDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_EQDE)
{
wcscpy(szTemp, L"MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\"");
}
else
{
MY_ASSERT(FALSE);
}
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\\\"");
hRetRes = pThreshold->LoadInstanceFromMOF(pObj, this, szTemp);
if (hRetRes==S_OK)
{
m_thresholdList.push_back(pThreshold);
}
else
{
MY_HRESASSERT(hRetRes);
delete pThreshold;
}
}
delete [] pszTempGUID;
pszTempGUID = NULL;
// Release it.
pObj->Release();
pObj = NULL;
}
// All done
pEnum->Release();
pEnum = NULL;
MY_OUTPUT(L"EXIT ***** CDataCollector::InternalizeThresholds...", 4);
return S_OK;
error:
MY_ASSERT(FALSE);
if (Query)
SysFreeString(Query);
if (Language)
SysFreeString(Language);
if (pszTempGUID)
delete [] pszTempGUID;
if (pObj)
pObj->Release();
if (pEnum)
pEnum->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
//
// Create an array element for each property we are interested
//
BOOL CDataCollector::InitContext(IWbemClassObject* pObj)
{
BOOL bRetValue = TRUE;
#ifdef SAVE
HRESULT hRes;
HRESULT hRetRes;
VARIANT v;
VARIANT vValue;
IUnknown* vUnknown;
IWbemClassObject* pCO;
BSTR bstrPropName = NULL;
long iLBound, iUBound;
LPTSTR szName;
LPTSTR szValue;
long lType;
VariantInit(&v);
bstrPropName = SysAllocString(L"Context");
if ((hRes = pObj->Get(bstrPropName, 0L, &v, NULL, NULL)) == S_OK)
{
if (V_VT(&v)==VT_NULL)
{
// MY_ASSERT(FALSE);
}
else
{
MY_ASSERT(V_VT(&v)==(VT_UNKNOWN|VT_ARRAY));
SafeArrayGetLBound(v.parray, 1, &iLBound);
SafeArrayGetUBound(v.parray, 1, &iUBound);
if ((iUBound - iLBound + 1) == 0)
{
MY_ASSERT(FALSE);
}
else
{
for (long i = iLBound; i <= iUBound; i++)
{
if (m_pContext == NULL)
{
hRes = CoCreateInstance(CLSID_WbemContext, NULL, CLSCTX_INPROC_SERVER,
IID_IWbemContext, (void **)&m_pContext);
if (S_OK != hRes)
{
MY_HRESASSERT(hRes);
}
}
VariantInit(&vValue);
vUnknown = NULL;
SafeArrayGetElement(v.parray, &i, &vUnknown);
pCO = (IWbemClassObject *)vUnknown;
hRetRes = GetStrProperty(pCO, L"Name", &szName);
MY_HRESASSERT(hRetRes);
hRetRes = GetUint32Property(pCO, L"Type", &lType);
MY_HRESASSERT(hRetRes);
hRetRes = GetStrProperty(pCO, L"Value", &szValue);
MY_HRESASSERT(hRetRes);
//
// Set the name value pair into the IWbemContext object
//
if (lType == CIM_SINT8 ||
lType == CIM_SINT16 ||
lType == CIM_CHAR16)
{
V_VT(&vValue) = VT_I2;
V_I2(&vValue) = _wtol(szValue);
}
else if (lType == CIM_SINT32 ||
lType == CIM_UINT16 ||
lType == CIM_UINT32)
{
V_VT(&vValue) = VT_I4;
V_I4(&vValue) = _wtol(szValue);
}
else if (lType == CIM_REAL32)
{
V_VT(&vValue) = VT_R4;
V_R4(&vValue) = wcstod(szValue, NULL);
}
else if (lType == CIM_BOOLEAN)
{
V_VT(&vValue) = VT_BOOL;
V_BOOL(&vValue) = (BOOL) _wtol(szValue);
}
else if (lType == CIM_SINT64 ||
lType == CIM_UINT64 ||
//XXX lType == CIM_REF ||
lType == CIM_STRING ||
lType == CIM_DATETIME)
{
V_VT(&vValue) = VT_BSTR;
V_BSTR(&vValue) = SysAllocString(szValue);
}
else if (lType == CIM_REAL64)
{
V_VT(&vValue) = VT_R8;
V_R8(&vValue) = wcstod(szValue, NULL);
}
else if (lType == CIM_UINT8)
{
V_VT(&vValue) = VT_UI1;
V_UI1(&vValue) = (unsigned char) _wtoi(szValue);
}
else
{
MY_ASSERT(FALSE);
}
hRes = m_pContext->SetValue(szName, 0L, &vValue);
if (S_OK != hRes)
{
MY_HRESASSERT(hRes);
}
VariantClear(&vValue);
delete [] szName;
delete [] szValue;
vUnknown->Release();
}
}
}
}
else
{
bRetValue = FALSE;
MY_HRESASSERT(hRes);
}
VariantClear(&v);
SysFreeString(bstrPropName);
#endif
MY_OUTPUT(L"EXIT ***** GetStrProperty...", 1);
return bRetValue;
}
//
// Create an array element for each property we are interested
//
HRESULT CDataCollector::InitPropertyStatus(IWbemClassObject* pObj)
{
HRESULT hRetRes = S_OK;
VARIANT v;
BSTR vStr = NULL;
BOOL bFound = FALSE;
long iLBound, iUBound;
PNSTRUCT pn;
int i, iSize;
CThreshold* pThreshold;
pn.szPropertyName = NULL;
pn.iRefCount = 1;
pn.type = 0;
VariantInit(&v);
if ((hRetRes = pObj->Get(L"Properties", 0L, &v, NULL, NULL)) == S_OK)
{
if (V_VT(&v)==VT_NULL)
{
}
else
{
MY_ASSERT(V_VT(&v)==(VT_BSTR|VT_ARRAY));
hRetRes = SafeArrayGetLBound(v.parray, 1, &iLBound);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = SafeArrayGetUBound(v.parray, 1, &iUBound);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if ((iUBound - iLBound + 1) == 0)
{
}
else
{
for (long i = iLBound; i <= iUBound; i++)
{
vStr = NULL;
hRetRes = SafeArrayGetElement(v.parray, &i, &vStr);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (_wcsicmp(vStr, L"CollectionInstanceCount") &&
_wcsicmp(vStr, L"CollectionErrorCode") &&
_wcsicmp(vStr, L"CollectionErrorDescription"))
{
pn.szPropertyName = new TCHAR[wcslen(vStr)+2];
MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pn.szPropertyName, vStr);
m_pnList.push_back(pn);
}
SysFreeString(vStr);
vStr = NULL;
}
}
}
}
else
{
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
VariantClear(&v);
//
// Insert all the properties used by Thresholds, that are not found in the list yet.
// Refcount those that are in there already.
//
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription"))
{
hRetRes = insertNewProperty(pThreshold->m_szPropertyName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
}
pn.szPropertyName = new TCHAR[wcslen(L"CollectionInstanceCount")+2];
MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pn.szPropertyName, L"CollectionInstanceCount");
m_pnList.push_back(pn);
pn.szPropertyName = new TCHAR[wcslen(L"CollectionErrorCode")+2];
MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pn.szPropertyName, L"CollectionErrorCode");
m_pnList.push_back(pn);
pn.szPropertyName = new TCHAR[wcslen(L"CollectionErrorDescription")+2];
MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pn.szPropertyName, L"CollectionErrorDescription");
m_pnList.push_back(pn);
return hRetRes;
error:
MY_ASSERT(FALSE);
// VariantClear(&v);
// if (pn.szPropertyName)
// pn.szPropertyName = NULL;
if (vStr)
SysFreeString(vStr);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
//
// This is the entry point for the Agents base 10 second timer. At this time we
// Have each DataCollector and Threshold do its job.
//
BOOL CDataCollector::OnAgentInterval(void)
{
int i, iSize;
long lIntervalCountTemp;
CThreshold* pThreshold;
BOOL bTimeOK;
MY_OUTPUT(L"ENTER ***** CDataCollector::OnAgentInterval...", 1);
//
// Don't do anything if we are not loaded correctly.
// Or, if a Threshold is having problems.
//
if (m_bValidLoad == FALSE)
return FALSE;
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
return FALSE;
}
m_lPrevState = m_lCurrState;
m_lNumberChanges = 0;
m_szErrorDescription[0] = '\0';
// Remember that the DISABLED state overrides SCHEDULEDOUT.
if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState==HM_DISABLED)
{
return TRUE;
}
//
// Make sure that we are in a valid time to run.
//
bTimeOK = checkTime();
if (bTimeOK==FALSE && m_lCurrState==HM_SCHEDULEDOUT && m_bEnabled && m_bParentEnabled)
{
return TRUE;
}
else if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED ||
bTimeOK==FALSE && m_lCurrState!=HM_SCHEDULEDOUT)
{
//
// Going into Scheduled Outage OR DISABLED.
// What if we are going from ScheduledOut to Disabled?
// Or from Disabled to ScheduledOut?
// Possible transitions:
// GOOD -> Disabled
// GOOD -> ScheduledOut
// Disabled -> ScheduledOut
// ScheduledOut -> Disabled
//
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
//
// This is where we are transitioning into the DISABLED State
//
EnumDone();
if (m_lPrevState == HM_SCHEDULEDOUT)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentScheduledOutFlag(FALSE);
}
}
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentEnabledFlag(FALSE);
}
m_lCurrState = HM_DISABLED;
CDataCollector::EvaluateThresholds(FALSE);
m_lNumberChanges = 1;
m_lIntervalCount = -1;
FireEvent(FALSE);
}
else
{
//
// This is where we are transitioning into the SCHEDULEDOUT State
//
EnumDone();
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentScheduledOutFlag(TRUE);
}
m_lCurrState = HM_SCHEDULEDOUT;
CDataCollector::EvaluateThresholds(FALSE);
m_lNumberChanges = 1;
m_lIntervalCount = -1;
FireEvent(FALSE);
}
return TRUE;
}
#ifdef SAVE
else if (m_lCurrState==HM_DISABLED || m_lCurrState==HM_SCHEDULEDOUT)
{
What was in action.cpp
//
// Comming out of Scheduled Outage OR DISABLED.
// Might be going from ScheduledOut/Disabled to Disabled,
// or disabled to ScheduledOut.
//
m_lCurrState = HM_GOOD;
FireEvent(-1, NULL, HMRES_ACTION_ENABLE);
}
#endif
else
{
if (m_lPrevState == HM_SCHEDULEDOUT)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentScheduledOutFlag(FALSE);
}
}
if (m_lPrevState == HM_DISABLED)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentEnabledFlag(TRUE);
}
}
//
// We are either beginning a Collection, or in the middle of one
//
m_lIntervalCount++;
if (m_bKeepCollectingSemiSync == FALSE)
{
//
// Here is where we need to fire an event in advance, because we are going to be in the
// collecting state until we have retrieved something, or in the case of the event based
// data collector, we reach the end of the collection interval.
//
if (m_lIntervalCount==0 || m_lIntervalCount==1)
{
m_lCurrState = HM_COLLECTING;
m_lPrevState = m_lCurrState;
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetCurrState(HM_COLLECTING);
}
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->FireEvent(TRUE);
}
FireEvent(TRUE);
//
// In order to smooth out the CPU utilization of the HealthMon Agent,
// random offset each Data Collector.
//
if (m_lCollectionIntervalMultiple != 0)
{
if (m_lIntervalCount==1)
{
m_lIntervalCount = rand()%m_lCollectionIntervalMultiple;
if (m_lIntervalCount == 0)
m_lIntervalCount++;
}
else
{
// This case we have been forced to forego the random, and do immediate
m_lIntervalCount = 1;
}
}
}
//
// Beginning a Collection
// Check to see if this is at an interval that we need to run at.
//
if ((m_lCollectionIntervalMultiple == 0) ||
(m_lIntervalCount!=1 && (m_lIntervalCount-1)%m_lCollectionIntervalMultiple))
{
return TRUE;
}
CollectInstance();
//
// Optomized, for when we know we have not recieved any events during the interval
//
if (m_bKeepCollectingSemiSync)
{
// This is for the case where this Data Collector might have been the only
// reason for the parent data group to be in a CRITICAL state, and now, because
// We do not push up the COLLECTING state, the data group might miss the change.
if (m_lCurrState==HM_COLLECTING && m_lPrevState!=m_lCurrState)
{
m_lNumberChanges++;
}
return TRUE;
}
}
else
{
//
// Means that we still have not received all the instance(s) back yet!
// Keep trying to collect the instance until the TimeOut has expired!
// Also watch for when the next interval has been reached and we still have not
// received the instance!
//
m_lCollectionTimeOutCount++;
CollectInstanceSemiSync();
if (m_bKeepCollectingSemiSync)
{
// Check to see if we are over the TimeOut period.
if (m_lCollectionTimeOutCount == m_lCollectionTimeOut)
{
if (m_ulErrorCode != HMRES_TIMEOUT)
{
lIntervalCountTemp = m_lIntervalCount;
ResetState(FALSE, FALSE);
m_lIntervalCount = lIntervalCountTemp;
}
else
{
EnumDone();
}
MY_ASSERT(FALSE);
m_ulErrorCode = HMRES_TIMEOUT;
GetLatestAgentError(HMRES_TIMEOUT, m_szErrorDescription);
StoreStandardProperties();
}
else
{
// This is the case where we just return, and keep trying to collect
return TRUE;
}
}
}
//
// We have made it to this point because we have received all of the instance(s)
//
//
// Evaluate the instance(s) property(s) against the threshold(s).
// In the case of evnt based data collector, we do not have any events to look at
// at the start, but need to wait for the end of the interval.
//
if (m_deType!=HM_EQDE || (m_deType==HM_EQDE && (m_lIntervalCount!=1 || m_ulErrorCode!=0)))
{
wcscpy(m_szDTCollectTime, m_szDTCurrTime);
wcscpy(m_szCollectTime, m_szCurrTime);
EvaluateThresholds(FALSE, TRUE, FALSE, FALSE);
if (m_deType!=HM_EQDE)
{
EvaluateThresholds(FALSE, FALSE, TRUE, FALSE);
}
}
// Event data collector will have called to send their own event
if (m_deType!=HM_EQDE)
{
SendEvents();
FireStatisticsEvent();
}
// To sync up prev and curr states for those cases that could keep producing events
if (m_ulErrorCode != 0)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetPrevState(HM_CRITICAL);
}
}
}
if (m_deType == HM_EQDE)
{
m_lNumInstancesCollected = 0;
}
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
{
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
break;
}
}
m_ulErrorCodePrev = m_ulErrorCode;
MY_OUTPUT(L"EXIT ***** CDataCollector::OnAgentInterval...", 1);
return TRUE;
}
BOOL CDataCollector::SendEvents(void)
{
int i, iSize;
long state;
CThreshold* pThreshold;
long lCurrChildCount = 0;
if (m_bValidLoad == FALSE)
return FALSE;
//
// See if any Thresholds were set into the RESET state,
// This causes the DataCollector to set all Thresholds to the GOOD state, and
// re-evaluate all thresholds.
//
//XXXWith this in we can implement the RESET feature, but we still need to debug fully,
CheckForReset();
//
// Set State of the DataCollector to the worst of everything under it
//
m_lNumberNormals = 0;
m_lNumberWarnings = 0;
m_lNumberCriticals = 0;
m_lNumberChanges = 0;
iSize = m_thresholdList.size();
lCurrChildCount = iSize;
if (iSize != 0)
{
m_lCurrState = -1;
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->GetCurrState();
MY_OUTPUT2(L"State=%d", state, 4);
if (state > m_lCurrState)
{
m_lCurrState = state;
}
if (state == HM_GOOD)
{
m_lNumberNormals++;
}
if (state == HM_WARNING)
{
m_lNumberWarnings++;
}
if (state == HM_CRITICAL)
{
m_lNumberCriticals++;
}
if (pThreshold->GetChange())
{
MY_OUTPUT(L"CHANGE", 4);
m_lNumberChanges++;
}
}
// The disabled state of things below us did not roll up
if (m_lCurrState==HM_DISABLED)
{
m_lCurrState = HM_GOOD;
if (m_lPrevState != m_lCurrState)
{
m_lNumberChanges++;
}
}
if (m_lCurrState == -1)
{
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
m_lCurrState = HM_DISABLED;
}
else
{
m_lCurrState = HM_GOOD;
}
if (m_lPrevState != m_lCurrState)
{
m_lNumberChanges = 1;
}
}
}
else
{
m_lCurrState = HM_GOOD;
if (m_lPrevState != m_lCurrState)
{
m_lNumberChanges = 1;
}
}
// Finally if all else fails, and we have a DE that is RESET required, and we have an INIT
// state, then set things to GOOD
if (m_bRequireReset && m_lCurrState == HM_COLLECTING)
{
m_lNumberChanges = 0;
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetCurrState(HM_GOOD);
if (pThreshold->GetChange())
{
m_lNumberChanges++;
}
}
m_lCurrState = HM_GOOD;
}
if (m_lPrevChildCount!=lCurrChildCount)
{
if (m_lNumberChanges==0 && m_lPrevState!=m_lCurrState)
{
m_lNumberChanges++;
}
}
m_lPrevChildCount = lCurrChildCount;
FireEvent(FALSE);
FirePerInstanceEvents();
return TRUE;
}
//
// If there has been a change in the state then send an event
//
HRESULT CDataCollector::FireEvent(BOOL bForce)
{
HRESULT hRetRes = S_OK;
IWbemClassObject* pInstance = NULL;
GUID guid;
HRESULT hRes;
MY_OUTPUT(L"ENTER ***** CDataCollector::FireEvent...", 2);
// Don't send if no-one is listening!
if (g_pDataCollectorEventSink == NULL)
{
return S_OK;
}
MY_OUTPUT2(L"m_lPrevState=%d", m_lPrevState, 4);
MY_OUTPUT2(L"m_lCurrState=%d", m_lCurrState, 4);
MY_OUTPUT2(L"m_lNumberChanges=%d", m_lNumberChanges, 4);
// A quick test to see if anything has really changed!
// Proceed if there have been changes
if (bForce || (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState))
{
}
else
{
return FALSE;
}
MY_OUTPUT2(L"EVENT: DataCollector State Change=%d", m_lCurrState, 4);
// Proceed if there have been changes
// yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")]
wcscpy(m_szDTTime, m_szDTCurrTime);
wcscpy(m_szTime, m_szCurrTime);
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, m_szStatusGUID, 100);
hRes = GetHMDataCollectorStatusInstance(&pInstance, TRUE);
if (FAILED(hRes))
{
MY_HRESASSERT(hRes);
MY_OUTPUT(L"failed to get instance!", 1);
return FALSE;
}
else
{
//
// Place Extrinsit event in vector for sending at end of interval.
// All get sent at once.
//
mg_DCEventList.push_back(pInstance);
}
MY_OUTPUT(L"EXIT ***** CDataCollector::FireEvent...", 2);
return hRetRes;
error:
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
//
// Send out events for each instance that has had a change of state.
// The state of each will be the worst of all.
//
BOOL CDataCollector::FirePerInstanceEvents(void)
{
long state;
int i, iSize;
BOOL bRetValue = TRUE;
IWbemClassObject* pInstance = NULL;
ACTUALINSTSTRUCT *pActualInst;
long firstInstanceState = -1;
MY_OUTPUT(L"ENTER ***** CDataCollector::FirePerInstanceEvents...", 2);
// Don't send if no-one is listening!
if (g_pDataCollectorPerInstanceEventSink == NULL)
{
return bRetValue;
}
//
// We can loop through the set of collected instances and ask each Threshold
// to tell us if the state has changed as far as each is concerned, for the
// property they are lookin at.
//
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
if ((state=PassBackStateIfChangedPerInstance(pActualInst->szInstanceID, (BOOL)i==0))!=-1)
{
if (i==0)
{
firstInstanceState = state;
}
// Update time since we had a state change
wcscpy(pActualInst->szDTTime, m_szDTCurrTime);
wcscpy(pActualInst->szTime, m_szCurrTime);
if (GetHMDataCollectorPerInstanceStatusEvent(pActualInst->szInstanceID, pActualInst, state, &pInstance, TRUE)==S_OK)
{
//
// Place Extrinsit event in vector for sending at end of interval.
// All get sent at once.
//
mg_DCPerInstanceEventList.push_back(pInstance);
}
}
}
//
// Do it for the three default properties
//
if (firstInstanceState==-1 && (state=PassBackStateIfChangedPerInstance(L"CollectionInstanceCount", FALSE))!=-1)
{
// Update time since we had a state change
wcscpy(m_szDTCICTime, m_szDTCurrTime);
wcscpy(m_szCICTime, m_szCurrTime);
if (GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &pInstance, TRUE)==S_OK)
{
//
// Place Extrinsit event in vector for sending at end of interval.
// All get sent at once.
//
mg_DCPerInstanceEventList.push_back(pInstance);
}
}
if (firstInstanceState==-1 && (state=PassBackStateIfChangedPerInstance(L"CollectionErrorCode", FALSE))!=-1)
{
// Update time since we had a state change
wcscpy(m_szDTCECTime, m_szDTCurrTime);
wcscpy(m_szCECTime, m_szCurrTime);
if (GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorCode", NULL, state, &pInstance, TRUE)==S_OK)
{
//
// Place Extrinsit event in vector for sending at end of interval.
// All get sent at once.
//
mg_DCPerInstanceEventList.push_back(pInstance);
}
}
MY_OUTPUT(L"EXIT ***** CDataCollector::FirePerInstanceEvents...", 2);
return TRUE;
}
long CDataCollector::PassBackStateIfChangedPerInstance(LPTSTR pszInstName, BOOL bCombineWithStandardProperties)
{
int i, iSize;
long worstState, state;
CThreshold* pThreshold;
worstState = -1;
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackStateIfChangedPerInstance(pszInstName);
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
if (bCombineWithStandardProperties)
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackStateIfChangedPerInstance(L"CollectionInstanceCount");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
state = pThreshold->PassBackStateIfChangedPerInstance(L"CollectionErrorCode");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
}
// May have had one Threshold go from CRITICAL to GOOD and have a change, while another
// Threshold was WARNING and stayed WARNING with no change, so need to go there.
if (worstState != -1)
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackWorstStatePerInstance(pszInstName);
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
if (bCombineWithStandardProperties)
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackWorstStatePerInstance(L"CollectionInstanceCount");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
state = pThreshold->PassBackWorstStatePerInstance(L"CollectionErrorCode");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
}
}
return worstState;
}
long CDataCollector::PassBackWorstStatePerInstance(LPTSTR pszInstName, BOOL bCombineWithStandardProperties)
{
int i, iSize;
long worstState, state;
CThreshold* pThreshold;
worstState = -1;
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackWorstStatePerInstance(pszInstName);
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
if (bCombineWithStandardProperties)
{
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->PassBackWorstStatePerInstance(L"CollectionInstanceCount");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
state = pThreshold->PassBackWorstStatePerInstance(L"CollectionErrorCode");
if (state != -1)
{
if (state==HM_DISABLED)
{
state = HM_GOOD;
}
if (state > worstState)
{
worstState = state;
}
}
}
}
return worstState;
}
// Only Send statistics information on a change
BOOL CDataCollector::FireStatisticsEvent(void)
{
BOOL bRetValue = TRUE;
if (m_bValidLoad == FALSE)
return FALSE;
MY_OUTPUT(L"ENTER ***** CDataCollector::FireStatisticsEvent...", 2);
// Don't send if no-one is listening!
if (g_pDataCollectorStatisticsEventSink == NULL)
{
return bRetValue;
}
MY_OUTPUT2(L"Someone listening for statistics GUID=%s", m_szGUID, 4);
fillInPropertyStatus(m_szDTCurrTime, m_szCurrTime);
MY_OUTPUT(L"EXIT ***** CDataCollector::FireStatisticsEvent...", 2);
return bRetValue;
}
BOOL CDataCollector::fillInPropertyStatus(LPTSTR szDTTime, LPTSTR szTime)
{
MY_ASSERT(FALSE);
//Not used anymore!
return TRUE;
}
//
// Store the values for the properties that we care about.
//
BOOL CDataCollector::StoreValues(IWbemClassObject* pObj, LPTSTR pszInstID)
{
HRESULT hRetRes = S_OK;
int i, iSize;
int j, jSize;
PNSTRUCT *ppn;
INSTSTRUCT *pinst;
HRESULT hRes;
VARIANT v;
BOOL bRetValue = TRUE;
BOOL bFirstType = FALSE;
BOOL bFound;
CThreshold* pThreshold;
VariantInit(&v);
if (m_bValidLoad == FALSE)
return FALSE;
MY_OUTPUT(L"ENTER ***** CDataCollector::StoreValues...", 1);
//
// LOOP through all the properties we are suppose to collect data for into the instance(s).
// If the type is set to 0 in the PropertyStat struct, then we know that it
// is the first time we have seen this instance, so set it!
//
iSize = m_pnList.size();
if (pObj)
{
for (i=0; i < iSize-3; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
bFound = FALSE;
jSize = ppn->instList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (!_wcsicmp(pinst->szInstanceID, pszInstID))
{
bFound = TRUE;
break;
}
}
MY_ASSERT(bFound == TRUE);
if (bFound == TRUE)
{
if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount") ||
!_wcsicmp(ppn->szPropertyName, L"CollectionErrorCode") ||
!_wcsicmp(ppn->szPropertyName, L"CollectionErrorDescription"))
{
// Don't do for the these properties
continue;
}
// Get the data from the perfmon property
VariantInit(&v);
if (ppn->type == 0)
{
bFirstType = TRUE;
}
if ((hRes = pObj->Get(ppn->szPropertyName, 0L, &v, &ppn->type, NULL)) == S_OK)
{
MY_OUTPUT(L"Property Get worked", 3);
if (bFirstType)
{
ResetInst(pinst, ppn->type);
}
if (V_VT(&v)==VT_NULL)
{
MY_OUTPUT(L"NULL TYPE", 3);
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
pinst->szCurrValue = NULL;
}
if (ppn->type == CIM_STRING)
{
pinst->szCurrValue = new TCHAR[5];
MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pinst->szCurrValue , L"");
}
pinst->bNull = TRUE;
}
else
{
// We are going from collecting NULL to actually getting something
if (bFirstType==FALSE && pinst->bNull==TRUE)
{
m_lCurrState = HM_COLLECTING;
jSize = m_thresholdList.size();
for (j=0; j<jSize; j++)
{
MY_ASSERT(j<m_thresholdList.size());
pThreshold = m_thresholdList[j];
pThreshold->SetCurrState(HM_COLLECTING);
}
}
pinst->bNull = FALSE;
if (V_VT(&v)==VT_R4)
{
pinst->currValue.fValue = V_R4(&v);
MY_ASSERT(ppn->type == CIM_REAL32);
}
else if (V_VT(&v)==VT_R8)
{
pinst->currValue.dValue = V_R8(&v);
MY_ASSERT(ppn->type == CIM_REAL64);
}
else if (V_VT(&v)==VT_I2)
{
pinst->currValue.lValue = (long) V_I2(&v);
}
else if (V_VT(&v)==VT_I4)
{
if (ppn->type == CIM_UINT32)
{
pinst->currValue.ulValue = V_UI4(&v);
}
else
{
pinst->currValue.lValue = (long) V_I4(&v);
}
}
// else if (V_VT(&v)==VT_UI4)
// {
// pinst->currValue.ulValue = (long) V_UI4(&v);
// }
else if (V_VT(&v)==VT_UI1)
{
pinst->currValue.lValue = (long) V_UI1(&v);
}
else if (V_VT(&v)==VT_BOOL)
{
pinst->currValue.lValue = (long) V_BOOL(&v);
if (pinst->currValue.lValue != 0.0)
{
pinst->currValue.lValue = 1.0;
}
}
else if (V_VT(&v)==VT_BSTR)
{
if (ppn->type == CIM_SINT64)
{
pinst->currValue.i64Value = _wtoi64(V_BSTR(&v));
}
else if (ppn->type == CIM_UINT64)
{
pinst->currValue.ui64Value = 0;
ReadUI64(V_BSTR(&v), pinst->currValue.ui64Value);
}
else
{
ppn->type = CIM_STRING;
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
pinst->szCurrValue = new TCHAR[wcslen(V_BSTR(&v))+2];
MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pinst->szCurrValue , V_BSTR(&v));
}
}
else
{
// If for example we had a VT_BSTR | VT_ARRAY would we end up here?
// We need to do something to detect arrays, and assert, or handle them???
MY_OUTPUT(L"UNKNOWN DATA TYPE", 3);
ppn->type = CIM_STRING;
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
pinst->szCurrValue = new TCHAR[8];
MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pinst->szCurrValue , L"UNKNOWN");
}
}
//
// Update the min,max and average values
//
if (ppn->type != CIM_STRING)
{
CalcStatistics(pinst, ppn->type);
}
}
else
{
m_ulErrorCode = hRes;
GetLatestWMIError(HMRES_BADDCPROP, hRes, m_szErrorDescription);
wcscat(m_szErrorDescription, L" ");
wcscat(m_szErrorDescription, ppn->szPropertyName);
bRetValue = FALSE;
MY_OUTPUT2(L"Couldn't Get instance property=%s", ppn->szPropertyName, 4);
}
VariantClear(&v);
}
}
}
else
{
if (!_wcsicmp(pszInstID, L"CollectionInstanceCount"))
{
i = iSize-3;
}
else if (!_wcsicmp(pszInstID, L"CollectionErrorCode"))
{
i = iSize-2;
}
else if (!_wcsicmp(pszInstID, L"CollectionErrorDescription"))
{
i = iSize-1;
}
else
{
MY_ASSERT(FALSE);
i = iSize-3;
}
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
bFound = FALSE;
jSize = ppn->instList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (!_wcsicmp(pinst->szInstanceID, pszInstID))
{
bFound = TRUE;
break;
}
}
MY_ASSERT(bFound == TRUE);
if (bFound == TRUE)
{
//
// Case where this is the special number of instances property!
//
if (!_wcsicmp(pszInstID, L"CollectionInstanceCount"))
{
ppn->type = CIM_UINT32;
pinst->currValue.ulValue = m_lNumInstancesCollected;
CalcStatistics(pinst, ppn->type);
}
else if (!_wcsicmp(pszInstID, L"CollectionErrorCode"))
{
ppn->type = CIM_UINT32;
pinst->currValue.ulValue = m_ulErrorCode;
CalcStatistics(pinst, ppn->type);
}
else if (!_wcsicmp(pszInstID, L"CollectionErrorDescription"))
{
ppn->type = CIM_STRING;
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
pinst->szCurrValue = new TCHAR[wcslen(m_szErrorDescription)+2];
MY_ASSERT(pinst->szCurrValue); if (!pinst->szCurrValue) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pinst->szCurrValue , m_szErrorDescription);
}
else
{
MY_ASSERT(FALSE);
}
}
}
MY_OUTPUT(L"EXIT ***** CDataCollector::StoreValues...", 1);
return bRetValue;
error:
MY_ASSERT(FALSE);
m_ulErrorCode = HMRES_NOMEMORY;
GetLatestAgentError(HMRES_NOMEMORY, m_szErrorDescription);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return FALSE;
}
BOOL CDataCollector::StoreStandardProperties(void)
{
HRESULT hRetRes;
if (m_bValidLoad == FALSE)
return FALSE;
//
// Set the standard properties
//
hRetRes = CheckInstanceExistance(NULL, L"CollectionInstanceCount");
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StoreValues(NULL, L"CollectionInstanceCount");
CheckInstanceExistance(NULL, L"CollectionErrorCode");
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StoreValues(NULL, L"CollectionErrorCode");
CheckInstanceExistance(NULL, L"CollectionErrorDescription");
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StoreValues(NULL, L"CollectionErrorDescription");
return TRUE;
error:
MY_ASSERT(FALSE);
m_ulErrorCode = hRetRes;
GetLatestWMIError(HMRES_OBJECTNOTFOUND, hRetRes, m_szErrorDescription);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return FALSE;
}
BOOL CDataCollector::CalcStatistics(INSTSTRUCT *pinst, CIMTYPE type)
{
int i;
int iSize;
VALSTRUCT val;
VALSTRUCT *pval;
VALLIST::iterator iaVAL;
union hm_datatypes value;
if (type == CIM_STRING)
{
MY_ASSERT(FALSE);
}
else if (type == CIM_DATETIME)
{
MY_ASSERT(FALSE);
}
else if (type == CIM_REAL32)
{
if (pinst->currValue.fValue < pinst->minValue.fValue)
{
pinst->minValue.fValue = pinst->currValue.fValue;
}
if (pinst->maxValue.fValue < pinst->currValue.fValue)
{
pinst->maxValue.fValue = pinst->currValue.fValue;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.fValue = pinst->currValue.fValue;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.fValue = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.fValue += pval->value.fValue;
}
if (i==0)
pinst->avgValue.fValue = value.fValue;
else
pinst->avgValue.fValue = value.fValue/i;
}
else if (type == CIM_REAL64)
{
if (pinst->currValue.dValue < pinst->minValue.dValue)
{
pinst->minValue.dValue = pinst->currValue.dValue;
}
if (pinst->maxValue.dValue < pinst->currValue.dValue)
{
pinst->maxValue.dValue = pinst->currValue.dValue;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.dValue = pinst->currValue.dValue;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.dValue = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.dValue += pval->value.dValue;
}
if (i==0)
pinst->avgValue.dValue = value.dValue;
else
pinst->avgValue.dValue = value.dValue/i;
}
else if (type == CIM_SINT64)
{
if (pinst->currValue.i64Value < pinst->minValue.i64Value)
{
pinst->minValue.i64Value = pinst->currValue.i64Value;
}
if (pinst->maxValue.i64Value < pinst->currValue.i64Value)
{
pinst->maxValue.i64Value = pinst->currValue.i64Value;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.i64Value = pinst->currValue.i64Value;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.i64Value = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.i64Value += pval->value.i64Value;
}
if (i==0)
pinst->avgValue.i64Value = value.i64Value;
else
pinst->avgValue.i64Value = value.i64Value/i;
}
else if (type == CIM_UINT64)
{
if (pinst->currValue.ui64Value < pinst->minValue.ui64Value)
{
pinst->minValue.ui64Value = pinst->currValue.ui64Value;
}
if (pinst->maxValue.ui64Value < pinst->currValue.ui64Value)
{
pinst->maxValue.ui64Value = pinst->currValue.ui64Value;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.ui64Value = pinst->currValue.ui64Value;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.ui64Value = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.ui64Value += pval->value.ui64Value;
}
if (i==0)
pinst->avgValue.ui64Value = value.ui64Value;
else
pinst->avgValue.ui64Value = value.ui64Value/i;
}
else if (type == CIM_UINT32)
{
// Must be an integer type
if (pinst->currValue.ulValue < pinst->minValue.ulValue)
{
pinst->minValue.ulValue = pinst->currValue.ulValue;
}
if (pinst->maxValue.ulValue < pinst->currValue.ulValue)
{
pinst->maxValue.ulValue = pinst->currValue.ulValue;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.ulValue = pinst->currValue.ulValue;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.ulValue = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.ulValue += pval->value.ulValue;
}
if (i==0)
pinst->avgValue.ulValue = value.ulValue;
else
pinst->avgValue.ulValue = value.ulValue/i;
}
else
{
// Must be an integer type
if (pinst->currValue.lValue < pinst->minValue.lValue)
{
pinst->minValue.lValue = pinst->currValue.lValue;
}
if (pinst->maxValue.lValue < pinst->currValue.lValue)
{
pinst->maxValue.lValue = pinst->currValue.lValue;
}
//
// Add new value to the end.
// If we are over the limit of number of samples to keep,
// drop the oldest.
//
val.value.lValue = pinst->currValue.lValue;
pinst->valList.push_back(val);
iSize = pinst->valList.size();
if (m_lStatisticsWindowSize < iSize)
{
iaVAL=pinst->valList.begin();
pinst->valList.erase(iaVAL);
}
//
// Now calculate the average from what we have.
//
value.lValue = 0;
iSize = pinst->valList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<pinst->valList.size());
pval = &pinst->valList[i];
value.lValue += pval->value.lValue;
}
if (i==0)
pinst->avgValue.lValue = value.lValue;
else
pinst->avgValue.lValue = value.lValue/i;
}
return TRUE;
}
BOOL CDataCollector::EvaluateThresholds(BOOL bIgnoreReset, BOOL bSkipStandard/*=FALSE*/, BOOL bSkipOthers/*=FALSE*/, BOOL bDoThresholdSkipClean/*=TRUE*/)
{
LPTSTR pszPropertyName;
int iSize;
int jSize;
int i;
int j;
CThreshold* pThreshold;
PNSTRUCT *ppn = NULL;
BOOL bFound = FALSE;
INSTSTRUCT *pinst;
if (m_bValidLoad == FALSE)
return FALSE;
//
// For each threshold associated with this DataCollector, find the property status
// structure, and have the threshold evaluate against the current values.
//
iSize = m_thresholdList.size();
for (i = 0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
break;
pszPropertyName = pThreshold->GetPropertyName();
if (bSkipStandard && (!_wcsicmp(pszPropertyName, L"CollectionInstanceCount") ||
!_wcsicmp(pszPropertyName, L"CollectionErrorCode") ||
!_wcsicmp(pszPropertyName, L"CollectionErrorDescription")))
{
if (bDoThresholdSkipClean)
pThreshold->SkipClean();
continue;
}
if (bSkipOthers && (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pszPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pszPropertyName, L"CollectionErrorDescription")))
{
if (bDoThresholdSkipClean)
pThreshold->SkipClean();
continue;
}
jSize = m_pnList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<m_pnList.size());
ppn = &m_pnList[j];
if (!_wcsicmp(ppn->szPropertyName, pszPropertyName))
{
bFound = TRUE;
break;
}
}
//
// If the type is still equal to zero, that means that the threshold is probably looking
// at a property that does not exist.
// Also remember that if we are transitioning to DISABLED, or SCHEDULEDOUT we need to
// go into the Threshold evaluation do disable them.
//
if ((m_lCurrState==HM_DISABLED || m_lCurrState==HM_SCHEDULEDOUT) ||
((m_ulErrorCode==0 || (m_ulErrorCode!=0 && !wcscmp(pszPropertyName, L"CollectionErrorCode"))) &&
(bFound && ppn->type!=0)))
{
//
// Also need to watch for case where we can't do evaluation yet.
// If AVERAGE is used, then wait until full window of samples has been collected.
// If difference, then must wait for the second one.
//
if (pThreshold->m_bUseDifference)
{
if (m_lIntervalCount < 2)
{
continue;
}
}
else if (pThreshold->m_bUseAverage)
{
// Need to find out how many samples we have
MY_ASSERT(ppn);
if (ppn->instList.size())
{
pinst = &ppn->instList[0];
if (pinst->valList.size() < m_lStatisticsWindowSize)
{
continue;
}
}
else
{
}
}
// If this threshold has already been violated and the RequireReset is TRUE
// then we don't need to test for re-arm.
if (bIgnoreReset == TRUE)
{
if (pThreshold->GetCurrState() != HM_RESET)
{
pThreshold->SetCurrState(HM_COLLECTING);
pThreshold->SetBackPrev(ppn);
pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset);
}
}
else
{
pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset);
}
}
else
{
if (pThreshold->m_bEnabled==FALSE || pThreshold->m_bParentEnabled==FALSE || pThreshold->m_bParentScheduledOut)
{
pThreshold->OnAgentInterval(&m_actualInstList, ppn, m_bRequireReset);
}
else if (m_ulErrorCode!=0)
{
// Case where had an error in the collection process that needs to take priority.
pThreshold->SetCurrState(HM_CRITICAL, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_DCUNKNOWN);
pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev);
}
else if (ppn->type==0)
{
// Having zero instances is not a crime if we are certain types of DataColectors.
if (m_lNumInstancesCollected>0)
{
// Case where the property to collect did not exist
m_ulErrorCode = HMRES_BADTHRESHPROP;
pThreshold->SetCurrState(HM_CRITICAL, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_BADTHRESHPROP);
pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev);
GetLatestAgentError(HMRES_BADTHRESHPROP, m_szErrorDescription);
wcscat(m_szErrorDescription, L" ");
wcscat(m_szErrorDescription, pszPropertyName);
StoreValues(NULL, L"CollectionErrorCode");
StoreValues(NULL, L"CollectionErrorDescription");
}
else
{
pThreshold->SetCurrState(HM_GOOD, m_ulErrorCode!=m_ulErrorCodePrev, HMRES_DCUNKNOWN);
pThreshold->FireEvent(m_ulErrorCode!=m_ulErrorCodePrev);
}
}
else
{
}
}
}
return TRUE;
}
HRESULT CDataCollector::SendHMDataCollectorStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID)
{
MY_ASSERT(pSink!=NULL);
//
// Is this the one we are looking for?
//
if (!_wcsicmp(m_szGUID, pszGUID))
{
//
// Don't do anything if we are not loaded correctly.
//
//XXX if (m_bValidLoad == FALSE)
//XXX return WBEM_E_INVALID_OBJECT;
return SendHMDataCollectorStatusInstances(pSink);
}
else
{
return WBEM_S_DIFFERENT;
}
}
HRESULT CDataCollector::SendHMDataCollectorStatusInstances(IWbemObjectSink* pSink)
{
HRESULT hRes = S_OK;
IWbemClassObject* pInstance = NULL;
MY_OUTPUT(L"ENTER ***** SendHMDataCollectorStatusInstances...", 2);
//XXX if (m_bValidLoad == FALSE)
//XXX return WBEM_E_INVALID_OBJECT;
if (pSink == NULL)
{
MY_OUTPUT(L"CDC::SendInitialHMMachStatInstances-Invalid Sink", 1);
return WBEM_E_FAILED;
}
hRes = GetHMDataCollectorStatusInstance(&pInstance, FALSE);
if (SUCCEEDED(hRes))
{
hRes = pSink->Indicate(1, &pInstance);
if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE)
{
MY_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1);
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1);
}
MY_OUTPUT(L"EXIT ***** SendHMDataCollectorStatusInstances...", 2);
return hRes;
}
HRESULT CDataCollector::SendHMDataCollectorPerInstanceStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID)
{
MY_ASSERT(pSink!=NULL);
//
// Is this the one we are looking for?
//
if (!_wcsicmp(m_szGUID, pszGUID))
{
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
return SendHMDataCollectorPerInstanceStatusInstances(pSink);
}
else
{
return WBEM_S_DIFFERENT;
}
}
// This one is for enumeration of all Instances outside of the hierarchy.
// Just the flat list.
HRESULT CDataCollector::SendHMDataCollectorPerInstanceStatusInstances(IWbemObjectSink* pSink)
{
HRESULT hRes;
long state;
int i, iSize;
BOOL bRetValue = TRUE;
IWbemClassObject* pInstance = NULL;
ACTUALINSTSTRUCT *pActualInst;
long firstInstanceState = -1;
MY_OUTPUT(L"ENTER ***** CDataCollector::SendHMDataCollectorPerInstanceStatusInstance...", 2);
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
if (pSink == NULL)
{
MY_OUTPUT(L"-Invalid Sink", 1);
return WBEM_E_FAILED;
}
//
// We can loop through the set of collected instances and ask each Threshold
// to tell us if the state has changed as far as each is concerned, for the
// property they are lookin at.
//
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
state = PassBackWorstStatePerInstance(pActualInst->szInstanceID, (BOOL)i==0);
if (state==-1) state = HM_COLLECTING;
if (i==0)
{
firstInstanceState = state;
}
hRes = GetHMDataCollectorPerInstanceStatusEvent(pActualInst->szInstanceID, pActualInst, state, &pInstance, FALSE);
if (SUCCEEDED(hRes))
{
hRes = pSink->Indicate(1, &pInstance);
if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE)
{
MY_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1);
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1);
}
}
//
// Do it for the three default properties
//
if (firstInstanceState==-1)
{
state = PassBackWorstStatePerInstance(L"CollectionInstanceCount", FALSE);
if (state==-1) state = HM_COLLECTING;
hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &pInstance, FALSE);
if (SUCCEEDED(hRes))
{
hRes = pSink->Indicate(1, &pInstance);
if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE)
{
MY_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1);
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1);
}
}
if (firstInstanceState==-1)
{
state = PassBackWorstStatePerInstance(L"CollectionErrorCode", FALSE);
if (state==-1) state = HM_COLLECTING;
hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorCode", NULL, state, &pInstance, FALSE);
if (SUCCEEDED(hRes))
{
hRes = pSink->Indicate(1, &pInstance);
if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE)
{
MY_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1);
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1);
}
}
#ifdef SAVE
state = PassBackWorstStatePerInstance(L"CollectionErrorDescription");
if (state==-1) state = HM_COLLECTING;
hRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionErrorDescription", NULL, state, &pInstance, FALSE);
if (SUCCEEDED(hRes))
{
hRes = pSink->Indicate(1, &pInstance);
if (FAILED(hRes) && hRes!=WBEM_E_SERVER_TOO_BUSY && hRes!=WBEM_E_CALL_CANCELLED && hRes!=WBEM_E_TRANSPORT_FAILURE)
{
MY_OUTPUT(L"SendHMDataCollectorStatusInstances-failed to send status!", 1);
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_OUTPUT(L":SendHMDataCollectorStatusInstances-failed to get instance!", 1);
}
#endif
MY_OUTPUT(L"EXIT ***** CDataCollector::FirePerInstanceEvents...", 2);
return S_OK;
}
HRESULT CDataCollector::SendHMDataCollectorStatisticsInstance(IWbemObjectSink* pSink, LPTSTR pszGUID)
{
MY_ASSERT(pSink!=NULL);
//
// Is this the one we are looking for?
//
if (!_wcsicmp(m_szGUID, pszGUID))
{
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
return SendHMDataCollectorStatisticsInstances(pSink);
}
else
{
return WBEM_S_DIFFERENT;
}
}
HRESULT CDataCollector::SendHMDataCollectorStatisticsInstances(IWbemObjectSink* pSink)
{
HRESULT hRes = S_OK;
MY_OUTPUT(L"ENTER ***** SendHMDataCollectorStatisticsInstances...", 2);
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
if (pSink == NULL)
{
MY_OUTPUT(L"CDC::SendInitialHMMachStatInstances-Invalid Sink", 1);
return WBEM_E_FAILED;
}
hRes = GetHMDataCollectorStatisticsInstances(m_szDTCollectTime, m_szCollectTime);
MY_OUTPUT(L"EXIT ***** SendHMDataCollectorStatisticsInstances...", 2);
return hRes;
}
HRESULT CDataCollector::SendHMThresholdStatusInstances(IWbemObjectSink* pSink)
{
int i;
int iSize;
CThreshold *pThreshold;
PNSTRUCT *ppn = NULL;
BOOL bFound = FALSE;
MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstances...", 1);
// Have all Thresholds of this DataCollector send their status
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SendHMThresholdStatusInstances(pSink);
}
MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstances...", 1);
return S_OK;
}
HRESULT CDataCollector::SendHMThresholdStatusInstance(IWbemObjectSink* pSink, LPTSTR pszGUID)
{
int i;
int iSize;
CThreshold *pThreshold;
PNSTRUCT *ppn = NULL;
HRESULT hRetRes = S_OK;
MY_OUTPUT(L"ENTER ***** SendHMThresholdStatusInstance...", 1);
// Try to find the one that needs sending
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
hRetRes = pThreshold->SendHMThresholdStatusInstance(pSink, pszGUID);
if (hRetRes==S_OK)
{
return S_OK;
}
else if (hRetRes!=WBEM_S_DIFFERENT)
{
return hRetRes;
}
}
MY_OUTPUT(L"EXIT ***** SendHMThresholdStatusInstance...", 1);
return WBEM_S_DIFFERENT;
}
HRESULT CDataCollector::GetHMDataCollectorStatusInstance(IWbemClassObject** ppInstance, BOOL bEventBased)
{
TCHAR szTemp[1024];
IWbemClassObject* pClass = NULL;
BSTR bsString = NULL;
HRESULT hRetRes = S_OK;
DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2;
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2];
MY_OUTPUT(L"ENTER ***** GetHMSystemStatusInstance...", 1);
if (bEventBased)
{
bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatusEvent");
MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
}
else
{
bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatus");
MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
}
hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL);
SysFreeString(bsString);
bsString = NULL;
if (FAILED(hRetRes))
{
return hRetRes;
}
hRetRes = pClass->SpawnInstance(0, ppInstance);
pClass->Release();
pClass = NULL;
if (FAILED(hRetRes))
return hRetRes;
if (m_bValidLoad == FALSE)
{
hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutUint32Property(*ppInstance, L"State", HM_CRITICAL);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_DC_LOADFAIL, szTemp, 1024))
{
wcscpy(szTemp, L"Data Collector failed to load.");
}
hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (GetComputerName(szComputerName, &dwNameLen))
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName);
}
else
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine");
}
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTTime);
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szTime);
hRetRes = PutStrProperty(*ppInstance, L"Name", L"...");
}
else
{
hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID);
hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID);
hRetRes = PutStrProperty(*ppInstance, L"Name", m_szName);
if (GetComputerName(szComputerName, &dwNameLen))
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName);
}
else
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine");
}
hRetRes = PutUint32Property(*ppInstance, L"State", m_lCurrState);
hRetRes = PutUint32Property(*ppInstance, L"CollectionInstanceCount", m_lNumInstancesCollected);
hRetRes = PutUUint32Property(*ppInstance, L"CollectionErrorCode", m_ulErrorCode);
hRetRes = PutStrProperty(*ppInstance, L"CollectionErrorDescription", m_szErrorDescription);
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTTime);
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szTime);
hRetRes = PutStrProperty(*ppInstance, L"StatusGUID", m_szStatusGUID);
if (m_lCurrState==HM_SCHEDULEDOUT)
{
if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_OUTAGE, szTemp, 1024))
{
wcscpy(szTemp, L"Data Collector in Scheduled Outage State");
}
hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp);
}
else if (m_lCurrState==HM_DISABLED)
{
if (g_hResLib == NULL || !LoadString(g_hResLib, HMRES_DISABLE, szTemp, 1024))
{
wcscpy(szTemp, L"Data Collector in Disabled State");
}
hRetRes = PutStrProperty(*ppInstance, L"Message", szTemp);
}
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
MY_OUTPUT(L"EXIT ***** GetHMSystemStatusInstance...", 1);
return hRetRes;
error:
MY_ASSERT(FALSE);
if (bsString)
SysFreeString(bsString);
if (pClass)
pClass->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
HRESULT CDataCollector::GetHMDataCollectorStatisticsInstances(LPTSTR szDTTime, LPTSTR szTime)
{
HRESULT hRetRes = S_OK;
PNSTRUCT *ppn = NULL;
INSTSTRUCT *pinst = NULL;
int i, iSize;
int j, jSize;
TCHAR szTemp[128] = {0};
IWbemClassObject* pClass = NULL;
IWbemClassObject* pInstance = NULL;
BSTR bsString = NULL;
DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2;
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2];
int rc = 0;
char buffer[50];
iSize = m_pnList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
jSize = ppn->instList.size();
for (j=0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
bsString = SysAllocString(L"MicrosoftHM_DataCollectorStatistics");
MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL);
SysFreeString(bsString);
bsString = NULL;
if (FAILED(hRetRes))
{
return hRetRes;
}
hRetRes = pClass->SpawnInstance(0, &pInstance);
pClass->Release();
pClass = NULL;
if (FAILED(hRetRes))
return hRetRes;
hRetRes = PutStrProperty(pInstance, L"GUID", m_szGUID);
if (GetComputerName(szComputerName, &dwNameLen))
{
hRetRes = PutStrProperty(pInstance, L"SystemName", szComputerName);
}
else
{
hRetRes = PutStrProperty(pInstance, L"SystemName", L"LocalMachine");
}
hRetRes = PutStrProperty(pInstance, L"PropertyName", ppn->szPropertyName);
hRetRes = PutStrProperty(pInstance, L"InstanceName", pinst->szInstanceID);
hRetRes = PutStrProperty(pInstance, L"TimeGeneratedGMT", szDTTime);
hRetRes = PutStrProperty(pInstance, L"LocalTimeFormatted", szTime);
if (pinst->bNull==TRUE)
{
hRetRes = PutStrProperty(pInstance, L"CurrentValue", L"NULL");
}
else if (ppn->type==CIM_STRING || ppn->type==CIM_DATETIME)
{
if (pinst->szCurrValue)
{
hRetRes = PutStrProperty(pInstance, L"CurrentValue", pinst->szCurrValue);
}
else
{
hRetRes = PutStrProperty(pInstance, L"CurrentValue", L"");
}
}
else if (ppn->type == CIM_REAL32)
{
_gcvt((double)pinst->currValue.fValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
else if (ppn->type == CIM_REAL64)
{
_gcvt(pinst->currValue.dValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
else if (ppn->type == CIM_SINT64)
{
_i64tow(pinst->currValue.i64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
else if (ppn->type == CIM_UINT64)
{
_ui64tow(pinst->currValue.ui64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
else if (ppn->type == CIM_UINT32)
{
// Must be an integer type
_ultow(pinst->currValue.ulValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
else
{
// Must be an integer type
_ltow(pinst->currValue.lValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"CurrentValue", szTemp);
}
if (pinst->bNull==TRUE)
{
hRetRes = PutStrProperty(pInstance, L"MinValue", L"");
hRetRes = PutStrProperty(pInstance, L"MaxValue", L"");
hRetRes = PutStrProperty(pInstance, L"AvgValue", L"");
}
else if (ppn->type==CIM_STRING || ppn->type==CIM_DATETIME)
{
hRetRes = PutStrProperty(pInstance, L"MinValue", L"");
hRetRes = PutStrProperty(pInstance, L"MaxValue", L"");
hRetRes = PutStrProperty(pInstance, L"AvgValue", L"");
}
else if (ppn->type == CIM_REAL32)
{
_gcvt((double)pinst->minValue.fValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_gcvt((double)pinst->maxValue.fValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_gcvt((double)pinst->avgValue.fValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
else if (ppn->type == CIM_REAL64)
{
_gcvt(pinst->minValue.dValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_gcvt(pinst->maxValue.dValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_gcvt(pinst->avgValue.dValue, 7, buffer);
rc = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, buffer, strlen(buffer), szTemp, 128);
szTemp[rc] = NULL;
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
else if (ppn->type == CIM_SINT64)
{
_i64tow(pinst->minValue.i64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_i64tow(pinst->maxValue.i64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_i64tow(pinst->avgValue.i64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
else if (ppn->type == CIM_UINT64)
{
_ui64tow(pinst->minValue.ui64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_ui64tow(pinst->maxValue.ui64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_ui64tow(pinst->avgValue.ui64Value, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
else if (ppn->type == CIM_UINT32)
{
// Must be an integer type
_ultow(pinst->minValue.ulValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_ultow(pinst->maxValue.ulValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_ultow(pinst->avgValue.ulValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
else
{
// Must be an integer type
_ltow(pinst->minValue.lValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MinValue", szTemp);
_ltow(pinst->maxValue.lValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"MaxValue", szTemp);
_ltow(pinst->avgValue.lValue, szTemp, 10 );
hRetRes = PutStrProperty(pInstance, L"AvgValue", szTemp);
}
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
// If we do not have all our samples, then don't show the average yet
if (pinst->valList.size() < m_lStatisticsWindowSize)
{
hRetRes = PutStrProperty(pInstance, L"AvgValue", L"-");
}
mg_DCStatsInstList.push_back(pInstance);
}
}
return S_OK;
error:
MY_ASSERT(FALSE);
if (bsString)
SysFreeString(bsString);
if (pClass)
pClass->Release();
iSize = mg_DCStatsInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<mg_DCStatsInstList.size());
pInstance = mg_DCStatsInstList[i];
pInstance->Release();
}
mg_DCStatsInstList.clear();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
long CDataCollector::GetCurrState(void)
{
return m_lCurrState;
}
HRESULT CDataCollector::FindAndModDataCollector(BSTR szGUID, IWbemClassObject* pObj)
{
HRESULT hRetRes = S_OK;
//
// Is this us we are looking for?
//
if (!_wcsicmp(m_szGUID, szGUID))
{
hRetRes = LoadInstanceFromMOF(pObj, NULL, L"", TRUE);
return hRetRes;
}
return WBEM_S_DIFFERENT;
}
HRESULT CDataCollector::FindAndModThreshold(BSTR szGUID, IWbemClassObject* pObj)
{
TCHAR szTemp[1024];
HRESULT hRetRes = S_OK;
int i, iSize;
CThreshold* pThreshold;
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
//
// Look at Threshold of this DataDataCollector
//
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
hRetRes = pThreshold->FindAndModThreshold(szGUID, pObj);
if (hRetRes==S_OK)
{
wcsncpy(szTemp, pThreshold->m_szPropertyName, 1023);
szTemp[1023] = '\0';
// Check to see if the Threshold is looking at a different property!
if (_wcsicmp(szTemp, pThreshold->m_szPropertyName))
{
if (_wcsicmp(szTemp, L"CollectionInstanceCount") &&
_wcsicmp(szTemp, L"CollectionErrorCode") &&
_wcsicmp(szTemp, L"CollectionErrorDescription"))
{
propertyNotNeeded(szTemp);
}
if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription"))
{
hRetRes = insertNewProperty(pThreshold->m_szPropertyName);
if (hRetRes != S_OK)
return hRetRes;
}
}
ResetState(TRUE, TRUE);
return S_OK;
}
else if (hRetRes!=WBEM_S_DIFFERENT)
{
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
}
return WBEM_S_DIFFERENT;
}
HRESULT CDataCollector::AddThreshold(BSTR szParentGUID, BSTR szChildGUID)
{
int i, iSize;
TCHAR szTemp[1024];
CThreshold* pThreshold = NULL;
IWbemClassObject *pObj = NULL;
BSTR Path = NULL;
HRESULT hRetRes;
LPTSTR pszTempGUID = NULL;
//
// Are we the parent DataGroup that we want to add under?
//
if (!_wcsicmp(m_szGUID, szParentGUID))
{
//
// First check to see if is in there already!
//
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (!_wcsicmp(szChildGUID, pThreshold->GetGUID()))
{
return S_OK;
}
}
//
// Add in the Threshold
//
wcscpy(szTemp, L"MicrosoftHM_ThresholdConfiguration.GUID=\"");
lstrcat(szTemp, szChildGUID);
lstrcat(szTemp, L"\"");
Path = SysAllocString(szTemp);
MY_ASSERT(Path); if (!Path) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
hRetRes = GetWbemObjectInst(&g_pIWbemServices, Path, NULL, &pObj);
if (!pObj)
{
SysFreeString(Path);
Path = NULL;
return hRetRes;
}
TCHAR msgbuf[1024];
wsprintf(msgbuf, L"ASSOCIATION: Threshold to DataCollector ParentDCGUID=%s ChildTGUID=%s", szParentGUID, szChildGUID);
MY_OUTPUT(msgbuf, 4);
// See if this is already read in. Need to prevent endless loop, circular references.
hRetRes = GetStrProperty(pObj, L"GUID", &pszTempGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (!g_pStartupSystem->FindPointerFromGUIDInMasterList(pszTempGUID))
{
//
// Create the internal class to represent the DataGroup
//
pThreshold = new CThreshold;
MY_ASSERT(pThreshold); if (!pThreshold) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if (m_deType == HM_PGDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PMDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PQDE)
{
wcscpy(szTemp, L"MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_EQDE)
{
wcscpy(szTemp, L"MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\"");
}
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\\\"");
if (pThreshold->LoadInstanceFromMOF(pObj, this, szTemp)==S_OK)
{
if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription"))
{
hRetRes = insertNewProperty(pThreshold->m_szPropertyName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
//
// Get Threshold and DataCollector synced up. Plus we may have been in the middle of a
// collection interval as this came in.
//
ResetState(TRUE, TRUE);
m_thresholdList.push_back(pThreshold);
}
else
{
delete pThreshold;
}
}
delete [] pszTempGUID;
pszTempGUID = NULL;
pObj->Release();
pObj = NULL;
SysFreeString(Path);
Path = NULL;
return S_OK;
}
return WBEM_S_DIFFERENT;
error:
MY_ASSERT(FALSE);
if (pszTempGUID)
delete [] pszTempGUID;
if (Path)
SysFreeString(Path);
if (pObj)
pObj->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
LPTSTR CDataCollector::GetGUID(void)
{
return m_szGUID;
}
BOOL CDataCollector::ResetResetThresholdStates(void)
{
int i, iSize;
CThreshold* pThreshold;
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->ResetResetThreshold();
}
return TRUE;
}
BOOL CDataCollector::GetChange(void)
{
if (m_lNumberChanges!=0 && m_lPrevState!=m_lCurrState)
{
return TRUE;
}
else
{
return FALSE;
}
}
//
// Called By the Delete method that the HMSystemConfiguration class exposes.
// We search down the hierarchy until we find what we need to delete.
// We are only search down form where we are, as the object above already verified
// that we are not what was being looked for.
//
HRESULT CDataCollector::FindAndDeleteByGUID(LPTSTR pszGUID)
{
BOOL bDeleted = FALSE;
int i, iSize;
CThreshold* pThreshold;
RLIST::iterator iaR;
//
// Traverse the complete hierarchy to find the object to delete.
//
iSize = m_thresholdList.size();
iaR=m_thresholdList.begin();
for (i=0; i<iSize; i++, iaR++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
if (!_wcsicmp(pszGUID, pThreshold->GetGUID()))
{
if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription"))
{
propertyNotNeeded(pThreshold->m_szPropertyName);
}
pThreshold->DeleteThresholdConfig();
delete pThreshold;
m_thresholdList.erase(iaR);
bDeleted = TRUE;
TCHAR msgbuf[1024];
wsprintf(msgbuf, L"DELETION: TGUID=%s", pszGUID);
MY_OUTPUT(msgbuf, 4);
//
// Get Threshold and DataCollector synced up. Plus we may have been in the middle of a
// collection interval as this came in.
//
ResetState(TRUE, TRUE);
break;
}
}
if (bDeleted == FALSE)
{
return S_FALSE;
}
else
{
return S_OK;
}
}
//
// HMSystemConfiguration class exposes this method.
//
HRESULT CDataCollector::FindAndEnableByGUID(LPTSTR pszGUID, BOOL bEnable)
{
BOOL bFound = FALSE;
int i, iSize;
CThreshold* pThreshold;
//
// Traverse the complete hierarchy to find the object to enable/disable.
//
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (!_wcsicmp(pszGUID, pThreshold->GetGUID()))
{
bFound = TRUE;
break;
}
}
if (bFound == FALSE)
{
return S_FALSE;
}
else
{
return S_OK;
}
}
//
// HMSystemConfiguration class exposes this method.
//
// Get rid of the data that was collected, so we can be clean,
// just as if we just started running.
//
//
HRESULT CDataCollector::ResetState(BOOL bPreserveThresholdStates, BOOL bDoImmediate)
{
CThreshold* pThreshold;
PNSTRUCT *ppn = NULL;
INSTSTRUCT *pinst;
InstIDSTRUCT *pInstID;
int i, j;
int iSize, jSize;
ACTUALINSTSTRUCT *pActualInst;
MY_OUTPUT(L"ENTER ***** CDataCollector::ResetState...", 1);
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
return S_OK;
}
CleanupSemiSync();
m_ulErrorCodePrev = MAX_ULONG;
m_lIntervalCount = 0;
if (bDoImmediate)
{
m_lIntervalCount = -1;
}
else
{
m_lIntervalCount = 0;
}
m_lCollectionTimeOutCount = 0;
m_lNumInstancesCollected = 0;
if (bPreserveThresholdStates == FALSE)
{
m_lCurrState = HM_COLLECTING;
}
m_bKeepCollectingSemiSync = FALSE;
iSize = m_pnList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
jSize = ppn->instList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
if (pinst->szInstanceID)
{
delete [] pinst->szInstanceID;
}
pinst->valList.clear();
}
ppn->instList.clear();
}
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->ClearInstList();
if (bPreserveThresholdStates == FALSE)
{
pThreshold->SetCurrState(HM_COLLECTING);
}
}
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
if (pActualInst->szInstanceID)
{
delete [] pActualInst->szInstanceID;
}
if (pActualInst->pInst)
{
pActualInst->pInst->Release();
pActualInst->pInst = NULL;
}
}
m_actualInstList.clear();
//
// Need this for sure with PMDC, does it adversly affect other DataCollectors
//
iSize = m_instIDList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_instIDList.size());
pInstID = &m_instIDList[i];
delete [] pInstID->szInstanceIDPropertyName;
}
m_instIDList.clear();
MY_OUTPUT(L"EXIT ***** CDataCollector::ResetState...", 1);
return S_OK;
}
//
// HMSystemConfiguration class exposes this method.
//
HRESULT CDataCollector::ResetStatistics(void)
{
INSTSTRUCT *pinst;
PNSTRUCT *ppn;
int i, j;
int iSize, jSize;
MY_OUTPUT(L"ENTER ***** CDataCollector::ResetStatistics...", 1);
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
return S_OK;
}
iSize = m_pnList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
jSize = ppn->instList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
pinst->szCurrValue = NULL;
ResetInst(pinst, ppn->type);
pinst->valList.clear();
}
}
EvaluateNow(TRUE);
MY_OUTPUT(L"EXIT ***** CDataCollector::ResetStatistics...", 1);
return S_OK;
}
//
// HMSystemConfiguration class exposes this method.
// Set the increment count back to zero temporarily, so it will
// run at the next second interval, then set back!
//
HRESULT CDataCollector::EvaluateNow(BOOL bDoImmediate)
{
MY_OUTPUT(L"ENTER ***** CDataCollector::EvaluateNow...", 1);
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
EnumDone();
if (bDoImmediate)
{
m_lIntervalCount = -1;
}
else
{
m_lIntervalCount = 0;
}
m_lCollectionTimeOutCount = 0;
if (m_deType != HM_EQDE)
{
m_lNumInstancesCollected = 0;
}
MY_OUTPUT(L"EXIT ***** CDataCollector::EvaluateNow...", 1);
return S_OK;
}
BOOL CDataCollector::SetParentEnabledFlag(BOOL bEnabled)
{
int i, iSize;
CThreshold* pThreshold;
m_bParentEnabled = bEnabled;
if (m_bEnabled==FALSE || m_bParentEnabled==FALSE)
{
}
else
{
m_lIntervalCount = 0;
}
//
// Now traverse children and call for everything below
//
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->SetParentEnabledFlag(m_bEnabled && m_bParentEnabled);
}
return TRUE;
}
BOOL CDataCollector::Init(void)
{
MY_OUTPUT(L"ENTER ***** CDataCollector::Init...", 1);
m_lIntervalCount = 0;
m_lCollectionTimeOutCount = 0;
m_lNumberNormals = 0;
m_lNumberWarnings = 0;
m_lNumberCriticals = 0;
m_lNumberChanges = 0;
m_lNumInstancesCollected = 0;
m_lCurrState = HM_COLLECTING;
m_lPrevState = HM_COLLECTING;
m_ulErrorCode = 0;
m_ulErrorCodePrev = MAX_ULONG;
m_lCollectionTimeOut = 0;
m_szGUID = NULL;
m_szParentObjPath = NULL;
m_pParentDG = NULL;
m_szName = NULL;
m_szDescription = NULL;
m_szUserName = NULL;
m_szPassword = NULL;
m_szTargetNamespace = NULL;
m_szLocal = NULL;
m_szTypeGUID = NULL;
m_pContext = NULL;
m_pCallResult = NULL;
m_bKeepCollectingSemiSync = FALSE;
m_bEnabled = TRUE;
m_bParentEnabled = TRUE;
m_pIWbemServices = NULL;
m_lCollectionIntervalMultiple = 60;
m_lStatisticsWindowSize = 6;
m_iActiveDays = 0;
m_lBeginHourTime = 0;
m_lBeginMinuteTime = 0;
m_lEndHourTime = 0;
m_lEndMinuteTime = 0;
m_lTypeGUID = 0;
m_bRequireReset = FALSE;
m_bReplicate = FALSE;
m_lId = 0;
m_szErrorDescription[0] = '\0';
m_szMessage = NULL;
m_szResetMessage = NULL;
m_lPrevChildCount = 0;
// yyyymmddhhmmss.ssssssXUtc; X = GMT(+ or -), Utc = 3 dig. offset from UTC.")]
wcscpy(m_szTime, m_szCurrTime);
wcscpy(m_szCollectTime, m_szCurrTime);
wcscpy(m_szCICTime, m_szCurrTime);
wcscpy(m_szCECTime, m_szCurrTime);
wcscpy(m_szDTTime, m_szDTCurrTime);
wcscpy(m_szDTCollectTime, m_szDTCurrTime);
wcscpy(m_szDTCICTime, m_szDTCurrTime);
wcscpy(m_szDTCECTime, m_szDTCurrTime);
MY_OUTPUT(L"EXIT ***** CDataCollector::Init...", 1);
return TRUE;
}
BOOL CDataCollector::Cleanup(BOOL bSavePrevSettings)
{
PNSTRUCT *ppn;
INSTSTRUCT *pinst;
int i, iSize;
int j, jSize;
CThreshold* pThreshold;
InstIDSTRUCT *pInstID;
ACTUALINSTSTRUCT *pActualInst;
IWbemClassObject* pInstance = NULL;
MY_OUTPUT(L"ENTER ***** CDataCollector::Cleanup...", 1);
if (bSavePrevSettings == FALSE)
{
// if (m_szParentObjPath)
// {
// delete [] m_szParentObjPath;
// m_szParentObjPath = NULL;
// }
}
if (m_szName)
{
delete [] m_szName;
m_szName = NULL;
}
if (m_szDescription)
{
delete [] m_szDescription;
m_szDescription = NULL;
}
if (m_szMessage)
{
delete [] m_szMessage;
m_szMessage = NULL;
}
if (m_szResetMessage)
{
delete [] m_szResetMessage;
m_szResetMessage = NULL;
}
if (m_szUserName)
{
delete [] m_szUserName;
m_szUserName = NULL;
}
if (m_szPassword)
{
delete [] m_szPassword;
m_szPassword = NULL;
}
if (m_szTargetNamespace)
{
delete [] m_szTargetNamespace;
m_szTargetNamespace = NULL;
}
if (m_szLocal)
{
delete [] m_szLocal;
m_szLocal = NULL;
}
iSize = m_instIDList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_instIDList.size());
pInstID = &m_instIDList[i];
delete [] pInstID->szInstanceIDPropertyName;
}
m_instIDList.clear();
if (m_szTypeGUID)
{
delete [] m_szTypeGUID;
m_szTypeGUID = NULL;
}
if (m_pContext != NULL)
{
m_pContext->Release();
m_pContext = NULL;
}
if (m_pCallResult != NULL)
{
m_pCallResult->Release();
m_pCallResult = NULL;
}
if (bSavePrevSettings)
{
ResetState(TRUE, TRUE);
//
// Need to also get rid of the Property names,
// As ResetState does not do that.
//
iSize = m_pnList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
if (ppn->szPropertyName)
{
delete [] ppn->szPropertyName;
}
}
m_pnList.clear();
}
else
{
iSize = m_pnList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
if (ppn->szPropertyName)
{
delete [] ppn->szPropertyName;
}
jSize = ppn->instList.size();
for (j = 0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
if (pinst->szInstanceID)
{
delete [] pinst->szInstanceID;
}
pinst->valList.clear();
}
ppn->instList.clear();
}
m_pnList.clear();
//
// Clean up everything under this DataCollector
//
if (m_bValidLoad == TRUE)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
delete pThreshold;
}
m_thresholdList.clear();
}
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
if (pActualInst->szInstanceID)
{
delete [] pActualInst->szInstanceID;
}
if (pActualInst->pInst)
{
pActualInst->pInst->Release();
pActualInst->pInst = NULL;
}
}
m_actualInstList.clear();
}
if (m_bValidLoad == FALSE)
{
EnumDone();
if (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK)
{
mg_DCEventList.push_back(pInstance);
}
}
MY_OUTPUT(L"EXIT ***** CDataCollector::Cleanup...", 1);
return TRUE;
}
#ifdef SAVE
//
// For when moving from one parent to another
//
BOOL CDataCollector::ModifyAssocForMove(CBase *pNewParentBase)
{
HRESULT hRes;
TCHAR szTemp[1024];
TCHAR szNewTemp[1024];
BSTR instName;
IWbemContext *pCtx = 0;
IWbemCallResult *pResult = 0;
IWbemClassObject* pObj = NULL;
IWbemClassObject* pNewObj = NULL;
MY_OUTPUT(L"ENTER ***** CDataGroup::ModifyAssocForMove...", 4);
MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4);
//
// Figure out the new parent path
//
if (pNewParentBase->m_hmStatusType == HMSTATUS_DATAGROUP)
{
wcscpy(szNewTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_DataGroupConfiguration.GUID=\"");
}
else
{
MY_ASSERT(FALSE);
}
lstrcat(szNewTemp, pNewParentBase->m_szGUID);
lstrcat(szNewTemp, L"\"");
//
// Delete the association from my parent to me.
//
if (m_deType == HM_PGDE)
{
wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\"");
}
else if (m_deType == HM_PMDE)
{
wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\"");
}
else if (m_deType == HM_PQDE)
{
wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\"");
}
else if (m_deType == HM_EQDE)
{
wcscpy(szTemp, L"\\\\.\\root\\cimv2\\MicrosoftHealthMonitor:MicrosoftHealthMonitor:MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\"");
}
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"");
instName = SysAllocString(L"MicrosoftHM_ConfigurationAssociation");
if ((hRes = g_pIWbemServices->GetObject(instName, 0L, NULL, &pObj, NULL)) != S_OK)
{
}
SysFreeString(instName);
if (pObj)
{
hRes = pObj->SpawnInstance(0, &pNewObj);
pObj->Release();
PutStrProperty(pNewObj, L"ChildPath", szTemp);
PutStrProperty(pNewObj, L"ParentPath", szNewTemp);
hRes = g_pIWbemServices->PutInstance(pNewObj, 0, NULL, &pResult);
pNewObj->Release();
pNewObj = NULL;
}
DeleteDEConfig(TRUE);
if (pNewParentBase->m_hmStatusType == HMSTATUS_DATAGROUP)
{
wcscpy(szNewTemp, L"MicrosoftHM_DataGroupConfiguration.GUID=\\\"");
lstrcat(szNewTemp, pNewParentBase->m_szGUID);
lstrcat(szNewTemp, L"\\\"");
}
else
{
MY_ASSERT(FALSE);
}
if (m_szParentObjPath)
{
delete [] m_szParentObjPath;
}
m_szParentObjPath = new TCHAR[wcslen(szNewTemp)+1];
wcscpy(m_szParentObjPath, szNewTemp);
m_pParentDG = (CDataGroup *) pNewParentBase;
MY_OUTPUT(L"EXIT ***** CDataGroup::ModifyAssocForMove...", 4);
return TRUE;
}
#endif
BOOL CDataCollector::ReceiveNewChildForMove(CBase *pBase)
{
//XXX seems to be some code missing here,
//did we clean up from the old place things like m_pnList, and add to the new one if it is a
//new property.
// Like what we do in -> CDataCollector::AddThreshold()
MY_ASSERT(FALSE);
MY_ASSERT(pBase->m_hmStatusType == HMSTATUS_DATACOLLECTOR);
m_thresholdList.push_back((CThreshold *)pBase);
// (CThreshold *)pBase->SetParentEnabledFlag(m_bEnabled);
if (_wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(((CThreshold *)pBase)->m_szPropertyName, L"CollectionErrorDescription"))
{
insertNewProperty(((CThreshold *)pBase)->m_szPropertyName);
// MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
//
// Get Threshold and DataCollector synced up. Plus we may have been in the middle of a
// collection interval as this came in.
//
ResetState(TRUE, TRUE);
return TRUE;
}
BOOL CDataCollector::DeleteChildFromList(LPTSTR pszGUID)
{
int i, iSize;
CThreshold* pThreshold;
RLIST::iterator iaR;
BOOL bFound = FALSE;
iSize = m_thresholdList.size();
iaR=m_thresholdList.begin();
for (i=0; i<iSize; i++, iaR++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
return FALSE;
if (!_wcsicmp(pszGUID, pThreshold->GetGUID()))
{
if (_wcsicmp(pThreshold->m_szPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pThreshold->m_szPropertyName, L"CollectionErrorDescription"))
{
propertyNotNeeded(pThreshold->m_szPropertyName);
}
m_thresholdList.erase(iaR);
bFound = TRUE;
break;
}
}
return bFound;
}
BOOL CDataCollector::DeleteDEConfig(BOOL bDeleteAssocOnly)
{
int i, iSize;
CThreshold* pThreshold;
HRESULT hRetRes = S_OK;
TCHAR szTemp[1024];
BSTR instName = NULL;
MY_OUTPUT(L"ENTER ***** CDataCollector::DeleteDEConfig...", 4);
MY_OUTPUT2(L"m_szGUID=%s", m_szGUID, 4);
//
// Delete the association from my parent to me.
//
if (m_deType == HM_PGDE)
{
wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledGetObjectDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PMDE)
{
wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledMethodDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_PQDE)
{
wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_PolledQueryDataCollectorConfiguration.GUID=\\\"");
}
else if (m_deType == HM_EQDE)
{
wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_EventQueryDataCollectorConfiguration.GUID=\\\"");
}
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\\\"\",ParentPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:");
lstrcat(szTemp, m_szParentObjPath);
lstrcat(szTemp, L"\"");
instName = SysAllocString(szTemp);
MY_ASSERT(instName); if (!instName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK)
{
SysFreeString(instName);
instName = NULL;
wcscpy(szTemp, L"MicrosoftHM_ConfigurationAssociation.ChildPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:MicrosoftHM_DataCollectorConfiguration.GUID=\\\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\\\"\",ParentPath=\"\\\\\\\\.\\\\root\\\\cimv2\\\\MicrosoftHealthMonitor:");
lstrcat(szTemp, m_szParentObjPath);
lstrcat(szTemp, L"\"");
instName = SysAllocString(szTemp);
MY_ASSERT(instName); if (!instName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK)
{
// MY_HRESASSERT(hRes);
}
}
SysFreeString(instName);
instName = NULL;
if (bDeleteAssocOnly)
{
return TRUE;
}
//
// Delete our exact instance
//
wcscpy(szTemp, L"MicrosoftHM_DataCollectorConfiguration.GUID=\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"");
instName = SysAllocString(szTemp);
MY_ASSERT(instName); if (!instName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
if ((hRetRes = g_pIWbemServices->DeleteInstance(instName, 0L, NULL, NULL)) != S_OK)
{
// MY_HRESASSERT(hRes);
}
SysFreeString(instName);
instName = NULL;
//
// Traverse the complete hierarchy and delete
//
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pThreshold->DeleteThresholdConfig();
delete pThreshold;
}
m_thresholdList.clear();
//
// Get rid of any associations to actions for this
//
g_pSystem->DeleteAllConfigActionAssoc(m_szGUID);
MY_OUTPUT(L"EXIT ***** CDataCollector::DeleteDEConfig...", 4);
return TRUE;
error:
MY_ASSERT(FALSE);
if (instName)
SysFreeString(instName);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return FALSE;
}
BOOL CDataCollector::DeleteDEInternal(void)
{
int i, iSize;
CThreshold* pThreshold;
MY_OUTPUT(L"ENTER ***** CDataCollector::DeleteDEInternal...", 4);
//
// Traverse the complete hierarchy and delete
//
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
delete pThreshold;
}
m_thresholdList.clear();
//
// Get rid of any associations to actions for this
//
// g_pSystem->DeleteAllConfigActionAssoc(m_szGUID);
MY_OUTPUT(L"EXIT ***** CDataCollector::DeleteDEInternal...", 4);
return TRUE;
}
HRESULT CDataCollector::FindAndCopyByGUID(LPTSTR pszGUID, ILIST* pConfigList, LPTSTR *pszOriginalParentGUID)
{
int i, iSize;
CThreshold* pThreshold;
HRESULT hRetRes = S_OK;
//
// Find what to copy
//
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (!_wcsicmp(pszGUID, pThreshold->GetGUID()))
{
hRetRes = pThreshold->Copy(pConfigList, NULL, NULL);
*pszOriginalParentGUID = m_szGUID;
return hRetRes;
}
}
return WBEM_S_DIFFERENT;
}
HRESULT CDataCollector::Copy(ILIST* pConfigList, LPTSTR pszOldParentGUID, LPTSTR pszNewParentGUID)
{
GUID guid;
TCHAR szTemp[1024];
TCHAR szNewGUID[1024];
IWbemClassObject* pInst = NULL;
IWbemClassObject* pInstCopy = NULL;
IWbemClassObject* pInstAssocCopy = NULL;
IWbemClassObject* pObj = NULL;
int i, iSize;
CThreshold* pThreshold;
BSTR Language = NULL;
BSTR Query = NULL;
IEnumWbemClassObject *pEnum;
ULONG uReturned;
IWbemContext *pCtx = 0;
LPTSTR pszParentPath = NULL;
LPTSTR pszChildPath = NULL;
LPTSTR pStr;
HRESULT hRetRes = S_OK;
MY_OUTPUT(L"ENTER ***** CDataCollector::Copy...", 1);
if (m_bValidLoad == FALSE)
return WBEM_E_INVALID_OBJECT;
//
// Get the origional starting point HMConfiguration instance.
//
wcscpy(szTemp, L"MicrosoftHM_Configuration.GUID=\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"");
hRetRes = GetWbemObjectInst(&g_pIWbemServices, szTemp, NULL, &pInst);
if (!pInst)
{
return hRetRes;
}
//
// Clone the instance, and change the GUID
//
hRetRes = pInst->Clone(&pInstCopy);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, szNewGUID, 100);
hRetRes = PutStrProperty(pInstCopy, L"GUID", szNewGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pConfigList->push_back(pInstCopy);
//
// Add instance of HMConfigurationAssociation where we are the child,
// using the parent GUID passed in.
// Change the GUIDs of both the Parent and Child.
// also make sure that the machine name is not in the path, and is relative!
//
if (pszOldParentGUID != NULL)
{
Language = SysAllocString(L"WQL");
MY_ASSERT(Language); if (!Language) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(szTemp, L"REFERENCES OF {MicrosoftHM_Configuration.GUID=\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"} WHERE ResultClass=MicrosoftHM_ConfigurationAssociation Role=ChildPath");
Query = SysAllocString(szTemp);
MY_ASSERT(Query); if (!Query) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
// Initialize IEnumWbemClassObject pointer
pEnum = 0;
// Issue query
hRetRes = g_pIWbemServices->ExecQuery(Language, Query, WBEM_FLAG_FORWARD_ONLY, 0, &pEnum);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
SysFreeString(Query);
Query = NULL;
SysFreeString(Language);
Language = NULL;
// Retrieve object in result set
pObj = NULL;
uReturned = 0;
hRetRes = pEnum->Next(0, 1, &pObj, &uReturned);
if (uReturned == 0)
{
hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error;
}
//
// Change the GUIDs
//
hRetRes = GetStrProperty(pObj, L"ParentPath", &pszParentPath);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = GetStrProperty(pObj, L"ChildPath", &pszChildPath);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pStr = wcschr(pszParentPath, '\"');
if (pStr)
{
pStr++;
wcsncpy(pStr, pszNewParentGUID, wcslen(pszNewParentGUID));
}
else
{
hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error;
}
pStr = wcschr(pszChildPath, '\"');
if (pStr)
{
pStr++;
wcsncpy(pStr, szNewGUID, wcslen(szNewGUID));
}
else
{
hRetRes = WBEM_E_INVALID_OBJECT_PATH; goto error;
}
hRetRes = pObj->Clone(&pInstAssocCopy);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(pInstAssocCopy, L"ParentPath", pszParentPath);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(pInstAssocCopy, L"ChildPath", pszChildPath);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pConfigList->push_back(pInstAssocCopy);
// Release it.
pObj->Release();
pObj = NULL;
pEnum->Release();
pEnum = NULL;
delete [] pszParentPath;
pszParentPath = NULL;
delete [] pszChildPath;
pszChildPath = NULL;
}
//
// Add in all children
//
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
hRetRes = pThreshold->Copy(pConfigList, m_szGUID, szNewGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
pInst->Release();
pInst = NULL;
MY_OUTPUT(L"EXIT ***** CDataCollector::Copy...", 1);
return S_OK;
error:
MY_ASSERT(FALSE);
if (pInst)
pInst->Release();
if (pObj)
pObj->Release();
if (pEnum)
pEnum->Release();
if (Query)
SysFreeString(Query);
if (Language)
SysFreeString(Language);
if (pszParentPath)
delete [] pszParentPath;
if (pszChildPath)
delete [] pszChildPath;
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
CBase *CDataCollector::GetParentPointerFromGUID(LPTSTR pszGUID)
{
int i, iSize;
CThreshold* pThreshold;
BOOL bFound = FALSE;
CBase *pBase;
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (!_wcsicmp(pszGUID, pThreshold->GetGUID()))
{
pBase = pThreshold;
bFound = TRUE;
break;
}
}
if (bFound == TRUE)
{
return pBase;
}
else
{
return NULL;
}
}
CBase *CDataCollector::FindImediateChildByName(LPTSTR pszName)
{
int i, iSize;
CThreshold* pThreshold;
BOOL bFound = FALSE;
CBase *pBase;
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
return NULL;
if (!_wcsicmp(pszName, pThreshold->m_szName))
{
pBase = pThreshold;
bFound = TRUE;
break;
}
}
if (bFound == TRUE)
{
return pBase;
}
else
{
return NULL;
}
}
BOOL CDataCollector::GetNextChildName(LPTSTR pszChildName, LPTSTR pszOutName)
{
TCHAR szTemp[1024];
TCHAR szIndex[1024];
int i, iSize;
BOOL bFound;
CThreshold* pThreshold;
int index;
// We are here because we know that one exists already with the same name.
// So, lets start off trying to guess what the next name should be and get one.
index = 0;
bFound = TRUE;
while (bFound == TRUE)
{
wcscpy(szTemp, pszChildName);
_itow(index, szIndex, 10);
lstrcat(szTemp, L" ");
lstrcat(szTemp, szIndex);
bFound = FALSE;
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->m_bValidLoad == FALSE)
break;
if (!_wcsicmp(szTemp, pThreshold->m_szName))
{
bFound = TRUE;
break;
}
}
index++;
}
wcscpy(pszOutName, szTemp);
return TRUE;
}
CBase *CDataCollector::FindPointerFromName(LPTSTR pszName)
{
int i, iSize;
CThreshold* pThreshold;
BOOL bFound = FALSE;
CBase *pBase;
iSize = m_thresholdList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (!_wcsicmp(pszName, pThreshold->GetGUID()))
{
pBase = pThreshold;
bFound = TRUE;
break;
}
}
if (bFound == TRUE)
{
return pBase;
}
else
{
return NULL;
}
}
HRESULT CDataCollector::GetInstanceID(IWbemClassObject* pObj, LPTSTR *pszID)
{
HRESULT hRetRes = NULL;
TCHAR szTemp[1024];
LPTSTR pszTemp = NULL;
InstIDSTRUCT InstID;
SAFEARRAY *psaNames = NULL;
BSTR PropName = NULL;
long lLower, lUpper;
int i, iSize;
InstIDSTRUCT *pInstID;
if (m_bValidLoad == FALSE)
return FALSE;
iSize = m_instIDList.size();
if (iSize == 0)
{
hRetRes = pObj->GetNames(NULL, WBEM_FLAG_KEYS_ONLY | WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
if (SUCCEEDED(hRetRes))
{
// Get the number of properties.
hRetRes = SafeArrayGetLBound(psaNames, 1, &lLower);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = SafeArrayGetUBound(psaNames, 1, &lUpper);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if ((lUpper - lLower + 1) == 0)
{
InstID.szInstanceIDPropertyName = new TCHAR[3];
MY_ASSERT(InstID.szInstanceIDPropertyName); if (!InstID.szInstanceIDPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(InstID.szInstanceIDPropertyName , L"@");
m_instIDList.push_back(InstID);
}
else
{
// For each property...
for (long k=lLower; k<=lUpper; k++)
{
// Get this property.
hRetRes = SafeArrayGetElement(psaNames, &k, &PropName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (SUCCEEDED(hRetRes))
{
InstID.szInstanceIDPropertyName = new TCHAR[wcslen(PropName)+2];
MY_ASSERT(InstID.szInstanceIDPropertyName); if (!InstID.szInstanceIDPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(InstID.szInstanceIDPropertyName , PropName);
SysFreeString(PropName);
PropName = NULL;
m_instIDList.push_back(InstID);
}
}
}
SafeArrayDestroy(psaNames);
psaNames = NULL;
}
}
MY_ASSERT(m_instIDList.size());
//
// Add it as a new instance if necessary
// All PropertyNames have the same list of instances.
// Just look at the first PropertyName, and search through
// its list of instances.
//
MY_ASSERT(m_instIDList.size());
pInstID = &m_instIDList[0];
if (!wcscmp(pInstID->szInstanceIDPropertyName, L"@"))
{
*pszID = new TCHAR[3];
MY_ASSERT(pszID); if (!pszID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(*pszID , L"@");
}
else
{
szTemp[0] = '\0';
iSize = m_instIDList.size();
for (i=0; i < iSize; i++)
{
if (i != 0)
wcscat(szTemp, L";");
MY_ASSERT(i<m_instIDList.size());
pInstID = &m_instIDList[i];
hRetRes = GetAsStrProperty(pObj, pInstID->szInstanceIDPropertyName, &pszTemp);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
wcscat(szTemp, pszTemp);
delete [] pszTemp;
pszTemp = NULL;
}
*pszID = new TCHAR[wcslen(szTemp)+2];
MY_ASSERT(pszID); if (!pszID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(*pszID , szTemp);
}
return hRetRes;
error:
MY_ASSERT(FALSE);
if (PropName)
SysFreeString(PropName);
if (pszTemp)
delete [] pszTemp;
if (psaNames)
SafeArrayDestroy(psaNames);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
//
// Adds new instances that have not been seen before, and makes ones seen alread as
// needed again. If pObj is NULL, that means it is one of the special Agent provided
// properties - CollectionInstanceCount, CollectionErrorCode or CollectionErrorDescription.
//
HRESULT CDataCollector::CheckInstanceExistance(IWbemClassObject *pObj, LPTSTR pszInstanceID)
{
HRESULT hRetRes = S_OK;
BOOL bFound;
PNSTRUCT *ppn;
INSTSTRUCT *pinst;
int i, j, iSize, jSize;
int foundInstID;
CThreshold *pThreshold;
IRSSTRUCT *pirs;
INSTSTRUCT inst;
LPTSTR pszPropertyName;
// BOOL bRetValue;
if (m_bValidLoad == FALSE)
return FALSE;
// Just need to look at the instance list of the first property to tell if the
// instance has been seen yet.
if (pObj)
{
bFound = FALSE;
iSize = m_pnList.size();
if (4 <= iSize)
{
i = 0;
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
jSize = ppn->instList.size();
for (j=0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (!_wcsicmp(pinst->szInstanceID, pszInstanceID))
{
bFound = TRUE;
foundInstID = j;
break;
}
}
}
}
else
{
bFound = FALSE;
iSize = m_pnList.size();
if (3 <= iSize)
{
if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount"))
{
i = iSize-3;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode"))
{
i = iSize-2;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription"))
{
i = iSize-1;
}
else
{
MY_ASSERT(FALSE);
i = iSize-3;
}
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
jSize = ppn->instList.size();
for (j=0; j < jSize ; j++)
{
MY_ASSERT(j<ppn->instList.size());
pinst = &ppn->instList[j];
if (!_wcsicmp(pinst->szInstanceID, pszInstanceID))
{
bFound = TRUE;
foundInstID = j;
break;
}
}
}
}
if (bFound == FALSE)
{
// Add an instance to each property name.
// Only add the CollectionInstanceCount instance to the CollectionInstanceCount property.
// and the CollectionErrorCode instance to the CollectionErrorCode property.
// and the CollectionErrorDescription instance to the CollectionErrorDescription property.
iSize = m_pnList.size();
if (pObj)
{
for (i=0; i < iSize-3; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
inst.szInstanceID = new TCHAR[wcslen(pszInstanceID)+2];
MY_ASSERT(inst.szInstanceID); if (!inst.szInstanceID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(inst.szInstanceID, pszInstanceID);
inst.szCurrValue = NULL;
ResetInst(&inst, ppn->type);
inst.bNull = FALSE;
inst.bNeeded = TRUE;
ppn->instList.push_back(inst);
}
// Also add instance for all thresholds under this DataCollector
// Only add the CollectionInstanceCount instance to the Threshold looking at
// the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription.
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pszPropertyName = pThreshold->GetPropertyName();
if (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pszPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pszPropertyName, L"CollectionErrorDescription"))
{
hRetRes = pThreshold->AddInstance(pszInstanceID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
}
}
else
{
if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount"))
{
i = iSize-3;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode"))
{
i = iSize-2;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription"))
{
i = iSize-1;
}
else
{
MY_ASSERT(FALSE);
i = iSize-3;
}
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
inst.szInstanceID = new TCHAR[wcslen(pszInstanceID)+2];
MY_ASSERT(inst.szInstanceID); if (!inst.szInstanceID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(inst.szInstanceID, pszInstanceID);
inst.szCurrValue = NULL;
ResetInst(&inst, ppn->type);
inst.bNull = FALSE;
inst.bNeeded = TRUE;
ppn->instList.push_back(inst);
// Also add instance for all thresholds under this DataCollector
// Only add the CollectionInstanceCount instance to the Threshold looking at
// the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription.
iSize = m_thresholdList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pszPropertyName = pThreshold->GetPropertyName();
if (!_wcsicmp(pszPropertyName, pszInstanceID) ||
!_wcsicmp(pszPropertyName, pszInstanceID) ||
!_wcsicmp(pszPropertyName, pszInstanceID))
{
hRetRes = pThreshold->AddInstance(pszInstanceID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
}
}
}
else
{
iSize = m_pnList.size();
if (pObj)
{
for (i=0; i < iSize-3 ; i++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
MY_ASSERT(foundInstID<ppn->instList.size());
pinst = &ppn->instList[foundInstID];
pinst->bNull = FALSE;
pinst->bNeeded = TRUE;
}
//Also for all thresholds under this DataCollector
iSize = m_thresholdList.size();
for (i=0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pszPropertyName = pThreshold->GetPropertyName();
if (_wcsicmp(pszPropertyName, L"CollectionInstanceCount") &&
_wcsicmp(pszPropertyName, L"CollectionErrorCode") &&
_wcsicmp(pszPropertyName, L"CollectionErrorDescription"))
{
MY_ASSERT(foundInstID<pThreshold->m_irsList.size());
pirs = &pThreshold->m_irsList[foundInstID];
pirs->bNeeded = TRUE;
}
}
}
else
{
if (!_wcsicmp(pszInstanceID, L"CollectionInstanceCount"))
{
i = iSize-3;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorCode"))
{
i = iSize-2;
}
else if (!_wcsicmp(pszInstanceID, L"CollectionErrorDescription"))
{
i = iSize-1;
}
else
{
MY_ASSERT(FALSE);
i = iSize-3;
}
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
MY_ASSERT(foundInstID<ppn->instList.size());
pinst = &ppn->instList[foundInstID];
pinst->bNull = FALSE;
pinst->bNeeded = TRUE;
// Also for all thresholds under this DataCollector
// Only add the CollectionInstanceCount instance to the Threshold looking at
// the CollectionInstanceCount property. Same for CollectionErrorCode and CollectionErrorDescription.
iSize = m_thresholdList.size();
for (i=0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
pszPropertyName = pThreshold->GetPropertyName();
if (!_wcsicmp(pszPropertyName, pszInstanceID) ||
!_wcsicmp(pszPropertyName, pszInstanceID) ||
!_wcsicmp(pszPropertyName, pszInstanceID))
{
MY_ASSERT(foundInstID<pThreshold->m_irsList.size());
pirs = &pThreshold->m_irsList[foundInstID];
pirs->bNeeded = TRUE;
}
}
}
}
if (pObj)
{
hRetRes = CheckActualInstanceExistance(pObj, pszInstanceID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
return hRetRes;
error:
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
HRESULT CDataCollector::CheckActualInstanceExistance(IWbemClassObject *pObj, LPTSTR pszInstanceID)
{
HRESULT hRetRes = S_OK;
BOOL bFound;
int i, iSize;
INSTSTRUCT inst;
ACTUALINSTSTRUCT actualInst;
ACTUALINSTSTRUCT *pActualInst;
if (m_bValidLoad == FALSE)
return FALSE;
//
// Check the list of actual instances that the Data Collector is collecting.
// We keep around the latest one(s) for the DataCollector.
//
bFound = FALSE;
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
if (!_wcsicmp(pActualInst->szInstanceID, pszInstanceID))
{
pActualInst->bNeeded = TRUE;
if (pActualInst->pInst)
{
pActualInst->pInst->Release();
pActualInst->pInst = NULL;
}
hRetRes = pObj->Clone(&pActualInst->pInst);
if (FAILED(hRetRes))
{
MY_HRESASSERT(hRetRes);
return hRetRes;
}
bFound = TRUE;
break;
}
}
if (bFound == FALSE)
{
actualInst.szInstanceID = new TCHAR[wcslen(pszInstanceID)+2];
MY_ASSERT(actualInst.szInstanceID); if (!actualInst.szInstanceID) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(actualInst.szInstanceID, pszInstanceID);
actualInst.pInst = NULL;
actualInst.bNeeded = TRUE;
wcscpy(actualInst.szDTTime, m_szDTCurrTime);
wcscpy(actualInst.szTime, m_szCurrTime);
hRetRes = pObj->Clone(&actualInst.pInst);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
m_actualInstList.push_back(actualInst);
}
return hRetRes;
error:
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
BOOL CDataCollector::GetEnabledChange(void)
{
BOOL bChanged = FALSE;
if ((m_bEnabled==FALSE || m_bParentEnabled==FALSE) && m_lCurrState!=HM_DISABLED)
{
bChanged = TRUE;
}
if ((m_bEnabled==TRUE && m_bParentEnabled==TRUE) && m_lCurrState==HM_DISABLED)
{
bChanged = TRUE;
}
return bChanged;
}
BOOL CDataCollector::SetCurrState(HM_STATE state, BOOL bCheckChanges/*FALSE*/)
{
m_lCurrState = state;
return TRUE;
}
BOOL CDataCollector::checkTime(void)
{
BOOL bTimeOK;
SYSTEMTIME st; // system time
//
// Make sure that we are in a valid time to run.
// NULL (-1) means run all the time.
//
bTimeOK = FALSE;
if (m_bEnabled==TRUE && m_bParentEnabled==TRUE)
{
GetLocalTime(&st);
bTimeOK = FALSE;
// Check the Day of the Week
if (!(m_iActiveDays&(1<<st.wDayOfWeek)))
{
}
else if (m_lBeginHourTime<0 || m_lEndHourTime<0)
{
bTimeOK = TRUE;
}
else if (m_lBeginHourTime==m_lEndHourTime && m_lBeginMinuteTime==m_lEndMinuteTime)
{
// Check the Hours of operation
// First see if we are doing an inclusive time tests, or an exclusive time test
//XXXStill need work here. What happens when we have the collection interval set
//to go off every 10 seconds. We will keep doing this
// Case where the time is exactly equal, and that means run this once per day
if (st.wHour==m_lBeginHourTime && st.wMinute==m_lBeginMinuteTime)
{
if (st.wSecond <= HM_POLLING_INTERVAL)
{
bTimeOK = TRUE;
}
}
}
else if ((m_lBeginHourTime < m_lEndHourTime) ||
((m_lBeginHourTime==m_lEndHourTime) && m_lBeginMinuteTime < m_lEndMinuteTime))
{
// Inclusive case
if ((m_lBeginHourTime < st.wHour) ||
((m_lBeginHourTime == st.wHour) && m_lBeginMinuteTime <= st.wMinute))
{
if ((st.wHour < m_lEndHourTime) ||
((st.wHour == m_lEndHourTime) && st.wMinute < m_lEndMinuteTime))
{
bTimeOK = TRUE;
}
}
}
else
{
// Exclusive case
if ((m_lEndHourTime > st.wHour) ||
((m_lEndHourTime == st.wHour) && m_lEndMinuteTime > st.wMinute))
{
bTimeOK = TRUE;
}
else if ((st.wHour > m_lBeginHourTime) ||
((st.wHour == m_lBeginHourTime) && st.wMinute >= m_lBeginMinuteTime))
{
bTimeOK = TRUE;
}
}
}
return bTimeOK;
}
HRESULT CDataCollector::GetHMDataCollectorPerInstanceStatusEvent(LPTSTR pszInstanceID, ACTUALINSTSTRUCT *pActualInst, long state, IWbemClassObject** ppInstance, BOOL bEventBased)
{
HRESULT hRetRes = S_OK;
GUID guid;
BSTR bsName = NULL;
VARIANT v;
IWbemClassObject* pEmbeddedDataCollectorInst = NULL;
IWbemClassObject* pClass = NULL;
BSTR bsString = NULL;
DWORD dwNameLen = MAX_COMPUTERNAME_LENGTH + 2;
TCHAR szComputerName[MAX_COMPUTERNAME_LENGTH + 2];
TCHAR szStatusGUID[1024];
VariantInit(&v);
MY_OUTPUT(L"ENTER *****CDataCollector::GetHMDataCollectorPerInstanceStatusEvent...", 1);
if (bEventBased)
{
bsString = SysAllocString(L"MicrosoftHM_DataCollectorPerInstanceStatusEvent");
MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
}
else
{
bsString = SysAllocString(L"MicrosoftHM_DataCollectorPerInstanceStatus");
MY_ASSERT(bsString); if (!bsString) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
}
hRetRes = g_pIWbemServices->GetObject(bsString, 0L, NULL, &pClass, NULL);
SysFreeString(bsString);
bsString = NULL;
if (FAILED(hRetRes))
{
MY_HRESASSERT(hRetRes);
return hRetRes;
}
hRetRes = pClass->SpawnInstance(0, ppInstance);
pClass->Release();
pClass = NULL;
if (FAILED(hRetRes))
{
MY_HRESASSERT(hRetRes);
return hRetRes;
}
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, szStatusGUID, 100);
hRetRes = PutStrProperty(*ppInstance, L"GUID", m_szGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"InstanceName", pszInstanceID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"Name", m_szName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"ParentGUID", m_pParentDG->m_szGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutUint32Property(*ppInstance, L"State", state);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutUint32Property(*ppInstance, L"CollectionInstanceCount", m_lNumInstancesCollected);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutUUint32Property(*ppInstance, L"CollectionErrorCode", m_ulErrorCode);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"CollectionErrorDescription", m_szErrorDescription);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"StatusGUID", szStatusGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (pActualInst)
{
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", pActualInst->szDTTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", pActualInst->szTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else if (!wcscmp(pszInstanceID, L"CollectionInstanceCount"))
{
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCICTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCICTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else if (!wcscmp(pszInstanceID, L"CollectionErrorCode"))
{
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCECTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCECTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else
{
MY_ASSERT(FALSE);
hRetRes = PutStrProperty(*ppInstance, L"TimeGeneratedGMT", m_szDTCurrTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = PutStrProperty(*ppInstance, L"LocalTimeFormatted", m_szCurrTime);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
// Get the computer name of the machine
if (GetComputerName(szComputerName, &dwNameLen))
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", szComputerName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else
{
hRetRes = PutStrProperty(*ppInstance, L"SystemName", L"LocalMachine");
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
if (state != HM_GOOD)
{
hRetRes = PutStrProperty(*ppInstance, L"Message", m_szMessage);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
else
{
hRetRes = PutStrProperty(*ppInstance, L"Message", m_szResetMessage);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
if (pActualInst)
{
hRetRes = FormatMessage(*ppInstance, pActualInst->pInst);
}
else
{
hRetRes = FormatMessage(*ppInstance, NULL);
}
//XXX
//Make sure that this code is correct
if (pActualInst && hRetRes==S_OK && m_bValidLoad)
{
hRetRes = pActualInst->pInst->Clone(&pEmbeddedDataCollectorInst);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
if (pEmbeddedDataCollectorInst)
{
bsName = SysAllocString(L"EmbeddedCollectedInstance");
MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
VariantInit(&v);
V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = (IUnknown*)pEmbeddedDataCollectorInst;
(V_UNKNOWN(&v))->AddRef();
hRetRes = (*ppInstance)->Put(bsName, 0L, &v, 0L);
VariantClear(&v);
SysFreeString(bsName);
bsName = NULL;
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pEmbeddedDataCollectorInst->Release();
pEmbeddedDataCollectorInst = NULL;
}
}
MY_OUTPUT(L"EXIT *****CDataCollector::GetHMDataCollectorPerInstanceStatusEvent...", 1);
return hRetRes;
error:
MY_ASSERT(FALSE);
if (bsString)
SysFreeString(bsString);
if (bsName)
SysFreeString(bsName);
if (pClass)
pClass->Release();
if (pEmbeddedDataCollectorInst)
pEmbeddedDataCollectorInst->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
//
// Do string replacement for the Message property
//
HRESULT CDataCollector::FormatMessage(IWbemClassObject* pIRSInstance, IWbemClassObject *pEmbeddedInstance)
{
HRESULT hRetRes = S_OK;
BSTR PropName = NULL;
LPTSTR pszMsg = NULL;
SAFEARRAY *psaNames = NULL;
long lNum;
LPTSTR pszDest = NULL;
LPTSTR pszUpperMsg = NULL;
LPTSTR pszNewMsg = NULL;
LPTSTR pStr = NULL;
LPTSTR pStr2 = NULL;
LPTSTR pStrStart = NULL;
TOKENSTRUCT tokenElmnt;
TOKENSTRUCT *pTokenElmnt;
REPSTRUCT repElmnt;
REPSTRUCT *pRepElmnt;
REPSTRUCT *pRepElmnt2;
REPLIST replacementList;
int i, iSize, iSizeNeeded, j;
long lLower, lUpper;
static TOKENLIST tokenList;
TOKENLIST embeddedInstTokenList;
if (m_bValidLoad == FALSE)
return FALSE;
//
// We only need to build the set of tokens one time, then from then on
// we just need to fill in the values for what the replacement strings are.
//
if (tokenList.size() == 0)
{
//
// First we build the set of tokens that we are looking for. Each property that
// is in the ThresholdStatusInstance. We build that set of strings,
// and the values to replace with.
//
//
// Now go through ThresholdInstance, which is where the Message String
// actually lives. Get that set of properties for the Instances.
//
hRetRes = pIRSInstance->GetNames(NULL, WBEM_FLAG_NONSYSTEM_ONLY, NULL, &psaNames);
if (SUCCEEDED(hRetRes))
{
// Get the number of properties.
SafeArrayGetLBound(psaNames, 1, &lLower);
SafeArrayGetUBound(psaNames, 1, &lUpper);
// For each property...
for (long l=lLower; l<=lUpper; l++)
{
// Get this property.
hRetRes = SafeArrayGetElement(psaNames, &l, &PropName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
// Will want to skip some that don't make sense.
if (!wcscmp(PropName, L"Message"))
{
SysFreeString(PropName);
PropName = NULL;
continue;
}
else if (!wcscmp(PropName, L"ResetMessage"))
{
SysFreeString(PropName);
PropName = NULL;
continue;
}
else if (!wcscmp(PropName, L"EmbeddedCollectedInstance"))
{
SysFreeString(PropName);
PropName = NULL;
continue;
}
tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1];
MY_ASSERT(tokenElmnt.szOrigToken); if (!tokenElmnt.szOrigToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(tokenElmnt.szOrigToken, PropName);
tokenElmnt.szToken = new TCHAR[wcslen(PropName)+3];
MY_ASSERT(tokenElmnt.szToken); if (!tokenElmnt.szToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(tokenElmnt.szToken, L"%");
wcscat(tokenElmnt.szToken, PropName);
wcscat(tokenElmnt.szToken, L"%");
_wcsupr(tokenElmnt.szToken);
tokenElmnt.szReplacementText = NULL;
tokenList.push_back(tokenElmnt);
SysFreeString(PropName);
PropName = NULL;
}
SafeArrayDestroy(psaNames);
psaNames = NULL;
}
}
//
// Populate the list of properties on the embedded instance that came from the
// Data Collector.
//
if (pEmbeddedInstance)
{
MY_ASSERT(pEmbeddedInstance);
hRetRes = pEmbeddedInstance->GetNames(NULL, WBEM_FLAG_ALWAYS, NULL, &psaNames);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
// Get the number of properties.
SafeArrayGetLBound(psaNames, 1, &lLower);
SafeArrayGetUBound(psaNames, 1, &lUpper);
// For each property...
for (long l=lLower; l<=lUpper; l++)
{
// Get this property.
hRetRes = SafeArrayGetElement(psaNames, &l, &PropName);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
tokenElmnt.szOrigToken = new TCHAR[wcslen(PropName)+1];
MY_ASSERT(tokenElmnt.szOrigToken); if (!tokenElmnt.szOrigToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(tokenElmnt.szOrigToken, PropName);
tokenElmnt.szToken = new TCHAR[wcslen(PropName)+29];
MY_ASSERT(tokenElmnt.szToken); if (!tokenElmnt.szToken) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(tokenElmnt.szToken, L"%");
wcscat(tokenElmnt.szToken, L"EmbeddedCollectedInstance.");
wcscat(tokenElmnt.szToken, PropName);
wcscat(tokenElmnt.szToken, L"%");
_wcsupr(tokenElmnt.szToken);
tokenElmnt.szReplacementText = NULL;
embeddedInstTokenList.push_back(tokenElmnt);
SysFreeString(PropName);
PropName = NULL;
}
SafeArrayDestroy(psaNames);
psaNames = NULL;
}
//
// Now we can fill in the values to use for the replacement strings.
//
//
// Now go through each ThresholdInstance, which is where the Message String
// actually lives. Get that set of properties of the Instance,
// And do the message formatting while there.
//
//
// Get the replacement strings for this instance
//
iSize = tokenList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<tokenList.size());
pTokenElmnt = &tokenList[i];
if (pTokenElmnt->szReplacementText != NULL)
{
delete [] pTokenElmnt->szReplacementText;
pTokenElmnt->szReplacementText = NULL;
}
if (!wcscmp(pTokenElmnt->szToken, L"%TESTCONDITION%"))
{
hRetRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
MY_ASSERT(lNum<9);
pStr = new TCHAR[wcslen(conditionLocStr[lNum])+1];
MY_ASSERT(pStr); if (!pStr) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pStr, conditionLocStr[lNum]);
}
else if (!wcscmp(pTokenElmnt->szToken, L"%STATE%"))
{
hRetRes = GetUint32Property(pIRSInstance, pTokenElmnt->szOrigToken, &lNum);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
MY_ASSERT(lNum<10);
pStr = new TCHAR[wcslen(stateLocStr[lNum])+1];
MY_ASSERT(pStr); if (!pStr) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pStr, stateLocStr[lNum]);
}
else
{
hRetRes = GetAsStrProperty(pIRSInstance, pTokenElmnt->szOrigToken, &pStr);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
}
pTokenElmnt->szReplacementText = pStr;
}
//
// Get the replacement strings for this instance - Embedded
//
iSize = embeddedInstTokenList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<embeddedInstTokenList.size());
pTokenElmnt = &embeddedInstTokenList[i];
if (pTokenElmnt->szReplacementText != NULL)
{
delete [] pTokenElmnt->szReplacementText;
pTokenElmnt->szReplacementText = NULL;
}
MY_ASSERT(pEmbeddedInstance);
hRetRes = GetAsStrProperty(pEmbeddedInstance, pTokenElmnt->szOrigToken, &pStr);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pTokenElmnt->szReplacementText = pStr;
}
//
// Now we have both lists of tokens that have replacement
// strings that go with them and the replacement strings
// that go with them
//
//
// Do formatting of Message. We replace all Variable Tags.
// Sample string -
// "Drive %InstanceName% is full. Currently at %CurrentValue%%."
//
//
// Get the origional un-formatted message first.
// To make case in-sensitive, do a _strdup and then a _wcsupr on the string
// to scan run the code on it, and then free the duplicated string.
//
// If it uses resource IDs, then get that string first, then format that!!!
hRetRes = GetStrProperty(pIRSInstance, L"Message", &pszMsg);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
pszUpperMsg = _wcsdup(pszMsg);
MY_ASSERT(pszUpperMsg); if (!pszUpperMsg) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
_wcsupr(pszUpperMsg);
//
// First loop through and find every token that needs replacing.
// Put that info into the replacement list.
//
// We will do strstr() for each special token until there are no more to find
// for each. At each find we will store the offset into the string of what
// we found. Then we sort by what came first.
//
// Quick test to see if it is worth searching
if (wcschr(pszUpperMsg, '%'))
{
iSize = tokenList.size();
pStrStart = pszUpperMsg;
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<tokenList.size());
pTokenElmnt = &tokenList[i];
pStr = wcsstr(pStrStart, pTokenElmnt->szToken);
if (pStr != NULL)
{
repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg);
repElmnt.len = wcslen(pTokenElmnt->szToken);
repElmnt.pszReplacementText = pTokenElmnt->szReplacementText;
replacementList.push_back(repElmnt);
i--;
pStrStart = pStr+1;
}
else
{
pStrStart = pszUpperMsg;
}
}
// Embedded stuff
iSize = embeddedInstTokenList.size();
pStrStart = pszUpperMsg;
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<embeddedInstTokenList.size());
pTokenElmnt = &embeddedInstTokenList[i];
pStr = wcsstr(pStrStart, pTokenElmnt->szToken);
if (pStr != NULL)
{
repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg);
repElmnt.len = wcslen(pTokenElmnt->szToken);
repElmnt.pszReplacementText = pTokenElmnt->szReplacementText;
replacementList.push_back(repElmnt);
i--;
pStrStart = pStr+1;
}
else
{
pStrStart = pszUpperMsg;
}
}
//
// Need to look for replacement strings that have not been replaced.
// Simply search for %EmbeddedCollectedInstance. and find the end % for each
// Replace them with <null>
//
if (!pEmbeddedInstance)
{
pStrStart = pszUpperMsg;
while (TRUE)
{
pStr = wcsstr(pStrStart, L"%EMBEDDEDCOLLECTEDINSTANCE.");
if (pStr != NULL)
{
repElmnt.pStartStr = pszMsg+(pStr-pszUpperMsg);
pStr2 = pStr;
while (pStr2++)
{
if (*pStr2=='%' || iswspace(*pStr2))
break;
}
if (*pStr2=='%')
{
repElmnt.len = (pStr2-pStr)+1;
repElmnt.pszReplacementText = L"<null>";
replacementList.push_back(repElmnt);
}
pStrStart = pStr+1;
}
else
{
break;
}
}
}
}
iSize = replacementList.size();
if (iSize != 0)
{
//
// Next, sort the replacement list from the first string to
// be replaced, to the last. Shell sort, Knuth, Vol13, pg. 84.
//
for (int gap=iSize/2; 0<gap; gap/=2)
{
for (i=gap; i<iSize; i++)
{
for (j=i-gap; 0<=j; j-=gap)
{
MY_ASSERT(j+gap<replacementList.size());
pRepElmnt = &replacementList[j+gap];
MY_ASSERT(j<replacementList.size());
pRepElmnt2 = &replacementList[j];
if (pRepElmnt->pStartStr < pRepElmnt2->pStartStr)
{
MY_ASSERT(j<replacementList.size());
repElmnt = replacementList[j];
MY_ASSERT(j+gap<replacementList.size());
replacementList[j] = replacementList[j+gap];
MY_ASSERT(j+gap<replacementList.size());
replacementList[j+gap] = repElmnt;
}
}
}
}
//
// Next, figure out the size needed for the Message with
// everything replaced.
//
iSizeNeeded = wcslen(pszMsg)+1;
iSize = replacementList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<replacementList.size());
pRepElmnt = &replacementList[i];
iSizeNeeded -= pRepElmnt->len;
iSizeNeeded += wcslen(pRepElmnt->pszReplacementText);
}
pszNewMsg = new TCHAR[iSizeNeeded];
MY_ASSERT(pszNewMsg); if (!pszNewMsg) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
*pszNewMsg = '\0';
//
// Next, we loop through and do the actual replacements.
// "Drive %InstanceName% is full. Currently at %CurrentValue%%."
//
pszDest = pszMsg;
iSize = replacementList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<replacementList.size());
pRepElmnt = &replacementList[i];
*(pRepElmnt->pStartStr) = '\0';
wcscat(pszNewMsg, pszDest);
wcscat(pszNewMsg, pRepElmnt->pszReplacementText);
//XXXWould memcpy be faster??? memcpy(pszDest, source, charCnt*sizeof(TCHAR));
pszDest = pRepElmnt->pStartStr+pRepElmnt->len;
}
wcscat(pszNewMsg, pszDest);
PutStrProperty(pIRSInstance, L"Message", pszNewMsg);
delete [] pszNewMsg;
pszNewMsg = NULL;
replacementList.clear();
}
else
{
PutStrProperty(pIRSInstance, L"Message", pszMsg);
}
delete [] pszMsg;
pszMsg = NULL;
free(pszUpperMsg);
pszUpperMsg = NULL;
// Free up the temporary token list
iSize = embeddedInstTokenList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<embeddedInstTokenList.size());
pTokenElmnt = &embeddedInstTokenList[i];
if (pTokenElmnt->szToken)
delete [] pTokenElmnt->szToken;
if (pTokenElmnt->szOrigToken)
delete [] pTokenElmnt->szOrigToken;
if (pTokenElmnt->szReplacementText)
delete [] pTokenElmnt->szReplacementText;
}
embeddedInstTokenList.clear();
return hRetRes;
error:
MY_ASSERT(FALSE);
if (PropName)
SysFreeString(PropName);
if (psaNames)
SafeArrayDestroy(psaNames);
if (pszNewMsg)
delete [] pszNewMsg;
if (pszMsg)
delete [] pszMsg;
if (pszUpperMsg)
free(pszUpperMsg);
iSize = embeddedInstTokenList.size();
for (i=0; i<iSize; i++)
{
MY_ASSERT(i<embeddedInstTokenList.size());
pTokenElmnt = &embeddedInstTokenList[i];
if (pTokenElmnt->szToken)
delete [] pTokenElmnt->szToken;
if (pTokenElmnt->szOrigToken)
delete [] pTokenElmnt->szOrigToken;
if (pTokenElmnt->szReplacementText)
delete [] pTokenElmnt->szReplacementText;
}
embeddedInstTokenList.clear();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
BOOL CDataCollector::SendReminderActionIfStateIsSame(IWbemObjectSink* pActionEventSink, IWbemObjectSink* pActionTriggerEventSink, IWbemClassObject* pActionInstance, IWbemClassObject* pActionTriggerInstance, unsigned long ulTriggerStates)
{
HRESULT hRetRes = S_OK;
IWbemClassObject* pInstance = NULL;
BSTR bsName = NULL;
VARIANT v;
long state;
int i, iSize;
BOOL bRetValue = TRUE;
ACTUALINSTSTRUCT *pActualInst;
long firstInstanceState = -1;
GUID guid;
TCHAR szStatusGUID[100];
VariantInit(&v);
MY_OUTPUT(L"ENTER ***** CDataCollector::SendReminderActionIfStateIsSame...", 2);
if (m_bValidLoad == FALSE)
return FALSE;
//
// We can loop through the set of collected instances and ask each Threshold
// to tell us if the state has changed as far as each is concerned, for the
// property they are lookin at.
//
iSize = m_actualInstList.size();
for (i=0; i < iSize; i++)
{
MY_ASSERT(i<m_actualInstList.size());
pActualInst = &m_actualInstList[i];
state = PassBackWorstStatePerInstance(pActualInst->szInstanceID, (BOOL)i==0);
if (state==-1) state = HM_COLLECTING;
if (i==0)
{
firstInstanceState = state;
}
// Check to see if still in the desired state
if (!(ulTriggerStates&(1<<state)))
{
continue;
}
hRetRes = GetHMDataCollectorPerInstanceStatusEvent(pActualInst->szInstanceID, pActualInst, state, &pInstance, TRUE);
if (SUCCEEDED(hRetRes))
{
PutUint32Property(pActionTriggerInstance, L"State", m_lCurrState);
bsName = SysAllocString(L"EmbeddedStatusEvent");
MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
VariantInit(&v);
V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = (IUnknown*)pInstance;
(V_UNKNOWN(&v))->AddRef();
hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L);
VariantClear(&v);
SysFreeString(bsName);
bsName = NULL;
MY_HRESASSERT(hRetRes);
if (pActionEventSink)
{
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, szStatusGUID, 100);
hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = pActionEventSink->Indicate(1, &pActionInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
if (pActionTriggerEventSink)
{
hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"failed to get instance!", 4);
}
}
//
// Do it for the three default properties
//
if (firstInstanceState==-1)
{
state = PassBackWorstStatePerInstance(L"CollectionInstanceCount", FALSE);
if (state==-1) state = HM_COLLECTING;
// Check to see if still in the desired state
if ((ulTriggerStates&(1<<state)))
{
hRetRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &pInstance, TRUE);
if (SUCCEEDED(hRetRes))
{
PutUint32Property(pActionTriggerInstance, L"State", m_lCurrState);
bsName = SysAllocString(L"EmbeddedStatusEvent");
MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
VariantInit(&v);
V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = (IUnknown*)pInstance;
(V_UNKNOWN(&v))->AddRef();
hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L);
VariantClear(&v);
SysFreeString(bsName);
bsName = NULL;
MY_HRESASSERT(hRetRes);
if (pActionEventSink)
{
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, szStatusGUID, 100);
hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = pActionEventSink->Indicate(1, &pActionInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
if (pActionTriggerEventSink)
{
hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"failed to get instance!", 4);
}
}
}
if (firstInstanceState==-1)
{
state = PassBackWorstStatePerInstance(L"CollectionErrorCode", FALSE);
if (state==-1) state = HM_COLLECTING;
// Check to see if still in the desired state
if ((ulTriggerStates&(1<<state)))
{
hRetRes = GetHMDataCollectorPerInstanceStatusEvent(L"CollectionInstanceCount", NULL, state, &pInstance, TRUE);
if (SUCCEEDED(hRetRes))
{
PutUint32Property(pActionTriggerInstance, L"State", m_lCurrState);
bsName = SysAllocString(L"EmbeddedStatusEvent");
MY_ASSERT(bsName); if (!bsName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
VariantInit(&v);
V_VT(&v) = VT_UNKNOWN;
V_UNKNOWN(&v) = (IUnknown*)pInstance;
(V_UNKNOWN(&v))->AddRef();
hRetRes = (pActionTriggerInstance)->Put(bsName, 0L, &v, 0L);
VariantClear(&v);
SysFreeString(bsName);
bsName = NULL;
MY_HRESASSERT(hRetRes);
if (pActionEventSink)
{
hRetRes = CoCreateGuid(&guid);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
StringFromGUID2(guid, szStatusGUID, 100);
hRetRes = PutStrProperty(pActionInstance, L"StatusGUID", szStatusGUID);
MY_HRESASSERT(hRetRes); if (hRetRes!=S_OK) goto error;
hRetRes = pActionEventSink->Indicate(1, &pActionInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
if (pActionTriggerEventSink)
{
hRetRes = pActionTriggerEventSink->Indicate(1, &pActionTriggerInstance);
//WBEM_E_SERVER_TOO_BUSY is Ok. Wbem will deliver.
if (FAILED(hRetRes) && hRetRes != WBEM_E_SERVER_TOO_BUSY)
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"Failed on Indicate!", 4);
}
}
pInstance->Release();
pInstance = NULL;
}
else
{
MY_HRESASSERT(hRetRes);
MY_OUTPUT(L"failed to get instance!", 4);
}
}
}
#ifdef SAVE
state = PassBackWorstStatePerInstance(L"CollectionErrorDescription");
#endif
MY_OUTPUT(L"EXIT ***** CDataCollector::SendReminderActionIfStateIsSame...", 2);
return TRUE;
error:
MY_ASSERT(FALSE);
if (bsName)
SysFreeString(bsName);
if (pInstance)
pInstance->Release();
m_bValidLoad = FALSE;
Cleanup(FALSE);
return FALSE;
}
HRESULT CDataCollector::insertNewProperty(LPTSTR pszPropertyName)
{
HRESULT hRetRes = S_OK;
int i, iSize;
PNSTRUCT *ppn;
BOOL bFound = FALSE;
BOOL bDoInsert = FALSE;
PNSTRUCT pn;
PNLIST::iterator iaPN;
bFound = FALSE;
iaPN=m_pnList.begin();
iSize = m_pnList.size();
for (i=0; i<iSize; i++, iaPN++)
{
MY_ASSERT(i<m_pnList.size());
ppn = &m_pnList[i];
if (!_wcsicmp(ppn->szPropertyName, pszPropertyName))
{
bFound = TRUE;
ppn->iRefCount++;
break;
}
// We know it can't be further than this one, and we can insert here
if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount"))
{
bDoInsert = TRUE;
break;
}
}
// Add it it is new!
if (bFound == FALSE)
{
pn.szPropertyName = new TCHAR[wcslen(pszPropertyName)+2];
MY_ASSERT(pn.szPropertyName); if (!pn.szPropertyName) {hRetRes = WBEM_E_OUT_OF_MEMORY; goto error;}
wcscpy(pn.szPropertyName, pszPropertyName);
pn.iRefCount = 1;
pn.type = 0;
if (bDoInsert)
{
m_pnList.insert(iaPN, pn);
}
else
{
m_pnList.push_back(pn);
}
}
return hRetRes;
error:
MY_ASSERT(FALSE);
m_bValidLoad = FALSE;
Cleanup(FALSE);
return hRetRes;
}
BOOL CDataCollector::propertyNotNeeded(LPTSTR pszPropertyName)
{
int j, jSize;
int k, kSize;
PNSTRUCT *ppn;
BOOL bAdded = FALSE;
PNLIST::iterator iaPN;
INSTSTRUCT *pinst;
//
// Delete the property if this Threshold was the last one that needed it.
// Refcount if there already.
//
iaPN=m_pnList.begin();
jSize = m_pnList.size();
for (j=0; j<jSize; j++, iaPN++)
{
MY_ASSERT(j<m_pnList.size());
ppn = &m_pnList[j];
if (!_wcsicmp(ppn->szPropertyName, pszPropertyName))
{
ppn->iRefCount--;
if (ppn->iRefCount==0)
{
kSize = ppn->instList.size();
for (k = 0; k < kSize ; k++)
{
MY_ASSERT(k<ppn->instList.size());
pinst = &ppn->instList[k];
if (pinst->szCurrValue)
{
delete [] pinst->szCurrValue;
}
if (pinst->szInstanceID)
{
delete [] pinst->szInstanceID;
}
pinst->valList.clear();
}
ppn->instList.clear();
m_pnList.erase(iaPN);
}
break;
}
// We know it can't be further than this one, and we can insert here
if (!_wcsicmp(ppn->szPropertyName, L"CollectionInstanceCount"))
{
break;
}
}
return TRUE;
}
BOOL CDataCollector::ResetInst(INSTSTRUCT *pinst, CIMTYPE type)
{
if (type == CIM_REAL32)
{
pinst->currValue.fValue = 0;
pinst->minValue.fValue = MAX_FLOAT;
pinst->maxValue.fValue = 0;
pinst->avgValue.fValue = 0;
}
else if (type == CIM_REAL64)
{
pinst->currValue.dValue = 0;
pinst->minValue.dValue = MAX_DOUBLE;
pinst->maxValue.dValue = 0;
pinst->avgValue.dValue = 0;
}
else if (type == CIM_SINT64)
{
pinst->currValue.i64Value = 0;
pinst->minValue.i64Value = MAX_I64;
pinst->maxValue.i64Value = 0;
pinst->avgValue.i64Value = 0;
}
else if (type == CIM_UINT64)
{
pinst->currValue.ui64Value = 0;
pinst->minValue.ui64Value = MAX_UI64;
pinst->maxValue.ui64Value = 0;
pinst->avgValue.ui64Value = 0;
}
else if (type == CIM_UINT32)
{
pinst->currValue.ulValue = 0;
pinst->minValue.ulValue = MAX_ULONG;
pinst->maxValue.ulValue = 0;
pinst->avgValue.ulValue = 0;
}
else
{
pinst->currValue.lValue = 0;
pinst->minValue.lValue = MAX_LONG;
pinst->maxValue.lValue = 0;
pinst->avgValue.lValue = 0;
}
return TRUE;
}
BOOL CDataCollector::CheckForReset(void)
{
BOOL bFoundReset;
BOOL bFoundNonNormal;
// PNSTRUCT *ppn;
long state;
int i, iSize;
// int j, jSize;
CThreshold* pThreshold;
// INSTSTRUCT *pinst;
// ACTUALINSTSTRUCT *pActualInst;
//
// See if we have a Threshold in the RESET state
//
bFoundReset = FALSE;
bFoundNonNormal = FALSE;
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
state = pThreshold->GetCurrState();
if (state == HM_RESET)
{
bFoundReset = TRUE;
}
if (state==HM_WARNING || state==HM_CRITICAL)
{
bFoundNonNormal = TRUE;
}
if (bFoundReset && bFoundNonNormal)
break;
}
if (bFoundReset && bFoundNonNormal)
{
// If we don't call the base method, we may get into an endless loop.
CDataCollector::EvaluateThresholds(TRUE, TRUE, FALSE, FALSE);
CDataCollector::EvaluateThresholds(TRUE, FALSE, TRUE, FALSE);
//
// Set back the RESET one(s)
//
m_lCurrState = HM_COLLECTING;
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->GetCurrState() == HM_RESET)
{
pThreshold->SetCurrState(HM_GOOD);
}
}
}
//#ifdef SAVE
//XXX???Do we want the following???
else if (bFoundReset)
{
if (m_deType!=HM_EQDE && m_bRequireReset)
{
iSize = m_thresholdList.size();
for (i = 0; i < iSize ; i++)
{
MY_ASSERT(i<m_thresholdList.size());
pThreshold = m_thresholdList[i];
if (pThreshold->GetCurrState() == HM_RESET)
{
pThreshold->ResetResetThreshold();
}
}
}
}
//#endif
return TRUE;
}
HRESULT CDataCollector::CheckForBadLoad(void)
{
HRESULT hRetRes = S_OK;
IWbemClassObject* pObj = NULL;
TCHAR szTemp[1024];
IWbemClassObject* pInstance = NULL;
if (m_bValidLoad == FALSE)
{
wcscpy(szTemp, L"MicrosoftHM_DataCollectorConfiguration.GUID=\"");
lstrcat(szTemp, m_szGUID);
lstrcat(szTemp, L"\"");
hRetRes = GetWbemObjectInst(&g_pIWbemServices, szTemp, NULL, &pObj);
if (!pObj)
{
MY_HRESASSERT(hRetRes);
return S_FALSE;
}
hRetRes = LoadInstanceFromMOF(pObj, NULL, L"", TRUE);
// Here is where we can try and send out a generic SOS if the load failed each time!!!
if (hRetRes != S_OK)
{
if (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK)
{
mg_DCEventList.push_back(pInstance);
}
}
else
{
if (GetHMDataCollectorStatusInstance(&pInstance, TRUE) == S_OK)
{
mg_DCEventList.push_back(pInstance);
}
ResetState(TRUE, TRUE);
}
MY_HRESASSERT(hRetRes);
pObj->Release();
pObj = NULL;
return hRetRes;
}
return S_OK;
}
Reference in a new issue Copy permalink