You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1679 lines
45 KiB
1679 lines
45 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1999-2002 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// ClusterService.cpp
|
|
//
|
|
// Description:
|
|
// Implementation of CClusterService class
|
|
//
|
|
// Author:
|
|
// Henry Wang (HenryWa) 19-JAN-2000
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Pch.h"
|
|
#include "EventProv.h"
|
|
#include "EventProv.tmh"
|
|
#include "clustergroup.h"
|
|
|
|
//****************************************************************************
|
|
//
|
|
// CEventProv
|
|
//
|
|
//****************************************************************************
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CEventProv::CEventProv( void )
|
|
//
|
|
// Description:
|
|
// Constructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CEventProv::CEventProv( void )
|
|
: m_pNs( 0 )
|
|
, m_pSink( 0 )
|
|
, m_cRef( 0 )
|
|
, m_pEventAdd( 0 )
|
|
, m_pEventRemove( 0 )
|
|
, m_pEventState( 0 )
|
|
, m_pEventGroupState( 0 )
|
|
, m_pEventResourceState( 0 )
|
|
, m_pEventProperty( 0 )
|
|
, m_hThread( 0 )
|
|
, m_esStatus( esPENDING )
|
|
{
|
|
UINT idx;
|
|
for ( idx = 0; idx < EVENT_TABLE_SIZE ; idx++ )
|
|
{
|
|
m_EventTypeTable[ idx ].m_pwco = NULL;
|
|
m_EventTypeTable[ idx ].m_pfn = NULL;
|
|
}
|
|
InterlockedIncrement( &g_cObj );
|
|
|
|
} //*** CEventProv::CEventProv()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CEventProv::!CEventProv( void )
|
|
//
|
|
// Description:
|
|
// Destructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CEventProv::~CEventProv( void )
|
|
{
|
|
InterlockedDecrement( &g_cObj );
|
|
|
|
if ( m_hThread != NULL )
|
|
{
|
|
CloseHandle( m_hThread );
|
|
}
|
|
|
|
if ( m_pNs != NULL )
|
|
{
|
|
m_pNs->Release();
|
|
}
|
|
|
|
if ( m_pSink != NULL )
|
|
{
|
|
m_pSink->Release();
|
|
}
|
|
|
|
if ( m_pEventAdd != NULL )
|
|
{
|
|
m_pEventAdd->Release();
|
|
}
|
|
|
|
if ( m_pEventRemove != NULL )
|
|
{
|
|
m_pEventRemove->Release();
|
|
}
|
|
|
|
if ( m_pEventState != NULL )
|
|
{
|
|
m_pEventState->Release();
|
|
}
|
|
|
|
if ( m_pEventGroupState != NULL )
|
|
{
|
|
m_pEventGroupState->Release();
|
|
}
|
|
|
|
if ( m_pEventResourceState != NULL )
|
|
{
|
|
m_pEventResourceState->Release();
|
|
}
|
|
|
|
if ( m_pEventProperty != NULL )
|
|
{
|
|
m_pEventProperty->Release();
|
|
}
|
|
|
|
} //*** CEventProv::~CEventProv()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP
|
|
// CEventProv::QueryInterface(
|
|
// REFIID riid,
|
|
// LPVOID * ppv
|
|
// )
|
|
//
|
|
// Description:
|
|
// Query for interfaces supported by this COM object.
|
|
//
|
|
// Arguments:
|
|
// riid -- Interface being queried for.
|
|
// ppv -- Pointer in which to return interface pointer.
|
|
//
|
|
// Return Values:
|
|
// NOERROR
|
|
// E_NOINTERFACE
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CEventProv::QueryInterface(
|
|
REFIID riid,
|
|
LPVOID * ppv
|
|
)
|
|
{
|
|
*ppv = 0;
|
|
|
|
if ( IID_IUnknown == riid || IID_IWbemEventProvider == riid )
|
|
{
|
|
*ppv = (IWbemEventProvider *) this;
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
if ( IID_IWbemEventProviderSecurity == riid )
|
|
{
|
|
*ppv = (IWbemEventProviderSecurity *) this;
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
if ( IID_IWbemProviderInit == riid )
|
|
{
|
|
*ppv = (IWbemProviderInit *) this;
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return E_NOINTERFACE;
|
|
|
|
} //*** CEventProv::QueryInterface()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP_( ULONG )
|
|
// CEventProv::AddRef( void )
|
|
//
|
|
// Description:
|
|
// Add a reference to the COM object.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// New reference count.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CEventProv::AddRef( void )
|
|
{
|
|
return InterlockedIncrement( (LONG *) &m_cRef );
|
|
|
|
} //*** CEventProv::AddRef()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP_( ULONG )
|
|
// CEventProv::Release( void )
|
|
//
|
|
// Description:
|
|
// Release a reference on the COM object.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// New reference count.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CEventProv::Release( void )
|
|
{
|
|
LONG cRef = InterlockedDecrement( (LONG *) &m_cRef );
|
|
if ( 0L == cRef )
|
|
{
|
|
m_esStatus = esPENDING_STOP;
|
|
CancelIo( m_hChange );
|
|
//
|
|
// wait for the thread completely stopped
|
|
//
|
|
while ( ! m_fStopped )
|
|
{
|
|
Sleep( 100 );
|
|
}
|
|
delete this;
|
|
}
|
|
|
|
return cRef;
|
|
|
|
} //*** CEventProv::Release()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// HRESULT
|
|
// CEventProv::ProvideEvents(
|
|
// IWbemObjectSink * pSinkIn,
|
|
// long lFlagsIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Start the provider to generate event
|
|
// Called by wmi
|
|
//
|
|
// Arguments:
|
|
// pSinkIn -- WMI sink pointer to send event back
|
|
// lFlagsIn -- WMI flag
|
|
//
|
|
// Return Values:
|
|
// WBEM_NO_ERROR
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CEventProv::ProvideEvents(
|
|
IWbemObjectSink * pSinkIn,
|
|
long lFlagsIn
|
|
)
|
|
{
|
|
DWORD dwTID;
|
|
HRESULT hr = WBEM_NO_ERROR;
|
|
|
|
// Copy the sink.
|
|
// ==============
|
|
m_pSink = pSinkIn;
|
|
m_pSink->AddRef();
|
|
|
|
// Create the event thread.
|
|
// ========================
|
|
|
|
m_hThread = CreateThread(
|
|
0,
|
|
0,
|
|
CEventProv::S_EventThread,
|
|
this,
|
|
0,
|
|
&dwTID
|
|
);
|
|
|
|
|
|
// Wait for provider to be 'ready'.
|
|
// ================================
|
|
|
|
while ( m_esStatus != esRUNNING )
|
|
{
|
|
Sleep( 100 );
|
|
}
|
|
|
|
return hr;
|
|
|
|
} //*** CEventProv::ProvideEvents
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// HRESULT
|
|
// CEventProv::AccessCheck(
|
|
// WBEM_CWSTR wszQueryLanguage,
|
|
// WBEM_CWSTR wszQuery,
|
|
// long lSidLength,
|
|
// const BYTE* pSid
|
|
// )
|
|
//
|
|
// Description:
|
|
// Checks the access permissions when a consumer attempts to subscribe to the event specified in wszQuery.
|
|
// The consumer is permitted to subscribe to the event if it has access permission for the event,
|
|
// otherwise subscription is prevented.
|
|
//
|
|
// Arguments:
|
|
// wszQueryLanguageIn -- Language of the following query filter. For this version of WMI, it will be "WQL".
|
|
// wszQueryIn -- Text of the event query filter, which was registered by a logical consumer.
|
|
// lSidLengthIn -- Integer that contains the SID length, or 0 if the subscription builder's token is available.
|
|
// pSidIn -- Pointer to the constant byte integer type that contains the SID, or NULL if the subscription
|
|
// builder's token is available.
|
|
//
|
|
// Return Values:
|
|
// WBEM_S_NO_ERROR -- The user has permission to subscribe to the event.
|
|
// WBEM_E_ACCESS_DENIED -- The user does not have permission to access the event.
|
|
// WBEM_E_FAILED -- Indicates a provider failure.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CEventProv::AccessCheck(
|
|
WBEM_CWSTR wszQueryLanguageIn,
|
|
WBEM_CWSTR wszQueryIn,
|
|
long lSidLengthIn,
|
|
const BYTE * pSidIn
|
|
)
|
|
{
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
SAFECLUSTER shCluster;
|
|
|
|
//
|
|
// Impersonate the client and call OpenCluster
|
|
//
|
|
hr = CoImpersonateClient();
|
|
if( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
try
|
|
{
|
|
//
|
|
// OpenCluster should fail with ERROR_ACCESS_DENIED if the client in unprivileged.
|
|
// Otherwise it should succeed.
|
|
//
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
}
|
|
catch ( CProvException provException )
|
|
{
|
|
hr = provException.hrGetError();
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
//
|
|
// Based on the MSDN definition, this function has to return 1 of the 3 return values
|
|
// listed above in the function header, so let's make it happen.
|
|
//
|
|
|
|
if ( FAILED( hr ) )
|
|
{
|
|
if ( hr == HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED ) )
|
|
{
|
|
hr = WBEM_E_ACCESS_DENIED;
|
|
}
|
|
else
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
}
|
|
} // if: FAILED( hr )
|
|
else
|
|
{
|
|
hr = WBEM_S_NO_ERROR;
|
|
} // else: hr succeeded
|
|
|
|
return hr;
|
|
|
|
} //*** CEventProv::AccessCheck
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// DWORD
|
|
// WINAPI
|
|
// CEventProv::S_EventThread(
|
|
// LPVOID pArgIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Event thread proc.
|
|
//
|
|
// Arguments:
|
|
// pArgIn --
|
|
//
|
|
// Return Values:
|
|
// Any return values from CEventProv::InstanceThread().
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
DWORD
|
|
WINAPI
|
|
CEventProv::S_EventThread(
|
|
LPVOID pArgIn
|
|
)
|
|
{
|
|
// Make transition to the per-instance method.
|
|
// ===========================================
|
|
|
|
((CEventProv *) pArgIn)->InstanceThread();
|
|
return 0;
|
|
|
|
} //*** CEventProv::S_EventThread()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// void
|
|
// CEventProv::InstanceThread( void )
|
|
//
|
|
// Description:
|
|
// This function is started as seperated thread, waiting for cluster
|
|
// event notification and then send event back to wmi
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::InstanceThread( void )
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
//SAFECHANGE shChange;
|
|
DWORD dwError;
|
|
DWORD_PTR dwpNotifyKey;
|
|
DWORD cchName = MAX_PATH;
|
|
DWORD dwFilterType;
|
|
CWstrBuf wsbName;
|
|
CError er;
|
|
DWORD cchReturnedName;
|
|
|
|
try
|
|
{
|
|
m_esStatus = esRUNNING;
|
|
m_fStopped = FALSE;
|
|
shCluster = OpenCluster( NULL );
|
|
m_hChange = CreateClusterNotifyPort(
|
|
(HCHANGE) INVALID_HANDLE_VALUE,
|
|
shCluster,
|
|
( cntCLUSTER_STATE_CHANGE | cntOBJECT_ADD | cntOBJECT_REMOVE
|
|
| cntPROPERTY_CHANGE | cntGROUP_STATE_CHANGE
|
|
| cntRESOURCE_STATE_CHANGE ),
|
|
1
|
|
);
|
|
|
|
wsbName.SetSize( cchName );
|
|
|
|
while ( m_esStatus == esRUNNING )
|
|
{
|
|
cchReturnedName = cchName;
|
|
wsbName.Empty(); // Null out the name field
|
|
//TracePrint(("Call GetClusterNotify to get next notification event\n"));
|
|
dwError = GetClusterNotify(
|
|
m_hChange,
|
|
&dwpNotifyKey,
|
|
&dwFilterType,
|
|
wsbName,
|
|
&cchReturnedName,
|
|
400
|
|
);
|
|
|
|
if ( dwError == ERROR_MORE_DATA )
|
|
{
|
|
cchName = ++cchReturnedName;
|
|
wsbName.SetSize( cchName );
|
|
dwError = GetClusterNotify(
|
|
m_hChange,
|
|
&dwpNotifyKey,
|
|
&dwFilterType,
|
|
wsbName,
|
|
&cchReturnedName,
|
|
400
|
|
);
|
|
} // if: more data
|
|
|
|
if ( dwError == ERROR_SUCCESS )
|
|
{
|
|
CWbemClassObject wco;
|
|
UINT idx;
|
|
DWORD dwType;
|
|
SEventTypeTable * pTypeEntry = NULL;
|
|
|
|
//
|
|
// locate table index for the event type
|
|
//
|
|
dwType = dwFilterType;
|
|
for ( idx = 0 ; (idx < EVENT_TABLE_SIZE) && ! ( dwType & 0x01 ) ; idx++ )
|
|
{
|
|
dwType = dwType >> 1;
|
|
}
|
|
TracePrint(("Received <%ws> event, ChangeEvent = %!EventIdx!", wsbName, dwFilterType));
|
|
|
|
pTypeEntry = &m_EventTypeTable[ idx ];
|
|
if ( pTypeEntry->m_pwco != NULL )
|
|
{
|
|
pTypeEntry->m_pwco->SpawnInstance( 0, &wco );
|
|
|
|
try
|
|
{
|
|
pTypeEntry->m_pfn(
|
|
wco,
|
|
pTypeEntry->m_pwszMof,
|
|
//pwszName,
|
|
wsbName,
|
|
pTypeEntry->m_eotObjectType,
|
|
dwFilterType
|
|
);
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
TracePrint((" **** Exception on last Event call\n"));
|
|
} // catch
|
|
} // if:
|
|
|
|
er = m_pSink->Indicate( 1, &wco );
|
|
|
|
} // if: success
|
|
|
|
} // while: running
|
|
} // try
|
|
catch( ... )
|
|
{
|
|
TracePrint(("Exiting event provider loop! %lx\n", m_esStatus));
|
|
// bugbug: when error occured, event provider should be shut down,
|
|
// the provider should notify wmi and clean up.
|
|
// wmi doesn't handle this release call correctly.
|
|
m_pSink->Release();
|
|
//
|
|
// set it to null to provent being released again by destructor
|
|
//
|
|
m_pSink = NULL;
|
|
} // catch
|
|
|
|
m_fStopped = TRUE;
|
|
|
|
} //*** CEventProv::InstanceThread()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetEventProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set an event property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetEventProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
CObjPath op;
|
|
|
|
TracePrint(("Set event property for <%ws>:<%ws>, Event = %!EventIdx!", pwszMofClassNameIn, pwszObjectNameIn, dwEventMinorIn ));
|
|
|
|
pwcoInout.SetProperty( pwszObjectNameIn, PVD_PROP_EVENT_NAME );
|
|
pwcoInout.SetProperty( static_cast< DWORD >( eotObjectTypeIn ), PVD_PROP_EVENT_TYPE );
|
|
pwcoInout.SetProperty( static_cast< DWORD >( 0 ), PVD_PROP_EVENT_TYPEMAJOR );
|
|
pwcoInout.SetProperty( dwEventMinorIn, PVD_PROP_EVENT_TYPEMINOR );
|
|
|
|
//
|
|
// setting object path
|
|
//
|
|
if ( ! op.Init( NULL ) )
|
|
{
|
|
TracePrint((" **** Out of memory! Throwing exception.\n"));
|
|
throw WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
op.SetClass( pwszMofClassNameIn );
|
|
|
|
//
|
|
// net interface objectpath is different from all the other objects
|
|
//
|
|
if ( eotObjectTypeIn == eotNET_INTERFACE )
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFENETINTERFACE shNetInterface;
|
|
DWORD cbName = MAX_PATH;
|
|
CWstrBuf wsbName;
|
|
DWORD cbReturn;
|
|
CError er;
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
wsbName.SetSize( cbName );
|
|
shNetInterface = OpenClusterNetInterface( shCluster, pwszObjectNameIn );
|
|
|
|
//
|
|
// NOTE - I didn't handle error_more_data, since max_path should be
|
|
// large enough for node name
|
|
//
|
|
er = ClusterNetInterfaceControl(
|
|
shNetInterface,
|
|
NULL,
|
|
CLUSCTL_NETINTERFACE_GET_NODE,
|
|
NULL,
|
|
0,
|
|
wsbName,
|
|
cbName,
|
|
&cbReturn
|
|
);
|
|
|
|
op.AddProperty( PVD_PROP_NETINTERFACE_SYSTEMNAME, wsbName );
|
|
op.AddProperty( PVD_PROP_NETINTERFACE_DEVICEID, pwszObjectNameIn );
|
|
} //if: event is net interface
|
|
else
|
|
{
|
|
op.AddProperty( PVD_PROP_NAME, pwszObjectNameIn );
|
|
}
|
|
|
|
pwcoInout.SetProperty(
|
|
static_cast< LPCWSTR >( op.GetObjectPathString() ),
|
|
PVD_PROP_EVENT_PATH
|
|
);
|
|
|
|
} //*** CEventProv::S_SetEventProperty()
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_AddEvent(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set an event property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_AddEvent(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
|
|
switch ( eotObjectTypeIn )
|
|
{
|
|
case eotGROUP:
|
|
case eotRESOURCE:
|
|
case eotRESOURCE_TYPE:
|
|
case eotNODE:
|
|
case eotNETWORK:
|
|
case eotNET_INTERFACE:
|
|
{
|
|
|
|
TracePrint(("Add event for <%ws>:<%ws>, Event = %!EventIdx!\n", pwszMofClassNameIn, pwszObjectNameIn, dwEventMinorIn ));
|
|
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
default:
|
|
TracePrint(("Add object event for <%ws>:<%ws>, Event = %!EventIdx!\n", pwszMofClassNameIn, pwszObjectNameIn, dwEventMinorIn ));
|
|
TracePrint((" **** Unknown Object Type!\n"));
|
|
throw WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_AddEvent()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_DeleteEvent(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set an event property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_DeleteEvent(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
|
|
switch ( eotObjectTypeIn )
|
|
{
|
|
case eotGROUP:
|
|
case eotRESOURCE:
|
|
case eotRESOURCE_TYPE:
|
|
case eotNODE:
|
|
case eotNETWORK:
|
|
case eotNET_INTERFACE:
|
|
{
|
|
|
|
TracePrint(("Delete event for <%ws>:<%ws>, Event = %!EventIdx!\n", pwszMofClassNameIn, pwszObjectNameIn, dwEventMinorIn ));
|
|
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
TracePrint(("Delete object event for <%ws>:<%ws>, Event = %!EventIdx!\n", pwszMofClassNameIn, pwszObjectNameIn, dwEventMinorIn ));
|
|
TracePrint((" **** Unknown Object Type!\n"));
|
|
throw WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_DeleteEvent()
|
|
|
|
#if 0
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetClusterStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a node state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetClusterStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
DWORD dwState;
|
|
DWORD dwError;
|
|
|
|
dwError = GetNodeClusterState( NULL, &dwState );
|
|
|
|
if ( dwError != ERROR_SUCCESS )
|
|
{
|
|
TracePrint((" **** Failed to get the node cluster state. Throwing exception!\n"));
|
|
throw CProvException( dwError );
|
|
}
|
|
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetClusterStateProperty()
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetNodeStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a node state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetNodeStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFENODE shNode;
|
|
DWORD dwState;
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
shNode = OpenClusterNode( shCluster, pwszObjectNameIn );
|
|
dwState = GetClusterNodeState( shNode );
|
|
|
|
if ( dwState == ClusterNodeStateUnknown )
|
|
{
|
|
TracePrint((" **** SetNodeStateProperty... node state unknown. Throwing exception!\n"));
|
|
throw CProvException( GetLastError() );
|
|
}
|
|
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetNodeStateProperty()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetNetworkStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a network state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetNetworkStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFENETWORK shNetwork;
|
|
DWORD dwState;
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
shNetwork = OpenClusterNetwork( shCluster, pwszObjectNameIn );
|
|
dwState = GetClusterNetworkState( shNetwork );
|
|
if ( dwState == ClusterNetworkStateUnknown )
|
|
{
|
|
TracePrint((" **** SetNetworkStateProperty... network state unknown. Throwing exception!\n"));
|
|
throw CProvException( GetLastError() );
|
|
}
|
|
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetNetworkStateProperty()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetNetInterfaceStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a network interface state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetNetInterfaceStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFENETINTERFACE shNetInterface;
|
|
DWORD dwState;
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
shNetInterface = OpenClusterNetInterface( shCluster, pwszObjectNameIn );
|
|
dwState = GetClusterNetInterfaceState( shNetInterface );
|
|
if ( dwState == ClusterNetInterfaceStateUnknown )
|
|
{
|
|
TracePrint((" **** SetNetInterfaceStateProperty... network interface state unknown. Throwing exception!\n"));
|
|
throw CProvException( GetLastError() );
|
|
}
|
|
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetNetInterfaceStateProperty()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetGroupStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a group state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetGroupStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFEGROUP shGroup;
|
|
DWORD dwState;
|
|
DWORD cchName = MAX_PATH;
|
|
CWstrBuf wsbNodeName;
|
|
|
|
wsbNodeName.SetSize( cchName );
|
|
shCluster = OpenCluster( NULL );
|
|
shGroup = OpenClusterGroup( shCluster, pwszObjectNameIn );
|
|
|
|
dwState = GetClusterGroupState( shGroup, wsbNodeName, &cchName );
|
|
if ( dwState == ClusterGroupStateUnknown )
|
|
{
|
|
//
|
|
// BUGBUG I am not handling error_more_data here, since it's not possible that
|
|
// nodeName exceed MAX_PATH, assuming it use netbios name
|
|
//
|
|
TracePrint(("ClusterGroup State is UNKNOWN. Throwing exception!\n"));
|
|
throw CProvException( GetLastError() );
|
|
} else {
|
|
TracePrint(("Setting group state for group <%ws> to %!GroupState!\n", pwszObjectNameIn, dwState ));
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
pwcoInout.SetProperty( wsbNodeName, PVD_PROP_EVENT_NODE );
|
|
}
|
|
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetGroupStateProperty()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// void
|
|
// CEventProv::S_SetResourceStateProperty(
|
|
// CWbemClassObject & pwcoInout,
|
|
// LPCWSTR pwszMofClassNameIn,
|
|
// LPCWSTR pwszObjectNameIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// DWORD dwEventMinorIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Set a resource state property.
|
|
//
|
|
// Arguments:
|
|
// pwcoInout --
|
|
// pwszMofClassNameIn --
|
|
// pwszObjectNameIn --
|
|
// eotObjectTypeIn --
|
|
// dwEventMinorIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::S_SetResourceStateProperty(
|
|
CWbemClassObject & pwcoInout,
|
|
LPCWSTR pwszMofClassNameIn,
|
|
LPCWSTR pwszObjectNameIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
DWORD dwEventMinorIn
|
|
)
|
|
{
|
|
SAFECLUSTER shCluster;
|
|
SAFERESOURCE shResource;
|
|
DWORD dwState;
|
|
DWORD cchNodeName = MAX_PATH;
|
|
CWstrBuf wsbNodeName;
|
|
DWORD cchGroupName = MAX_PATH;
|
|
CWstrBuf wsbGroupName;
|
|
|
|
shCluster = OpenCluster( NULL );
|
|
wsbNodeName.SetSize( cchNodeName );
|
|
wsbGroupName.SetSize( cchGroupName );
|
|
shResource = OpenClusterResource( shCluster, pwszObjectNameIn );
|
|
if ( !shResource.BIsNULL() ) {
|
|
dwState = GetClusterResourceState(
|
|
shResource,
|
|
wsbNodeName,
|
|
&cchNodeName,
|
|
wsbGroupName,
|
|
&cchGroupName
|
|
);
|
|
} else {
|
|
dwState = (DWORD) ClusterResourceStateUnknown;
|
|
}
|
|
|
|
TracePrint(("Setting resource state for resource <%ws> to %!ResourceState!\n", pwszObjectNameIn, dwState ));
|
|
pwcoInout.SetProperty( dwState, PVD_PROP_EVENT_NEWSTATE );
|
|
pwcoInout.SetProperty( wsbNodeName, PVD_PROP_EVENT_NODE );
|
|
pwcoInout.SetProperty( wsbGroupName, PVD_PROP_EVENT_GROUP );
|
|
|
|
S_SetEventProperty(
|
|
pwcoInout,
|
|
pwszMofClassNameIn,
|
|
pwszObjectNameIn,
|
|
eotObjectTypeIn,
|
|
dwEventMinorIn
|
|
);
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::S_SetResourceStateProperty()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// void
|
|
// CEventProv::InsertTable(
|
|
// DWORD dwIdxIn,
|
|
// CLUSTER_CHANGE eTypeIn,
|
|
// EEventObjectType eotObjectTypeIn,
|
|
// LPCWSTR pwszMofIn,
|
|
// IWbemClassObject * pwcoIn,
|
|
// FPSETPROP pfnIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Insert values in the event table.
|
|
//
|
|
// Arguments:
|
|
// dwIdxIn --
|
|
// eTypeIn --
|
|
// eotObjectTypeIn --
|
|
// pwszMofIn --
|
|
// pwcoIn --
|
|
// pfnIn --
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CEventProv::InsertTable(
|
|
DWORD dwIdxIn,
|
|
CLUSTER_CHANGE eTypeIn,
|
|
EEventObjectType eotObjectTypeIn,
|
|
LPCWSTR pwszMofIn,
|
|
IWbemClassObject * pwcoIn,
|
|
FPSETPROP pfnIn
|
|
)
|
|
{
|
|
m_EventTypeTable[ dwIdxIn ].m_eType = eTypeIn;
|
|
m_EventTypeTable[ dwIdxIn ].m_eotObjectType = eotObjectTypeIn;
|
|
m_EventTypeTable[ dwIdxIn ].m_pwszMof = pwszMofIn;
|
|
m_EventTypeTable[ dwIdxIn ].m_pwco = pwcoIn;
|
|
m_EventTypeTable[ dwIdxIn ].m_pfn= pfnIn;
|
|
|
|
return;
|
|
|
|
} //*** CEventProv::InsertTable()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// HRESULT
|
|
// CEventProv::Initialize(
|
|
// LPWSTR pwszUserIn,
|
|
// LONG lFlagsIn,
|
|
// LPWSTR pwszNamespaceIn,
|
|
// LPWSTR pwszLocaleIn,
|
|
// IWbemServices * pNamespaceIn,
|
|
// IWbemContext * pCtxIn,
|
|
// IWbemProviderInitSink * pInitSinkIn
|
|
// )
|
|
//
|
|
// Description:
|
|
// Initializing the provider by setting up a lookup table.
|
|
// called by wmi only once to create provider object.
|
|
//
|
|
// Arguments:
|
|
// pwszUserIn -- User name
|
|
// lFlagsIn -- WMI flag
|
|
// pwszNamespaceIn -- Name space
|
|
// pwszLocaleIn -- Locale string
|
|
// pCtxIn -- WMI context
|
|
// pInitSinkIn -- WMI sink pointer
|
|
//
|
|
// Return Values:
|
|
// WBEM_NO_ERROR
|
|
// WBEM_E_FAILED
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CEventProv::Initialize(
|
|
LPWSTR pwszUserIn,
|
|
LONG lFlagsIn,
|
|
LPWSTR pwszNamespaceIn,
|
|
LPWSTR pwszLocaleIn,
|
|
IWbemServices * pNamespaceIn,
|
|
IWbemContext * pCtxIn,
|
|
IWbemProviderInitSink * pInitSinkIn
|
|
)
|
|
{
|
|
HRESULT hr;
|
|
CError er;
|
|
|
|
UNREFERENCED_PARAMETER( pwszUserIn );
|
|
UNREFERENCED_PARAMETER( lFlagsIn );
|
|
UNREFERENCED_PARAMETER( pwszNamespaceIn );
|
|
UNREFERENCED_PARAMETER( pwszLocaleIn );
|
|
|
|
m_pNs = pNamespaceIn;
|
|
m_pNs->AddRef();
|
|
|
|
//
|
|
// Grab the class definition for the event.
|
|
//
|
|
try
|
|
{
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_ADD ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventAdd,
|
|
0
|
|
);
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_REMOVE ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventRemove,
|
|
0
|
|
);
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_STATECHANGE ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventState,
|
|
0
|
|
);
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_GROUPSTATECHANGE ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventGroupState,
|
|
0
|
|
);
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_RESOURCESTATECHANGE ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventResourceState,
|
|
0
|
|
);
|
|
#if 0
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_NODESTATECHANGE ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventNodeState,
|
|
0
|
|
);
|
|
#endif
|
|
er = m_pNs->GetObject(
|
|
_bstr_t( PVD_CLASS_EVENT_PROP ),
|
|
0,
|
|
pCtxIn,
|
|
&m_pEventProperty,
|
|
0
|
|
);
|
|
|
|
//
|
|
// initialize mapping table
|
|
//
|
|
|
|
//
|
|
// node events
|
|
//
|
|
InsertTable(
|
|
0,
|
|
CLUSTER_CHANGE_NODE_STATE,
|
|
eotNODE,
|
|
PVD_CLASS_NODE,
|
|
m_pEventState,
|
|
S_SetNodeStateProperty
|
|
);
|
|
InsertTable(
|
|
1,
|
|
CLUSTER_CHANGE_NODE_DELETED,
|
|
eotNODE,
|
|
PVD_CLASS_NODE,
|
|
m_pEventRemove,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
2,
|
|
CLUSTER_CHANGE_NODE_ADDED,
|
|
eotNODE,
|
|
PVD_CLASS_NODE,
|
|
m_pEventAdd,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
3,
|
|
CLUSTER_CHANGE_NODE_PROPERTY,
|
|
eotNODE,
|
|
PVD_CLASS_NODE,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
//
|
|
// registry event, don't care
|
|
//
|
|
|
|
//
|
|
// Resource
|
|
//
|
|
InsertTable(
|
|
8,
|
|
CLUSTER_CHANGE_RESOURCE_STATE,
|
|
eotRESOURCE,
|
|
PVD_CLASS_RESOURCE,
|
|
m_pEventResourceState,
|
|
S_SetResourceStateProperty
|
|
);
|
|
InsertTable(
|
|
9,
|
|
CLUSTER_CHANGE_RESOURCE_DELETED,
|
|
eotRESOURCE,
|
|
PVD_CLASS_RESOURCE,
|
|
m_pEventRemove,
|
|
S_DeleteEvent
|
|
);
|
|
InsertTable(
|
|
10,
|
|
CLUSTER_CHANGE_RESOURCE_ADDED,
|
|
eotRESOURCE,
|
|
PVD_CLASS_RESOURCE,
|
|
m_pEventAdd,
|
|
S_AddEvent
|
|
);
|
|
InsertTable(
|
|
11,
|
|
CLUSTER_CHANGE_RESOURCE_PROPERTY,
|
|
eotRESOURCE,
|
|
PVD_CLASS_RESOURCE,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
//
|
|
// group
|
|
//
|
|
InsertTable(
|
|
12,
|
|
CLUSTER_CHANGE_GROUP_STATE,
|
|
eotGROUP,
|
|
PVD_CLASS_GROUP,
|
|
m_pEventGroupState,
|
|
S_SetGroupStateProperty
|
|
);
|
|
InsertTable(
|
|
13,
|
|
CLUSTER_CHANGE_GROUP_DELETED,
|
|
eotGROUP,
|
|
PVD_CLASS_GROUP,
|
|
m_pEventRemove,
|
|
S_DeleteEvent
|
|
);
|
|
InsertTable(
|
|
14,
|
|
CLUSTER_CHANGE_GROUP_ADDED,
|
|
eotGROUP,
|
|
PVD_CLASS_GROUP,
|
|
m_pEventAdd,
|
|
S_AddEvent
|
|
);
|
|
InsertTable(
|
|
15,
|
|
CLUSTER_CHANGE_GROUP_PROPERTY,
|
|
eotGROUP,
|
|
PVD_CLASS_GROUP,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
|
|
//
|
|
// Resource Type
|
|
//
|
|
InsertTable(
|
|
16,
|
|
CLUSTER_CHANGE_RESOURCE_TYPE_DELETED,
|
|
eotRESOURCE_TYPE,
|
|
PVD_CLASS_RESOURCETYPE,
|
|
m_pEventRemove,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
17,
|
|
CLUSTER_CHANGE_RESOURCE_TYPE_ADDED,
|
|
eotRESOURCE_TYPE,
|
|
PVD_CLASS_RESOURCETYPE,
|
|
m_pEventAdd,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
18,
|
|
CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY,
|
|
eotRESOURCE_TYPE,
|
|
PVD_CLASS_RESOURCETYPE,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
|
|
//
|
|
// skip 19 - CLUSTER_CHANGE_CLUSTER_RECONNECT
|
|
//
|
|
|
|
//
|
|
// network
|
|
//
|
|
InsertTable(
|
|
20,
|
|
CLUSTER_CHANGE_NETWORK_STATE,
|
|
eotNETWORK,
|
|
PVD_CLASS_NETWORK,
|
|
m_pEventState,
|
|
S_SetNetworkStateProperty
|
|
);
|
|
InsertTable(
|
|
21,
|
|
CLUSTER_CHANGE_NETWORK_DELETED,
|
|
eotNETWORK,
|
|
PVD_CLASS_NETWORK,
|
|
m_pEventRemove,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
22,
|
|
CLUSTER_CHANGE_NETWORK_ADDED,
|
|
eotNETWORK,
|
|
PVD_CLASS_NETWORK,
|
|
m_pEventAdd,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
23,
|
|
CLUSTER_CHANGE_NETWORK_PROPERTY,
|
|
eotNETWORK,
|
|
PVD_CLASS_NETWORK,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
//
|
|
// net interface
|
|
//
|
|
InsertTable(
|
|
24,
|
|
CLUSTER_CHANGE_NETINTERFACE_STATE,
|
|
eotNET_INTERFACE,
|
|
PVD_CLASS_NETWORKINTERFACE,
|
|
m_pEventState,
|
|
S_SetNetInterfaceStateProperty
|
|
);
|
|
InsertTable(
|
|
25,
|
|
CLUSTER_CHANGE_NETINTERFACE_DELETED,
|
|
eotNET_INTERFACE,
|
|
PVD_CLASS_NETWORKINTERFACE,
|
|
m_pEventRemove,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
26,
|
|
CLUSTER_CHANGE_NETINTERFACE_ADDED,
|
|
eotNET_INTERFACE,
|
|
PVD_CLASS_NETWORKINTERFACE,
|
|
m_pEventAdd,
|
|
S_SetEventProperty
|
|
);
|
|
InsertTable(
|
|
27,
|
|
CLUSTER_CHANGE_NETINTERFACE_PROPERTY,
|
|
eotNET_INTERFACE,
|
|
PVD_CLASS_NETWORKINTERFACE,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
//
|
|
// other
|
|
//
|
|
InsertTable(
|
|
28,
|
|
CLUSTER_CHANGE_QUORUM_STATE,
|
|
eotQUORUM,
|
|
PVD_CLASS_RESOURCE,
|
|
m_pEventState,
|
|
S_SetResourceStateProperty
|
|
);
|
|
/* InsertTable(
|
|
29,
|
|
CLUSTER_CHANGE_CLUSTER_STATE,
|
|
eotCLUSTER,
|
|
PVD_CLASS_CLUSTER,
|
|
m_pEventState,
|
|
S_SetClusterStateProperty );
|
|
*/
|
|
InsertTable(
|
|
30,
|
|
CLUSTER_CHANGE_CLUSTER_PROPERTY,
|
|
eotCLUSTER,
|
|
PVD_CLASS_CLUSTER,
|
|
m_pEventProperty,
|
|
S_SetEventProperty
|
|
);
|
|
//
|
|
// skip 31 - CLUSTER_CHANGE_HANDLE_CLOSE
|
|
//
|
|
|
|
// Tell CIMOM that we're up and running.
|
|
// =====================================
|
|
hr = WBEM_S_INITIALIZED;
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
hr = WBEM_E_FAILED;
|
|
} // catch
|
|
|
|
pInitSinkIn->SetStatus( hr, 0 );
|
|
return WBEM_S_NO_ERROR;
|
|
|
|
} //*** CEventProv::Initialize()
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// HRESULT
|
|
// CEventProv::S_HrCreateThis(
|
|
// IUnknown * pUnknownOuterIn,
|
|
// VOID ** ppvOut
|
|
// )
|
|
//
|
|
// Description:
|
|
// Create a CEventProv object.
|
|
//
|
|
// Arguments:
|
|
// pUnknownOutIn --
|
|
// ppvOut --
|
|
//
|
|
// Return Values:
|
|
// S_OK
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CEventProv::S_HrCreateThis(
|
|
IUnknown * pUnknownOuterIn,
|
|
VOID ** ppvOut
|
|
)
|
|
{
|
|
*ppvOut = new CEventProv();
|
|
return S_OK;
|
|
|
|
} //*** CEventProv::S_HrCreateThis()
|