windows-xp/Source/XPSP1/NT/base/cluster/mgmt/cluscfg/startup/startupnotify.cpp

//////////////////////////////////////////////////////////////////////////////
//
//  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()