able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/admin/msclus/clusresg.cpp

2046 lines
48 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// Module Name:
// ClusResG.cpp
//
// Description:
// Implementation of the resource group classes for the MSCLUS
// automation classes.
//
// Author:
// Charles Stacy Harris (stacyh) 28-Feb-1997
// Galen Barbee (galenb) July 1998
//
// Revision History:
// July 1998 GalenB Maaaaaajjjjjjjjjoooooorrrr clean up
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "ClusterObject.h"
#include "property.h"
#include "clusres.h"
#include "clusresg.h"
#include "clusneti.h"
#include "clusnode.h"
/////////////////////////////////////////////////////////////////////////////
// Global variables
/////////////////////////////////////////////////////////////////////////////
static const IID * iidCClusResGroup[] =
{
&IID_ISClusResGroup
};
static const IID * iidCClusResGroups[] =
{
&IID_ISClusResGroups
};
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResGroup class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::CClusResGroup
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroup::CClusResGroup( void )
{
m_hGroup = NULL;
m_pClusRefObject = NULL;
m_pClusterResources = NULL;
m_pPreferredOwnerNodes = NULL;
m_pCommonProperties = NULL;
m_pPrivateProperties = NULL;
m_pCommonROProperties = NULL;
m_pPrivateROProperties = NULL;
m_piids = (const IID *) iidCClusResGroup;
m_piidsSize = ARRAYSIZE( iidCClusResGroup );
} //*** CClusResGroup::CClusResGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::~CClusResGroup
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroup::~CClusResGroup( void )
{
if ( m_hGroup != NULL )
{
CloseClusterGroup( m_hGroup );
m_hGroup = 0;
}
if ( m_pClusterResources != NULL )
{
m_pClusterResources->Release();
m_pClusterResources = NULL;
}
if ( m_pPreferredOwnerNodes != NULL )
{
m_pPreferredOwnerNodes->Release();
m_pPreferredOwnerNodes = NULL;
}
if ( m_pCommonProperties != NULL )
{
m_pCommonProperties->Release();
m_pCommonProperties = NULL;
} // if: release the property collection
if ( m_pPrivateProperties != NULL )
{
m_pPrivateProperties->Release();
m_pPrivateProperties = NULL;
} // if: release the property collection
if ( m_pCommonROProperties != NULL )
{
m_pCommonROProperties->Release();
m_pCommonROProperties = NULL;
} // if: release the property collection
if ( m_pPrivateROProperties != NULL )
{
m_pPrivateROProperties->Release();
m_pPrivateROProperties = NULL;
} // if: release the property collection
if ( m_pClusRefObject != NULL )
{
m_pClusRefObject->Release();
m_pClusRefObject = NULL;
}
} //*** CClusResGroup::~CClusResGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Create
//
// Description:
// Finish the heavy weight construction.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// bstrGroupName [IN] - The name of this group.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroup::Create(
IN ISClusRefObject * pClusRefObject,
IN BSTR bstrGroupName
)
{
ASSERT( pClusRefObject != NULL );
ASSERT( bstrGroupName != NULL );
HRESULT _hr = E_POINTER;
if ( ( pClusRefObject != NULL ) && ( bstrGroupName != NULL ) )
{
m_pClusRefObject = pClusRefObject;
m_pClusRefObject->AddRef();
HCLUSTER _hCluster = 0;
_hr = m_pClusRefObject->get_Handle((ULONG_PTR *) &_hCluster);
if ( SUCCEEDED( _hr ) )
{
m_hGroup = ::CreateClusterGroup( _hCluster, bstrGroupName );
if ( m_hGroup == 0 )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
m_bstrGroupName = bstrGroupName;
_hr = S_OK;
}
}
}
return _hr;
} //*** CClusResGroup::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Open
//
// Description:
// Open the passed group on the cluster.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// bstrGroupName [IN] - The name of this group.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroup::Open(
IN ISClusRefObject * pClusRefObject,
IN BSTR bstrGroupName
)
{
ASSERT( pClusRefObject != NULL );
ASSERT( bstrGroupName != NULL );
HRESULT _hr = E_POINTER;
if ( ( pClusRefObject != NULL ) && ( bstrGroupName != NULL ) )
{
m_pClusRefObject = pClusRefObject;
m_pClusRefObject->AddRef();
HCLUSTER _hCluster = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
m_hGroup = ::OpenClusterGroup( _hCluster, bstrGroupName );
if ( m_hGroup == NULL )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
m_bstrGroupName = bstrGroupName;
_hr = S_OK;
}
}
}
return _hr;
} //*** CClusResGroup::Open()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::GetProperties
//
// Description:
// Creates a property collection for this object type (Resource Group).
//
// Arguments:
// ppProperties [OUT] - Catches the newly created collection.
// bPrivate [IN] - Are these private properties? Or Common?
// bReadOnly [IN] - Are these read only properties?
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroup::GetProperties(
ISClusProperties ** ppProperties,
BOOL bPrivate,
BOOL bReadOnly
)
{
//ASSERT( ppProperties != NULL );
HRESULT _hr = E_POINTER;
if ( ppProperties != NULL )
{
CComObject<CClusProperties> * pProperties = NULL;
*ppProperties = NULL;
_hr = CComObject< CClusProperties >::CreateInstance( &pProperties );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< CComObject< CClusProperties > > ptrProperties( pProperties );
_hr = ptrProperties->Create( this, bPrivate, bReadOnly );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrProperties->Refresh();
if ( SUCCEEDED( _hr ) )
{
_hr = ptrProperties->QueryInterface( IID_ISClusProperties, (void **) ppProperties );
if ( SUCCEEDED( _hr ) )
{
ptrProperties->AddRef();
if ( bPrivate )
{
if ( bReadOnly )
{
m_pPrivateROProperties = pProperties;
}
else
{
m_pPrivateProperties = pProperties;
}
}
else
{
if ( bReadOnly )
{
m_pCommonROProperties = pProperties;
}
else
{
m_pCommonProperties = pProperties;
}
}
}
}
}
}
}
return _hr;
} //*** CClusResGroup::GetProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_Handle
//
// Description:
// Returns the handle to this object (Group).
//
// Arguments:
// phandle [OUT] - Catches the handle.
//
// Return Value:
// S_OK if successful, or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_Handle( OUT ULONG_PTR * phandle )
{
//ASSERT( phandle != NULL );
HRESULT _hr = E_POINTER;
if ( phandle != NULL )
{
*phandle = (ULONG_PTR)m_hGroup;
_hr = S_OK;
}
return _hr;
} //*** CClusResGroup::get_Handle()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Close
//
// Description:
// Close the handle to the cluster object (Group).
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::Close( void )
{
DWORD _sc = ::CloseClusterGroup( m_hGroup );
if ( m_pClusRefObject )
{
m_pClusRefObject->Release();
m_pClusRefObject = NULL;
}
m_hGroup = NULL;
return HRESULT_FROM_WIN32( _sc );
} //*** CClusResGroup::Close()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::put_Name
//
// Description:
// Change the name of this object (Group).
//
// Arguments:
// bstrGroupName [IN] - The new name.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::put_Name( IN BSTR bstrGroupName )
{
//ASSERT( bstrGroupName != NULL );
HRESULT _hr = E_POINTER;
if ( bstrGroupName != NULL )
{
DWORD _sc = ::SetClusterGroupName( m_hGroup, bstrGroupName );
if ( _sc == ERROR_SUCCESS )
{
m_bstrGroupName = bstrGroupName;
}
_hr = HRESULT_FROM_WIN32( _sc );
}
return _hr;
} //*** CClusResGroup::put_Name()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_Name
//
// Description:
// Return the name of this object (Resource Group).
//
// Arguments:
// pbstrGroupName [OUT] - Catches the name of this object.
//
// Return Value:
// S_OK if successful, or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_Name( OUT BSTR * pbstrGroupName )
{
//ASSERT( pbstrGroupName != NULL );
HRESULT _hr = E_POINTER;
if ( pbstrGroupName != NULL )
{
*pbstrGroupName = m_bstrGroupName.Copy();
_hr = S_OK;
}
return _hr;
} //*** CClusResGroup::get_Name()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_State
//
// Description:
// Returns the current cluster group state for this group.
//
// Arguments:
// pcgsState [OUT] - Catches the cluster group state.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_State( OUT CLUSTER_GROUP_STATE * pcgsState )
{
//ASSERT( pcgsState != NULL );
HRESULT _hr = E_POINTER;
if ( pcgsState != NULL )
{
CLUSTER_GROUP_STATE _cgsState = ::WrapGetClusterGroupState( m_hGroup, NULL );
if ( _cgsState == ClusterGroupStateUnknown )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
*pcgsState = _cgsState;
_hr = S_OK;
}
}
return _hr;
} //*** CClusResGroup::get_State()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_OwnerNode
//
// Description:
// Returns the owner node for this group. The owner node is the node
// where the group is currently online.
//
// Arguments:
// ppOwnerNode [OUT[ - Catches the owner node interface.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_OwnerNode( OUT ISClusNode ** ppOwnerNode )
{
//ASSERT( ppOwnerNode != NULL );
HRESULT _hr = E_POINTER;
if ( ppOwnerNode != NULL )
{
DWORD _sc = 0;
PWCHAR pwszNodeName = NULL;
CLUSTER_GROUP_STATE cgs = ClusterGroupStateUnknown;
cgs = WrapGetClusterGroupState( m_hGroup, &pwszNodeName );
if ( cgs != ClusterGroupStateUnknown )
{
CComObject<CClusNode> * pNode = NULL;
*ppOwnerNode = NULL;
_hr = CComObject<CClusNode>::CreateInstance( &pNode );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
pNode->AddRef();
_hr = pNode->Open( ptrRefObject, pwszNodeName );
if ( SUCCEEDED( _hr ) )
{
_hr = pNode->QueryInterface( IID_ISClusNode, (void **) ppOwnerNode );
}
pNode->Release();
}
::LocalFree( pwszNodeName );
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResGroup::get_OwnerNode()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_Resources
//
// Description:
// Returns the collection of resources that belong to this group.
//
// Arguments:
// ppClusterGroupResources [OUT] - Catches the collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_Resources(
OUT ISClusResGroupResources ** ppClusterGroupResources
)
{
return ::HrCreateResourceCollection< CClusResGroupResources, ISClusResGroupResources, HGROUP >(
&m_pClusterResources,
m_hGroup,
ppClusterGroupResources,
IID_ISClusResGroupResources,
m_pClusRefObject
);
} //*** CClusResGroup::get_Resources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_PreferredOwnerNodes
//
// Description:
// Returns the collection of preferred owner nodes for this group.
//
// Arguments:
// ppOwnerNodes [OUT] - Catches the collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_PreferredOwnerNodes(
ISClusResGroupPreferredOwnerNodes ** ppOwnerNodes
)
{
return ::HrCreateResourceCollection< CClusResGroupPreferredOwnerNodes, ISClusResGroupPreferredOwnerNodes, HGROUP >(
&m_pPreferredOwnerNodes,
m_hGroup,
ppOwnerNodes,
IID_ISClusResGroupPreferredOwnerNodes,
m_pClusRefObject
);
} //*** CClusResGroup::get_PreferredOwnerNodes()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Delete
//
// Description:
// Removes this object (Resource Group) from the cluster.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::Delete( void )
{
DWORD _sc = ERROR_INVALID_HANDLE;
if ( m_hGroup != NULL )
{
_sc = DeleteClusterGroup( m_hGroup );
if ( _sc == ERROR_SUCCESS )
{
m_hGroup = NULL;
}
}
return HRESULT_FROM_WIN32( _sc );
} //*** CClusResGroup::Delete()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Online
//
// Description:
// Bring this group online on the passed in node, or on to the node
// it is currently offline if no node is specified.
//
// Arguments:
// varTimeout [IN] - How long in seconds to wait for the group to
// come online.
// varNode [IN] - Node to bring the group online.
// pvarPending [OUT] - Catches the pending state. True if we timed
// out before the group came completely online.
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::Online(
IN VARIANT varTimeout,
IN VARIANT varNode,
OUT VARIANT * pvarPending
)
{
//ASSERT( pNode != NULL );
//ASSERT( pvarPending != NULL );
HRESULT _hr = E_POINTER;
if ( pvarPending != NULL )
{
_hr = ::VariantChangeTypeEx( &varTimeout, &varTimeout, LOCALE_SYSTEM_DEFAULT, 0, VT_I4 );
if ( SUCCEEDED( _hr ) )
{
HNODE _hNode = NULL;
HCLUSTER _hCluster = NULL;
CComObject< CClusNode > * _pcnNode = NULL;
ISClusNode * _piscNode = NULL;
pvarPending->vt = VT_BOOL;
pvarPending->boolVal = VARIANT_FALSE;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
if ( varNode.vt == ( VT_VARIANT | VT_BYREF ) )
{
if ( varNode.pvarVal != NULL )
{
IDispatch * _pidNode = varNode.pvarVal->pdispVal;
_hr = _pidNode->QueryInterface( IID_ISClusNode, (void **) &_piscNode );
if ( SUCCEEDED( _hr ) )
{
_hr = _piscNode->get_Handle( (ULONG_PTR *) &_hNode );
_piscNode->Release();
} // if: did we get the ISClusNode interface?
} // if: we have a variant value pointer
} // if: was the option parameter present?
else if ( varNode.vt == VT_DISPATCH )
{
IDispatch * _pidNode = varNode.pdispVal;
_hr = _pidNode->QueryInterface( IID_ISClusNode, (void **) &_piscNode );
if ( SUCCEEDED( _hr ) )
{
_hr = _piscNode->get_Handle( (ULONG_PTR *) &_hNode );
_piscNode->Release();
} // if: did we get the ISClusNode interface?
} // else if: we have a dispatch variant
else if ( varNode.vt == VT_BSTR )
{
_hr = CComObject< CClusNode >::CreateInstance( &_pcnNode );
if ( SUCCEEDED( _hr ) )
{
_pcnNode->AddRef();
_hr = _pcnNode->Open( m_pClusRefObject, ( varNode.vt & VT_BYREF) ? (*varNode.pbstrVal) : varNode.bstrVal );
if ( SUCCEEDED( _hr ) )
{
_hr = _pcnNode->get_Handle( (ULONG_PTR *) &_hNode );
} // if:
} // if:
} // else if: we have a string variant
else if ( varNode.vt == VT_EMPTY )
{
_hNode = NULL;
} // else if: it is empty
else if ( ( varNode.vt == VT_ERROR ) && ( varNode.scode == DISP_E_PARAMNOTFOUND ) )
{
_hNode = NULL;
} // else if: the optional parameter was not specified
else
{
_hr = ::VariantChangeTypeEx( &varNode, &varNode, LOCALE_SYSTEM_DEFAULT, 0, VT_I4 );
if ( SUCCEEDED( _hr ) )
{
if ( varNode.lVal != 0 )
{
_hr = E_INVALIDARG;
} // if: this is not zero then we cannot accept this parameter format. If varNode.lVal was zero then we could assume it was a NULL arg...
} // if: coerce to a long
} // else: the node variant could be invalid -- check for a zero, and if found treat it like a NULL...
if ( SUCCEEDED( _hr ) )
{
BOOL bPending = FALSE;
_hr = ::HrWrapOnlineClusterGroup(
_hCluster,
m_hGroup,
_hNode,
varTimeout.lVal,
(long *) &bPending
);
if ( SUCCEEDED( _hr ) )
{
if ( bPending )
{
pvarPending->boolVal = VARIANT_TRUE;
} // if: pending?
} // if: online succeeded
} // if: we have a node handle
} // if: get_Handle() -- cluster handle
if ( _pcnNode != NULL )
{
_pcnNode->Release();
} // if: did we create a node?
} // if: wasn't the right type
} //if: pvarPending != NULL
return _hr;
} //*** CClusResGroup::Online()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Move
//
// Description:
// Move this group to the passed in node, or to the best available node
// if no node was passed, and restore its online state.
//
// Arguments:
// varTimeout [IN] - How long in seconds to wait for the group to
// come move and complete stat restoration.
// varNode [IN] - Node to move the group to.
// pvarPending [OUT] - Catches the pending state. True if we timed
// out before the group came completely online.
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::Move(
IN VARIANT varTimeout,
IN VARIANT varNode,
OUT VARIANT * pvarPending
)
{
//ASSERT( pNode != NULL );
//ASSERT( pvarPending != NULL );
HRESULT _hr = E_POINTER;
if ( pvarPending != NULL )
{
_hr = ::VariantChangeTypeEx( &varTimeout, &varTimeout, LOCALE_SYSTEM_DEFAULT, 0, VT_I4 );
if ( SUCCEEDED( _hr ) )
{
HNODE _hNode = NULL;
HCLUSTER _hCluster = NULL;
CComObject< CClusNode > * _pcnNode = NULL;
ISClusNode * _piscNode = NULL;
pvarPending->vt = VT_BOOL;
pvarPending->boolVal = VARIANT_FALSE;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
if ( varNode.vt == ( VT_VARIANT | VT_BYREF ) )
{
if ( varNode.pvarVal != NULL )
{
IDispatch * _pidNode = varNode.pvarVal->pdispVal;
_hr = _pidNode->QueryInterface( IID_ISClusNode, (void **) &_piscNode );
if ( SUCCEEDED( _hr ) )
{
_hr = _piscNode->get_Handle( (ULONG_PTR *) &_hNode );
_piscNode->Release();
} // if: did we get the ISClusNode interface?
} // if: we have a variant value pointer
} // if: was the option parameter present?
else if ( varNode.vt == VT_DISPATCH )
{
IDispatch * _pidNode = varNode.pdispVal;
_hr = _pidNode->QueryInterface( IID_ISClusNode, (void **) &_piscNode );
if ( SUCCEEDED( _hr ) )
{
_hr = _piscNode->get_Handle( (ULONG_PTR *) &_hNode );
_piscNode->Release();
} // if: did we get the ISClusNode interface?
} // else if: we have a dispatch variant
else if ( varNode.vt == VT_BSTR )
{
_hr = CComObject< CClusNode >::CreateInstance( &_pcnNode );
if ( SUCCEEDED( _hr ) )
{
_pcnNode->AddRef();
_hr = _pcnNode->Open( m_pClusRefObject, ( varNode.vt & VT_BYREF) ? (*varNode.pbstrVal) : varNode.bstrVal );
if ( SUCCEEDED( _hr ) )
{
_hr = _pcnNode->get_Handle( (ULONG_PTR *) &_hNode );
} // if:
} // if:
} // else if: we have a string variant
else if ( varNode.vt == VT_EMPTY )
{
_hNode = NULL;
} // else if: it is empty
else if ( ( varNode.vt == VT_ERROR ) && ( varNode.scode == DISP_E_PARAMNOTFOUND ) )
{
_hNode = NULL;
} // else if: the optional parameter was not specified
else
{
_hr = ::VariantChangeTypeEx( &varNode, &varNode, LOCALE_SYSTEM_DEFAULT, 0, VT_I4 );
if ( SUCCEEDED( _hr ) )
{
if ( varNode.lVal != 0 )
{
_hr = E_INVALIDARG;
} // if: this is not zero then we cannot accept this parameter format. If varNode.lVal was zero then we could assume it was a NULL arg...
} // if: coerce to a long
} // else: the node variant could be invalid -- check for a zero, and if found treat it like a NULL...
if ( SUCCEEDED( _hr ) )
{
BOOL bPending = FALSE;
_hr = ::HrWrapMoveClusterGroup(
_hCluster,
m_hGroup,
_hNode,
varTimeout.lVal,
(long *) &bPending
);
if ( SUCCEEDED( _hr ) )
{
if ( bPending )
{
pvarPending->boolVal = VARIANT_TRUE;
} // if: pending?
} // if: Move group succeeded
} // if: we have all handles
} // if: get_Handle() -- cluster handle
if ( _pcnNode != NULL )
{
_pcnNode->Release();
} // if: did we create a node?
} // if: wasn't the right type
} //if: pvarPending != NULL
return _hr;
} //*** CClusResGroup::Move()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::Offline
//
// Description:
// Take the group offline.
//
// Arguments:
// varTimeout [IN] - How long in seconds to wait for the group to
// go offline.
// pvarPending [OUT] - Catches the pending state. True if we timed
// out before the group came completely online.
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::Offline(
IN VARIANT varTimeout,
OUT VARIANT * pvarPending
)
{
//ASSERT( nTimeout >= 0 );
//ASSERT( pvarPending != NULL );
HRESULT _hr = E_POINTER;
if ( pvarPending != NULL )
{
_hr = ::VariantChangeTypeEx( &varTimeout, &varTimeout, LOCALE_SYSTEM_DEFAULT, 0, VT_I4 );
if ( SUCCEEDED( _hr ) )
{
HCLUSTER _hCluster;
pvarPending->vt = VT_BOOL;
pvarPending->boolVal = VARIANT_FALSE;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
BOOL bPending = FALSE;
_hr = ::HrWrapOfflineClusterGroup( _hCluster, m_hGroup, varTimeout.lVal, (long *) &bPending );
if ( SUCCEEDED( _hr ) )
{
if ( bPending )
{
pvarPending->boolVal = VARIANT_TRUE;
} // if: pending?
} // if: offline group succeeded
} // if: get_Handle() -- cluster handle
} // if: wasn't the right type
} //if: pvarPending != NULL
return _hr;
} //*** CClusResGroup::Offline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_CommonProperties
//
// Description:
// Get this object's (Resource Group) common properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_CommonProperties(
OUT ISClusProperties ** ppProperties
)
{
//ASSERT( ppProperties != NULL );
HRESULT _hr = E_POINTER;
if ( ppProperties != NULL )
{
if ( m_pCommonProperties )
{
_hr = m_pCommonProperties->QueryInterface( IID_ISClusProperties, (void **) ppProperties );
}
else
{
_hr = GetProperties( ppProperties, FALSE, FALSE );
}
}
return _hr;
} //*** CClusResGroup::get_CommonProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_PrivateProperties
//
// Description:
// Get this object's (Resource Group) private properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_PrivateProperties(
OUT ISClusProperties ** ppProperties
)
{
//ASSERT( ppProperties != NULL );
HRESULT _hr = E_POINTER;
if ( ppProperties != NULL )
{
if ( m_pPrivateProperties )
{
_hr = m_pPrivateProperties->QueryInterface( IID_ISClusProperties, (void **) ppProperties );
}
else
{
_hr = GetProperties( ppProperties, TRUE, FALSE );
}
}
return _hr;
} //*** CClusResGroup::get_PrivateProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_CommonROProperties
//
// Description:
// Get this object's (Resource Group) common read only properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_CommonROProperties(
OUT ISClusProperties ** ppProperties
)
{
//ASSERT( ppProperties != NULL );
HRESULT _hr = E_POINTER;
if ( ppProperties != NULL )
{
if ( m_pCommonROProperties )
{
_hr = m_pCommonROProperties->QueryInterface( IID_ISClusProperties, (void **) ppProperties );
}
else
{
_hr = GetProperties( ppProperties, FALSE, TRUE );
}
}
return _hr;
} //*** CClusResGroup::get_CommonROProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_PrivateROProperties
//
// Description:
// Get this object's (Resource Group) private read only properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_PrivateROProperties(
OUT ISClusProperties ** ppProperties
)
{
//ASSERT( ppProperties != NULL );
HRESULT _hr = E_POINTER;
if ( ppProperties != NULL )
{
if ( m_pPrivateROProperties )
{
_hr = m_pPrivateROProperties->QueryInterface( IID_ISClusProperties, (void **) ppProperties );
}
else
{
_hr = GetProperties( ppProperties, TRUE, TRUE );
}
}
return _hr;
} //*** CClusResGroup::get_PrivateROProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::get_Cluster
//
// Description:
// Returns the cluster object for the cluster where this group lives.
//
// Arguments:
// ppCluster [OUT] - Catches the cluster object.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroup::get_Cluster( OUT ISCluster ** ppCluster )
{
return ::HrGetCluster( ppCluster, m_pClusRefObject );
} //*** CClusResGroup::get_Cluster()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::HrLoadProperties
//
// Description:
// This virtual function does the actual load of the property list from
// the cluster.
//
// Arguments:
// rcplPropList [IN OUT] - The property list to load.
// bReadOnly [IN] - Load the read only properties?
// bPrivate [IN] - Load the common or the private properties?
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroup::HrLoadProperties(
IN OUT CClusPropList & rcplPropList,
IN BOOL bReadOnly,
IN BOOL bPrivate
)
{
HRESULT _hr = S_FALSE;
DWORD _dwControlCode = 0;
DWORD _sc = ERROR_SUCCESS;
if ( bReadOnly )
{
_dwControlCode = bPrivate
? CLUSCTL_GROUP_GET_RO_PRIVATE_PROPERTIES
: CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES;
}
else
{
_dwControlCode = bPrivate
? CLUSCTL_GROUP_GET_PRIVATE_PROPERTIES
: CLUSCTL_GROUP_GET_COMMON_PROPERTIES;
}
_sc = rcplPropList.ScGetGroupProperties( m_hGroup, _dwControlCode );
_hr = HRESULT_FROM_WIN32( _sc );
return _hr;
} //*** CClusResGroup::HrLoadProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroup::ScWriteProperties
//
// Description:
// This virtual function does the actual saving of the property list to
// the cluster.
//
// Arguments:
// rcplPropList [IN] - The property list to save.
// bPrivate [IN] - Save the common or the private properties?
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusResGroup::ScWriteProperties(
const CClusPropList & rcplPropList,
BOOL bPrivate
)
{
DWORD dwControlCode = bPrivate ? CLUSCTL_GROUP_SET_PRIVATE_PROPERTIES : CLUSCTL_GROUP_SET_COMMON_PROPERTIES;
DWORD nBytesReturned = 0;
DWORD _sc = ERROR_SUCCESS;
_sc = ClusterGroupControl(
m_hGroup,
NULL,
dwControlCode,
rcplPropList,
rcplPropList.CbBufferSize(),
0,
0,
&nBytesReturned
);
return _sc;
} //*** CClusResGroup::ScWriteProperties()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResGroups class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::CClusResGroups
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroups::CClusResGroups( void )
{
m_pClusRefObject = NULL;
m_piids = (const IID *) iidCClusResGroups;
m_piidsSize = ARRAYSIZE( iidCClusResGroups );
} //*** CClusResGroups::CClusResGroups()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::~CClusResGroups
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroups::~CClusResGroups( void )
{
Clear();
if ( m_pClusRefObject != NULL )
{
m_pClusRefObject->Release();
m_pClusRefObject = NULL;
}
} //*** CClusResGroups::~CClusResGroups()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::Create
//
// Description:
// Finish the heavy weight construction.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// pwszNodeName [IN] - Optional node name. If this argument
// is supplied then this is a collection of
// groups that are owned by that node.
//
// Return Value:
// S_OK if successful, or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::Create(
IN ISClusRefObject * pClusRefObject,
IN LPCWSTR pwszNodeName
)
{
ASSERT( pClusRefObject != NULL );
//ASSERT( pwszNodeName != NULL );
HRESULT _hr = E_POINTER;
if ( ( pClusRefObject != NULL ) /*&& ( pwszNodeName != NULL )*/ )
{
m_pClusRefObject= pClusRefObject;
m_pClusRefObject->AddRef();
m_bstrNodeName = pwszNodeName;
_hr = S_OK;
}
return _hr;
} //*** CClusResGroups::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::FindItem
//
// Description:
// Find the passed in group in the collection.
//
// Arguments:
// pszGroupName [IN] - The name of the group to find.
// pnIndex [OUT] - Catches the index of the group.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG if the group was
// not found.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::FindItem(
IN LPWSTR pszGroupName,
OUT ULONG * pnIndex
)
{
//ASSERT( pszGroupName != NULL );
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( ( pszGroupName != NULL ) && ( pnIndex != NULL ) )
{
CComObject<CClusResGroup> * pGroup = NULL;
int nMax = m_ResourceGroups.size();
_hr = E_INVALIDARG;
for( int i = 0; i < nMax; i++ )
{
pGroup = m_ResourceGroups[ i ];
if ( pGroup && ( lstrcmpi( pszGroupName, pGroup->Name() ) == 0 ) )
{
*pnIndex = i;
_hr = S_OK;
break;
}
}
}
return _hr;
} //*** CClusResGroups::FindItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::FindItem
//
// Description:
// Find the passed in group in the collection.
//
// Arguments:
// pResourceGroup [IN] - The group to find.
// pnIndex [OUT] - Catches the index of the group.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG is the group was
// not found.
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::FindItem(
IN ISClusResGroup * pResourceGroup,
OUT ULONG * pnIndex
)
{
//ASSERT( pResourceGroup != NULL );
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( ( pResourceGroup != NULL ) && ( pnIndex != NULL ) )
{
CComBSTR _bstrName;
_hr = pResourceGroup->get_Name( &_bstrName );
if ( SUCCEEDED( _hr ) )
{
_hr = FindItem( _bstrName, pnIndex );
}
}
return _hr;
} //*** CClusResGroups::FindItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::GetIndex
//
// Description:
// Get the index from the passed in variant.
//
// Arguments:
// varIndex [IN] - Hold the index. This is a one based number,
// or the name of the group as a string.
// pnIndex [OUT] - Catches the zero based index in the collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG if the index is out
// of range.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::GetIndex(
IN VARIANT varIndex,
OUT ULONG * pnIndex
)
{
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( pnIndex != NULL )
{
CComVariant v;
ULONG nIndex = 0;
*pnIndex = 0;
v.Copy( &varIndex );
// Check to see if the index is a number.
_hr = v.ChangeType( VT_I4 );
if ( SUCCEEDED( _hr ) )
{
nIndex = v.lVal;
nIndex--; // Adjust index to be 0 relative instead of 1 relative
}
else
{
// Check to see if the index is a string.
_hr = v.ChangeType( VT_BSTR );
if ( SUCCEEDED( _hr ) )
{
// Search for the string.
_hr = FindItem( v.bstrVal, &nIndex );
}
}
// We found an index, now check the range.
if ( SUCCEEDED( _hr ) )
{
if ( nIndex < m_ResourceGroups.size() )
{
*pnIndex = nIndex;
}
else
{
_hr = E_INVALIDARG;
}
}
}
return _hr;
} //*** CClusResGroups::GetIndex()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::RemoveAt
//
// Description:
// Remove the object (Group) at the passed in index/position from the
// collection.
//
// Arguments:
// nPos [IN] - Index of the object to remove.
//
// Return Value:
// S_OK if successful, or E_INVALIDARG is the index is out of range.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::RemoveAt( IN size_t pos )
{
CComObject<CClusResGroup> * pResourceGroup = NULL;
ResourceGroupList::iterator first = m_ResourceGroups.begin();
ResourceGroupList::iterator last = m_ResourceGroups.end();
HRESULT _hr = E_INVALIDARG;
for ( size_t t = 0; ( t < pos ) && ( first != last ); t++, first++ );
if ( first != last )
{
pResourceGroup = *first;
if ( pResourceGroup )
{
pResourceGroup->Release();
}
m_ResourceGroups.erase( first );
_hr = S_OK;
}
return _hr;
} //*** CClusResGroups::RemoveAt()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::get_Count
//
// Description:
// Returns the count of elements (Groups) in the collection.
//
// Arguments:
// plCount [OUT] - Catches the count.
//
// Return Value:
// S_OK if successful, or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::get_Count( OUT long * plCount )
{
//ASSERT( plCount != NULL );
HRESULT _hr = E_POINTER;
if ( plCount != NULL )
{
*plCount = m_ResourceGroups.size();
_hr = S_OK;
}
return _hr;
} //*** CClusResGroups::get_Count()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::Clear
//
// Description:
// Clean out the vector of ClusResGroup objects.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CClusResGroups::Clear( void )
{
::ReleaseAndEmptyCollection< ResourceGroupList, CComObject< CClusResGroup > >( m_ResourceGroups );
} //*** CClusResGroups::Clear()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::get_Item
//
// Description:
// Returns the object (Group) at the passed in index.
//
// Arguments:
// varIndex [IN] - Hold the index. This is a one based number, or
// a string that is the name of the group to get.
// ppProperty [OUT] - Catches the property.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG if the index is out
// of range, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::get_Item(
IN VARIANT varIndex,
OUT ISClusResGroup ** ppResourceGroup
)
{
//ASSERT( ppResourceGroup != NULL );
HRESULT _hr = E_POINTER;
if ( ppResourceGroup != NULL )
{
CComObject<CClusResGroup> * pGroup = NULL;
// Zero the out param
*ppResourceGroup = NULL;
ULONG nIndex = 0;
_hr = GetIndex( varIndex, &nIndex );
if ( SUCCEEDED( _hr ) )
{
pGroup = m_ResourceGroups[ nIndex ];
_hr = pGroup->QueryInterface( IID_ISClusResGroup, (void **) ppResourceGroup );
}
}
return _hr;
} //*** CClusResGroups::get_Item()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::get__NewEnum
//
// Description:
// Create and return a new enumeration for this collection.
//
// Arguments:
// ppunk [OUT] - Catches the new enumeration.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::get__NewEnum(
IUnknown ** ppunk
)
{
return ::HrNewIDispatchEnum< ResourceGroupList, CComObject< CClusResGroup > >( ppunk, m_ResourceGroups );
} //*** CClusResGroups::get__NewEnum()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::CreateItem
//
// Description:
// Create a new object (Group) and add it to the collection.
//
// Arguments:
// bstrResourceGroupName [IN] - The name of the new group.
// ppResourceGroup [OUT] - Catches the new object.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::CreateItem(
IN BSTR bstrResourceGroupName,
OUT ISClusResGroup ** ppResourceGroup
)
{
//ASSERT( bstrResourceGroupName != NULL );
//ASSERT( ppResourceGroup != NULL );
HRESULT _hr = E_POINTER;
if ( ( bstrResourceGroupName != NULL ) && ( ppResourceGroup != NULL ) )
{
ULONG nIndex;
*ppResourceGroup = NULL;
_hr = FindItem( bstrResourceGroupName, &nIndex );
if ( FAILED( _hr ) )
{
CComObject< CClusResGroup > * pResourceGroup = NULL;
_hr = CComObject< CClusResGroup >::CreateInstance( &pResourceGroup );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResGroup > > ptrGroup( pResourceGroup );
_hr = ptrGroup->Create( ptrRefObject, bstrResourceGroupName );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrGroup->QueryInterface( IID_ISClusResGroup, (void **) ppResourceGroup );
if ( SUCCEEDED( _hr ) )
{
ptrGroup->AddRef();
m_ResourceGroups.insert( m_ResourceGroups.end(), ptrGroup );
}
}
}
} // if: group already exists
else
{
CComObject< CClusResGroup > * pResourceGroup = NULL;
pResourceGroup = m_ResourceGroups[ nIndex ];
_hr = pResourceGroup->QueryInterface( IID_ISClusResGroup, (void **) ppResourceGroup );
}
}
return _hr;
} //*** CClusResGroups::CreateItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::DeleteItem
//
// Description:
// Deletes the object (group) at the passed in index.
//
// Arguments:
// varIndex [IN] - The index of the object to delete.
//
// Return Value:
// S_OK if successful, E_INVALIDARG, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::DeleteItem( IN VARIANT varIndex )
{
HRESULT _hr = S_OK;
ULONG nIndex = 0;
_hr = GetIndex( varIndex, &nIndex );
if ( SUCCEEDED( _hr ) )
{
ISClusResGroup * pResourceGroup = (ISClusResGroup *) m_ResourceGroups[ nIndex ];
// Delete the resource group.
_hr = pResourceGroup->Delete();
if ( SUCCEEDED( _hr ) )
{
RemoveAt( nIndex );
}
}
return _hr;
} //*** CClusResGroups::DeleteItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::Refresh
//
// Description:
// Load the collection from the cluster.
//
// Arguments:
// None.
//
// Return Value:
// S_OK is successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroups::Refresh( void )
{
Clear();
if ( m_pClusRefObject == NULL )
{
return E_POINTER;
} // if: we have a cluster handle wrapper
if ( m_bstrNodeName == (BSTR) NULL )
{
return RefreshCluster();
} // if: this collection is for a cluster
else
{
return RefreshNode();
} // else: this collection is for a node
} //*** CClusResGroups::Refresh()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::RefreshCluster
//
// Description:
// Load all of the groups in the cluster into this collection.
//
// Arguments:
// None.
//
// Return Value:
// S_OK is successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::RefreshCluster( void )
{
HCLUSTER _hCluster = NULL;
HRESULT _hr;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
HCLUSENUM hEnum = NULL;
DWORD _sc = ERROR_SUCCESS;
hEnum = ::ClusterOpenEnum( _hCluster, CLUSTER_ENUM_GROUP );
if ( hEnum != NULL )
{
DWORD dwType;
LPWSTR pwszName = NULL;
CComObject< CClusResGroup > * pResourceGroup = NULL;
int nIndex;
for( nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); nIndex++ )
{
_sc = ::WrapClusterEnum( hEnum, nIndex, &dwType, &pwszName );
if ( _sc == ERROR_NO_MORE_ITEMS)
{
_hr = S_OK;
break;
}
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResGroup >::CreateInstance( &pResourceGroup );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResGroup > > ptrGroup( pResourceGroup );
_hr = ptrGroup->Open( ptrRefObject, pwszName );
if ( SUCCEEDED( _hr ) )
{
ptrGroup->AddRef();
m_ResourceGroups.insert( m_ResourceGroups.end(), ptrGroup );
}
}
::LocalFree( pwszName );
pwszName = NULL;
}
else
{
_hr = HRESULT_FROM_WIN32( _sc );
}
} // end for
::ClusterCloseEnum( hEnum ) ;
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResGroups::RefreshCluster()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroups::RefreshNode
//
// Description:
// Load all of the groups owned by the node at m_bstrNodeName.
//
// Arguments:
// None.
//
// Return Value:
// S_OK is successful, or Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroups::RefreshNode( void )
{
HCLUSTER _hCluster = NULL;
HRESULT _hr;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &_hCluster );
if ( SUCCEEDED( _hr ) )
{
HCLUSENUM hEnum = NULL;
DWORD _sc = ERROR_SUCCESS;
hEnum = ::ClusterOpenEnum( _hCluster, CLUSTER_ENUM_GROUP );
if ( hEnum != NULL )
{
DWORD dwType;
LPWSTR pwszName = NULL;
LPWSTR pwszNodeName = NULL;
CComObject< CClusResGroup > * pResourceGroup = NULL;
CLUSTER_GROUP_STATE cgs = ClusterGroupStateUnknown;
int _nIndex;
for( _nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); _nIndex++ )
{
_sc = ::WrapClusterEnum( hEnum, _nIndex, &dwType, &pwszName );
if ( _sc == ERROR_NO_MORE_ITEMS )
{
_hr = S_OK;
break;
}
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResGroup >::CreateInstance( &pResourceGroup );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResGroup > > ptrGroup( pResourceGroup );
_hr = ptrGroup->Open( ptrRefObject, pwszName );
if ( SUCCEEDED( _hr ) )
{
cgs = WrapGetClusterGroupState( ptrGroup->Hgroup(), &pwszNodeName );
if ( cgs != ClusterGroupStateUnknown )
{
if ( lstrcmpi( m_bstrNodeName, pwszNodeName ) == 0 )
{
ptrGroup->AddRef();
m_ResourceGroups.insert( m_ResourceGroups.end(), ptrGroup );
}
::LocalFree( pwszNodeName );
pwszNodeName = NULL;
}
}
}
::LocalFree( pwszName );
pwszName = NULL;
}
else
{
_hr = HRESULT_FROM_WIN32( _sc );
}
} // for:
::ClusterCloseEnum( hEnum );
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResGroups::RefreshNode()
Reference in a new issue Copy permalink