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.
1815 lines
51 KiB
1815 lines
51 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2000-2001 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CBCAInterface.cpp
|
|
//
|
|
// Description:
|
|
// This file contains the implementation of the CBCAInterface
|
|
// class.
|
|
//
|
|
// Maintained By:
|
|
// David Potter (DavidP) 12-JUN-2001
|
|
// Vij Vasu (VVasu) 07-MAR-2000
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Include Files
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
// The precompiled header for this library
|
|
#include "Pch.h"
|
|
|
|
// The header file for this class
|
|
#include "CBCAInterface.h"
|
|
|
|
// Needed by Dll.h
|
|
#include <CFactory.h>
|
|
|
|
// For g_cObjects
|
|
#include <Dll.h>
|
|
|
|
// For the CBaseClusterForm class
|
|
#include "CBaseClusterForm.h"
|
|
|
|
// For the CBaseClusterJoin class
|
|
#include "CBaseClusterJoin.h"
|
|
|
|
// For the CBaseClusterCleanup class
|
|
#include "CBaseClusterCleanup.h"
|
|
|
|
// For the exception classes
|
|
#include "Exceptions.h"
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Macro Definitions
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Constant Definitions
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
DEFINE_THISCLASS( "CBCAInterface" );
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::CBCAInterface
|
|
//
|
|
// Description:
|
|
// Constructor of the CBCAInterface 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.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CBCAInterface::CBCAInterface( void )
|
|
: m_cRef( 1 )
|
|
, m_fCommitComplete( false )
|
|
, m_fRollbackPossible( false )
|
|
, m_lcid( LOCALE_SYSTEM_DEFAULT )
|
|
, m_fCallbackSupported( false )
|
|
{
|
|
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();
|
|
|
|
} //*** CBCAInterface::CBCAInterface
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::~CBCAInterface
|
|
//
|
|
// Description:
|
|
// Destructor of the CBCAInterface class.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CBCAInterface::~CBCAInterface( 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();
|
|
|
|
} //*** CBCAInterface::~CBCAInterface
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// static
|
|
// CBCAInterface::S_HrCreateInstance
|
|
//
|
|
// Description:
|
|
// Creates a CBCAInterface 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
|
|
CBCAInterface::S_HrCreateInstance(
|
|
IUnknown ** ppunkOut
|
|
)
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr = S_OK;
|
|
CBCAInterface * pbcaInterface = NULL;
|
|
|
|
Assert( ppunkOut != NULL );
|
|
if ( ppunkOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
pbcaInterface = new CBCAInterface();
|
|
if ( pbcaInterface == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( pbcaInterface->QueryInterface(
|
|
IID_IUnknown
|
|
, reinterpret_cast< void ** >( ppunkOut )
|
|
)
|
|
);
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if ( pbcaInterface != NULL )
|
|
{
|
|
pbcaInterface->Release();
|
|
}
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CBCAInterface::S_HrCreateInstance
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::AddRef
|
|
//
|
|
// Description:
|
|
// Increment the reference count of this object by one.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// The new reference count.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CBCAInterface::AddRef( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
InterlockedIncrement( &m_cRef );
|
|
|
|
CRETURN( m_cRef );
|
|
|
|
} //*** CBCAInterface::AddRef
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::Release
|
|
//
|
|
// Description:
|
|
// Decrement the reference count of this object by one.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// The new reference count.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP_( ULONG )
|
|
CBCAInterface::Release( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
LONG cRef;
|
|
|
|
cRef = InterlockedDecrement( &m_cRef );
|
|
|
|
if ( cRef == 0 )
|
|
{
|
|
TraceDo( delete this );
|
|
} // if: reference count decremented to zero
|
|
|
|
CRETURN( cRef );
|
|
|
|
} //*** CBCAInterface::Release
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::QueryInterface
|
|
//
|
|
// Description:
|
|
// Query this object for the passed in interface.
|
|
//
|
|
// Arguments:
|
|
// riidIn
|
|
// Id of interface requested.
|
|
//
|
|
// ppvOut
|
|
// 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.
|
|
//
|
|
// E_POINTER
|
|
// If ppvOut is NULL.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::QueryInterface(
|
|
REFIID riidIn
|
|
, void ** ppvOut
|
|
)
|
|
{
|
|
TraceQIFunc( riidIn, ppvOut );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Validate arguments.
|
|
//
|
|
|
|
Assert( ppvOut != NULL );
|
|
if ( ppvOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Handle known interfaces.
|
|
//
|
|
|
|
if ( IsEqualIID( riidIn, IID_IUnknown ) )
|
|
{
|
|
*ppvOut = static_cast< IClusCfgBaseCluster * >( this );
|
|
} // if: IUnknown
|
|
else if ( IsEqualIID( riidIn, IID_IClusCfgBaseCluster ) )
|
|
{
|
|
*ppvOut = TraceInterface( __THISCLASS__, IClusCfgBaseCluster, this, 0 );
|
|
} // else if:
|
|
else if ( IsEqualIID( riidIn, IID_IClusCfgInitialize ) )
|
|
{
|
|
*ppvOut = TraceInterface( __THISCLASS__, IClusCfgInitialize, this, 0 );
|
|
} // else if:
|
|
else
|
|
{
|
|
*ppvOut = NULL;
|
|
hr = E_NOINTERFACE;
|
|
} // else
|
|
|
|
//
|
|
// Add a reference to the interface if successful.
|
|
//
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
((IUnknown *) *ppvOut)->AddRef( );
|
|
} // if: success
|
|
|
|
Cleanup:
|
|
|
|
QIRETURN_IGNORESTDMARSHALLING( hr, riidIn );
|
|
|
|
} //*** CBCAInterface::QueryInterface
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::Initialize
|
|
//
|
|
// Description:
|
|
// Initialize this component.
|
|
//
|
|
// Arguments:
|
|
// punkCallbackIn
|
|
// Pointer to the IUnknown interface of a component that implements
|
|
// the IClusCfgCallback interface.
|
|
//
|
|
// lcidIn
|
|
// Locale id for this component.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::Initialize(
|
|
IUnknown * punkCallbackIn,
|
|
LCID lcidIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgInitialize]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Store the locale id in the member variable.
|
|
m_lcid = lcidIn;
|
|
|
|
// Indicate that SendStatusReports will not be supported unless a non-
|
|
// NULL callback interface pointer was specified. This is done in
|
|
// the constructor as well, but is also done here since this method
|
|
// could be called multiple times.
|
|
SetCallbackSupported( false );
|
|
|
|
if ( punkCallbackIn == NULL )
|
|
{
|
|
LogMsg( "[BC] No notifications will be sent." );
|
|
goto Cleanup;
|
|
}
|
|
|
|
TraceFlow( "The callback pointer is not NULL." );
|
|
|
|
// Try and get the "normal" callback interface.
|
|
hrRetVal = THR( m_spcbCallback.HrQueryAndAssign( punkCallbackIn ) );
|
|
|
|
if ( FAILED( hrRetVal ) )
|
|
{
|
|
LogMsg( "[BC] An error occurred (0x%#08x) trying to get a pointer to the callback interface. No notifications will be sent.", hrRetVal );
|
|
goto Cleanup;
|
|
} // if: we could not get the callback interface
|
|
|
|
SetCallbackSupported( true );
|
|
|
|
LogMsg( "[BC] Progress messages will be sent." );
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::Initialize
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SetCreate
|
|
//
|
|
// Description:
|
|
// Indicate that a cluster is to be created with this computer as the first node.
|
|
//
|
|
// Arguments:
|
|
// pcszClusterNameIn
|
|
// Name of the cluster to be formed.
|
|
//
|
|
// pcccServiceAccountIn
|
|
// Information about the cluster service account.
|
|
//
|
|
// dwClusterIPAddressIn
|
|
// dwClusterIPSubnetMaskIn
|
|
// pcszClusterIPNetworkIn
|
|
// Information about the cluster IP address
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::SetCreate(
|
|
const WCHAR * pcszClusterNameIn
|
|
, const WCHAR * pcszClusterBindingStringIn
|
|
, IClusCfgCredentials * pcccServiceAccountIn
|
|
, const DWORD dwClusterIPAddressIn
|
|
, const DWORD dwClusterIPSubnetMaskIn
|
|
, const WCHAR * pcszClusterIPNetworkIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgBaseCluster]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Set the thread locale.
|
|
if ( SetThreadLocale( m_lcid ) == FALSE )
|
|
{
|
|
DWORD sc = TW32( GetLastError() );
|
|
|
|
// If SetThreadLocale() fails, do not abort. Just log the error.
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying to set the thread locale.", sc );
|
|
|
|
} // if: SetThreadLocale() failed
|
|
|
|
try
|
|
{
|
|
LogMsg( "[BC] Initializing a cluster create operation." );
|
|
|
|
// Reset these state variables, to account for exceptions.
|
|
SetRollbackPossible( false );
|
|
|
|
// Setting this to true prevents Commit from being called while we are
|
|
// in this routine or if this routine doesn't complete successfully.
|
|
SetCommitCompleted( true );
|
|
|
|
{
|
|
// Create a CBaseClusterForm object and assign it to a smart pointer.
|
|
SmartBCAPointer spbcaTemp(
|
|
new CBaseClusterForm(
|
|
this
|
|
, pcszClusterNameIn
|
|
, pcszClusterBindingStringIn
|
|
, pcccServiceAccountIn
|
|
, dwClusterIPAddressIn
|
|
, dwClusterIPSubnetMaskIn
|
|
, pcszClusterIPNetworkIn
|
|
)
|
|
);
|
|
|
|
if ( spbcaTemp.FIsEmpty() )
|
|
{
|
|
LogMsg( "Could not initialize the cluster create operation. A memory allocation failure occurred." );
|
|
THROW_RUNTIME_ERROR( E_OUTOFMEMORY, IDS_ERROR_CLUSTER_FORM_INIT );
|
|
} // if: the memory allocation failed.
|
|
|
|
//
|
|
// If the creation succeeded store the pointer in a member variable for
|
|
// use during commit.
|
|
//
|
|
m_spbcaCurrentAction = spbcaTemp;
|
|
}
|
|
|
|
LogMsg( "[BC] Initialization completed. A cluster will be created on commit." );
|
|
|
|
// Indicate if rollback is possible.
|
|
SetRollbackPossible( m_spbcaCurrentAction->FIsRollbackPossible() );
|
|
|
|
// Indicate that this action has not been committed.
|
|
SetCommitCompleted( false );
|
|
|
|
} // try: to initialize a cluster create operation
|
|
catch( CAssert & raExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( raExceptionObject ) );
|
|
|
|
} // catch( CAssert & )
|
|
catch( CExceptionWithString & resExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( resExceptionObject ) );
|
|
|
|
} // catch( CExceptionWithString & )
|
|
catch( CException & reExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( reExceptionObject ) );
|
|
|
|
} // catch( CException & )
|
|
catch( ... )
|
|
{
|
|
// Catch everything. Do not let any exceptions pass out of this function.
|
|
hrRetVal = THR( HrProcessException() );
|
|
} // catch all
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::SetCreate
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SetAdd
|
|
//
|
|
// Description:
|
|
// Indicate that this computer should be added to a cluster.
|
|
//
|
|
// Arguments:
|
|
// pcszClusterNameIn
|
|
// Name of the cluster to add nodes to.
|
|
//
|
|
// pcccServiceAccountIn
|
|
// Information about the cluster service account.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::SetAdd(
|
|
const WCHAR * pcszClusterNameIn
|
|
, const WCHAR * pcszClusterBindingStringIn
|
|
, IClusCfgCredentials * pcccServiceAccountIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgBaseCluster]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Set the thread locale.
|
|
if ( SetThreadLocale( m_lcid ) == FALSE )
|
|
{
|
|
DWORD sc = TW32( GetLastError() );
|
|
|
|
// If SetThreadLocale() fails, do not abort. Just log the error.
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying to set the thread locale.", sc );
|
|
|
|
} // if: SetThreadLocale() failed
|
|
|
|
try
|
|
{
|
|
LogMsg( "[BC] Initializing add nodes to cluster." );
|
|
|
|
// Reset these state variables, to account for exceptions.
|
|
SetRollbackPossible( false );
|
|
|
|
// Setting this to true prevents Commit from being called while we are
|
|
// in this routine or if this routine doesn't complete successfully.
|
|
SetCommitCompleted( true );
|
|
|
|
{
|
|
// Create a CBaseClusterJoin object and assign it to a smart pointer.
|
|
SmartBCAPointer spbcaTemp(
|
|
new CBaseClusterJoin(
|
|
this
|
|
, pcszClusterNameIn
|
|
, pcszClusterBindingStringIn
|
|
, pcccServiceAccountIn
|
|
)
|
|
);
|
|
|
|
if ( spbcaTemp.FIsEmpty() )
|
|
{
|
|
LogMsg( "[BC] Could not initialize cluster add nodes. A memory allocation failure occurred." );
|
|
THROW_RUNTIME_ERROR( E_OUTOFMEMORY, IDS_ERROR_CLUSTER_JOIN_INIT );
|
|
} // if: the memory allocation failed.
|
|
|
|
//
|
|
// If the creation succeeded store the pointer in a member variable for
|
|
// use during commit.
|
|
//
|
|
m_spbcaCurrentAction = spbcaTemp;
|
|
}
|
|
|
|
LogMsg( "[BC] Initialization completed. This computer will be added to a cluster on commit." );
|
|
|
|
// Indicate if rollback is possible.
|
|
SetRollbackPossible( m_spbcaCurrentAction->FIsRollbackPossible() );
|
|
|
|
// Indicate that this action has not been committed.
|
|
SetCommitCompleted( false );
|
|
|
|
} // try: to initialize for adding nodes to a cluster
|
|
catch( CAssert & raExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( raExceptionObject ) );
|
|
|
|
} // catch( CAssert & )
|
|
catch( CExceptionWithString & resExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( resExceptionObject ) );
|
|
|
|
} // catch( CExceptionWithString & )
|
|
catch( CException & reExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( reExceptionObject ) );
|
|
|
|
} // catch( CException & )
|
|
catch( ... )
|
|
{
|
|
// Catch everything. Do not let any exceptions pass out of this function.
|
|
hrRetVal = THR( HrProcessException() );
|
|
} // catch all
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::SetAdd
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SetCleanup
|
|
//
|
|
// Description:
|
|
// Indicate that this node needs to be cleaned up. The ClusSvc service
|
|
// should not be running when this action is committed.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::SetCleanup( void )
|
|
{
|
|
TraceFunc( "[IClusCfgBaseCluster]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Set the thread locale.
|
|
if ( SetThreadLocale( m_lcid ) == FALSE )
|
|
{
|
|
DWORD sc = TW32( GetLastError() );
|
|
|
|
// If SetThreadLocale() fails, do not abort. Just log the error.
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying to set the thread locale.", sc );
|
|
|
|
} // if: SetThreadLocale() failed
|
|
|
|
try
|
|
{
|
|
LogMsg( "[BC] Initializing node clean up." );
|
|
|
|
// Reset these state variables, to account for exceptions.
|
|
SetRollbackPossible( false );
|
|
|
|
// Setting this to true prevents Commit from being called while we are
|
|
// in this routine or if this routine doesn't complete successfully.
|
|
SetCommitCompleted( true );
|
|
|
|
{
|
|
// Create a CBaseClusterCleanup object and assign it to a smart pointer.
|
|
SmartBCAPointer spbcaTemp( new CBaseClusterCleanup( this ) );
|
|
|
|
if ( spbcaTemp.FIsEmpty() )
|
|
{
|
|
LogMsg( "[BC] Could not initialize node clean up. A memory allocation failure occurred. Throwing an exception" );
|
|
THROW_RUNTIME_ERROR( E_OUTOFMEMORY, IDS_ERROR_CLUSTER_CLEANUP_INIT );
|
|
} // if: the memory allocation failed.
|
|
|
|
//
|
|
// If the creation succeeded store the pointer in a member variable for
|
|
// use during commit.
|
|
//
|
|
m_spbcaCurrentAction = spbcaTemp;
|
|
}
|
|
|
|
LogMsg( "[BC] Initialization completed. This node will be cleaned up on commit." );
|
|
|
|
// Indicate if rollback is possible.
|
|
SetRollbackPossible( m_spbcaCurrentAction->FIsRollbackPossible() );
|
|
|
|
// Indicate that this action has not been committed.
|
|
SetCommitCompleted( false );
|
|
|
|
} // try: to initialize node clean up
|
|
catch( CAssert & raExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( raExceptionObject ) );
|
|
|
|
} // catch( CAssert & )
|
|
catch( CExceptionWithString & resExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( resExceptionObject ) );
|
|
|
|
} // catch( CExceptionWithString & )
|
|
catch( CException & reExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( reExceptionObject ) );
|
|
|
|
} // catch( CException & )
|
|
catch( ... )
|
|
{
|
|
// Catch everything. Do not let any exceptions pass out of this function.
|
|
hrRetVal = THR( HrProcessException() );
|
|
} // catch all
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::SetCleanup
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::Commit
|
|
//
|
|
// Description:
|
|
// Perform the action indicated by a previous call to one of the SetXXX
|
|
// routines.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// HRESULT_FROM_WIN32( ERROR_CLUSCFG_ALREADY_COMMITTED )
|
|
// If this commit has already been performed.
|
|
//
|
|
// E_INVALIDARG
|
|
// If no action has been set using a SetXXX call.
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::Commit( void )
|
|
{
|
|
TraceFunc( "[IClusCfgBaseCluster]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Set the thread locale.
|
|
if ( SetThreadLocale( m_lcid ) == FALSE )
|
|
{
|
|
DWORD sc = TW32( GetLastError() );
|
|
|
|
// If SetThreadLocale() fails, do not abort. Just log the error.
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying to set the thread locale.", sc );
|
|
|
|
} // if: SetThreadLocale() failed
|
|
|
|
// Has this action already been committed?
|
|
if ( FIsCommitComplete() )
|
|
{
|
|
SendStatusReport(
|
|
TASKID_Major_Configure_Cluster_Services
|
|
, TASKID_Minor_Commit_Already_Complete
|
|
, 0
|
|
, 1
|
|
, 1
|
|
, HRESULT_FROM_WIN32( TW32( ERROR_CLUSCFG_ALREADY_COMMITTED ) )
|
|
, IDS_ERROR_COMMIT_ALREADY_COMPLETE
|
|
, true
|
|
);
|
|
|
|
LogMsg( "[BC] The desired cluster configuration has already been performed." );
|
|
hrRetVal = HRESULT_FROM_WIN32( TW32( ERROR_CLUSCFG_ALREADY_COMMITTED ) );
|
|
goto Cleanup;
|
|
} // if: already committed
|
|
|
|
// Check if the arguments to commit have been set.
|
|
if ( m_spbcaCurrentAction.FIsEmpty() )
|
|
{
|
|
LogMsg( "[BC] Commit was called when an operation has not been specified." );
|
|
hrRetVal = THR( E_INVALIDARG ); // BUGBUG: 29-JAN-2001 DavidP Replace E_INVALIDARG
|
|
goto Cleanup;
|
|
} // if: the pointer to the action to be committed is NULL
|
|
|
|
LogMsg( "[BC] About to perform the desired cluster configuration." );
|
|
|
|
// Commit the desired action.
|
|
try
|
|
{
|
|
m_spbcaCurrentAction->Commit();
|
|
LogMsg( "[BC] Cluster configuration completed successfully." );
|
|
|
|
// If we are here, then everything has gone well.
|
|
SetCommitCompleted( true );
|
|
|
|
} // try: to commit the desired action.
|
|
catch( CAssert & raExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( raExceptionObject ) );
|
|
|
|
} // catch( CAssert & )
|
|
catch( CExceptionWithString & resExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( resExceptionObject ) );
|
|
|
|
} // catch( CExceptionWithString & )
|
|
catch( CException & reExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( reExceptionObject ) );
|
|
|
|
} // catch( CException & )
|
|
catch( ... )
|
|
{
|
|
// Catch everything. Do not let any exceptions pass out of this function.
|
|
hrRetVal = THR( HrProcessException() );
|
|
} // catch all
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::Commit
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// STDMETHODIMP
|
|
// CBCAInterface::Rollback( void )
|
|
//
|
|
// Description:
|
|
// Rollback a committed configuration.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the call succeeded
|
|
//
|
|
// E_PENDING
|
|
// If this action has not yet been committed successfully.
|
|
//
|
|
// HRESULT_FROM_WIN32( ERROR_CLUSCFG_ROLLBACK_FAILED )
|
|
// If this action cannot be rolled back.
|
|
//
|
|
// E_INVALIDARG
|
|
// If no action has been set using a SetXXX call.
|
|
//
|
|
// Other HRESULTs
|
|
// If the call failed.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CBCAInterface::Rollback( void )
|
|
{
|
|
TraceFunc( "[IClusCfgCallback]" );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
|
|
// Check if this action list has completed successfully.
|
|
if ( ! FIsCommitComplete() )
|
|
{
|
|
// Cannot rollback an incomplete action.
|
|
SendStatusReport(
|
|
TASKID_Major_Configure_Cluster_Services
|
|
, TASKID_Minor_Rollback_Failed_Incomplete_Commit
|
|
, 0
|
|
, 1
|
|
, 1
|
|
, E_PENDING
|
|
, IDS_ERROR_ROLLBACK_FAILED_INCOMPLETE_COMMIT
|
|
, true
|
|
);
|
|
|
|
LogMsg( "[BC] Cannot rollback - action not yet committed." );
|
|
hrRetVal = THR( E_PENDING );
|
|
goto Cleanup;
|
|
|
|
} // if: this action was not completed successfully
|
|
|
|
// Check if this action can be rolled back.
|
|
if ( ! FIsRollbackPossible() )
|
|
{
|
|
// Cannot rollback an incompleted action.
|
|
SendStatusReport(
|
|
TASKID_Major_Configure_Cluster_Services
|
|
, TASKID_Minor_Rollback_Not_Possible
|
|
, 0
|
|
, 1
|
|
, 1
|
|
, HRESULT_FROM_WIN32( ERROR_CLUSCFG_ROLLBACK_FAILED )
|
|
, IDS_ERROR_ROLLBACK_NOT_POSSIBLE
|
|
, true
|
|
);
|
|
|
|
LogMsg( "[BC] This action cannot be rolled back." ); // BUGBUG: 29-JAN-2001 DavidP Why?
|
|
hrRetVal = HRESULT_FROM_WIN32( TW32( ERROR_CLUSCFG_ROLLBACK_FAILED ) );
|
|
goto Cleanup;
|
|
|
|
} // if: this action was not completed successfully
|
|
|
|
// Check if the arguments to rollback have been set.
|
|
if ( m_spbcaCurrentAction.FIsEmpty() )
|
|
{
|
|
LogMsg( "[BC] Rollback was called when an operation has not been specified." );
|
|
hrRetVal = THR( E_INVALIDARG ); // BUGBUG: 29-JAN-2001 DavidP Replace E_INVALIDARG
|
|
goto Cleanup;
|
|
} // if: the pointer to the action to be committed is NULL
|
|
|
|
|
|
LogMsg( "[BC] About to rollback the cluster configuration just committed." );
|
|
|
|
// Commit the desired action.
|
|
try
|
|
{
|
|
m_spbcaCurrentAction->Rollback();
|
|
LogMsg( "[BC] Cluster configuration rolled back." );
|
|
|
|
// If we are here, then everything has gone well.
|
|
SetCommitCompleted( false );
|
|
|
|
} // try: to rollback the desired action.
|
|
catch( CAssert & raExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( raExceptionObject ) );
|
|
|
|
} // catch( CAssert & )
|
|
catch( CExceptionWithString & resExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( resExceptionObject ) );
|
|
|
|
} // catch( CExceptionWithString & )
|
|
catch( CException & reExceptionObject )
|
|
{
|
|
// Process the exception.
|
|
hrRetVal = THR( HrProcessException( reExceptionObject ) );
|
|
|
|
} // catch( CException & )
|
|
catch( ... )
|
|
{
|
|
// Catch everything. Do not let any exceptions pass out of this function.
|
|
hrRetVal = THR( HrProcessException() );
|
|
} // catch all
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hrRetVal );
|
|
|
|
} //*** CBCAInterface::Rollback
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SendStatusReport
|
|
//
|
|
// Description:
|
|
// Send a progress notification [ string id overload ].
|
|
//
|
|
// Arguments:
|
|
// clsidTaskMajorIn
|
|
// clsidTaskMinorIn
|
|
// GUIDs identifying the notification.
|
|
//
|
|
// ulMinIn
|
|
// ulMaxIn
|
|
// ulCurrentIn
|
|
// Values that indicate the percentage of this task that is
|
|
// completed.
|
|
//
|
|
// hrStatusIn
|
|
// Error code.
|
|
//
|
|
// uiDescriptionStringIdIn
|
|
// String ID of the description of the notification.
|
|
//
|
|
// fIsAbortAllowedIn
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CRuntimeError
|
|
// If any of the APIs fail.
|
|
//
|
|
// CAbortException
|
|
// If the configuration was aborted.
|
|
//
|
|
// Remarks:
|
|
// In the current implementation, IClusCfgCallback::SendStatusReport
|
|
// returns E_ABORT to indicate that the user wants to abort
|
|
// the cluster configuration.
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::SendStatusReport(
|
|
const CLSID & clsidTaskMajorIn
|
|
, const CLSID & clsidTaskMinorIn
|
|
, ULONG ulMinIn
|
|
, ULONG ulMaxIn
|
|
, ULONG ulCurrentIn
|
|
, HRESULT hrStatusIn
|
|
, UINT uiDescriptionStringIdIn
|
|
, bool fIsAbortAllowedIn // = true
|
|
)
|
|
{
|
|
TraceFunc( "uiDescriptionStringIdIn" );
|
|
|
|
if ( FIsCallbackSupported() )
|
|
{
|
|
CStr strDescription;
|
|
|
|
// Lookup the string using the string Id.
|
|
strDescription.LoadString( g_hInstance, uiDescriptionStringIdIn );
|
|
|
|
// Send progress notification ( call the overloaded function )
|
|
SendStatusReport(
|
|
clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, ulCurrentIn
|
|
, hrStatusIn
|
|
, strDescription.PszData()
|
|
, fIsAbortAllowedIn
|
|
);
|
|
} // if: callbacks are supported
|
|
else
|
|
{
|
|
LogMsg( "[BC] Callbacks are not supported. No status report will be sent." );
|
|
} // else: callbacks are not supported
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::SendStatusReport
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SendStatusReport
|
|
//
|
|
// Description:
|
|
// Send a progress notification [ string id & REF string id overload ].
|
|
//
|
|
// Arguments:
|
|
// clsidTaskMajorIn
|
|
// clsidTaskMinorIn
|
|
// GUIDs identifying the notification.
|
|
//
|
|
// ulMinIn
|
|
// ulMaxIn
|
|
// ulCurrentIn
|
|
// Values that indicate the percentage of this task that is
|
|
// completed.
|
|
//
|
|
// hrStatusIn
|
|
// Error code.
|
|
//
|
|
// uiDescriptionStringIdIn
|
|
// String ID of the description of the notification.
|
|
//
|
|
// uiDescriptionRefStringIdIn
|
|
// REF String ID of the description of the notification.
|
|
//
|
|
// fIsAbortAllowedIn
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CRuntimeError
|
|
// If any of the APIs fail.
|
|
//
|
|
// CAbortException
|
|
// If the configuration was aborted.
|
|
//
|
|
// Remarks:
|
|
// In the current implementation, IClusCfgCallback::SendStatusReport
|
|
// returns E_ABORT to indicate that the user wants to abort
|
|
// the cluster configuration.
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::SendStatusReport(
|
|
const CLSID & clsidTaskMajorIn
|
|
, const CLSID & clsidTaskMinorIn
|
|
, ULONG ulMinIn
|
|
, ULONG ulMaxIn
|
|
, ULONG ulCurrentIn
|
|
, HRESULT hrStatusIn
|
|
, UINT uiDescriptionStringIdIn
|
|
, UINT uiDescriptionRefStringIdIn
|
|
, bool fIsAbortAllowedIn // = true
|
|
)
|
|
{
|
|
TraceFunc( "uiDescriptionStringIdIn" );
|
|
|
|
if ( FIsCallbackSupported() )
|
|
{
|
|
CStr strDescription;
|
|
|
|
// Lookup the string using the string Id.
|
|
strDescription.LoadString( g_hInstance, uiDescriptionStringIdIn );
|
|
|
|
if ( uiDescriptionRefStringIdIn == 0 )
|
|
{
|
|
// Send progress notification ( call the overloaded function )
|
|
SendStatusReport(
|
|
clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, ulCurrentIn
|
|
, hrStatusIn
|
|
, strDescription.PszData()
|
|
, fIsAbortAllowedIn
|
|
);
|
|
}
|
|
else
|
|
{
|
|
CStr strDescriptionRef;
|
|
|
|
// Lookup the string using the Ref string Id.
|
|
strDescriptionRef.LoadString( g_hInstance, uiDescriptionRefStringIdIn );
|
|
|
|
// Send progress notification ( call the overloaded function )
|
|
SendStatusReport(
|
|
clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, ulCurrentIn
|
|
, hrStatusIn
|
|
, strDescription.PszData()
|
|
, strDescriptionRef.PszData()
|
|
, fIsAbortAllowedIn
|
|
);
|
|
}
|
|
|
|
} // if: callbacks are supported
|
|
else
|
|
{
|
|
LogMsg( "[BC] Callbacks are not supported. No status report will be sent." );
|
|
} // else: callbacks are not supported
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::SendStatusReport
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SendStatusReport
|
|
//
|
|
// Description:
|
|
// Send a progress notification [ string overload ].
|
|
//
|
|
// Arguments:
|
|
// clsidTaskMajorIn
|
|
// clsidTaskMinorIn
|
|
// GUIDs identifying the notification.
|
|
//
|
|
// ulMinIn
|
|
// ulMaxIn
|
|
// ulCurrentIn
|
|
// Values that indicate the percentage of this task that is
|
|
// completed.
|
|
//
|
|
// hrStatusIn
|
|
// Error code.
|
|
//
|
|
// pcszDescriptionStringIn
|
|
// String ID of the description of the notification.
|
|
//
|
|
// fIsAbortAllowedIn
|
|
// An optional parameter indicating if this configuration step can
|
|
// be aborted or not. Default value is true.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CRuntimeError
|
|
// If any of the APIs fail.
|
|
//
|
|
// CAbortException
|
|
// If the configuration was aborted.
|
|
//
|
|
// Remarks:
|
|
// In the current implementation, IClusCfgCallback::SendStatusReport
|
|
// returns E_ABORT to indicate that the user wants to abort
|
|
// the cluster configuration.
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::SendStatusReport(
|
|
const CLSID & clsidTaskMajorIn
|
|
, const CLSID & clsidTaskMinorIn
|
|
, ULONG ulMinIn
|
|
, ULONG ulMaxIn
|
|
, ULONG ulCurrentIn
|
|
, HRESULT hrStatusIn
|
|
, const WCHAR * pcszDescriptionStringIn
|
|
, bool fIsAbortAllowedIn // = true
|
|
)
|
|
{
|
|
TraceFunc1( "pcszDescriptionStringIn = '%ws'", pcszDescriptionStringIn );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
FILETIME ft;
|
|
|
|
if ( !FIsCallbackSupported() )
|
|
{
|
|
// Nothing needs to be done.
|
|
goto Cleanup;
|
|
} // if: callbacks are not supported
|
|
|
|
GetSystemTimeAsFileTime( &ft );
|
|
|
|
// Send progress notification
|
|
hrRetVal = THR(
|
|
m_spcbCallback->SendStatusReport(
|
|
NULL
|
|
, clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, ulCurrentIn
|
|
, hrStatusIn
|
|
, pcszDescriptionStringIn
|
|
, &ft
|
|
, NULL
|
|
)
|
|
);
|
|
|
|
// Has the user requested an abort?
|
|
if ( hrRetVal == E_ABORT )
|
|
{
|
|
LogMsg( "[BC] A request to abort the configuration has been recieved." );
|
|
if ( fIsAbortAllowedIn )
|
|
{
|
|
LogMsg( "[BC] Configuration will be aborted." );
|
|
THROW_ABORT( E_ABORT, IDS_USER_ABORT );
|
|
} // if: this operation can be aborted
|
|
else
|
|
{
|
|
LogMsg( "[BC] This configuration operation cannot be aborted. Request will be ignored." );
|
|
} // else: this operation cannot be aborted
|
|
} // if: the user has indicated that that configuration should be aborted
|
|
else
|
|
{
|
|
if ( FAILED( hrRetVal ) )
|
|
{
|
|
LogMsg( "[BC] Error 0x%#08x has occurred - no more status messages will be sent.", hrRetVal );
|
|
|
|
// Disable all further callbacks.
|
|
SetCallbackSupported( false );
|
|
} // if: something went wrong trying to send a status report
|
|
} // else: abort was not requested
|
|
|
|
Cleanup:
|
|
|
|
if ( FAILED( hrRetVal ) )
|
|
{
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying send a status message. Throwing an exception.", hrRetVal );
|
|
THROW_RUNTIME_ERROR( hrRetVal, IDS_ERROR_SENDING_REPORT );
|
|
} // if: an error occurred
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::SendStatusReport
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::SendStatusReport
|
|
//
|
|
// Description:
|
|
// Send a progress notification [ string & REF string overload ].
|
|
//
|
|
// Arguments:
|
|
// clsidTaskMajorIn
|
|
// clsidTaskMinorIn
|
|
// GUIDs identifying the notification.
|
|
//
|
|
// ulMinIn
|
|
// ulMaxIn
|
|
// ulCurrentIn
|
|
// Values that indicate the percentage of this task that is
|
|
// completed.
|
|
//
|
|
// hrStatusIn
|
|
// Error code.
|
|
//
|
|
// pcszDescriptionStringIn
|
|
// String ID of the description of the notification.
|
|
//
|
|
// pcszDescriptionRefStringIn
|
|
// REF String ID of the description of the notification.
|
|
//
|
|
// fIsAbortAllowedIn
|
|
// An optional parameter indicating if this configuration step can
|
|
// be aborted or not. Default value is true.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CRuntimeError
|
|
// If any of the APIs fail.
|
|
//
|
|
// CAbortException
|
|
// If the configuration was aborted.
|
|
//
|
|
// Remarks:
|
|
// In the current implementation, IClusCfgCallback::SendStatusReport
|
|
// returns E_ABORT to indicate that the user wants to abort
|
|
// the cluster configuration.
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::SendStatusReport(
|
|
const CLSID & clsidTaskMajorIn
|
|
, const CLSID & clsidTaskMinorIn
|
|
, ULONG ulMinIn
|
|
, ULONG ulMaxIn
|
|
, ULONG ulCurrentIn
|
|
, HRESULT hrStatusIn
|
|
, const WCHAR * pcszDescriptionStringIn
|
|
, const WCHAR * pcszDescriptionRefStringIn
|
|
, bool fIsAbortAllowedIn // = true
|
|
)
|
|
{
|
|
TraceFunc1( "pcszDescriptionRefStringIn = '%ws'", pcszDescriptionRefStringIn );
|
|
|
|
HRESULT hrRetVal = S_OK;
|
|
FILETIME ft;
|
|
|
|
if ( !FIsCallbackSupported() )
|
|
{
|
|
// Nothing needs to be done.
|
|
goto Cleanup;
|
|
} // if: callbacks are not supported
|
|
|
|
GetSystemTimeAsFileTime( &ft );
|
|
|
|
// Send progress notification
|
|
hrRetVal = THR(
|
|
m_spcbCallback->SendStatusReport(
|
|
NULL
|
|
, clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, ulCurrentIn
|
|
, hrStatusIn
|
|
, pcszDescriptionStringIn
|
|
, &ft
|
|
, pcszDescriptionRefStringIn
|
|
)
|
|
);
|
|
|
|
// Has the user requested an abort?
|
|
if ( hrRetVal == E_ABORT )
|
|
{
|
|
LogMsg( "[BC] A request to abort the configuration has been recieved." );
|
|
if ( fIsAbortAllowedIn )
|
|
{
|
|
LogMsg( "[BC] Configuration will be aborted." );
|
|
THROW_ABORT( E_ABORT, IDS_USER_ABORT );
|
|
} // if: this operation can be aborted
|
|
else
|
|
{
|
|
LogMsg( "[BC] This configuration operation cannot be aborted. Request will be ignored." );
|
|
} // else: this operation cannot be aborted
|
|
} // if: the user has indicated that that configuration should be aborted
|
|
else
|
|
{
|
|
if ( FAILED( hrRetVal ) )
|
|
{
|
|
LogMsg( "[BC] Error 0x%#08x has occurred - no more status messages will be sent.", hrRetVal );
|
|
|
|
// Disable all further callbacks.
|
|
SetCallbackSupported( false );
|
|
} // if: something went wrong trying to send a status report
|
|
} // else: abort was not requested
|
|
|
|
Cleanup:
|
|
|
|
if ( FAILED( hrRetVal ) )
|
|
{
|
|
LogMsg( "[BC] Error 0x%#08x occurred trying send a status message. Throwing an exception.", hrRetVal );
|
|
THROW_RUNTIME_ERROR( hrRetVal, IDS_ERROR_SENDING_REPORT );
|
|
} // if: an error occurred
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::SendStatusReport
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::QueueStatusReportCompletion
|
|
//
|
|
// Description:
|
|
// Queue a status report for sending when an exception is caught.
|
|
//
|
|
// Arguments:
|
|
// clsidTaskMajorIn
|
|
// clsidTaskMinorIn
|
|
// GUIDs identifying the notification.
|
|
//
|
|
// ulMinIn
|
|
// ulMaxIn
|
|
// Values that indicate the range of steps for this report.
|
|
//
|
|
// uiDescriptionStringIdIn
|
|
// String ID of the description of the notification.
|
|
//
|
|
// uiReferenceStringIdIn
|
|
// Reference string ID of the description of the notification.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any thrown by CList::Append()
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::QueueStatusReportCompletion(
|
|
const CLSID & clsidTaskMajorIn
|
|
, const CLSID & clsidTaskMinorIn
|
|
, ULONG ulMinIn
|
|
, ULONG ulMaxIn
|
|
, UINT uiDescriptionStringIdIn
|
|
, UINT uiReferenceStringIdIn
|
|
)
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
// Queue the status report only if callbacks are supported.
|
|
if ( m_fCallbackSupported )
|
|
{
|
|
// Append this status report to the end of the pending list.
|
|
m_prlPendingReportList.Append(
|
|
SPendingStatusReport(
|
|
clsidTaskMajorIn
|
|
, clsidTaskMinorIn
|
|
, ulMinIn
|
|
, ulMaxIn
|
|
, uiDescriptionStringIdIn
|
|
, uiReferenceStringIdIn
|
|
)
|
|
);
|
|
}
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::QueueStatusReportCompletion
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::CompletePendingStatusReports
|
|
//
|
|
// Description:
|
|
// Send all the status reports that were queued for sending when an
|
|
// exception occurred. This function is meant to be called from an exception
|
|
// handler when an exception is caught.
|
|
//
|
|
// Arguments:
|
|
// hrStatusIn
|
|
// The error code to be sent with the pending status reports.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None, since this function is usually called in an exception handler.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void
|
|
CBCAInterface::CompletePendingStatusReports(
|
|
HRESULT hrStatusIn
|
|
) throw()
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
if ( m_fCallbackSupported )
|
|
{
|
|
try
|
|
{
|
|
PendingReportList::CIterator ciCurrent = m_prlPendingReportList.CiBegin();
|
|
PendingReportList::CIterator ciLast = m_prlPendingReportList.CiEnd();
|
|
|
|
// Iterate through the list of pending status reports and send each pending report.
|
|
while ( ciCurrent != ciLast )
|
|
{
|
|
// Send the current status report.
|
|
SendStatusReport(
|
|
ciCurrent->m_clsidTaskMajor
|
|
, ciCurrent->m_clsidTaskMinor
|
|
, ciCurrent->m_ulMin
|
|
, ciCurrent->m_ulMax
|
|
, ciCurrent->m_ulMax
|
|
, hrStatusIn
|
|
, ciCurrent->m_uiDescriptionStringId
|
|
, ciCurrent->m_uiReferenceStringId
|
|
, false
|
|
);
|
|
|
|
// Move to the next one.
|
|
m_prlPendingReportList.DeleteAndMoveToNext( ciCurrent );
|
|
|
|
} // while: the pending status report list is not empty
|
|
|
|
} // try: to send status report
|
|
catch( ... )
|
|
{
|
|
THR( E_UNEXPECTED );
|
|
|
|
// Nothing can be done here if the sending of the status report fails.
|
|
LogMsg( "[BC] An unexpected error has occurred trying to complete pending status messages. It will not be propagated." );
|
|
} // catch: all exceptions
|
|
|
|
} // if: callbacks are supported
|
|
|
|
// Empty the pending status report list.
|
|
m_prlPendingReportList.Empty();
|
|
|
|
TraceFuncExit();
|
|
|
|
} //*** CBCAInterface::CompletePendingStatusReports
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::HrProcessException
|
|
//
|
|
// Description:
|
|
// Process an exception that should be shown to the user.
|
|
//
|
|
// Arguments:
|
|
// CExceptionWithString & resExceptionObjectInOut
|
|
// The exception object that has been caught.
|
|
//
|
|
// Return Value:
|
|
// The error code stored in the exception object.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CBCAInterface::HrProcessException(
|
|
CExceptionWithString & resExceptionObjectInOut
|
|
) throw()
|
|
{
|
|
TraceFunc( "resExceptionObjectInOut" );
|
|
|
|
LogMsg(
|
|
TEXT("[BC] A runtime error has occurred in file '%s', line %d. Error code is %#08x.") SZ_NEWLINE
|
|
TEXT(" The error string is '%s'.")
|
|
, resExceptionObjectInOut.PszGetThrowingFile()
|
|
, resExceptionObjectInOut.UiGetThrowingLine()
|
|
, resExceptionObjectInOut.HrGetErrorCode()
|
|
, resExceptionObjectInOut.StrGetErrorString().PszData()
|
|
);
|
|
|
|
// If the user has not been notified
|
|
if ( ! resExceptionObjectInOut.FHasUserBeenNotified() )
|
|
{
|
|
try
|
|
{
|
|
SendStatusReport(
|
|
TASKID_Major_Configure_Cluster_Services
|
|
, TASKID_Minor_Rolling_Back_Cluster_Configuration
|
|
, 1, 1, 1
|
|
, resExceptionObjectInOut.HrGetErrorCode()
|
|
, resExceptionObjectInOut.StrGetErrorString().PszData()
|
|
, resExceptionObjectInOut.StrGetErrorRefString().PszData()
|
|
, false // fIsAbortAllowedIn
|
|
);
|
|
|
|
resExceptionObjectInOut.SetUserNotified();
|
|
|
|
} // try: to send status report
|
|
catch( ... )
|
|
{
|
|
THR( E_UNEXPECTED );
|
|
|
|
// Nothing can be done here if the sending of the status report fails.
|
|
LogMsg( "[BC] An unexpected error has occurred trying to send a progress notification. It will not be propagated." );
|
|
} // catch: all exceptions
|
|
} // if: the user has not been notified of this exception
|
|
|
|
// Complete sending pending status reports.
|
|
CompletePendingStatusReports( resExceptionObjectInOut.HrGetErrorCode() );
|
|
|
|
HRETURN( resExceptionObjectInOut.HrGetErrorCode() );
|
|
|
|
} //*** CBCAInterface::HrProcessException
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::HrProcessException
|
|
//
|
|
// Description:
|
|
// Process an assert exception.
|
|
//
|
|
// Arguments:
|
|
// const CAssert & rcaExceptionObjectIn
|
|
// The exception object that has been caught.
|
|
//
|
|
// Return Value:
|
|
// The error code stored in the exception object.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CBCAInterface::HrProcessException(
|
|
const CAssert & rcaExceptionObjectIn
|
|
) throw()
|
|
{
|
|
TraceFunc( "rcaExceptionObjectIn" );
|
|
|
|
LogMsg(
|
|
TEXT("[BC] An assertion has failed in file '%s', line %d. Error code is %#08x.") SZ_NEWLINE
|
|
TEXT(" The error string is '%s'.")
|
|
, rcaExceptionObjectIn.PszGetThrowingFile()
|
|
, rcaExceptionObjectIn.UiGetThrowingLine()
|
|
, rcaExceptionObjectIn.HrGetErrorCode()
|
|
, rcaExceptionObjectIn.StrGetErrorString().PszData()
|
|
);
|
|
|
|
// Complete sending pending status reports.
|
|
CompletePendingStatusReports( rcaExceptionObjectIn.HrGetErrorCode() );
|
|
|
|
HRETURN( rcaExceptionObjectIn.HrGetErrorCode() );
|
|
|
|
} //*** CBCAInterface::HrProcessException
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::HrProcessException
|
|
//
|
|
// Description:
|
|
// Process a general exception.
|
|
//
|
|
// Arguments:
|
|
// const CException & rceExceptionObjectIn
|
|
// The exception object that has been caught.
|
|
//
|
|
// Return Value:
|
|
// The error code stored in the exception object.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CBCAInterface::HrProcessException(
|
|
const CException & rceExceptionObjectIn
|
|
) throw()
|
|
{
|
|
TraceFunc( "roeExceptionObjectIn" );
|
|
|
|
LogMsg(
|
|
"[BC] An exception has occurred in file '%s', line %d. Error code is %#08x."
|
|
, rceExceptionObjectIn.PszGetThrowingFile()
|
|
, rceExceptionObjectIn.UiGetThrowingLine()
|
|
, rceExceptionObjectIn.HrGetErrorCode()
|
|
);
|
|
|
|
// Complete sending pending status reports.
|
|
CompletePendingStatusReports( rceExceptionObjectIn.HrGetErrorCode() );
|
|
|
|
HRETURN( rceExceptionObjectIn.HrGetErrorCode() );
|
|
|
|
} //*** CBCAInterface::HrProcessException
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CBCAInterface::HrProcessException
|
|
//
|
|
// Description:
|
|
// Process an unknown exception.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// E_UNEXPECTED
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CBCAInterface::HrProcessException( void ) throw()
|
|
{
|
|
TraceFunc( "void" );
|
|
|
|
HRESULT hr = E_UNEXPECTED;
|
|
|
|
LogMsg( "[BC] An unknown exception (for example, an access violation) has occurred." );
|
|
|
|
// Complete sending pending status reports.
|
|
CompletePendingStatusReports( hr );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CBCAInterface::HrProcessException
|