////////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2000-2001 Microsoft Corporation // // Module Name: // PostCfgManager.cpp // // Description: // CPostCfgManager implementation. // // Maintained By: // Galen Barbee (GalenB) 09-JUN-2000 // ////////////////////////////////////////////////////////////////////////////// #include "pch.h" #include "guids.h" #include "clusudef.h" #include "GroupHandle.h" #include "ResourceEntry.h" #include "IPostCfgManager.h" #include "IPrivatePostCfgResource.h" #include "PostCfgMgr.h" #include "CreateServices.h" #include "PostCreateServices.h" #include "PreCreateServices.h" #include "ResTypeServices.h" #include "..\Wizard\Resource.h" #include "PostCfgResources.h" #include "ClusCfgPrivate.h" #include #include DEFINE_THISCLASS("CPostCfgManager") #define RESOURCE_INCREMENT 25 // // Failure code. // #define SSR_LOG_ERR( _major, _minor, _hr, _msg ) \ { \ THR( SendStatusReport( m_bstrNodeName, _major, _minor, 0, 0, 0, _hr, _msg, NULL, NULL ) ); \ } #define SSR_LOG1( _major, _minor, _hr, _fmt, _bstr, _arg1 ) \ { \ HRESULT hrTemp; \ THR( HrFormatStringIntoBSTR( _fmt, &_bstr, _arg1 ) ); \ hrTemp = THR( SendStatusReport( NULL, _major, _minor, 0, 1, 1, _hr, _bstr, NULL, NULL ) ); \ if ( FAILED( hrTemp ) )\ { \ _hr = hrTemp; \ } \ } #define SSR_LOG2( _major, _minor, _hr, _fmt, _bstr, _arg1, _arg2 ) \ { \ HRESULT hrTemp; \ THR( HrFormatStringIntoBSTR( _fmt, &_bstr, _arg1, _arg2 ) ); \ hrTemp = THR( SendStatusReport( NULL, _major, _minor, 0, 1, 1, _hr, _bstr, NULL, NULL ) ); \ if ( FAILED( hrTemp ) )\ { \ _hr = hrTemp; \ } \ } // // Structure that holds the mapping for well known resource types. // struct SResTypeGUIDPtrAndName { const GUID * m_pcguidTypeGUID; const WCHAR * m_pszTypeName; }; // Mapping of well known resource type GUIDs to the type names. const SResTypeGUIDPtrAndName gc_rgWellKnownResTypeMap[] = { { &RESTYPE_PhysicalDisk, CLUS_RESTYPE_NAME_PHYS_DISK }, { &RESTYPE_IPAddress, CLUS_RESTYPE_NAME_IPADDR }, { &RESTYPE_NetworkName, CLUS_RESTYPE_NAME_NETNAME }, { &RESTYPE_LocalQuorum, CLUS_RESTYPE_NAME_LKQUORUM } }; // Size of the above array. const int gc_cWellKnownResTypeMapSize = sizeof( gc_rgWellKnownResTypeMap ) / sizeof( gc_rgWellKnownResTypeMap[ 0 ] ); // ************************************************************************ // // Constructor / Destructor // // ************************************************************************ ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::S_HrCreateInstance( // IUnknown ** ppunkOut // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::S_HrCreateInstance( IUnknown ** ppunkOut ) { TraceFunc( "" ); HRESULT hr; Assert( ppunkOut != NULL ); CPostCfgManager * pPostCfgManager = new CPostCfgManager; if ( pPostCfgManager != NULL ) { hr = THR( pPostCfgManager->HrInit() ); if ( SUCCEEDED( hr ) ) { hr = THR( pPostCfgManager->TypeSafeQI( IUnknown, ppunkOut ) ); } pPostCfgManager->Release(); } else { hr = E_OUTOFMEMORY; } HRETURN( hr ); } // S_HrCreateInstance() ////////////////////////////////////////////////////////////////////////////// // // CPostCfgManager::CPostCfgManager( void ) // ////////////////////////////////////////////////////////////////////////////// CPostCfgManager::CPostCfgManager( void ) { TraceFunc( "" ); InterlockedIncrement( &g_cObjects ); TraceFuncExit(); } // CPostCfgManager() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrInit( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrInit( void ) { TraceFunc( "" ); ULONG idxMapEntry; HRESULT hr = S_OK; // IUnknown stuff Assert( m_cRef == 0 ); AddRef(); // Add one count Assert( m_pcccb == NULL ); Assert( m_lcid == 0 ); // IPostCfgManager Assert( m_peccmr == NULL ); Assert( m_pccci == NULL ); Assert( m_cAllocedResources == 0 ); Assert( m_cResources == 0 ); Assert( m_rgpResources == NULL ); Assert( m_idxIPAddress == 0 ); Assert( m_idxClusterName == 0 ); Assert( m_idxQuorumResource == 0 ); Assert( m_idxLastStorage == 0 ); Assert( m_hCluster == NULL ); Assert( m_pgnResTypeGUIDNameMap == NULL ); Assert( m_idxNextMapEntry == 0 ); Assert( m_cMapSize == 0 ); Assert( m_ecmCommitChangesMode == cmUNKNOWN ); m_cNetName = 1; m_cIPAddress = 1; // Set the boolean flag, m_isQuorumChanged to false; m_isQuorumChanged = false; // Default allocation for mappings m_cMapSize = 20; m_pgnResTypeGUIDNameMap = new SResTypeGUIDAndName[ m_cMapSize ]; if ( m_pgnResTypeGUIDNameMap == NULL ) goto OutOfMemory; // Prefill the resource type GUID to name map with well known entries. for ( idxMapEntry = 0; idxMapEntry < gc_cWellKnownResTypeMapSize; ++idxMapEntry ) { hr = THR( HrMapResTypeGUIDToName( *gc_rgWellKnownResTypeMap[ idxMapEntry ].m_pcguidTypeGUID , gc_rgWellKnownResTypeMap [ idxMapEntry ].m_pszTypeName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_Init_MapResTypeGuidToName , hr , L"" ); break; } // if: there was an error creating a mapping } hr = THR( HrGetComputerName( ComputerNameNetBIOS, &m_bstrNodeName ) ); Cleanup: HRETURN( hr ); OutOfMemory: hr = E_OUTOFMEMORY; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_Init_OutOfMemory , hr , L"Out of memory" ); goto Cleanup; } // HrInit() ////////////////////////////////////////////////////////////////////////////// // // CPostCfgManager::~CPostCfgManager() // ////////////////////////////////////////////////////////////////////////////// CPostCfgManager::~CPostCfgManager( void ) { TraceFunc( "" ); ULONG idxMapEntry; if ( m_peccmr != NULL ) { m_peccmr->Release(); } if ( m_pcccb != NULL ) { m_pcccb->Release(); } if ( m_pccci != NULL ) { m_pccci->Release(); } if ( m_rgpResources != NULL ) { while ( m_cAllocedResources != 0 ) { m_cAllocedResources --; if ( m_rgpResources[ m_cAllocedResources ] != NULL ) { delete m_rgpResources[ m_cAllocedResources ]; } } TraceFree( m_rgpResources ); } if ( m_hCluster != NULL ) { CloseCluster( m_hCluster ); } // Free the resource type GUID to name map entries for ( idxMapEntry = 0; idxMapEntry < m_idxNextMapEntry; ++idxMapEntry ) { delete m_pgnResTypeGUIDNameMap[ idxMapEntry ].m_pszTypeName; } // for: iterate through the map, freeing each entry // Free the map itself. delete [] m_pgnResTypeGUIDNameMap; TraceSysFreeString( m_bstrNodeName ); InterlockedDecrement( &g_cObjects ); TraceFuncExit(); } // ~CPostCfgManager() // ************************************************************************ // // IUnknown // // ************************************************************************ ////////////////////////////////////////////////////////////////////////////// // // STDMETHODIMP // CPostCfgManager::QueryInterface( // REFIID riid, // LPVOID *ppv // ) // ////////////////////////////////////////////////////////////////////////////// STDMETHODIMP CPostCfgManager::QueryInterface( REFIID riid, LPVOID *ppv ) { TraceQIFunc( riid, ppv ); HRESULT hr = E_NOINTERFACE; if ( IsEqualIID( riid, IID_IUnknown ) ) { *ppv = static_cast< IPostCfgManager * >( this ); hr = S_OK; } // if: IUnknown else if ( IsEqualIID( riid, IID_IPostCfgManager ) ) { *ppv = TraceInterface( __THISCLASS__, IPostCfgManager, this, 0 ); hr = S_OK; } // else if: IPostCfgManager else if ( IsEqualIID( riid, IID_IClusCfgInitialize ) ) { *ppv = TraceInterface( __THISCLASS__, IClusCfgInitialize, this, 0 ); hr = S_OK; } // else if: IClusCfgInitialize else if ( IsEqualIID( riid, IID_IClusCfgCallback ) ) { *ppv = TraceInterface( __THISCLASS__, IClusCfgCallback, this, 0 ); hr = S_OK; } // else if: IClusCfgInitialize if ( SUCCEEDED( hr ) ) { ((IUnknown*) *ppv)->AddRef(); } // if: success QIRETURN( hr, riid ); } // QueryInterface() ////////////////////////////////////////////////////////////////////////////// // // STDMETHODIMP_(ULONG) // CPostCfgManager::AddRef( void ) // ////////////////////////////////////////////////////////////////////////////// STDMETHODIMP_(ULONG) CPostCfgManager::AddRef( void ) { TraceFunc( "[IUnknown]" ); m_cRef++; // apartment object RETURN( m_cRef ); } // AddRef() ////////////////////////////////////////////////////////////////////////////// // // STDMETHODIMP_(ULONG) // CPostCfgManager::Release( void ) // ////////////////////////////////////////////////////////////////////////////// STDMETHODIMP_(ULONG) CPostCfgManager::Release( void ) { TraceFunc( "[IUnknown]" ); m_cRef--; // apartment object if ( m_cRef ) RETURN( m_cRef ); TraceDo( delete this ); RETURN(0); } // Release() //**************************************************************************** // // IClusCfgInitialize // //**************************************************************************** ///////////////////////////////////////////////////////////////////////////// //++ // // CPostCfgManager::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 CPostCfgManager::Initialize( IUnknown * punkCallbackIn , LCID lcidIn ) { TraceFunc( "[IClusCfgInitialize]" ); HRESULT hr = S_OK; IClusCfgCallback * pcccb = NULL; if ( punkCallbackIn != NULL ) { hr = THR( punkCallbackIn->TypeSafeQI( IClusCfgCallback, &pcccb ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_Initialize_QI, hr, L"" ); goto Cleanup; } } m_lcid = lcidIn; // Release any previous callback. if ( m_pcccb != NULL ) { m_pcccb->Release(); } // Give ownership away m_pcccb = pcccb; pcccb = NULL; #if defined(DEBUG) if ( m_pcccb != NULL ) { m_pcccb = TraceInterface( L"CPostCfgManager!IClusCfgCallback", IClusCfgCallback, m_pcccb, 1 ); } #endif // DEBUG Cleanup: if ( pcccb != NULL ) { pcccb->Release(); } HRETURN( hr ); } //*** CPostCfgManager::Initialize() //**************************************************************************** // // IPostCfgManager // //**************************************************************************** ////////////////////////////////////////////////////////////////////////////// // // STDMETHODIMP // CPostCfgManager::CommitChanges( // IEnumClusCfgManagedResources * peccmrIn, // IClusCfgClusterInfo * pccciIn // ) // ////////////////////////////////////////////////////////////////////////////// STDMETHODIMP CPostCfgManager::CommitChanges( IEnumClusCfgManagedResources * peccmrIn, IClusCfgClusterInfo * pccciIn ) { TraceFunc( "[IPostCfgManager]" ); HRESULT hr; DWORD dw; IClusCfgResTypeServicesInitialize * pccrtsiResTypeServicesInit = NULL; // Validate parameters Assert( peccmrIn != NULL ); Assert( pccciIn != NULL ); // // Grab our interfaces. // if ( m_peccmr != NULL ) { m_peccmr->Release(); } hr = THR( peccmrIn->TypeSafeQI( IEnumClusCfgManagedResources, &m_peccmr ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_QI_Resources, hr, L"" ); goto Cleanup; } if ( m_pccci != NULL ) { m_pccci->Release(); } hr = THR( pccciIn->TypeSafeQI( IClusCfgClusterInfo, &m_pccci ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_QI_ClusterInfo, hr, L"" ); goto Cleanup; } // // Are we creating, adding nodes, or have we been evicted? // hr = STHR( pccciIn->GetCommitMode( &m_ecmCommitChangesMode ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_GetCommitMode, hr, L"" ); goto Cleanup; } // // Create an instance of the resource type services component // hr = THR( CoCreateInstance( CLSID_ClusCfgResTypeServices , NULL , CLSCTX_INPROC_SERVER , __uuidof( pccrtsiResTypeServicesInit ) , reinterpret_cast< void ** >( &pccrtsiResTypeServicesInit ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_CoCreate_ResTypeService, hr, L"[PostCfg] Error occurred trying to create the resource type services component" ); goto Cleanup; } // if: we could not create the resource type services component // Initialize the resource type services component. hr = THR( pccrtsiResTypeServicesInit->SetParameters( m_pccci ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_SetParameters, hr, L"[PostCfg] Error occurred trying to initialize the resource type services component." ); goto Cleanup; } // if: we could not initialize the resource type services component if ( ( m_ecmCommitChangesMode == cmCREATE_CLUSTER ) || ( m_ecmCommitChangesMode == cmADD_NODE_TO_CLUSTER ) ) { // // Make sure we have all we need to be successful! // if ( m_hCluster == NULL ) { m_hCluster = OpenCluster( NULL ); if ( m_hCluster == NULL ) { dw = GetLastError(); hr = HRESULT_FROM_WIN32( TW32( dw ) ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CommitChanges_OpenCluster, hr, L"[PostCfg] Failed to get cluster handle. Aborting." ); goto Cleanup; } } // // Configure resource types. // hr = THR( HrConfigureResTypes( pccrtsiResTypeServicesInit ) ); if ( FAILED( hr ) ) goto Cleanup; // // Create the resource instances. // hr = THR( HrPreCreateResources() ); if ( FAILED( hr ) ) goto Cleanup; hr = THR( HrCreateGroups() ); if ( FAILED( hr ) ) { // // MUSTDO: gpease 28-SEP-2000 // For Beta1 will we ignore errors in group creation // and abort the process. // hr = S_OK; goto Cleanup; } hr = THR( HrCreateResources() ); if ( FAILED( hr ) ) goto Cleanup; hr = THR( HrPostCreateResources() ); if ( FAILED( hr ) ) goto Cleanup; // // Notify any components registered on this computer, of a cluster // member set change ( form, join or evict ). // hr = THR( HrNotifyMemberSetChangeListeners() ); if ( FAILED( hr ) ) goto Cleanup; } // if: we are forming or joining else if ( m_ecmCommitChangesMode == cmCLEANUP_NODE_AFTER_EVICT ) { // // Notify any components registered on this computer, of a cluster // member set change ( form, join or evict ). // hr = THR( HrNotifyMemberSetChangeListeners() ); if ( FAILED( hr ) ) goto Cleanup; // ISSUE MUSTDO: Decide if we need to add evict processing for managed resources here. ( 03-AUG-2000 Vij Vasu ) // // Configure resource types. // hr = THR( HrConfigureResTypes( pccrtsiResTypeServicesInit ) ); if ( FAILED( hr ) ) goto Cleanup; } // else if: we have just been evicted Cleanup: if ( pccrtsiResTypeServicesInit != NULL ) { pccrtsiResTypeServicesInit->Release(); } // if: we had created the resource type services component HRETURN( hr ); } // CommitChanges() //**************************************************************************** // // IClusCfgCallback // //**************************************************************************** STDMETHODIMP CPostCfgManager::SendStatusReport( LPCWSTR pcszNodeNameIn , CLSID clsidTaskMajorIn , CLSID clsidTaskMinorIn , ULONG ulMinIn , ULONG ulMaxIn , ULONG ulCurrentIn , HRESULT hrStatusIn , LPCWSTR pcszDescriptionIn , FILETIME * pftTimeIn , LPCWSTR pcszReferenceIn ) { TraceFunc( "[IClusCfgCallback]" ); HRESULT hr = S_OK; FILETIME ft; if ( pftTimeIn == NULL ) { GetSystemTimeAsFileTime( &ft ); pftTimeIn = &ft; } // if: if ( m_pcccb != NULL ) { hr = STHR( m_pcccb->SendStatusReport( pcszNodeNameIn != NULL ? pcszNodeNameIn : m_bstrNodeName, clsidTaskMajorIn, clsidTaskMinorIn, ulMinIn, ulMaxIn, ulCurrentIn, hrStatusIn, pcszDescriptionIn, pftTimeIn, pcszReferenceIn ) ); } HRETURN( hr ); } // SendStatusReport() //**************************************************************************** // // Private methods // //**************************************************************************** ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrPreCreateResources( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrPreCreateResources( void ) { TraceFunc( "" ); CResourceEntry * presentry; HRESULT hr = E_UNEXPECTED; BSTR bstrName = NULL; BSTR bstrNotification = NULL; IClusCfgManagedResourceInfo * pccmri = NULL; IClusCfgManagedResourceCfg * pccmrc = NULL; IUnknown * punkServices = NULL; IPrivatePostCfgResource * ppcr = NULL; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); LogMsg( "PostCfg: Starting pre-create..." ); hr = THR( HrPreInitializeExistingResources() ); if ( FAILED( hr ) ) goto Cleanup; // // Make sure the enumer is in the state we think it is. // hr = STHR( m_peccmr->Reset() ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_Reset, hr, L"" ); goto Cleanup; } hr = THR( CPreCreateServices::S_HrCreateInstance( &punkServices ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_CPreCreateServices, hr, L"[PreCreate] Failed to create services object. Aborting." ); goto Cleanup; } hr = THR( punkServices->TypeSafeQI( IPrivatePostCfgResource, &ppcr ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_CPreCreateServices_QI, hr, L"[PreCreate] Failed to create services object. Aborting." ); goto Cleanup; } // // Update the UI layer. // hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_QUERYING_FOR_RESOURCE_DEPENDENCIES, &bstrNotification ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_LoadString_Querying, hr, L"" ); goto Cleanup; } hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Querying_For_Resource_Dependencies, 0, 5, 0, S_OK, bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // // Loop thru the resources, requesting the resources to PreCreate() // themselves. This will cause the resources to callback into the // services object and store class type and resource type information // as well as any required dependencies the resource might have. // for( ;; ) { // // Cleanup. We put this here because of error conditions below. // TraceSysFreeString( bstrName ); bstrName = NULL; if ( pccmri != NULL ) { pccmri->Release(); pccmri = NULL; } if ( pccmrc != NULL ) { pccmrc->Release(); pccmrc = NULL; } // // Ask to get the next resource. // hr = STHR( m_peccmr->Next( 1, &pccmri, NULL ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_Next, hr, L"[PreCreate] Getting next managed resource failed. Aborting." ); goto Cleanup; } if ( hr == S_FALSE ) { break; // exit loop } // // Retrieve its name for logging, etc. We will ultimately store this in the // resource entry to be reused (ownership will be transferred). // hr = THR( pccmri->GetName( &bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_GetName, hr, L"[PreCreate] Failed to retrieve a resource's name. Skipping." ); continue; } // // Check to see if the resource wants to be managed or not. // hr = STHR( pccmri->IsManaged() ); if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_IsManaged, hr, L"[PreCreate] %1!ws!: Failed determine if it is to be managed. Skipping.", bstrNotification, bstrName ); continue; } if ( hr == S_FALSE ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_IsManaged_False, hr, L"[PreCreate] %1!ws!: Resource does not want to be managed. Skipping.", bstrNotification, bstrName ); continue; } /* hr = STHR( HrIsLocalQuorum( bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_IsLocalQuorum, hr, L"Error occured trying to determine if the resource was the local quorum resource.", bstrNotification, bstrName ); continue; } // if: // // Ignore the local quorum resource since it is special and won't need its own group. // if ( hr == S_OK ) { continue; } // if: */ // // Get the config interface for this resource (if any). // hr = THR( pccmri->TypeSafeQI( IClusCfgManagedResourceCfg, &pccmrc ) ); if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_EnumResources_QI_pccmrc, hr, L"[PreCreate] %1!ws!: Failed QI for IClusCfgManagedResourceCfg. Skipping.", bstrNotification, bstrName ); continue; } // // Grow the resource list if nessecary. // if ( m_cResources == m_cAllocedResources ) { ULONG idxNewCount = m_cAllocedResources + RESOURCE_INCREMENT; CResourceEntry ** plistNew; plistNew = (CResourceEntry **) TraceAlloc( 0, sizeof( CResourceEntry *) * idxNewCount ); if ( plistNew == NULL ) goto OutOfMemory; CopyMemory( plistNew, m_rgpResources, sizeof(CResourceEntry *) * m_cAllocedResources ); TraceFree( m_rgpResources ); m_rgpResources = plistNew; for ( ; m_cAllocedResources < idxNewCount; m_cAllocedResources ++ ) { m_rgpResources[ m_cAllocedResources ] = new CResourceEntry(); if ( m_rgpResources[ m_cAllocedResources ] == NULL ) goto OutOfMemory; } } // // Check to see if this resource is the quorum resource. If it is, point the services // object to the quorum resource entry (m_idxQuorumResource). // hr = STHR( pccmri->IsQuorumDevice() ); if ( hr == S_OK ) { presentry = m_rgpResources[ m_idxQuorumResource ]; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_PreCreate_EnumResources_IsQuorumDevice_S_OK, hr, L"[PreCreate] %1!ws!: Setting this resource to be the quorum device.", bstrNotification, bstrName ); // // We need to release the previous quorum's resource handle. // THR( presentry->SetHResource( NULL ) ); // We don't care if this fails... we'll overwrite it later. // Set the quorum changed flag here. m_isQuorumChanged = true; } else { presentry = m_rgpResources[ m_cResources ]; if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_PreCreate_EnumResources_IsQuorumDevice_Failed , hr , L"" ); } } // // Setup the new entry. // hr = THR( presentry->SetAssociatedResource( pccmrc ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_PreCreate_EnumResources_SetAssociatedResouce , hr , L"" ); continue; } hr = THR( presentry->SetName( bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_PreCreate_EnumResources_SetName, hr, L"" ); continue; } // We gave ownership away when we called SetName() above. bstrName = NULL; // // Point the PreCreate services to the resource entry. // hr = THR( ppcr->SetEntry( presentry ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_PreCreate_EnumResources_SetEntry, hr, L"" ); continue; } // // Ask the resource to configure itself. Every resource that wants to be // created in the default cluster must implement PreCreate(). Those that // return E_NOTIMPL will be ignored. // // Don't wrap - this can fail with E_NOTIMPL. hr = pccmrc->PreCreate( punkServices ); if ( FAILED( hr ) ) { if ( hr == E_NOTIMPL ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_PreCreate_E_NOTIMPL, hr, L"[PreCreate] %1!ws!: Failed. Resource returned E_NOTIMPL. This resource will not be created. Skipping.", bstrNotification, bstrName ); } else { HRESULT hrStored = MAKE_HRESULT( 0, HRESULT_FACILITY( hr ), HRESULT_CODE( hr ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_Resource_Failed_PreCreate, hr, L"%1!ws! failed PreCreate( ).", bstrNotification, bstrName ); hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_RESOURCE_FAILED_PRECREATE, &bstrNotification ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_PreCreate_LoadString_Resource_Failed , hr , L"" ); goto Cleanup; } hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Resource_Failed_PreCreate, 0, 1, 1, hrStored, bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure } continue; } if ( presentry != m_rgpResources[ m_idxQuorumResource ] ) { m_cResources ++; } SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_Succeeded, hr, L"[PreCreate] %1!ws!: Succeeded.", bstrNotification, bstrName ); } // for: ever SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PreCreate_Finished, hr, L"[PreCreate] Finished.", bstrNotification, bstrName ); #if defined(DEBUG) // DebugDumpDepencyTree(); #endif hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Querying_For_Resource_Dependencies, 0, 5, 5, S_OK, NULL, // don't need to update string NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure hr = S_OK; Cleanup: TraceSysFreeString( bstrNotification ); TraceSysFreeString( bstrName ); if ( pccmri != NULL ) { pccmri->Release(); } if ( pccmrc != NULL ) { pccmrc->Release(); } if ( punkServices != NULL ) { punkServices->Release(); } if ( ppcr != NULL ) { ppcr->Release(); } HRETURN( hr ); OutOfMemory: LogMsg( "PostCfg: Out of memory. Aborting." ); hr = THR( E_OUTOFMEMORY ); goto Cleanup; } // HrPreCreateResources() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrCreateGroups( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrCreateGroups( void ) { TraceFunc( "" ); DWORD dwTypeDummy; DWORD dwStatus; WCHAR szGroupName[ 128 ]; ULONG cchGroupName; ULONG cGroup; HGROUP hGroup = NULL; CGroupHandle * pgh = NULL; ULONG idxResource; ULONG idxMatchDepedency; ULONG idxMatchResource; const CLSID * pclsidType; const CLSID * pclsidClassType; EDependencyFlags dfFlags; CResourceEntry * presentry; HRESULT hr = E_UNEXPECTED; HCLUSENUM hClusEnum = NULL; BSTR bstrGroupName = NULL; BSTR bstrNotification = NULL; BSTR bstrClusterNameGroup = NULL; DWORD sc; HRESOURCE hClusterNameResource = NULL; CLUSTER_RESOURCE_STATE crs; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); Assert( m_idxLastStorage == 0 ); m_idxLastStorage = m_idxQuorumResource; // // Phase 1: Figure out the dependency tree. // hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Begin , hr , L"[Grouping] Figuring out dependency tree to determine grouping." ); for ( idxResource = 0; idxResource < m_cResources; idxResource ++ ) { CResourceEntry * presentryResource = m_rgpResources[ idxResource ]; ULONG cDependencies; hr = THR( presentryResource->GetCountOfTypeDependencies( &cDependencies ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetCountOfTypeDependencies , hr , L"" ); continue; } for ( idxMatchDepedency = 0; idxMatchDepedency < cDependencies; idxMatchDepedency ++ ) { BOOL fFoundMatch = FALSE; const CLSID * pclsidMatchType; EDependencyFlags dfMatchFlags; hr = THR( presentryResource->GetTypeDependencyPtr( idxMatchDepedency, &pclsidMatchType, &dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_GetTypeDependencyPtr, hr, L"" ); continue; } // // See if it is one of the "well known" types. // // // We special case storage class device because we want to spread as many // resources across as many storage devices as possible. This helps prevent // the ganging of resources into one large group. // if ( *pclsidMatchType == RESCLASSTYPE_StorageDevice ) { // // The below THR may fire in certain configurations. Please validate // the configuration before removing the THR. // // If it returns E_FAIL, we should fall thru and attempt "normal" // resource negociations. // hr = THR( HrAttemptToAssignStorageToResource( idxResource, dfMatchFlags ) ); if ( SUCCEEDED( hr ) ) { fFoundMatch = TRUE; } else if ( FAILED( hr ) ) { if ( hr != E_FAIL ) { goto Cleanup; } } } else if ( *pclsidMatchType == RESCLASSTYPE_NetworkName ) { BSTR bstrName = NULL; hr = THR( HrFormatStringIntoBSTR( g_hInstance, IDS_NETNAMEFORMAT, &bstrName, m_cNetName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_FormatString_NetName, hr, L"[Grouping] Failed to create name for net name resource. Aborting." ); goto Cleanup; } hr = THR( HrAddSpecialResource( bstrName, &RESTYPE_NetworkName, &RESCLASSTYPE_NetworkName ) ); if ( FAILED( hr ) ) continue; presentry = m_rgpResources[ m_cResources - 1 ]; // Net name depends on an IP address. hr = THR( presentry->AddTypeDependency( &RESCLASSTYPE_IPAddress, dfSHARED ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_AddTypeDependency , hr , L"" ); continue; } fFoundMatch = TRUE; } else if ( *pclsidMatchType == RESCLASSTYPE_IPAddress ) { BSTR bstrName = NULL; hr = THR( HrFormatStringIntoBSTR( g_hInstance, IDS_IPADDRESSFORMAT, &bstrName, FIRST_IPADDRESS( m_cIPAddress ), SECOND_IPADDRESS( m_cIPAddress ), THIRD_IPADDRESS( m_cIPAddress ), FOURTH_IPADDRESS( m_cIPAddress ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_FormatString_IPAddress, hr, L"[Grouping] Failed to create name for IP address resource. Aborting." ); goto Cleanup; } hr = THR( HrAddSpecialResource( bstrName, &RESTYPE_IPAddress, &RESCLASSTYPE_IPAddress ) ); if ( FAILED( hr ) ) continue; m_cIPAddress ++; fFoundMatch = TRUE; } else if ( *pclsidMatchType == RESTYPE_ClusterNetName ) { presentry = m_rgpResources[ m_idxClusterName ]; hr = THR( presentry->AddDependent( idxResource, dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_NetName_AddDependent , hr , L"" ); continue; } fFoundMatch = TRUE; } else if ( *pclsidMatchType == RESTYPE_ClusterIPAddress ) { presentry = m_rgpResources[ m_idxIPAddress ]; hr = THR( presentry->AddDependent( idxResource, dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_IPAddress_AddDependent , hr , L"" ); continue; } fFoundMatch = TRUE; } else if ( *pclsidMatchType == RESTYPE_ClusterQuorumDisk ) { presentry = m_rgpResources[ m_idxQuorumResource ]; hr = THR( presentry->AddDependent( idxResource, dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_QuorumDisk_AddDependent , hr , L"" ); continue; } fFoundMatch = TRUE; } // // Check out the resources to see if it matches any of them. // if ( !fFoundMatch ) { // // We can always start at the quorum resource because the resource with indexes // below that are handled in the special case code above. // for ( idxMatchResource = m_idxQuorumResource; idxMatchResource < m_cResources; idxMatchResource ++ ) { presentry = m_rgpResources[ idxMatchResource ]; hr = THR( presentry->GetTypePtr( &pclsidType ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetTypePtr , hr , L"" ); continue; } hr = THR( presentry->GetClassTypePtr( &pclsidClassType ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetClassTypePtr , hr , L"" ); continue; } hr = THR( presentry->GetFlags( &dfFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetFlags , hr , L"" ); continue; } // // Try matching it to the resource type. // if ( *pclsidType == *pclsidMatchType || *pclsidClassType == *pclsidMatchType ) { if ( ! ( dfFlags & dfEXCLUSIVE ) || ( ( dfFlags & dfSHARED ) && ( dfMatchFlags & dfSHARED ) ) ) { hr = THR( presentry->SetFlags( dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_SetFlags , hr , L"" ); continue; } hr = THR( presentry->AddDependent( idxResource, dfMatchFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Resource_AddDependent , hr , L"" ); continue; } fFoundMatch = TRUE; break; // exit loop } } } // for: idxMatchResource } // if: not fFoundMatch // // If we didn't match the dependency, unmark the resource from being managed. // if ( !fFoundMatch ) { BSTR bstrName; IClusCfgManagedResourceInfo * pccmri; IClusCfgManagedResourceCfg * pccmrc; // // KB: gpease 17-JUN-2000 // No need to free bstrName because the resource entry controls // the lifetime - we're just borrowing it. // hr = THR( presentryResource->GetName( &bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetName , hr , L"" ); continue; } hr = S_FALSE; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_MissingDependent, hr, L"[Grouping] %1!ws!: Missing dependent resource. This resource will not be configured.", bstrNotification, bstrName ); hr = THR( presentryResource->GetAssociatedResource( &pccmrc ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetAssociateResource , hr , L"" ); continue; } hr = THR( pccmrc->TypeSafeQI( IClusCfgManagedResourceInfo, &pccmri ) ); pccmrc->Release(); // release promptly. if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_QI_pccmri, hr, L"[Grouping] %1!ws!: Resource failed to QI for IClusCfgManagedResourceInfo.", bstrNotification, bstrName ); continue; } hr = THR( pccmri->SetManaged( FALSE ) ); pccmri->Release(); // release promptly. if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_SetManaged, hr, L"[Grouping] %1!ws!: Resource failed SetManaged( FALSE ).", bstrNotification, bstrName ); } } } // for: idxDepedency } // for: idxResource #if defined(DEBUG) // DebugDumpDepencyTree(); #endif hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Creating , hr , L"[Grouping] Creating groups." ); sc = TW32( ResUtilGetCoreClusterResources( m_hCluster, &hClusterNameResource, NULL, NULL ) ); if ( sc != ERROR_SUCCESS ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Get_ClusterNameGroup , hr , L"[Grouping] Failed to get cluster name group handle. Aborting." ); goto Cleanup; } hr = THR( HrGetClusterResourceState( hClusterNameResource, NULL, &bstrClusterNameGroup, NULL ) ); if ( FAILED( hr ) ) { goto Cleanup; } // if: hGroup = OpenClusterGroup( m_hCluster, bstrClusterNameGroup ); if ( hGroup == NULL ) { hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_OpenClusterGroup, hr, L"[Grouping] Failed OpenClusterGroup('%1!ws!'). Aborting.", bstrNotification, bstrClusterNameGroup ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Open_ClusterGroup , hr , L"[Grouping] Failed to open cluster name group. Aborting." ); goto Cleanup; } // // Wrap it up and give ownership away. // hr = THR( CGroupHandle::S_HrCreateInstance( &pgh, hGroup ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Create_CGroupHandle , hr , L"" ); goto Cleanup; } hGroup = NULL; // // Set all the entries in the 'Cluster Name Group' to the group. // for ( idxResource = 0; idxResource <= m_idxQuorumResource; idxResource ++ ) { hr = THR( HrSetGroupOnResourceAndItsDependents( idxResource, pgh ) ); if ( FAILED( hr ) ) continue; } // for: idxResource // // Loop thru the resources looking for groups. // cGroup = 0; for ( idxResource = m_idxQuorumResource + 1; idxResource < m_cResources; idxResource ++ ) { CResourceEntry * presentryResource = m_rgpResources[ idxResource ]; ULONG cDependencies; if ( pgh != NULL ) { pgh->Release(); pgh = NULL; } hr = THR( presentryResource->GetCountOfTypeDependencies( &cDependencies ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_GetCountOfTypeDependencies2 , hr , L"" ); continue; } // // Don't consider resources that have indicated that the depend on // somebody else. // if ( cDependencies != 0 ) continue; // // See if any of the dependent resource has already has a group assigned // to it. This allows for multiple roots to be combined into a single // group due to lower dependencies. // // Don't create a group for the local quoum resource! hr = STHR( HrFindGroupFromResourceOrItsDependents( idxResource, &pgh ) ); if ( FAILED( hr ) ) continue; if ( hr == S_FALSE ) { // // We need to create a new group. // // // Create a name for our group. // for( ;; ) { hr = THR( HrFormatStringIntoBSTR( g_hInstance, IDS_GROUP_X, &bstrGroupName, cGroup ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_FormatString_Group, hr, L"[Grouping] Failed to create group name. Aborting." ); goto Cleanup; } // // Create the group in the cluster. // hGroup = CreateClusterGroup( m_hCluster, bstrGroupName ); if ( hGroup == NULL ) { dwStatus = GetLastError(); switch ( dwStatus ) { case ERROR_OBJECT_ALREADY_EXISTS: cGroup ++; break; // keep looping default: hr = HRESULT_FROM_WIN32( TW32( dwStatus ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_CreateClusterGroup, hr, L"[Grouping] %1!ws!: Failed to create group. Aborting.", bstrNotification, bstrGroupName ); goto Cleanup; } } else { break; } } // // Bring the group online to set its persistent state to Online. // dwStatus = TW32( OnlineClusterGroup( hGroup, NULL ) ); if ( dwStatus != ERROR_SUCCESS ) { hr = HRESULT_FROM_WIN32( dwStatus ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_OnlineClusterGroup, hr, L"[Grouping] %1!ws!: Failed to bring group online. Aborting.", bstrNotification, bstrGroupName ); goto Cleanup; } // // Wrap the handle for ref counting. // hr = THR( CGroupHandle::S_HrCreateInstance( &pgh, hGroup ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateGroups_Create_CGroupHandle2 , hr , L"" ); goto Cleanup; } hGroup = NULL; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_Created, hr, L"[Grouping] %1!ws!: Group created.", bstrNotification, bstrGroupName ); cGroup ++; } hr = THR( HrSetGroupOnResourceAndItsDependents( idxResource, pgh ) ); if ( FAILED( hr ) ) continue; } // for: idxResource hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateGroups_Finished, hr, L"[Grouping] Finished." ); #if defined(DEBUG) // DebugDumpDepencyTree(); #endif Cleanup: if ( hClusterNameResource != NULL ) { CloseClusterResource( hClusterNameResource ); } // if: TraceSysFreeString( bstrNotification ); TraceSysFreeString( bstrGroupName ); TraceSysFreeString( bstrClusterNameGroup ); if ( hClusEnum != NULL ) { TW32( ClusterCloseEnum( hClusEnum ) ); } if ( hGroup != NULL ) { BOOL fRet = CloseClusterGroup( hGroup ); Assert( fRet ); } if ( pgh != NULL ) { pgh->Release(); } HRETURN( hr ); } // HrCreateGroups() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrCreateResources( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrCreateResources( void ) { TraceFunc( "" ); BSTR bstrName; // don't free! ULONG idxResource; HRESULT hr; BSTR bstrNotification = NULL; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); // // Make a message using the name. // hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_CREATING_RESOURCE, &bstrNotification ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_CreateResources_LoadString_Creating , hr , L"" ); goto Cleanup; } // // Tell the UI what we are doing. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Creating_Resource, 0, m_cResources, // KB: this was multiplied by 4; should it be? 0, S_OK, bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // // TODO: gpease 24-AUG-2000 // What to do if we have a failure?? For now I think we should keep going! // hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateResources_Starting, hr, L"[Create] Starting..." ); for ( idxResource = m_idxQuorumResource; idxResource < m_cResources; idxResource ++ ) { hr = THR( HrCreateResourceAndDependents( idxResource ) ); if ( FAILED( hr ) ) continue; } // for: idxResource hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_CreateResources_Finished, hr, L"[Create] Finished." ); // // Tell the UI what we are doing. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Creating_Resource, 0, m_cResources, // KB: once these were multiplied by 4. Should they be? m_cResources, S_OK, NULL, NULL, NULL ) ); // // TODO: gpease 24-AUG-2000 // What to do if we have a failure?? For now I think we should keep going! // Cleanup: TraceSysFreeString( bstrNotification ); HRETURN( hr ); } // HrCreateResources() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrPostCreateResources( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrPostCreateResources( void ) { TraceFunc( "" ); HRESULT hr; ULONG idxResource; BSTR bstrNotification = NULL; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); // // Tell the UI what's going on. // hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_STARTING_RESOURCES, &bstrNotification ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_PostCreateResources_LoadString_Starting , hr , L"" ); goto Cleanup; } hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Starting_Resources, 0, m_cResources, 0, S_OK, bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // // TODO: gpease 24-AUG-2000 // What to do if we have a failure?? For now I think we should keep going! // hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PostCreateResources_Starting, hr, L"[PostCreate] Starting..." ); // // Reset the configure flag on every resource. // for( idxResource = 0; idxResource < m_cResources ; idxResource ++ ) { hr = THR( m_rgpResources[ idxResource ]->SetConfigured( FALSE ) ); if ( FAILED( hr ) ) continue; } // for: idxResource // // Loop thru the resource calling PostCreate(). // for( idxResource = 0; idxResource < m_cResources ; idxResource ++ ) { hr = THR( HrPostCreateResourceAndDependents( idxResource ) ); if ( FAILED( hr ) ) continue; } // for: ever hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_PostCreateResources_Finished, hr, L"[PostCreate] Finished." ); hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Starting_Resources, 0, m_cResources, // KB: once these were multiplied by 4; should they be? m_cResources, S_OK, NULL, // don't need to change text NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure Cleanup: TraceSysFreeString( bstrNotification ); HRETURN( hr ); } // HrPostCreateResources() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrFindNextSharedStorage( // ULONG idxSeedIn, // ULONG * pidxOut // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrFindNextSharedStorage( ULONG * pidxInout ) { TraceFunc( "" ); HRESULT hr; ULONG idxNextDiskResource; const CLSID * pclsidClassType; CResourceEntry * presentry; EDependencyFlags dfFlags; BOOL fFirstPass = TRUE; Assert( pidxInout != NULL ); for( idxNextDiskResource = *pidxInout + 1 ; fFirstPass && idxNextDiskResource != *pidxInout ; idxNextDiskResource ++ ) { if ( idxNextDiskResource >= m_cResources ) { fFirstPass = FALSE; idxNextDiskResource = m_idxQuorumResource; } presentry = m_rgpResources[ idxNextDiskResource ]; hr = THR( presentry->GetClassTypePtr( &pclsidClassType ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_FindNextSharedStorage_GetClassTypePtr , hr , L"" ); continue; } // Skip non-storage class devices if ( *pclsidClassType != RESCLASSTYPE_StorageDevice ) continue; hr = THR( presentry->GetFlags( &dfFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_FindNextSharedStorage_GetFlags , hr , L"" ); continue; } if ( ! ( dfFlags & dfEXCLUSIVE ) ) { *pidxInout = idxNextDiskResource; hr = S_OK; goto Cleanup; } } // for: fFirstPass && idxNextDiskResource hr = THR( E_FAIL ); Cleanup: HRETURN( hr ); } // HrFindNextSharedStorage() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrAttemptToAssignStorageToResource( // ULONG idxResource // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrAttemptToAssignStorageToResource( ULONG idxResourceIn, EDependencyFlags dfResourceFlagsIn ) { TraceFunc1( "idxResource = %u", idxResourceIn ); HRESULT hr; ULONG idxStorage; CResourceEntry * presentry; // // Find the next available shared storage resource. // idxStorage = m_idxLastStorage; hr = THR( HrFindNextSharedStorage( &idxStorage ) ); if ( FAILED( hr ) ) goto Cleanup; // // If the resource wants exclusive rights the the disk, then the quorum // resource can not be used. The quorum device must always have SHARED // access to it. // if ( ( dfResourceFlagsIn & dfEXCLUSIVE ) && ( idxStorage == m_idxQuorumResource ) ) { hr = THR( HrFindNextSharedStorage( &idxStorage ) ); if ( idxStorage == m_idxQuorumResource ) { // // There must not be anymore storage devices available for exclusive // access. Return failure. // hr = THR( E_FAIL ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrAttemptToAssignStorageToResource_NoMoreStorage, hr, L"There must not be anymore storage devices available for exclusive access." ); goto Cleanup; } } presentry = m_rgpResources[ idxStorage ]; // // Set the dependency flags. // hr = THR( presentry->SetFlags( dfResourceFlagsIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAttemptToAssignStorageToResource_SetFlags , hr , L"" ); goto Cleanup; } // // If the resource wants exclusive access to the storage resource, move // any existing SHARED dependents to another resource. There will always // be at least one SHARED resource because the quorum disk can't not be // assigned to EXCLUSIVE access. // if ( dfResourceFlagsIn & dfEXCLUSIVE ) { ULONG idxNewStorage = idxStorage; hr = THR( HrFindNextSharedStorage( &idxNewStorage ) ); if ( FAILED( hr ) ) goto Cleanup; hr = THR( HrMovedDependentsToAnotherResource( idxStorage, idxNewStorage ) ); if ( FAILED( hr ) ) goto Cleanup; } // // Add the resource as a dependent of this storage resource. // hr = THR( presentry->AddDependent( idxResourceIn, dfResourceFlagsIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAttemptToAssignStorageToResource_AddDependent , hr , L"" ); goto Cleanup; } m_idxLastStorage = idxStorage; hr = S_OK; Cleanup: HRETURN( hr ); } // HrAttemptToAssignStorageToResource() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrMovedDependentsToAnotherResource( // ULONG idxSourceIn, // ULONG idxDestIn // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrMovedDependentsToAnotherResource( ULONG idxSourceIn, ULONG idxDestIn ) { TraceFunc( "" ); HRESULT hr; ULONG cDependents; ULONG idxDependent; EDependencyFlags dfFlags; CResourceEntry * presentrySrc; CResourceEntry * presentryDst; // // Move the shared resources to another shared disk. // presentrySrc = m_rgpResources[ idxSourceIn ]; presentryDst = m_rgpResources[ idxDestIn ]; hr = THR( presentrySrc->GetCountOfDependents( &cDependents ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrMovedDependentsToAnotherResource_GetCountOfDependents , hr , L"" ); goto Cleanup; } for ( ; cDependents != 0 ; ) { cDependents --; hr = THR( presentrySrc->GetDependent( cDependents, &idxDependent, &dfFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrMovedDependentsToAnotherResource_GetDependent , hr , L"" ); goto Cleanup; } hr = THR( presentryDst->AddDependent( idxDependent, dfFlags ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrMovedDependentsToAnotherResource_AddDependent , hr , L"" ); goto Cleanup; } } // for: cDependents hr = THR( presentrySrc->ClearDependents() ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrMovedDependentsToAnotherResource_ClearDependents , hr , L"" ); goto Cleanup; } Cleanup: HRETURN( hr ); } // HrMovedDependentsToAnotherResource() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrSetGroupOnResourceAndItsDependents( // ULONG idxResourceIn, // CGroupHandle * pghIn // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrSetGroupOnResourceAndItsDependents( ULONG idxResourceIn, CGroupHandle * pghIn ) { TraceFunc1( "idxResourceIn = %u", idxResourceIn ); HRESULT hr; ULONG cDependents; ULONG idxDependent; EDependencyFlags dfDependent; CResourceEntry * presentry; presentry = m_rgpResources[ idxResourceIn ]; hr = THR( presentry->SetGroupHandle( pghIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrSetGroupOnResourceAndItsDependents_SetGroupHandle , hr , L"" ); goto Cleanup; } // // Follow the depents list. // hr = THR( presentry->GetCountOfDependents( &cDependents ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrSetGroupOnResourceAndItsDependents_GetCountOfDependents , hr , L"" ); goto Cleanup; } for ( ; cDependents != 0 ; ) { cDependents --; hr = THR( presentry->GetDependent( cDependents, &idxDependent, &dfDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrSetGroupOnResourceAndItsDependents_GetDependent , hr , L"" ); continue; } hr = THR( HrSetGroupOnResourceAndItsDependents( idxDependent, pghIn ) ); if ( FAILED( hr ) ) continue; } // for: cDependents hr = S_OK; Cleanup: HRETURN( hr ); } // HrSetGroupOnResourceAndItsDependents() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrFindGroupFromResourceOrItsDependents( // ULONG idxResourceIn, // CGroupHandle ** ppghOut // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrFindGroupFromResourceOrItsDependents( ULONG idxResourceIn, CGroupHandle ** ppghOut ) { TraceFunc1( "idxResourceIn = %u", idxResourceIn ); HRESULT hr; ULONG cDependents; ULONG idxDependent; BSTR bstrName; // don't free BSTR bstrGroup = NULL; HRESOURCE hResource; HRESOURCE hResourceToClose = NULL; HGROUP hGroup = NULL; EDependencyFlags dfDependent; CResourceEntry * presentry; BSTR bstrNotification = NULL; Assert( ppghOut != NULL ); presentry = m_rgpResources[ idxResourceIn ]; // // See if we already have a cached version of the group handle. // hr = THR( presentry->GetGroupHandle( ppghOut) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrFindGroupFromResourceOrItsDependents_GetGroupHandle, hr, L"GetGroupHandle failed." ); goto Cleanup; } if ( hr == S_OK && *ppghOut != NULL ) goto Cleanup; // // Else, see if we can located an existing resource and group. // // don't wrap - this can fail with H_R_W32( ERROR_INVALID_DATA ) hr = presentry->GetHResource( &hResource ); if ( FAILED( hr ) ) { Assert( hr == HRESULT_FROM_WIN32( ERROR_INVALID_DATA ) ); Assert( hResource == NULL ); // Just borrowing it's name.... don't free hr = THR( presentry->GetName( &bstrName ) ); if ( hr == S_OK ) { hResourceToClose = OpenClusterResource( m_hCluster, bstrName ); hResource = hResourceToClose; } } if ( hResource != NULL ) { CLUSTER_RESOURCE_STATE crs; DWORD cbGroup = 200; ReAllocGroupName: bstrGroup = TraceSysAllocStringLen( NULL, cbGroup ); if ( bstrGroup == NULL ) goto OutOfMemory; crs = GetClusterResourceState( hResource, NULL, NULL, bstrGroup, &cbGroup ); if ( crs != ClusterResourceStateUnknown ) { hGroup = OpenClusterGroup( m_hCluster, bstrGroup ); if ( hGroup != NULL ) { hr = THR( CGroupHandle::S_HrCreateInstance( ppghOut, hGroup ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrFindGroupFromResourceOrItsDependents_Create_CGroupHandle, hr, L"" ); goto Cleanup; } hGroup = NULL; // gave ownership away above goto Cleanup; } else { hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrFindGroupFromResourceOrItsDependents_OpenClusterGroup, hr, L"[Grouping] %1!ws!: OpenClusterGroup() failed. Aborting.", bstrNotification, bstrGroup ); goto Cleanup; } } else { DWORD dwErr = GetLastError(); switch ( dwErr ) { case ERROR_MORE_DATA: cbGroup += sizeof(WCHAR); // add terminating NULL TraceSysFreeString( bstrGroup ); goto ReAllocGroupName; default: hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrFindGroupFromResourceOrItsDependents_GetClusterResourceState, hr, L"[Grouping] %1!ws!: GetClusterResourceState( ) failed. Aborting.", bstrNotification, bstrName ); goto Cleanup; } } } // else the resource might not exist... continue.... // // Follow the depents list. // hr = THR( presentry->GetCountOfDependents( &cDependents ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrFindGroupFromResourceOrItsDependents_GetCountOfDependents , hr , L"" ); goto Cleanup; } for ( ; cDependents != 0 ; ) { cDependents --; hr = THR( presentry->GetDependent( cDependents, &idxDependent, &dfDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrFindGroupFromResourceOrItsDependents_GetDependent , hr , L"" ); goto Cleanup; } hr = STHR( HrFindGroupFromResourceOrItsDependents( idxDependent, ppghOut) ); if ( FAILED( hr ) ) goto Cleanup; if ( hr == S_OK && *ppghOut != NULL ) goto Cleanup; } // for: cDependents // // Failed to find an existing group. // hr = S_FALSE; *ppghOut = NULL; Cleanup: if ( hResourceToClose != NULL ) { CloseClusterResource( hResourceToClose ); } if ( hGroup != NULL ) { CloseClusterGroup( hGroup ); } TraceSysFreeString( bstrGroup ); TraceSysFreeString( bstrNotification ); HRETURN( hr ); OutOfMemory: hr = E_OUTOFMEMORY; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrFindGroupFromResourceOrItsDependents_OutOfMemory, hr, L"Out of Memory." ); goto Cleanup; } // HrFindGroupFromResourceOrItsDependents() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrCreateResourceAndDependents( // ULONG idxResourceIn // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrCreateResourceAndDependents( ULONG idxResourceIn ) { TraceFunc1( "idxResourceIn = %u", idxResourceIn ); HRESULT hr; BSTR bstrName; // don't free! ULONG cDependents; ULONG idxDependent; HGROUP hGroup; // don't close! HRESOURCE hResource; const CLSID * pclsidResType; CGroupHandle * pgh; EDependencyFlags dfDependent; BSTR bstrNotification = NULL; IClusCfgManagedResourceCfg * pccmrc = NULL; CResourceEntry * presentry = m_rgpResources[ idxResourceIn ]; IUnknown * punkServices = NULL; IPrivatePostCfgResource * ppcr = NULL; IClusCfgResourceCreate * pccrc = NULL; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); // // Create a service object for this resource. // hr = THR( CCreateServices::S_HrCreateInstance( &punkServices ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_Create_CCreateServices, hr, L"[Create] Failed to create services object. Aborting." ); goto Cleanup; } hr = THR( punkServices->TypeSafeQI( IPrivatePostCfgResource, &ppcr ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_Create_CCreateServices_QI , hr , L"" ); goto Cleanup; } hr = THR( ppcr->SetEntry( presentry ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_SetEntry , hr , L"" ); goto Cleanup; } // // See if it was configured in a previous pass. // hr = STHR( presentry->IsConfigured() ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_IsConfigured , hr , L"" ); goto Cleanup; } if ( hr == S_FALSE ) { // // Make sure that Create() is not called again because of recursion. // hr = THR( presentry->SetConfigured( TRUE ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_SetConfigured , hr , L"" ); goto Cleanup; } // // Grab some useful information: name, group handle, ... // hr = THR( presentry->GetName( &bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_GetName , hr , L"" ); goto Cleanup; } hr = THR( presentry->GetGroupHandle( &pgh) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_GetGroupHandle , hr , L"" ); goto Cleanup; } hr = THR( pgh->GetHandle( &hGroup ) ); pgh->Release(); // release promptly if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_GetHandle , hr , L"" ); goto Cleanup; } // // Some resource that we pre-create don't have an associated managed resource. // Skip "creating" them but do create their dependents. Note that "special" // resources are create below in the else statement. // // Don't wrap - this can fail with Win32 ERROR_INVALID_DATA if the pointer is invalid. hr = presentry->GetAssociatedResource( &pccmrc ); if ( FAILED( hr ) && hr != HRESULT_FROM_WIN32( ERROR_INVALID_DATA ) ) { THR( hr ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_GetAssociatedResource , hr , L"" ); goto Cleanup; } if ( SUCCEEDED( hr ) ) { // Don't wrap - this can fail with E_NOTIMPL. hr = pccmrc->Create( punkServices ); if ( FAILED( hr ) ) { if ( hr == E_NOTIMPL ) { hr = S_OK; // ignore the error. } // if: E_NOTIMPL else { HRESULT hr2; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_Create_Failed, hr, L"[Create] %1!ws!: Create() failed. Its dependents may not be created. Skipping.", bstrNotification, bstrName ); hr2 = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_RESOURCE_FAILED_CREATE, &bstrNotification ) ); if ( FAILED( hr2 ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_LoadString_CreateFailed , hr , L"" ); hr = hr2; goto Cleanup; } hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Resource_Failed_Create, 0, 1, 1, MAKE_HRESULT( 0, HRESULT_FACILITY( hr ), HRESULT_CODE( hr ) ), bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure } // else: other failure } // if: failure if ( SUCCEEDED( hr ) ) { LPCWSTR pcszResType; // don't free. hr = THR( presentry->GetTypePtr( &pclsidResType ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_GetTypePtr , hr , L"" ); goto Cleanup; } pcszResType = PcszLookupTypeNameByGUID( *pclsidResType ); if ( pcszResType == NULL ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_PcszLookupTypeNameByGUID, hr, L"[Create] %1!ws!: Resource cannot be created because the resource type is not registered. Its dependents may not be created. Skipping.", bstrNotification, bstrName ); } else { hr = THR( HrCreateResourceInstance( idxResourceIn, hGroup, pcszResType, &hResource ) ); if ( FAILED( hr ) ) goto Cleanup; } } // if: success } // if: interface else { // // See if it is one of the "special" types that we can generate on the fly. // const CLSID * pclsidType; hr = THR( presentry->GetTypePtr( &pclsidType ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_InvalidData_GetTypePtr , hr , L"" ); goto Cleanup; } if ( *pclsidType == RESTYPE_NetworkName ) { // // Create a new network name resource. // hr = THR( punkServices->TypeSafeQI( IClusCfgResourceCreate, &pccrc ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_NetworkName_QI_pccrc , hr , L"" ); goto Cleanup; } hr = THR( pccrc->SetPropertyString( L"Name", bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_NetworkName_SetPropertyString , hr , L"" ); goto Cleanup; } hr = THR( HrCreateResourceInstance( idxResourceIn, hGroup, L"Network Name", &hResource ) ); if ( FAILED( hr ) ) goto Cleanup; } else if ( *pclsidType == RESTYPE_IPAddress ) { // // Create a new IP address resource. // hr = THR( punkServices->TypeSafeQI( IClusCfgResourceCreate, &pccrc ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_IPAddress_QI_pccrc , hr , L"" ); goto Cleanup; } // // TODO: gpease 21-JUN-2000 // Since we do not have a way to generate an appropriate IP address, // we don't set any properties. This will cause it to fail to come // online. // hr = THR( HrCreateResourceInstance( idxResourceIn, hGroup, L"IP Address", &hResource ) ); if ( FAILED( hr ) ) goto Cleanup; } else { // // else... the resource is one of the pre-created resources that BaseCluster // created. Log and continue creating its dependents. // hr = S_OK; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_NothingNew, hr, L"[Create] %1!ws!: Nothing new to create. Configuring dependents.", bstrNotification, bstrName ); } } // else: no interface } // if: not created // // Now that we created the resource instance, we need to create its dependents. // hr = THR( presentry->GetCountOfDependents( &cDependents ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_Dependents_GetCountOfDependents , hr , L"" ); goto Cleanup; } for( ; cDependents != 0; ) { DWORD dw; BSTR bstrDependent; HRESOURCE hResourceDependent; CResourceEntry * presentryDependent; cDependents --; hr = THR( presentry->GetDependent( cDependents, &idxDependent, &dfDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_Dependents_GetDependent , hr , L"" ); continue; } hr = THR( HrCreateResourceAndDependents( idxDependent ) ); if ( FAILED( hr ) ) continue; // // Add the dependencies on the resource. // presentryDependent = m_rgpResources[ idxDependent ]; hr = THR( presentryDependent->GetName( &bstrDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_Dependents_GetName , hr , L"" ); continue; } hr = THR( presentryDependent->GetHResource( &hResourceDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceAndDependents_Dependents_GetHResource , hr , L"" ); continue; } dw = TW32( AddClusterResourceDependency( hResourceDependent, hResource ) ); if ( dw != ERROR_SUCCESS ) { hr = HRESULT_FROM_WIN32( dw ); SSR_LOG2( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_Dependents_AddClusterResourceDependency, hr, L"[Create] %1!ws!: Could not set dependency on %2!ws!.", bstrNotification, bstrDependent, bstrName ); } else { hr = S_OK; SSR_LOG2( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceAndDependents_Dependents_Succeeded, hr, L"[Create] %1!ws!: Successfully set dependency set on %2!ws!.", bstrNotification, bstrDependent, bstrName ); } } // for: cDependents hr = S_OK; Cleanup: TraceSysFreeString( bstrNotification ); if ( pccmrc != NULL ) { pccmrc->Release(); } if ( punkServices != NULL ) { punkServices->Release(); } if ( ppcr != NULL ) { ppcr->Release(); } if ( pccrc != NULL ) { pccrc->Release(); } HRETURN( hr ); } // HrCreateResourceAndDependents() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrPostCreateResourceAndDependents( // ULONG idxResourceIn // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrPostCreateResourceAndDependents( ULONG idxResourceIn ) { TraceFunc1( "idxResourceIn = %u", idxResourceIn ); Assert( m_ecmCommitChangesMode != cmUNKNOWN ); HRESULT hr; BSTR bstrName; // don't free ULONG cDependents; ULONG idxDependent; HRESOURCE hResource; EDependencyFlags dfDependent; BSTR bstrNotification = NULL; BSTR bstrLocalQuorumNotification = NULL; IClusCfgManagedResourceCfg * pccmrc = NULL; CResourceEntry * presentry = m_rgpResources[ idxResourceIn ]; IUnknown * punkServices = NULL; IPrivatePostCfgResource * ppcr = NULL; // Validate state Assert( m_peccmr != NULL ); Assert( m_pccci != NULL ); hr = STHR( presentry->IsConfigured() ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_IsConfigured , hr , L"" ); goto Cleanup; } if ( hr == S_FALSE ) { // // Make sure that PostCreate() is not called again because of recursion. // hr = THR( presentry->SetConfigured( TRUE ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_SetConfigured , hr , L"" ); goto Cleanup; } // // Grab the name of the resource for logging. // hr = THR( presentry->GetName( &bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_GetName , hr , L"" ); goto Cleanup; } // // Bring the resource online. // hr = presentry->GetHResource( &hResource ); if ( SUCCEEDED( hr ) ) { DWORD dwErr; // Don't wrap - can return ERROR_IO_PENDING. dwErr = OnlineClusterResource( hResource ); switch ( dwErr ) { case ERROR_SUCCESS: SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_OpenClusterResource, hr, L"[PostCreate] %1!ws!: Resource brought online successfully.", bstrNotification, bstrName ); hr = S_OK; break; case ERROR_IO_PENDING: { CLUSTER_RESOURCE_STATE crs = ClusterResourceOnlinePending; hr = HRESULT_FROM_WIN32( dwErr ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_OpenClusterResourcePending, hr, L"[PostCreate] %1!ws!: Online pending...", bstrNotification, bstrName ); for( ; crs == ClusterResourceOnlinePending ; ) { crs = GetClusterResourceState( hResource, NULL, NULL, NULL, NULL ); switch ( crs ) { case ClusterResourceOnline: // no-op hr = S_OK; break; case ClusterResourceInitializing: crs = ClusterResourceOnlinePending; // fall thru case ClusterResourceOnlinePending: Sleep( 500 ); // sleep a 1/2 second break; case ClusterResourceStateUnknown: dwErr = GetLastError(); hr = HRESULT_FROM_WIN32( TW32( dwErr ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_ClusterResourceStateUnknown, hr, L"[PostCreate] %1!ws!: Resource failed to come online. Dependent resources might fail too.", bstrNotification, bstrName ); break; case ClusterResourceOfflinePending: case ClusterResourceOffline: hr = THR( E_FAIL ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_ClusterResourceOffline, hr, L"[PostCreate] %1!ws!: Resource went offline. Dependent resources might fail too.", bstrNotification, bstrName ); break; case ClusterResourceFailed: hr = E_FAIL; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_ClusterResourceFailed, hr, L"[PostCreate] %1!ws!: Resource failed. Check Event Log. Dependent resources might fail too.", bstrNotification, bstrName ); break; } // switch: crs } // for: crs } break; default: hr = HRESULT_FROM_WIN32( TW32( dwErr ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_OnlineClusterResource_Failed, hr, L"[PostCreate] %1!ws!: Resource failed to come online. Dependent resources might fail too.", bstrNotification, bstrName ); break; } // switch: dwErr } // if: hResource // // Set it to the quorum resource if marked so. // if ( SUCCEEDED( hr ) && idxResourceIn == m_idxQuorumResource ) { DWORD dwErr; dwErr = TW32( SetClusterQuorumResource( hResource, NULL, CLUSTER_QUORUM_DEFAULT_MAX_LOG_SIZE ) ); if ( dwErr != ERROR_SUCCESS ) { hr = HRESULT_FROM_WIN32( dwErr ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_SetClusterQuorumResource, hr, L"[PostCreate] %1!ws!: Failure setting resource to be the quorum resource.", bstrNotification, bstrName ); } else { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_SetClusterQuorumResource_Succeeded, hr, L"[PostCreate] %1!ws!: Successfully set as quorum resource.", bstrNotification, bstrName ); } // // Create a notification about setting the quorum resource. // hr = THR( HrFormatMessageIntoBSTR( g_hInstance, IDS_TASKID_MINOR_SET_QUORUM_DEVICE, &bstrNotification, bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_FormatMessage_SetQuorum , hr , L"" ); // ignore the failure. } // // Send a status that we found the quorum device. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Set_Quorum_Device, 0, 5, 5, HRESULT_FROM_WIN32( dwErr ), bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // Do this only if the quorum has changed. if ( ( dwErr == ERROR_SUCCESS ) && ( m_ecmCommitChangesMode == cmCREATE_CLUSTER ) && m_isQuorumChanged) { TraceFlow( "We are forming a cluster and the quorum resouce has changed - trying to delete the local quorum resource." ); m_dwLocalQuorumStatusMax = 0; // // If we are here, we are forming and we have successfully set a new quorum resource. // So, delete the local quorum resource. // // Create a notification about deleting the local quorum resource. hr = THR( HrFormatMessageIntoBSTR( g_hInstance, IDS_DELETING_LOCAL_QUORUM_RESOURCE, &bstrLocalQuorumNotification ) ); // ignore the failure. // Send a status that we are deleting the quorum device. hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Delete_LocalQuorum, 0, m_dwLocalQuorumStatusMax, m_dwLocalQuorumStatusMax, HRESULT_FROM_WIN32( dwErr ), bstrLocalQuorumNotification, NULL, NULL ) ); dwErr = TW32( ResUtilEnumResourcesEx( m_hCluster , NULL , CLUS_RESTYPE_NAME_LKQUORUM , S_DwDeleteLocalQuorumResource , this ) ); if ( dwErr != ERROR_SUCCESS ) { LogMsg( "PostCfg: An error occurred trying to enumerate localquorum resources (dwErr=%#08x).", dwErr ); } // if: an error occurred trying to enumerate all local quorum resources else { LogMsg( "PostCfg: Successfully deleted the local quorum resource." ); } // if: we successfully deleted the localquorum resource // Complete the status that we are deleting the quorum device. ++m_dwLocalQuorumStatusMax; hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Delete_LocalQuorum, 0, m_dwLocalQuorumStatusMax, m_dwLocalQuorumStatusMax, HRESULT_FROM_WIN32( dwErr ), NULL, // don't update text NULL, NULL ) ); } // if: we are forming a cluster and there have been no errors setting the quorum resource hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Locate_Existing_Quorum_Device, 0, 10, 10, hr, NULL, // don't update text NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure } // // Some resource that we pre-create don't have an associated // managed resource. Skip "creating" them but do create their // dependents. // // Don't wrap - this can fail with Win32 ERROR_INVALID_DATA if the pointer is invalid. hr = presentry->GetAssociatedResource( &pccmrc ); if ( FAILED( hr ) && hr != HRESULT_FROM_WIN32( ERROR_INVALID_DATA ) ) { THR( hr ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_GetAssociatedResource , hr , L"" ); goto Error; } if ( SUCCEEDED( hr ) ) { // // Create a service object for this resource. // hr = THR( CPostCreateServices::S_HrCreateInstance( &punkServices ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_Create_CPostCreateServices, hr, L"[PostCreate] Failed to create services object. Aborting." ); goto Error; } hr = THR( punkServices->TypeSafeQI( IPrivatePostCfgResource, &ppcr ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_Create_CPostCreateServices_QI_ppcr , hr , L"" ); goto Error; } hr = THR( ppcr->SetEntry( presentry ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_SetEntry , hr , L"" ); goto Error; } // Don't wrap - this can fail with E_NOTIMPL. hr = pccmrc->PostCreate( punkServices ); if ( FAILED( hr ) ) { if ( hr == E_NOTIMPL ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_PostCreate_E_NOTIMPL, hr, L"[PostCreate] %1!ws!: PostCreate() returned E_NOTIMPL. Ignoring.", bstrNotification, bstrName ); } // if: E_NOTIMPL else { HRESULT hr2; SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_PostCreate_Failed, hr, L"[PostCreate] %1!ws!: PostCreate() failed. Ignoring.", bstrNotification, bstrName ); hr2 = THR( HrFormatMessageIntoBSTR( g_hInstance, IDS_TASKID_MINOR_RESOURCE_FAILED_POSTCREATE_LOG, &bstrNotification, bstrName, hr ) ); if ( FAILED( hr2 ) ) { hr = hr2; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_FormatMessage_PostCreate_Failed , hr , L"" ); goto Cleanup; } hr2 = THR( SendStatusReport( NULL, TASKID_Major_Client_And_Server_Log, TASKID_Minor_Resource_Failed_PostCreate, 0, 1, 1, hr, bstrNotification, NULL, NULL ) ); if ( FAILED( hr2 ) ) { hr = hr2; goto Cleanup; } hr2 = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_RESOURCE_FAILED_POSTCREATE, &bstrNotification ) ); if ( FAILED( hr2 ) ) { hr = hr2; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_FormatMessage_ResourcePostCreate_Failed , hr , L"" ); goto Cleanup; } hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Resource_Failed_PostCreate, 0, 1, 1, MAKE_HRESULT( 0, HRESULT_FACILITY( hr ), HRESULT_CODE( hr ) ), bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure } // else: other failure } // if: failure else { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_PostCreate_Succeeded, hr, L"[PostCreate] %1!ws!: PostCreate() succeeded.", bstrNotification, bstrName ); } // else: success } // if: inteface else { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrPostCreateResourceAndDependents_PostCreate_NotNeeded, hr, L"[PostCreate] %1!ws!: No PostCreate() needed. Configuring dependents.", bstrNotification, bstrName ); } // else: no interface } // if: not created // // Now that we created the resource instance, we need to create its dependents. // hr = THR( presentry->GetCountOfDependents( &cDependents ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_GetCountOfDependents , hr , L"" ); goto Error; } for( ; cDependents != 0; ) { cDependents --; hr = THR( presentry->GetDependent( cDependents, &idxDependent, &dfDependent ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPostCreateResourceAndDependents_GetDependent , hr , L"" ); continue; } hr = THR( HrPostCreateResourceAndDependents( idxDependent ) ); if ( FAILED( hr ) ) continue; } // for: cDependents // // Update the UI layer. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Starting_Resources, 0, m_cResources, // KB: once these were multiplied by 4; should they be? idxResourceIn, S_OK, NULL, // don't need to change text NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure hr = S_OK; Cleanup: if ( pccmrc != NULL ) { pccmrc->Release(); } if ( punkServices != NULL ) { punkServices->Release(); } if ( ppcr != NULL ) { ppcr->Release(); } TraceSysFreeString( bstrNotification ); TraceSysFreeString( bstrLocalQuorumNotification ); HRETURN( hr ); Error: THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Starting_Resources, 0, m_cResources, // KB: once these were multiplied by 4; should they be? idxResourceIn, hr, NULL, // don't need to change text NULL, NULL ) ); goto Cleanup; } // HrPostCreateResourceAndDependents() ////////////////////////////////////////////////////////////////////////////// //++ // // HRESULT // CPostCfgManager::HrNotifyMemberSetChangeListeners // // Description: // Notify all components on the local computer registered to get // notification of cluster member set change (form, join or evict). // // Arguments: // None. // // Return Values: // S_OK // Success. // // other HRESULTs // Something went wrong during the notifications. // //-- ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrNotifyMemberSetChangeListeners( void ) { TraceFunc( "" ); const UINT uiCHUNK_SIZE = 16; HRESULT hr = S_OK; ICatInformation * pciCatInfo = NULL; IEnumCLSID * plceListenerClsidEnum = NULL; // Validate state Assert( m_pccci != NULL ); do { ULONG cReturned = 0; CATID rgCatIdsImplemented[ 1 ]; rgCatIdsImplemented[ 0 ] = CATID_ClusCfgMemberSetChangeListeners; // // Enumerate all the enumerators registered in the // CATID_ClusCfgMemberSetChangeListeners category // hr = THR( CoCreateInstance( CLSID_StdComponentCategoriesMgr , NULL , CLSCTX_SERVER , IID_ICatInformation , reinterpret_cast< void ** >( &pciCatInfo ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrNotifyMemberSetChangeListeners_CoCreate_StdComponentCategoriesMgr, hr, L"Error occurred trying to get a pointer to the enumerator of the CATID_ClusCfgMemberSetChangeListeners category." ); 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_ClusCfgMemberSetChangeListeners category. hr = THR( pciCatInfo->EnumClassesOfCategories( 1 , rgCatIdsImplemented , 0 , NULL , &plceListenerClsidEnum ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrNotifyMemberSetChangeListeners_EnumClassesOfCategories, hr, L"Error occurred trying to get a pointer to the enumerator of the CATID_ClusCfgMemberSetChangeListeners category." ); break; } // if: we could not get a pointer to the IEnumCLSID interface // Enumerate the CLSIDs of the registered enumerators do { CLSID rgListenerClsidArray[ uiCHUNK_SIZE ]; ULONG idxCLSID; hr = STHR( plceListenerClsidEnum->Next( uiCHUNK_SIZE , rgListenerClsidArray , &cReturned ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrNotifyMemberSetChangeListeners_Next, hr, L"Error occurred trying enumerate member set listener enumerators." ); break; } // if: we could not get a pointer to the IEnumCLSID interface // hr may be S_FALSE here, so reset it. hr = S_OK; for ( idxCLSID = 0; idxCLSID < cReturned; ++idxCLSID ) { hr = THR( HrProcessMemberSetChangeListener( rgListenerClsidArray[ idxCLSID ] ) ); if ( FAILED( hr ) ) { // The processing of one of the listeners failed. // Log the error, but continue processing other listeners. SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrNotifyMemberSetChangeListeners_HrProcessMemberSetChangeListener, hr, L"Error occurred trying to process a member set change listener. Ignoring. Other listeners will be processed." ); hr = S_OK; } // if: this listener 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 ( plceListenerClsidEnum != NULL ) { plceListenerClsidEnum->Release(); } // if: we had obtained a pointer to the enumerator of listener CLSIDs HRETURN( hr ); } //*** CPostCfgManager::HrNotifyMemberSetChangeListeners() ////////////////////////////////////////////////////////////////////////////// //++ // // HRESULT // CPostCfgManager::HrProcessMemberSetChangeListener // // Description: // This function notifies a listener of cluster member set changes. // // Arguments: // rclsidListenerClsidIn // CLSID of the listener component. // // Return Values: // S_OK // Success. // // other HRESULTs // Something went wrong during the notification. // //-- ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrProcessMemberSetChangeListener( const CLSID & rclsidListenerClsidIn ) { TraceFunc( "" ); HRESULT hr = S_OK; IClusCfgMemberSetChangeListener * pccmclListener = NULL; TraceMsgGUID( mtfFUNC, "The CLSID of this listener is ", rclsidListenerClsidIn ); do { // // Create the listener represented by the CLSID passed in // hr = THR( CoCreateInstance( rclsidListenerClsidIn , NULL , CLSCTX_INPROC_SERVER , __uuidof( pccmclListener ) , reinterpret_cast< void ** >( &pccmclListener ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessMemberSetChangeListener_CoCreate_Listener, hr, L"Error occurred trying to get a pointer to the the member set change listener." ); break; } // if: we could not get a pointer to the IClusCfgMemberSetChangeListener interface hr = THR( pccmclListener->Notify( m_pccci ) ); if ( FAILED( hr ) ) { // The processing of this listeners failed. SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessMemberSetChangeListener_Notify, hr, L"Error occurred trying to notify a listener." ); break; } // if: this listeners failed } while( false ); // dummy do-while loop to avoid gotos. // // Cleanup code // if ( pccmclListener != NULL ) { pccmclListener->Release(); } // if: we had obtained a pointer to the listener interface HRETURN( hr ); } //*** CPostCfgManager::HrProcessMemberSetChangeListener() ////////////////////////////////////////////////////////////////////////////// //++ // // HRESULT // CPostCfgManager::HrConfigureResTypes // // Description: // Enumerate all components on the local computer registered for resource // type configuration. // // Arguments: // IUnknown * punkResTypeServicesIn // A pointer to the IUnknown interface on a component that provides // services that help configure resource types. // // Return Values: // S_OK // Success. // // other HRESULTs // Something went wrong during the enumeration. // //-- ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrConfigureResTypes( IUnknown * punkResTypeServicesIn ) { TraceFunc( "" ); const UINT uiCHUNK_SIZE = 16; HRESULT hr = S_OK; ICatInformation * pciCatInfo = NULL; IEnumCLSID * prceResTypeClsidEnum = NULL; // Validate state Assert( m_pccci != NULL ); do { ULONG cReturned = 0; CATID rgCatIdsImplemented[ 1 ]; rgCatIdsImplemented[ 0 ] = CATID_ClusCfgResourceTypes; // // Enumerate all the enumerators registered in the // CATID_ClusCfgResourceTypes category // hr = THR( CoCreateInstance( CLSID_StdComponentCategoriesMgr , NULL , CLSCTX_SERVER , IID_ICatInformation , reinterpret_cast< void ** >( &pciCatInfo ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrConfigureResTypes_CoCreate_CategoriesMgr, hr, L"Error occurred trying to get a pointer to the enumerator of the CATID_ClusCfgResourceTypes category." ); 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_ClusCfgResourceTypes category. hr = THR( pciCatInfo->EnumClassesOfCategories( 1 , rgCatIdsImplemented , 0 , NULL , &prceResTypeClsidEnum ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrConfigureResTypes_Enum, hr, L"Error occurred trying to get a pointer to the enumerator of the CATID_ClusCfgResourceTypes category." ); break; } // if: we could not get a pointer to the IEnumCLSID interface // Enumerate the CLSIDs of the registered resource types do { CLSID rgResTypeCLSIDArray[ uiCHUNK_SIZE ]; ULONG idxCLSID; cReturned = 0; hr = STHR( prceResTypeClsidEnum->Next( uiCHUNK_SIZE , rgResTypeCLSIDArray , &cReturned ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrConfigureResTypes_Next, hr, L"Error occurred trying enumerate resource type configuration components." ); 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( HrProcessResType( rgResTypeCLSIDArray[ idxCLSID ], punkResTypeServicesIn ) ); if ( FAILED( hr ) ) { BSTR bstrCLSID = NULL; BSTR bstrNotification = NULL; THR( StringFromCLSID( rgResTypeCLSIDArray[ idxCLSID ], &bstrCLSID ) ); // The processing of one of the resource types failed. // Log the error, but continue processing other resource types. SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrConfigureResTypes_HrProcessResType, hr, L"[ResType] Error occurred trying to process a resource type. Ignoring. Other resource types will be processed. The CLSID of the failed resource type is %1!ws!.", bstrNotification, bstrCLSID ); TraceSysFreeString( bstrNotification ); SysFreeString( bstrCLSID ); 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 ( prceResTypeClsidEnum != NULL ) { prceResTypeClsidEnum->Release(); } // if: we had obtained a pointer to the enumerator of resource type CLSIDs HRETURN( hr ); } //*** CPostCfgManager::HrConfigureResTypes() ////////////////////////////////////////////////////////////////////////////// //++ // // HRESULT // CPostCfgManager::HrProcessResType // // Description: // This function instantiates a resource type configuration component // and calls the appropriate methods. // // Arguments: // rclsidResTypeCLSIDIn // CLSID of the resource type configuration 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 resource type. // //-- ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrProcessResType( const CLSID & rclsidResTypeCLSIDIn , IUnknown * punkResTypeServicesIn ) { TraceFunc( "" ); HRESULT hr = S_OK; IClusCfgResourceTypeInfo * pcrtiResTypeInfo = NULL; BSTR bstrResTypeName = NULL; GUID guidResTypeGUID; BSTR bstrNotification = NULL; TraceMsgGUID( mtfFUNC, "The CLSID of this resource type is ", rclsidResTypeCLSIDIn ); do { // // Create the component represented by the CLSID passed in // hr = THR( CoCreateInstance( rclsidResTypeCLSIDIn , NULL , CLSCTX_INPROC_SERVER , __uuidof( pcrtiResTypeInfo ) , reinterpret_cast< void ** >( &pcrtiResTypeInfo ) ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_CoCreate_ResTypeClsid, hr, L"[ResType] Error occurred trying to create the resource type configuration component." ); break; } // if: we could not create the resource type configuration component // // Initialize the newly created component // { IClusCfgInitialize * pcci = NULL; HRESULT hrTemp; // Check if this component supports the callback interface. hrTemp = THR( pcrtiResTypeInfo->QueryInterface< IClusCfgInitialize >( &pcci ) ); if ( FAILED( hrTemp ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_QI_pcci, hrTemp, L"Error occurred trying to get a pointer to the IClusCfgInitialize interface. This resource type does not support initialization." ); } // if: the callback interface is not supported else { // Initialize this component. hr = THR( pcci->Initialize( TraceInterface( __THISCLASS__, IClusCfgCallback, this, 0 ) , m_lcid ) ); // This interface is no longer needed. pcci->Release(); // Did initialization succeed? if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_Initialize, hr, L"Error occurred trying initialize a resource type configuration component." ); break; } // if: the initialization failed } // else: the callback interface is supported } // Get the name of the current resource type. hr = THR( pcrtiResTypeInfo->GetTypeName( &bstrResTypeName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_GetTypeName, hr, L"Error occurred trying to get the name of a resource type." ); break; } // if: we could not get the resource type name SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_AboutToConfigureType, hr, L"[ResType] %1!ws!: About to configure resource type...", bstrNotification, bstrResTypeName ); // Configure this resource type. hr = THR( pcrtiResTypeInfo->CommitChanges( m_pccci, punkResTypeServicesIn ) ); if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_CommitChanges, hr, L"[ResType] %1!ws!: Error occurred trying to configure the resource type.", bstrNotification, bstrResTypeName ); break; } // if: this resource type configuration failed // Get and store the resource type GUID hr = STHR( pcrtiResTypeInfo->GetTypeGUID( &guidResTypeGUID ) ); if ( FAILED( hr ) ) { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_GetTypeGUID, hr, L"[ResType] %1!ws!: Error occurred trying to get the resource type GUID.", bstrNotification, bstrResTypeName ); break; } // if: this resource type configuration failed if ( hr == S_OK ) { TraceMsgGUID( mtfFUNC, "The GUID of this resource type is", guidResTypeGUID ); hr = THR( HrMapResTypeGUIDToName( guidResTypeGUID, bstrResTypeName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_HrMapResTypeGUIDToName, hr, L"Error occurred trying to create a mapping between a GUID and a name" ); // Something went wrong with our code - we cannot continue. break; } // if: we could not add the mapping } // if: this resource type has a GUID else { // Reset hr hr = S_OK; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrProcessResType_NoGuid, hr, L"This resource type does not have a GUID associated with it." ); } // else: this resource type does not have a GUID } while( false ); // dummy do-while loop to avoid gotos. // // Cleanup code // if ( pcrtiResTypeInfo != NULL ) { pcrtiResTypeInfo->Release(); } // if: we had obtained a pointer to the resource type info interface if ( bstrResTypeName != NULL ) { SysFreeString( bstrResTypeName ); } // if: a bstr was allocated for this resource type TraceSysFreeString( bstrNotification ); HRETURN( hr ); } //*** CPostCfgManager::HrProcessResType() ////////////////////////////////////////////////////////////////////////////// //++ // // HRESULT // CPostCfgManager::HrMapResTypeGUIDToName // // Description: // Create a mapping between a resource type GUID and a resource type name. // // Arguments: // rcguidTypeGuidIn // Resource type GUID which is to be mapped to a resource type name. // // pcszTypeNameIn // The resource type name to map the above GUID to. // // Return Values: // S_OK // Success. // // other HRESULTs // If something went wrong // //-- ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrMapResTypeGUIDToName( const GUID & rcguidTypeGuidIn , const WCHAR * pcszTypeNameIn ) { TraceFunc( "" ); HRESULT hr = S_OK; do { ULONG cchTypeNameSize; WCHAR * pszTypeName; // // Validate the parameters // // Validate the parameters if ( ( pcszTypeNameIn == NULL ) || ( *pcszTypeNameIn == L'\0' ) ) { hr = THR( E_INVALIDARG ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_HrMapResTypeGUIDToName_InvalidArg, hr, L"An empty resource type name cannot be added to the map." ); break; } // if: the resource type name is empty // Check if the existing map buffer is big enough to hold another entry. if ( m_idxNextMapEntry >= m_cMapSize ) { // Double the size of the map buffer ULONG cNewMapSize = m_cMapSize * 2; ULONG idxMapEntry; SResTypeGUIDAndName * pgnNewMap = new SResTypeGUIDAndName[ cNewMapSize ]; if ( pgnNewMap == NULL ) { hr = THR( E_OUTOFMEMORY ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_HrMapResTypeGUIDToName_OutOfMemory_NewMap, hr, L"Memory allocation failed trying to add a new resource type GUID to name map entry." ); break; } // if: memory allocation failed // Copy the contents of the old buffer to the new one. for ( idxMapEntry = 0; idxMapEntry < m_idxNextMapEntry; ++idxMapEntry ) { pgnNewMap[ idxMapEntry ] = m_pgnResTypeGUIDNameMap[ idxMapEntry ]; } // for: iterate through the existing map // Update the member variables delete [] m_pgnResTypeGUIDNameMap; m_pgnResTypeGUIDNameMap = pgnNewMap; m_cMapSize = cNewMapSize; } // if: the map buffer is not big enough for another entry // // Add the new entry to the map // cchTypeNameSize = wcslen( pcszTypeNameIn ) + 1; pszTypeName = new WCHAR[ cchTypeNameSize ]; if ( pszTypeName == NULL ) { hr = THR( E_OUTOFMEMORY ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log, TASKID_HrMapResTypeGUIDToName_OutOfMemory_TypeName, hr, L"Memory allocation failed trying to add a new resource type GUID to name map entry." ); break; } // if: memory allocation failed wcsncpy( pszTypeName, pcszTypeNameIn, cchTypeNameSize ); m_pgnResTypeGUIDNameMap[ m_idxNextMapEntry ].m_guidTypeGUID = rcguidTypeGuidIn; m_pgnResTypeGUIDNameMap[ m_idxNextMapEntry ].m_pszTypeName = pszTypeName; ++m_idxNextMapEntry; } while( false ); // dummy do-while loop to avoid gotos HRETURN( hr ); } //*** CPostCfgManager::HrMapResTypeGUIDToName() ////////////////////////////////////////////////////////////////////////////// //++ // // LPCWSTR // CPostCfgManager::PcszLookupTypeNameByGUID // // Description: // Given a resource type GUID this function finds the resource type name // if any. // // Arguments: // rcguidTypeGuidIn // Resource type GUID which is to be mapped to a resource type name. // // Return Values: // Pointer to the name of the resource type // If the type GUID maps to name // // NULL // If there is no type name associated with the input GUID //-- ////////////////////////////////////////////////////////////////////////////// const WCHAR * CPostCfgManager::PcszLookupTypeNameByGUID( const GUID & rcguidTypeGuidIn ) { TraceFunc( "" ); ULONG idxCurrentMapEntry; const WCHAR * pcszTypeName = NULL; TraceMsgGUID( mtfFUNC, "Trying to look up the the type name of resource type ", rcguidTypeGuidIn ); for ( idxCurrentMapEntry = 0; idxCurrentMapEntry < m_idxNextMapEntry; ++idxCurrentMapEntry ) { if ( IsEqualGUID( rcguidTypeGuidIn, m_pgnResTypeGUIDNameMap[ idxCurrentMapEntry ].m_guidTypeGUID ) != FALSE ) { // A mapping has been found. pcszTypeName = m_pgnResTypeGUIDNameMap[ idxCurrentMapEntry ].m_pszTypeName; TraceMsg( mtfFUNC, "The name of the type is '%s'", pcszTypeName ); break; } // if: this GUID has been found in the map } // for: iterate through the existing entries in the map if ( pcszTypeName == NULL ) { TraceMsg( mtfFUNC, "The input GUID does not map to any resource type name." ); } // if: this GUID does not exist in the map RETURN( pcszTypeName ); } //*** CPostCfgManager::PcszLookupTypeNameByGUID() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrPreInitializeExistingResources( void ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrPreInitializeExistingResources( void ) { TraceFunc( "" ); HRESULT hr; BSTR bstrName; // don't free HRESOURCE hResource; CResourceEntry * presentry; DWORD dwMaxLogSize; DWORD dw; BSTR bstrNotification = NULL; BSTR bstrClusterNameResourceName = NULL; BSTR bstrClusterIPAddressResourceName = NULL; BSTR bstrClusterQuorumResourceName = NULL; HRESOURCE hClusterNameResource = NULL; HRESOURCE hClusterIPAddressResource = NULL; HRESOURCE hClusterQuorumResource = NULL; Assert( m_rgpResources == NULL ); Assert( m_cAllocedResources == 0 ); Assert( m_cResources == 0 ); hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_TASKID_MINOR_LOCATE_EXISTING_QUORUM_DEVICE, &bstrNotification ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_LoadString_LocateExistingQuorum , hr , L"" ); goto Cleanup; } m_rgpResources = (CResourceEntry **) TraceAlloc( 0, sizeof(CResourceEntry *) * RESOURCE_INCREMENT ); if ( m_rgpResources == NULL ) { goto OutOfMemory; } // if: for ( ; m_cAllocedResources < RESOURCE_INCREMENT; m_cAllocedResources ++ ) { m_rgpResources[ m_cAllocedResources] = new CResourceEntry(); if ( m_rgpResources[ m_cAllocedResources ] == NULL ) { goto OutOfMemory; } // if: } // for: Assert( m_cAllocedResources == RESOURCE_INCREMENT ); // // Create default resources such as Cluster IP, Cluster Name resource, and Quorum Device // Assert( m_cResources == 0 ); // // Get the core resources and their names. // hr = THR( HrGetCoreClusterResourceNames( &bstrClusterNameResourceName , &hClusterNameResource , &bstrClusterIPAddressResourceName , &hClusterIPAddressResource , &bstrClusterQuorumResourceName , &hClusterQuorumResource ) ); if ( FAILED( hr ) ) { goto Cleanup; } // if: // // Add Cluster IP Address resource // m_idxIPAddress = m_cResources; presentry = m_rgpResources[ m_cResources ]; // This give ownership of bstrClusterIPAddressResourceName away hr = THR( presentry->SetName( bstrClusterIPAddressResourceName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_IP_SetName , hr , L"" ); goto Cleanup; } bstrClusterIPAddressResourceName = NULL; hr = THR( presentry->SetType( &RESTYPE_ClusterIPAddress ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_IP_SetType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetClassType( &RESCLASSTYPE_IPAddress ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_IP_SetClassType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetFlags( dfSHARED ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_IP_SetFlags , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetHResource( hClusterIPAddressResource ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_IP_SetHResource , hr , L"" ); goto Cleanup; } hClusterIPAddressResource = NULL; m_cResources ++; // // Add Cluster Name resource // m_idxClusterName = m_cResources; presentry = m_rgpResources[ m_cResources ]; // This give ownership of bstrClusterNameResourceName away hr = THR( presentry->SetName( bstrClusterNameResourceName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_SetName , hr , L"" ); goto Cleanup; } bstrClusterNameResourceName = NULL; hr = THR( presentry->SetType( &RESTYPE_ClusterNetName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_SetType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetClassType( &RESCLASSTYPE_NetworkName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_SetClassType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetFlags( dfSHARED ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_SetFlags , hr , L"" ); goto Cleanup; } // Add the dependency on the IP address. hr = THR( presentry->AddTypeDependency( &RESTYPE_ClusterIPAddress, dfSHARED ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_AddTypeDependency , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetHResource( hClusterNameResource ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Name_SetHResource , hr , L"" ); goto Cleanup; } hClusterNameResource = NULL; m_cResources ++; // // Add Quorum resource // // // KB: gpease 19-JUN-2000 // Anything before the quorum device will be considered to be // in the Cluster Group. // m_idxQuorumResource = m_cResources; presentry = m_rgpResources[ m_cResources ]; // This give ownership of bstrClusterQuorumResourceName away hr = THR( presentry->SetName( bstrClusterQuorumResourceName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Quorum_SetName , hr , L"" ); goto Cleanup; } bstrClusterQuorumResourceName = NULL; hr = THR( presentry->SetType( &RESTYPE_ClusterQuorumDisk ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Quorum_SetType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetClassType( &RESCLASSTYPE_StorageDevice ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Quorum_SetClassType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetFlags( dfSHARED ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Quorum_SetFlags , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetHResource( hClusterQuorumResource ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_Quorum_SetHResource , hr , L"" ); goto Cleanup; } hClusterQuorumResource = NULL; m_cResources ++; // // Make sure that the default resource allocation can hold all the // default resources. // AssertMsg( m_cResources <= m_cAllocedResources, "Default resource allocation needs to be bigger!" ); goto Cleanup; OutOfMemory: hr = E_OUTOFMEMORY; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrPreInitializeExistingResources_OutOfMemory , hr , L"Out of memory" ); Cleanup: // // Send a status that we found the quorum device. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Locate_Existing_Quorum_Device, 0, 10, 10, hr, bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure TraceSysFreeString( bstrNotification ); TraceSysFreeString( bstrClusterNameResourceName ); TraceSysFreeString( bstrClusterIPAddressResourceName ); TraceSysFreeString( bstrClusterQuorumResourceName ); if ( hClusterNameResource != NULL ) { CloseClusterResource( hClusterNameResource ); } // if: if ( hClusterIPAddressResource != NULL ) { CloseClusterResource( hClusterIPAddressResource ); } // if: if ( hClusterQuorumResource != NULL ) { CloseClusterResource( hClusterQuorumResource ); } // if: HRETURN( hr ); } // HrPreInitializeExistingResources( void ) ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrAddSpecialResource( // BSTR bstrNameIn, // const CLSID * pclsidTypeIn, // const CLSID * pclsidClassTypeIn // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrAddSpecialResource( BSTR bstrNameIn, const CLSID * pclsidTypeIn, const CLSID * pclsidClassTypeIn ) { TraceFunc( "" ); HRESULT hr; CResourceEntry * presentry; // // Grow the resource list if nessecary. // if ( m_cResources == m_cAllocedResources ) { ULONG idxNewCount = m_cAllocedResources + RESOURCE_INCREMENT; CResourceEntry ** pnewList; pnewList = (CResourceEntry **) TraceAlloc( 0, sizeof( CResourceEntry * ) * idxNewCount ); if ( pnewList == NULL ) goto OutOfMemory; CopyMemory( pnewList, m_rgpResources, sizeof(CResourceEntry *) * m_cAllocedResources ); TraceFree( m_rgpResources ); m_rgpResources = pnewList; for ( ; m_cAllocedResources < idxNewCount ; m_cAllocedResources ++ ) { m_rgpResources[ m_cAllocedResources ] = new CResourceEntry(); if ( m_rgpResources[ m_cAllocedResources ] == NULL ) goto OutOfMemory; } } presentry = m_rgpResources[ m_cResources ]; // // Setup the new entry. // hr = THR( presentry->SetName( bstrNameIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAddSpecialResource_SetName , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetType( pclsidTypeIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAddSpecialResource_SetType , hr , L"" ); goto Cleanup; } hr = THR( presentry->SetClassType( pclsidClassTypeIn ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAddSpecialResource_SetClassType , hr , L"" ); goto Cleanup; } m_cResources ++; Cleanup: HRETURN( hr ); OutOfMemory: { hr = E_OUTOFMEMORY; SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrAddSpecialResource_OutOfMemory , hr , L"Out of memory" ); } goto Cleanup; } // HrAddSpecialResource() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrCreateResourceInstance( // ULONG idxResourceIn, // HGROUP hGroupIn, // LPCWSTR pszResTypeIn, // HRESOURCE * phResourceOut // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrCreateResourceInstance( ULONG idxResourceIn, HGROUP hGroupIn, LPCWSTR pszResTypeIn, HRESOURCE * phResourceOut ) { TraceFunc3( "idxResourceIn = %u, hGroupIn = %p, pszResTypeIn = '%ws'", idxResourceIn, hGroupIn, pszResTypeIn ); HRESULT hr; DWORD dw; BSTR bstrName; // don't free CResourceEntry * presentry; BSTR bstrNotification = NULL; Assert( phResourceOut != NULL ); Assert( idxResourceIn < m_cResources ); Assert( hGroupIn != NULL ); presentry = m_rgpResources[ idxResourceIn ]; hr = THR( presentry->GetName( &bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceInstance_GetName , hr , L"" ); goto Cleanup; } // // Tell the UI what we are doing. // hr = THR( SendStatusReport( NULL, TASKID_Major_Configure_Resources, TASKID_Minor_Creating_Resource, 0, m_cResources, // KB: once these were multiplied by 4. Should they be? idxResourceIn, S_OK, NULL, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // // TODO: gpease 24-AUG-2000 // What to do if we have a failure?? For now I think we should keep going! // // // See if the resource already exists. We need to do this because the user // might have clicked "Retry" in the UI. We don't want to create another // instance of existing resources. // *phResourceOut = OpenClusterResource( m_hCluster, bstrName ); if ( *phResourceOut == NULL ) { // // Create a new resource instance. // *phResourceOut = CreateClusterResource( hGroupIn, bstrName, pszResTypeIn, 0 ); if ( *phResourceOut == NULL ) { hr = HRESULT_FROM_WIN32( TW32( GetLastError() ) ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceInstance_CreateClusterResource, hr, L"[Create] %1!ws!: CreateClusterResource failed. Its dependents may not be created. Skipping.", bstrNotification, bstrName ); goto Cleanup; } // if: failure SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceInstance_CreateClusterResource_Successful, hr, L"[Create] %1!ws!: Resource created successfully.", bstrNotification, bstrName ); } else { SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceInstance_FoundExistingResource, hr, L"[Create] %1!ws!: Found existing resource.", bstrNotification, bstrName ); // // Make sure the resource is in the group we think it is. // // don't wrap - this can fail with ERROR_ALREADY_EXISTS. dw = ChangeClusterResourceGroup( *phResourceOut, hGroupIn ); if ( dw == ERROR_ALREADY_EXISTS ) { // no-op. It's the way we want it. } else if ( dw != ERROR_SUCCESS ) { hr = HRESULT_FROM_WIN32( dw ); SSR_LOG1( TASKID_Major_Client_And_Server_Log, TASKID_Minor_HrCreateResourceInstance_ChangeClusterResourceGroup, hr, L"[Create] %1!ws!: Can move existing resource to proper group. Configuration may not work.", bstrNotification, bstrName ); } } // // Store off the resource handle. // hr = THR( presentry->SetHResource( *phResourceOut ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceInstance_SetHResource , hr , L"" ); goto Cleanup; } // // Configure resource. // hr = THR( presentry->Configure() ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceInstance_Configure , hr , L"" ); // ignore the error and continue. } // // Make a message using the name. // hr = THR( HrFormatMessageIntoBSTR( g_hInstance, IDS_TASKID_MINOR_CREATING_RESOURCE, &bstrNotification, bstrName ) ); if ( FAILED( hr ) ) { SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrCreateResourceInstance_LoadString_CreatingResource , hr , L"" ); goto Cleanup; } // // Tell the UI what we are doing. // hr = THR( SendStatusReport( NULL, TASKID_Major_Client_And_Server_Log, // informative only TASKID_Minor_Creating_Resource, 0, 2, 2, hr, // log the error on the client side bstrNotification, NULL, NULL ) ); if ( hr == E_ABORT ) goto Cleanup; // ignore failure // // TODO: gpease 24-AUG-2000 // What to do if we have a failure?? For now I think we should keep going! // hr = S_OK; Cleanup: TraceSysFreeString( bstrNotification ); HRETURN( hr ); } // HrCreateResourceInstance() ////////////////////////////////////////////////////////////////////////////// // // DWORD // CPostCfgManager::S_DwDeleteLocalQuorumResource( // ) // ////////////////////////////////////////////////////////////////////////////// DWORD CPostCfgManager::S_DwDeleteLocalQuorumResource( HCLUSTER hClusterIn , HRESOURCE hSelfIn , HRESOURCE hLQuorumIn , PVOID pvParamIn ) { TraceFunc( "" ); DWORD sc = ERROR_SUCCESS; signed long slOfflineTimeOut = 60; // seconds CLUSTER_RESOURCE_STATE crs; HCHANGE hc = reinterpret_cast< HCHANGE >( INVALID_HANDLE_VALUE ); CPostCfgManager * pcpcmThis = reinterpret_cast< CPostCfgManager * >( pvParamIn ); DWORD dwStatusCurrent; // // Check if the this pointer is valid. // if ( pvParamIn == NULL ) { // If the pointer is invalid, set it to a valid address and continue. TW32( ERROR_INVALID_PARAMETER ); TraceFlow( "Error: The pointer to the CPostCfgManager object cannot be NULL." ); LogMsg( "PostCfg: Error: An invalid parameter was received while trying to delete the local quorum resource." ); goto Cleanup; } // Get the state of the resource. crs = GetClusterResourceState( hLQuorumIn, NULL, NULL, NULL, NULL ); // Check if it is offline - if it is, then we can proceed to deleting it. if ( crs == ClusterResourceOffline ) { TraceFlow( "The localquorum resource is already offline." ); goto Cleanup; } TraceFlow( "Trying to take the localquorum resource offline." ); // If we are here, the resource is not yet offline. Instruct it to go offline. sc = OfflineClusterResource( hLQuorumIn ); if ( ( sc != ERROR_SUCCESS ) && ( sc != ERROR_IO_PENDING ) ) { TW32( sc ); TraceFlow1( "Error %#08x occurred trying to take the local quorum resource offline.", sc ); LogMsg( "PostCfg: Error %#08x occurred trying to take the local quorum resource offline.", sc ); goto Cleanup; } // if: an error occurred trying to take the resource offline if ( sc == ERROR_IO_PENDING ) { TraceFlow1( "Waiting %d seconds for the localquorum resource to go offline.", slOfflineTimeOut ); // Create a notification port for resource state changes hc = CreateClusterNotifyPort( reinterpret_cast< HCHANGE >( INVALID_HANDLE_VALUE ) , hClusterIn , CLUSTER_CHANGE_RESOURCE_STATE , NULL ); if ( hc == NULL ) { sc = TW32( GetLastError() ); TraceFlow1( "Error %#08x occurred trying to create a cluster notification port.", sc ); LogMsg( "PostCfg: Error %#08x occurred trying to create a cluster notification port.", sc ); goto Cleanup; } // if: we could not create a notification port sc = TW32( RegisterClusterNotify( hc, CLUSTER_CHANGE_RESOURCE_STATE, hLQuorumIn, NULL ) ); if ( sc != ERROR_SUCCESS ) { TraceFlow1( "Error %#08x occurred trying to register for cluster notifications.", sc ); LogMsg( "PostCfg: Error %#08x occurred trying to register for cluster notifications.", sc ); goto Cleanup; } // if: // Change the status report range. dwStatusCurrent = pcpcmThis->m_dwLocalQuorumStatusMax; pcpcmThis->m_dwLocalQuorumStatusMax += slOfflineTimeOut; // Wait for slOfflineTimeOut seconds for the resource to go offline. for ( ; slOfflineTimeOut > 0; --slOfflineTimeOut ) { DWORD dwFilterType; crs = GetClusterResourceState( hLQuorumIn, NULL, NULL, NULL, NULL ); if ( crs == ClusterResourceOffline ) { TraceFlow1( "The local quorum resource has gone offline with %d seconds to spare.", slOfflineTimeOut ); break; } // if: the resource is now offline sc = GetClusterNotify( hc, NULL, &dwFilterType, NULL, NULL, 1000 ); // wait for one second if ( ( sc != ERROR_SUCCESS ) && ( sc != WAIT_TIMEOUT ) ) { TW32( sc ); TraceFlow1( "Error %#08x occurred trying wait for a resource state change notification.", sc ); LogMsg( "PostCfg: Error %#08x occurred trying wait for a resource state change notification.", sc ); goto Cleanup; } // if: something went wrong // Reset sc, since it could be WAIT_TIMEOUT here sc = ERROR_SUCCESS; Assert( dwFilterType == CLUSTER_CHANGE_RESOURCE_STATE ); // Send a status report that we are deleting the quorum device. ++dwStatusCurrent; THR( pcpcmThis->SendStatusReport( NULL , TASKID_Major_Configure_Resources , TASKID_Minor_Delete_LocalQuorum , 0 , pcpcmThis->m_dwLocalQuorumStatusMax , dwStatusCurrent , HRESULT_FROM_WIN32( sc ) , NULL // don't update text , NULL , NULL ) ); } // for: loop while the timeout has not expired } // if: else { crs = ClusterResourceOffline; // the resource went offline immediately. } // else: // // If we are here, then one of two things could have happened: // 1. The resource has gone offline // 2. The timeout has expired // Check to see which of the above is true. // if ( crs != ClusterResourceOffline ) { // We cannot be here if the timeout has not expired. Assert( slOfflineTimeOut <= 0 ); TraceFlow( "The local quorum resource could not be taken offline." ); LogMsg( "PostCfg: Error: The local quorum resource could not be taken offline." ); sc = TW32( WAIT_TIMEOUT ); goto Cleanup; } // if: the timeout has expired // If we are here, the resource is offline. TraceFlow( "The local quorum resource is offline." ); if ( pcpcmThis != NULL ) { // Send a status report that we are deleting the quorum device. ++pcpcmThis->m_dwLocalQuorumStatusMax; THR( pcpcmThis->SendStatusReport( NULL , TASKID_Major_Configure_Resources , TASKID_Minor_Delete_LocalQuorum , 0 , pcpcmThis->m_dwLocalQuorumStatusMax , pcpcmThis->m_dwLocalQuorumStatusMax , HRESULT_FROM_WIN32( sc ) , NULL // don't update text , NULL , NULL ) ); } // if: the this pointer is valid // If we are here, the resource is offline - now delete it. sc = TW32( DeleteClusterResource( hLQuorumIn ) ); if ( sc != ERROR_SUCCESS ) { TraceFlow1( "Error %#08x occurred trying to delete the localquorum resource.", sc ); LogMsg( "PostCfg: Error %#08x occurred trying to delete the localquorum resource.", sc ); } // if: we could not delete the resource else { TraceFlow( "The localquorum resource has been deleted." ); LogMsg( "The localquorum resource has been deleted." ); } // else: the resource has been deleted // Send a status report that we are deleting the quorum device. ++pcpcmThis->m_dwLocalQuorumStatusMax; THR( pcpcmThis->SendStatusReport( NULL , TASKID_Major_Configure_Resources , TASKID_Minor_Delete_LocalQuorum , 0 , pcpcmThis->m_dwLocalQuorumStatusMax , pcpcmThis->m_dwLocalQuorumStatusMax , HRESULT_FROM_WIN32( sc ) , NULL // don't update text , NULL , NULL ) ); Cleanup: // // Cleanup // if ( hc != INVALID_HANDLE_VALUE ) { CloseClusterNotifyPort( hc ); } // if: we had created a cluster notification port RETURN( sc ); } // S_DwDeleteLocalQuorumResource() ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrGetCoreClusterResourceNames( // BSTR * pbstrClusterNameResourceOut // , BSTR * pbstrClusterIPAddressNameOut // , BSTR * pbstrClusterQuorumResourceNameOut // ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrGetCoreClusterResourceNames( BSTR * pbstrClusterNameResourceNameOut , HRESOURCE * phClusterNameResourceOut , BSTR * pbstrClusterIPAddressNameOut , HRESOURCE * phClusterIPAddressResourceOut , BSTR * pbstrClusterQuorumResourceNameOut , HRESOURCE * phClusterQuorumResourceOut ) { TraceFunc( "" ); Assert( pbstrClusterNameResourceNameOut != NULL ); Assert( phClusterNameResourceOut != NULL ); Assert( pbstrClusterIPAddressNameOut != NULL ); Assert( phClusterIPAddressResourceOut != NULL ); Assert( pbstrClusterQuorumResourceNameOut != NULL ); Assert( phClusterQuorumResourceOut != NULL ); HRESULT hr = S_OK; WCHAR * pszName = NULL; DWORD cchName = 33; HRESOURCE hClusterIPAddressResource = NULL; HRESOURCE hClusterNameResource = NULL; HRESOURCE hClusterQuorumResource = NULL; DWORD sc; BSTR * pbstr = NULL; HRESOURCE hResource = NULL; int idx; sc = TW32( ResUtilGetCoreClusterResources( m_hCluster, &hClusterNameResource, &hClusterIPAddressResource, &hClusterQuorumResource ) ); if ( sc != ERROR_SUCCESS ) { hr = HRESULT_FROM_WIN32( sc ); goto Cleanup; } // if: pszName = new WCHAR[ cchName ]; if ( pszName == NULL ) { goto OutOfMemory; } // if: for ( idx = 0; idx < 3; ) { switch ( idx ) { case 0: { hResource = hClusterNameResource; pbstr = pbstrClusterNameResourceNameOut; break; } // case: case 1: { hResource = hClusterIPAddressResource; pbstr = pbstrClusterIPAddressNameOut; break; } // case: case 2: { hResource = hClusterQuorumResource; pbstr = pbstrClusterQuorumResourceNameOut; break; } // case: } // switch: sc = ResUtilGetResourceName( hResource, pszName, &cchName ); if ( sc == ERROR_MORE_DATA ) { delete [] pszName; pszName = NULL; cchName++; pszName = new WCHAR[ cchName ]; if ( pszName == NULL ) { goto OutOfMemory; } // if: continue; } // if: if ( sc == ERROR_SUCCESS ) { *pbstr = TraceSysAllocString( pszName ); if ( *pbstr == NULL ) { goto OutOfMemory; } // if: pbstr = NULL; idx++; continue; } // if: if ( sc != ERROR_SUCCESS ) { TW32( sc ); hr = HRESULT_FROM_WIN32( sc ); SSR_LOG_ERR( TASKID_Major_Client_And_Server_Log , TASKID_Minor_HrGetCoreClusterResourceNames_GetResourceName , hr , L"" ); goto Cleanup; } // if: } // for: // // Give ownership to the caller // *phClusterNameResourceOut = hClusterNameResource; hClusterNameResource = NULL; *phClusterIPAddressResourceOut = hClusterIPAddressResource; hClusterIPAddressResource = NULL; *phClusterQuorumResourceOut = hClusterQuorumResource; hClusterQuorumResource = NULL; goto Cleanup; OutOfMemory: hr = THR( E_OUTOFMEMORY ); Cleanup: if ( hClusterNameResource != NULL ) { CloseClusterResource( hClusterNameResource ); } // if: if ( hClusterIPAddressResource != NULL ) { CloseClusterResource( hClusterIPAddressResource ); } // if: if ( hClusterQuorumResource != NULL ) { CloseClusterResource( hClusterQuorumResource ); } // if: if ( pbstr != NULL ) { TraceSysFreeString( *pbstr ); } // if: delete [] pszName; HRETURN( hr ); } //***CPostCfgManager::HrGetCoreClusterResourceNames /* ////////////////////////////////////////////////////////////////////////////// // // HRESULT // CPostCfgManager::HrIsLocalQuorum( BSTR bstrNameIn ) // ////////////////////////////////////////////////////////////////////////////// HRESULT CPostCfgManager::HrIsLocalQuorum( BSTR bstrNameIn ) { TraceFunc( "" ); Assert( bstrNameIn != NULL ); HRESULT hr = S_FALSE; BSTR bstrLocalQuorum = NULL; hr = THR( HrLoadStringIntoBSTR( g_hInstance, IDS_LOCAL_QUORUM_DISPLAY_NAME, &bstrLocalQuorum ) ); if ( FAILED( hr ) ) { goto Cleanup; } // if: if ( _wcsicmp( bstrNameIn, bstrLocalQuorum ) == 0 ) { hr = S_OK; } // if: else { hr = S_FALSE; } // else: Cleanup: TraceSysFreeString( bstrLocalQuorum ); HRETURN( hr ); } //***CPostCfgManager::HrIsLocalQuorum */ #if defined(DEBUG) ////////////////////////////////////////////////////////////////////////////// // // void // CPostCfgManager::DebugDumpDepencyTree( void ) // ////////////////////////////////////////////////////////////////////////////// void CPostCfgManager::DebugDumpDepencyTree( void ) { TraceFunc( "" ); ULONG idxResource; ULONG cDependents; ULONG idxDependent; BSTR bstrName; // don't free CResourceEntry * presentry; EDependencyFlags dfDependent; for ( idxResource = 0; idxResource < m_cResources ; idxResource ++ ) { presentry = m_rgpResources[ idxResource ]; THR( presentry->GetName( &bstrName ) ); DebugMsgNoNewline( "%ws(#%u) -> ", bstrName, idxResource ); THR( presentry->GetCountOfDependents( &cDependents ) ); for ( ; cDependents != 0 ; ) { cDependents --; THR( presentry->GetDependent( cDependents, &idxDependent, &dfDependent ) ); THR( m_rgpResources[ idxDependent ]->GetName( &bstrName ) ); DebugMsgNoNewline( "%ws(#%u) ", bstrName, idxDependent ); } // for: cDependents DebugMsg( L"" ); } // for: idxResource TraceFuncExit(); } // DebugDumpDepencyTree() #endif // #if defined(DEBUG)