archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
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.
9 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: 75c48ba87f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '75c48ba87f'
${ noResults }
windows-xp/Source/XPSP1/NT/base/cluster/mgmt/cluscfg/startup/startupnotify.cpp

756 lines
22 KiB
Raw Blame History

//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000 Microsoft Corporation
//
// Module Name:
// StartupNotify.cpp
//
// Description:
// This file contains the implementation of the CStartupNotify
// class.
//
// Documentation:
// TODO: fill in pointer to external documentation
//
// Header File:
// StartupNotify.h
//
// Maintained By:
// Vij Vasu (VVasu) 15-JUN-2000
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Include Files
//////////////////////////////////////////////////////////////////////////////
// The precompiled header for this library
#include "pch.h"
// The header file for this class
#include "StartupNotify.h"
// For POSTCONFIG_COMPLETE_EVENT_NAME
#include "EventName.h"
//////////////////////////////////////////////////////////////////////////////
// Macro Definitions
//////////////////////////////////////////////////////////////////////////////
DEFINE_THISCLASS( "CStartupNotify" );
//////////////////////////////////////////////////////////////////////////////
//++
//
// CStartupNotify::CStartupNotify()
//
// Description:
// Constructor of the CStartupNotify class. This initializes
// the m_cRef variable to 1 instead of 0 to account of possible
// QueryInterface failure in DllGetClassObject.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CStartupNotify::CStartupNotify( void )
: m_cRef( 1 )
{
TraceFunc( "" );
// Increment the count of components in memory so the DLL hosting this
// object cannot be unloaded.
InterlockedIncrement( &g_cObjects );
TraceFlow1( "Component count = %d.", g_cObjects );
TraceFuncExit();
} //*** CStartupNotify::CStartupNotify
//////////////////////////////////////////////////////////////////////////////
//++
//
// CStartupNotify::~CStartupNotify()
//
// Description:
// Destructor of the CStartupNotify class.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
CStartupNotify::~CStartupNotify( void )
{
TraceFunc( "" );
// There's going to be one less component in memory. Decrement component count.
InterlockedDecrement( &g_cObjects );
TraceFlow1( "Component count = %d.", g_cObjects );
TraceFuncExit();
} //*** CStartupNotify::~CStartupNotify
//////////////////////////////////////////////////////////////////////////////
//++
//
// HRESULT
// CStartupNotify::S_HrCreateInstance(
// IUnknown ** ppunkOut
// )
//
// Description:
// Creates a CStartupNotify instance.
//
// Arguments:
// ppunkOut
// The IUnknown interface of the new object.
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Not enough memory to create the object.
//
// other HRESULTs
// Object initialization failed.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CStartupNotify::S_HrCreateInstance( IUnknown ** ppunkOut )
{
TraceFunc( "" );
HRESULT hr = E_INVALIDARG;
CStartupNotify * pStartupNotify = NULL;
do
{
// Allocate memory for the new object.
pStartupNotify = new CStartupNotify();
if ( pStartupNotify == NULL )
{
LogMsg( "Could not allocate memory for a evict cleanup object." );
TraceFlow( "Could not allocate memory for a evict cleanup object." );
hr = THR( E_OUTOFMEMORY );
break;
} // if: out of memory
hr = THR( pStartupNotify->QueryInterface( IID_IUnknown, reinterpret_cast< void ** >( ppunkOut ) ) );
TraceFlow1( "*ppunkOut = %#X.", *ppunkOut );
}
while( false ); // dummy do-while loop to avoid gotos.
if ( pStartupNotify != NULL )
{
pStartupNotify->Release();
} // if: the pointer to the notification object is not NULL
HRETURN( hr );
} //*** CStartupNotify::S_HrCreateInstance()
//////////////////////////////////////////////////////////////////////////////
//++
//
// STDMETHODIMP_( ULONG )
// CStartupNotify::AddRef()
//
// Description:
// Increment the reference count of this object by one.
//
// Arguments:
// None.
//
// Return Value:
// The new reference count.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CStartupNotify::AddRef( void )
{
TraceFunc( "[IUnknown]" );
InterlockedIncrement( &m_cRef );
TraceFlow1( "m_cRef = %d", m_cRef );
RETURN( m_cRef );
} //*** CStartupNotify::AddRef()
//////////////////////////////////////////////////////////////////////////////
//++
//
// STDMETHODIMP_( ULONG )
// CStartupNotify::Release()
//
// Description:
// Decrement the reference count of this object by one.
//
// Arguments:
// None.
//
// Return Value:
// The new reference count.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP_( ULONG )
CStartupNotify::Release( void )
{
TraceFunc( "[IUnknown]" );
InterlockedDecrement( &m_cRef );
TraceFlow1( "m_cRef = %d", m_cRef );
if ( m_cRef == 0 )
{
TraceDo( delete this );
RETURN( 0 );
} // if: reference count decremented to zero
RETURN( m_cRef );
} //*** CStartupNotify::Release()
//////////////////////////////////////////////////////////////////////////////
//++
//
// STDMETHODIMP
// CStartupNotify::QueryInterface()
//
// Description:
// Decrement the reference count of this object by one.
//
// Arguments:
// IN REFIID riid
// Id of interface requested.
//
// OUT void ** ppv
// Pointer to the requested interface.
//
// Return Value:
// S_OK
// If the interface is available on this object.
//
// E_NOINTERFACE
// If the interface is not available.
//
// Remarks:
// None.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CStartupNotify::QueryInterface( REFIID riid, void ** ppv )
{
TraceQIFunc( riid, ppv );
HRESULT hr = S_OK;
if ( ppv != NULL )
{
if ( IsEqualIID( riid, IID_IUnknown ) )
{
*ppv = static_cast< IClusCfgStartupNotify * >( this );
} // if: IUnknown
else if ( IsEqualIID( riid, IID_IClusCfgStartupNotify ) )
{
*ppv = TraceInterface( __THISCLASS__, IClusCfgStartupNotify, this, 0 );
} // else if:
else
{
hr = E_NOINTERFACE;
} // else
if ( SUCCEEDED( hr ) )
{
((IUnknown *) *ppv)->AddRef( );
} // if: success
else
{
*ppv = NULL;
} // else: something failed
} // if: the output pointer was valid
else
{
hr = E_INVALIDARG;
} // else: the output pointer is invalid
QIRETURN( hr, riid );
} //*** CStartupNotify::QueryInterface()
//////////////////////////////////////////////////////////////////////////////
//++
//
// CStartupNotify::SendNotifications()
//
// Description:
// This method is called by the Cluster Service to inform the implementor
// of this interface to send out notification of cluster service startup
// to interested listeners. If this method is being called for the first
// time, the method waits till the post configuration steps are complete
// before sending out the notifications.
//
// Arguments:
// None.
//
// Return Values:
// S_OK
// Success.
//
// Other HRESULTs
// The call failed.
//
//--
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP
CStartupNotify::SendNotifications( void )
{
TraceFunc( "[IClusCfgStartupNotify]" );
HRESULT hr = S_OK;
HANDLE heventPostCfgCompletion = NULL;
do
{
//
// If the cluster service is being started for the first time, as a part
// of adding this node to a cluster (forming or joining), then we have
// to wait till the post-configuration steps are completed before we
// can send out notifications.
//
TraceFlow1( "Trying to create an event named '%s'.", POSTCONFIG_COMPLETE_EVENT_NAME );
// Create an event in the signalled state. If this event already existed
// we get a handle to that event, and the state of the event is not changed.
heventPostCfgCompletion = CreateEvent(
NULL // event security attributes
, TRUE // manual-reset event
, TRUE // create in signaled state
, POSTCONFIG_COMPLETE_EVENT_NAME
);
if ( heventPostCfgCompletion == NULL )
{
hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) );
LogMsg( "Error %#x occurred trying to create an event named '%s'.", hr, POSTCONFIG_COMPLETE_EVENT_NAME );
TraceFlow2( "Error %#x occurred trying to create an event named '%s'.", hr, POSTCONFIG_COMPLETE_EVENT_NAME );
break;
} // if: we could not get a handle to the event
TraceFlow( "Waiting for the event to be signaled." );
//
// Now, wait for this event to be signaled. If this method was called due to this
// node being part of a cluster, this event would have been created in the unsignaled state
// by the cluster configuration server. However, if this was not the first time that
// the cluster service is starting on this node, the event would have been created in the
// signaled state above, and so, the wait below will exit immediately.
//
do
{
DWORD dwStatus;
// Wait for any message sent or posted to this queue
// or for our event to be signaled.
dwStatus = MsgWaitForMultipleObjects(
1
, &heventPostCfgCompletion
, FALSE
, 900000 // If no one has signaled this event in 15 minutes, abort.
, QS_ALLINPUT
);
// The result tells us the type of event we have.
if ( dwStatus == ( WAIT_OBJECT_0 + 1 ) )
{
MSG msg;
// Read all of the messages in this next loop,
// removing each message as we read it.
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) != 0 )
{
// If it is a quit message, we are done pumping messages.
if ( msg.message == WM_QUIT)
{
TraceFlow( "Get a WM_QUIT message. Exit message pump loop." );
break;
} // if: we got a WM_QUIT message
// Otherwise, dispatch the message.
DispatchMessage( &msg );
} // while: there are still messages in the window message queue
} // if: we have a message in the window message queue
else
{
if ( dwStatus == WAIT_OBJECT_0 )
{
TraceFlow( "Our event has been signaled. Exiting wait loop." );
break;
} // else if: our event is signaled
else
{
if ( dwStatus == -1 )
{
hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) );
LogMsg( "Error %#x occurred trying to wait for an event to be signaled.", hr );
TraceFlow1( "Error %#x occurred trying to wait for an event to be signaled.", hr );
} // if: MsgWaitForMultipleObjects() returned an error
else
{
hr = THR( HRESULT_FROM_WIN32( dwStatus ) );
LogMsg( "An error occurred trying to wait for an event to be signaled. Status code is %d.", dwStatus );
TraceFlow1( "An error occurred trying to wait for an event to be signaled. Status code is %d.", dwStatus );
} // else: an unexpected value was returned by MsgWaitForMultipleObjects()
break;
} // else: an unexpected result
} // else: MsgWaitForMultipleObjects() exited for a reason other than a waiting message
}
while( true ); // do-while: loop infinitely
if ( FAILED( hr ) )
{
TraceFlow( "Something went wrong trying to wait for the event to be signaled." );
break;
} // if: something has gone wrong
TraceFlow( "Our event has been signaled. Proceed with the notifications." );
// Send out the notifications
hr = THR( HrNotifyListeners() );
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to notify cluster startup listeners.", hr );
LogMsg( "Error %#x occurred trying to notify cluster startup listeners.", hr );
break;
} // if: something went wrong while sending out notifications
TraceFlow( "Sending of cluster startup notifications complete." );
LogMsg( "Sending of cluster startup notifications complete." );
}
while( false ); // dummy do-while loop to avoid gotos
//
// Clean up
//
if ( heventPostCfgCompletion != NULL )
{
CloseHandle( heventPostCfgCompletion );
} // if: we had created the event
HRETURN( hr );
} //*** CStartupNotify::SendNotifications()
//////////////////////////////////////////////////////////////////////////////
//++
//
// HRESULT
// CStartupNotify::HrNotifyListeners
//
// Description:
// Enumerate all components on the local computer registered for cluster
// startup notification.
//
// Arguments:
// None.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs
// Something went wrong during the enumeration.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CStartupNotify::HrNotifyListeners( void )
{
TraceFunc( "" );
const UINT uiCHUNK_SIZE = 16;
HRESULT hr = S_OK;
ICatInformation * pciCatInfo = NULL;
IEnumCLSID * psleStartupListenerClsidEnum = NULL;
IUnknown * punkResTypeServices = NULL;
do
{
ULONG cReturned = 0;
CATID rgCatIdsImplemented[ 1 ];
rgCatIdsImplemented[ 0 ] = CATID_ClusCfgStartupListeners;
//
// Enumerate all the enumerators registered in the
// CATID_ClusCfgStartupListeners category
//
hr = THR(
CoCreateInstance(
CLSID_StdComponentCategoriesMgr
, NULL
, CLSCTX_SERVER
, IID_ICatInformation
, reinterpret_cast< void ** >( &pciCatInfo )
)
);
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to get a pointer to the enumerator of the CATID_ClusCfgStartupListeners category.", hr );
LogMsg( "Error %#x occurred trying to get a pointer to the enumerator of the CATID_ClusCfgStartupListeners category.", hr );
break;
} // if: we could not get a pointer to the ICatInformation interface
// Get a pointer to the enumerator of the CLSIDs that belong to the CATID_ClusCfgStartupListeners category.
hr = THR(
pciCatInfo->EnumClassesOfCategories(
1
, rgCatIdsImplemented
, 0
, NULL
, &psleStartupListenerClsidEnum
)
);
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to get a pointer to the enumerator of the CATID_ClusCfgStartupListeners category.", hr );
LogMsg( "Error %#x occurred trying to get a pointer to the enumerator of the CATID_ClusCfgStartupListeners category.", hr );
break;
} // if: we could not get a pointer to the IEnumCLSID interface
//
// Create an instance of the resource type services component
//
hr = THR(
CoCreateInstance(
CLSID_ClusCfgResTypeServices
, NULL
, CLSCTX_INPROC_SERVER
, __uuidof( punkResTypeServices )
, reinterpret_cast< void ** >( &punkResTypeServices )
)
);
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to create the resource type services component.", hr );
LogMsg( "Error %#x occurred trying to create the resource type services component.", hr );
break;
} // if: we could not create the resource type services component
// Enumerate the CLSIDs of the registered startup listeners
do
{
CLSID rgStartupListenerClsids[ uiCHUNK_SIZE ];
ULONG idxCLSID;
cReturned = 0;
hr = STHR(
psleStartupListenerClsidEnum->Next(
uiCHUNK_SIZE
, rgStartupListenerClsids
, &cReturned
)
);
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying enumerate startup listener components.", hr );
LogMsg( "Error %#x occurred trying enumerate startup listener components.", hr );
break;
} // if: we could not get the next set of CLSIDs
// hr may be S_FALSE here, so reset it.
hr = S_OK;
for ( idxCLSID = 0; idxCLSID < cReturned; ++idxCLSID )
{
hr = THR( HrProcessListener( rgStartupListenerClsids[ idxCLSID ], punkResTypeServices ) );
if ( FAILED( hr ) )
{
// The processing of one of the listeners failed.
// Log the error, but continue processing other listeners.
TraceFlow1( "Error %#x occurred trying to process a cluster startup listener. Other listeners will be processed.", hr );
TraceMsgGUID( mtfALWAYS, "The CLSID of the failed listener is ", rgStartupListenerClsids[ idxCLSID ] );
LogMsg( "Error %#x occurred trying to process a cluster startup listener. Other listeners will be processed.", hr );
hr = S_OK;
} // if: this enumerator failed
} // for: iterate through the returned CLSIDs
}
while( cReturned > 0 ); // while: there are still CLSIDs to be enumerated
if ( FAILED( hr ) )
{
break;
} // if: something went wrong in the loop above
}
while( false ); // dummy do-while loop to avoid gotos.
//
// Cleanup code
//
if ( pciCatInfo != NULL )
{
pciCatInfo->Release();
} // if: we had obtained a pointer to the ICatInformation interface
if ( psleStartupListenerClsidEnum != NULL )
{
psleStartupListenerClsidEnum->Release();
} // if: we had obtained a pointer to the enumerator of startup listener CLSIDs
if ( punkResTypeServices != NULL )
{
punkResTypeServices->Release();
} // if: we had created the resource type services component
HRETURN( hr );
} //*** CStartupNotify::HrNotifyListeners()
//////////////////////////////////////////////////////////////////////////////
//++
//
// HRESULT
// CStartupNotify::HrProcessListener
//
// Description:
// This function instantiates a cluster startup listener component
// and calls the appropriate methods.
//
// Arguments:
// rclsidListenerCLSIDIn
// CLSID of the startup listener component
//
// punkResTypeServicesIn
// Pointer to the IUnknown interface on the resource type services
// component. This interface provides methods that help configure
// resource types.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs
// Something went wrong during the processing of the listener.
//
//--
//////////////////////////////////////////////////////////////////////////////
HRESULT
CStartupNotify::HrProcessListener(
const CLSID & rclsidListenerCLSIDIn
, IUnknown * punkResTypeServicesIn
)
{
TraceFunc( "" );
HRESULT hr = S_OK;
IClusCfgStartupListener * pcslStartupListener = NULL;
TraceMsgGUID( mtfALWAYS, "The CLSID of this startup listener is ", rclsidListenerCLSIDIn );
do
{
//
// Create the component represented by the CLSID passed in
//
hr = THR(
CoCreateInstance(
rclsidListenerCLSIDIn
, NULL
, CLSCTX_INPROC_SERVER
, __uuidof( pcslStartupListener )
, reinterpret_cast< void ** >( &pcslStartupListener )
)
);
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to create the cluster startup listener component.", hr );
LogMsg( "Error %#x occurred trying to create a cluster startup listener component.", hr );
break;
} // if: we could not create the cluster startup listener component
// Notify this listener.
hr = THR( pcslStartupListener->Notify( punkResTypeServicesIn ) );
if ( FAILED( hr ) )
{
TraceFlow1( "Error %#x occurred trying to notify this startup listener.", hr );
LogMsg( "Error %#x occurred trying to notify a cluster startup listener.", hr );
break;
} // if: this notification
}
while( false ); // dummy do-while loop to avoid gotos.
//
// Cleanup code
//
if ( pcslStartupListener != NULL )
{
pcslStartupListener->Release();
} // if: we had obtained a pointer to the startup listener interface
HRETURN( hr );
} //*** CStartupNotify::HrProcessListener()