archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/base/cluster/admin/msclus/clusres.cpp

4167 lines
122 KiB
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1997-2002 Microsoft Corporation
//
// Module Name:
// ClusRes.cpp
//
// Description:
// Implementation of the resource 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 <Winbase.h>
#include "ClusterObject.h"
#include "property.h"
#include "clusres.h"
#include "clusresg.h"
#include "clusrest.h"
#include "clusneti.h"
#include "clusnode.h"
/////////////////////////////////////////////////////////////////////////////
// Global variables
/////////////////////////////////////////////////////////////////////////////
static const IID * iidCClusResource[] =
{
&IID_ISClusResource
};
static const IID * iidCClusResources[] =
{
&IID_ISClusResources
};
static const IID * iidCClusResDependencies[] =
{
&IID_ISClusResDependencies
};
static const IID * iidCClusResDependents[] =
{
&IID_ISClusResDependents
};
static const IID * iidCClusResGroupResources[] =
{
&IID_ISClusResGroupResources
};
static const IID * iidCClusResTypeResources[] =
{
&IID_ISClusResTypeResources
};
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResource class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::CClusResource
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResource::CClusResource( void )
{
m_hResource = NULL;
m_pClusRefObject = NULL;
m_pCommonProperties = NULL;
m_pPrivateProperties = NULL;
m_pCommonROProperties = NULL;
m_pPrivateROProperties = NULL;
m_piids = (const IID *) iidCClusResource;
m_piidsSize = ARRAYSIZE( iidCClusResource );
} //*** CClusResource::CClusResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::~CClusResource
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResource::~CClusResource( void )
{
if ( m_hResource != NULL )
{
::CloseClusterResource( m_hResource );
m_hResource = NULL;
} // if:
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;
} // if: release the property collection
} //*** CClusResource::~CClusResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Create
//
// Description:
// Finish creating the object.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// hGroup [IN] - Group to create the resource in.
// bstrResourceName [IN] - Name of the new resource.
// bstrResourceType [IN] - The type of resource to create.
// dwFlags [IN] - Creatation flags, separate resmon, etc.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResource::Create(
IN ISClusRefObject * pClusRefObject,
IN HGROUP hGroup,
IN BSTR bstrResourceName,
IN BSTR bstrResourceType,
IN long dwFlags
)
{
ASSERT( pClusRefObject != NULL );
ASSERT( bstrResourceName != NULL );
ASSERT( bstrResourceType != NULL );
HRESULT _hr = E_POINTER;
if ( ( pClusRefObject != NULL ) &&
( bstrResourceName != NULL ) &&
( bstrResourceType != NULL ) )
{
m_pClusRefObject = pClusRefObject;
m_pClusRefObject->AddRef();
m_hResource = ::CreateClusterResource( hGroup, bstrResourceName, bstrResourceType, dwFlags );
if ( m_hResource == NULL )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
m_bstrResourceName = bstrResourceName;
_hr= S_OK;
}
}
/*
if ( _hr == S_OK )
{
OutputDebugStringW( L"CClusResource::Create() succeeded.\n" );
} // if: success!
else
{
WCHAR sz[ 256 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CClusResource::Create() failed. (hr = %#08x)\n", _hr );
OutputDebugStringW( sz );
} // else: failure...
*/
return _hr;
} //*** CClusResource::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Open
//
// Description:
// Open a handle to the resource object on the cluster.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// bstrResourceName [IN] - Name of the resource to open.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResource::Open(
IN ISClusRefObject * pClusRefObject,
IN BSTR bstrResourceName
)
{
ASSERT( pClusRefObject != NULL );
ASSERT( bstrResourceName != NULL );
HRESULT _hr = E_POINTER;
if ( ( pClusRefObject != NULL ) && ( bstrResourceName != NULL ) )
{
m_pClusRefObject = pClusRefObject;
m_pClusRefObject->AddRef();
HCLUSTER hCluster;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
m_hResource = OpenClusterResource( hCluster, bstrResourceName );
if ( m_hResource == NULL )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
m_bstrResourceName = bstrResourceName;
_hr = S_OK;
}
}
}
return _hr;
} //*** CClusResource::Open()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::GetProperties
//
// Description:
// Creates a property collection for this object type (Resource).
//
// 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 CClusResource::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 = ptrProperties;
}
else
{
m_pPrivateProperties = ptrProperties;
}
}
else
{
if ( bReadOnly )
{
m_pCommonROProperties = ptrProperties;
}
else
{
m_pCommonProperties = ptrProperties;
}
}
}
}
}
}
}
return _hr;
} //*** CClusResource::GetProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Handle
//
// Description:
// Return the handle to this object (Resource).
//
// Arguments:
// phandle [OUT] - Catches the handle.
//
// Return Value:
// S_OK if successful, or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Handle(
OUT ULONG_PTR * phandle
)
{
//ASSERT( phandle != NULL );
HRESULT _hr = E_POINTER;
if ( phandle != NULL )
{
*phandle = (ULONG_PTR) m_hResource;
_hr = S_OK;
}
return _hr;
} //*** CClusResource::get_Handle()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Close
//
// Description:
// Close the handle to the cluster object (Resource).
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::Close( void )
{
HRESULT _hr = E_POINTER;
if ( m_hResource != NULL )
{
if ( CloseClusterResource( m_hResource ) )
{
m_hResource = NULL;
_hr = S_OK;
}
else
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::Close()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::put_Name
//
// Description:
// Change the name of this object (Resource).
//
// Arguments:
// bstrResourceName [IN] - The new name.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::put_Name( IN BSTR bstrResourceName )
{
//ASSERT( bstrResourceName != NULL );
HRESULT _hr = E_POINTER;
if ( bstrResourceName != NULL )
{
DWORD _sc = ERROR_SUCCESS;
_sc = ::SetClusterResourceName( m_hResource, bstrResourceName );
if ( _sc == ERROR_SUCCESS )
{
m_bstrResourceName = bstrResourceName;
}
_hr = HRESULT_FROM_WIN32( _sc );
}
return _hr;
} //*** CClusResource::put_Name()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Name
//
// Description:
// Return the name of this object (Resource).
//
// Arguments:
// pbstrResourceName [OUT] - Catches the name of this object.
//
// Return Value:
// S_OK if successful, E_POINTER, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Name( OUT BSTR * pbstrResourceName )
{
//ASSERT( pbstrResourceName != NULL );
HRESULT _hr = E_POINTER;
if ( pbstrResourceName != NULL )
{
*pbstrResourceName = m_bstrResourceName.Copy();
_hr = S_OK;
}
return _hr;
} //*** CClusResource::get_Name()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_State
//
// Description:
// Returs the current state of this object (Resource).
//
// Arguments:
// pcrsState [OUT] - Catches the resource's state.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_State(
OUT CLUSTER_RESOURCE_STATE * pcrsState
)
{
//ASSERT( pcrsState != NULL );
HRESULT _hr = E_POINTER;
if ( pcrsState != NULL )
{
CLUSTER_RESOURCE_STATE crsState = ::WrapGetClusterResourceState( m_hResource, NULL, NULL );
if ( crsState == ClusterResourceStateUnknown )
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
*pcrsState = crsState;
_hr = S_OK;
}
}
return _hr;
} //*** CClusResource::get_State()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_CoreFlag
//
// Description:
// Returns this object's (Resource) core flags.
//
// Arguments:
// pFlags [OUT] - Catches the flags.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_CoreFlag(
OUT CLUS_FLAGS * pFlags
)
{
//ASSERT( pFlags != NULL );
HRESULT _hr = E_POINTER;
if ( pFlags != NULL )
{
DWORD _sc = ERROR_SUCCESS;
DWORD dwData;
DWORD cbData;
_sc = ::ClusterResourceControl(
m_hResource,
NULL,
CLUSCTL_RESOURCE_GET_FLAGS,
NULL,
0,
&dwData,
sizeof( dwData ),
&cbData
);
if ( _sc != ERROR_SUCCESS )
{
_hr = HRESULT_FROM_WIN32( _sc );
}
else
{
*pFlags = (CLUS_FLAGS) dwData;
_hr = S_OK;
}
}
return _hr;
} //*** CClusResource::get_CoreFlag()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::BecomeQuorumResource
//
// Description:
// Make this resource (Physical Disk) the quorum resource.
//
// Arguments:
// bstrDevicePath [IN] - Path to the quorum device.
// lMaxLogSize [IN] - Maximun quorum log file size.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::BecomeQuorumResource(
IN BSTR bstrDevicePath,
IN long lMaxLogSize
)
{
//ASSERT( bstrDevicePath != NULL );
HRESULT _hr = E_POINTER;
if ( bstrDevicePath != NULL )
{
if ( m_hResource != NULL )
{
DWORD _sc = ERROR_SUCCESS;
_sc = ::SetClusterQuorumResource( m_hResource, bstrDevicePath, lMaxLogSize );
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::BecomeQuorumResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Delete
//
// Description:
// Removes this object (Resource) from the cluster.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::Delete( void )
{
DWORD _sc = ERROR_INVALID_HANDLE;
if ( m_hResource != NULL )
{
_sc = ::DeleteClusterResource( m_hResource );
if ( _sc == ERROR_SUCCESS )
{
m_hResource = NULL;
}
}
/*
if ( _sc == ERROR_SUCCESS )
{
OutputDebugStringW( L"CClusResource::Delete() succeeded.\n" );
} // if: success!
else
{
WCHAR sz[ 256 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CClusResource::Delete() failed. (m_hResource = %d) (sc = %#08x)\n", m_hResource, _sc );
OutputDebugStringW( sz );
} // else: failure...
*/
return HRESULT_FROM_WIN32( _sc );
} //*** CClusResource::Delete()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Fail
//
// Description:
// Initiate a failure in this resource.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::Fail( void )
{
HRESULT _hr = E_POINTER;
if ( m_hResource != NULL )
{
DWORD _sc = ERROR_SUCCESS;
_sc = ::FailClusterResource( m_hResource );
_hr = HRESULT_FROM_WIN32( _sc );
}
return _hr;
} //*** CClusResource::Fail()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Online
//
// Description:
// Bring this resource online.
//
// Arguments:
// nTimeut [IN] - How long in seconds to wait for the resource
// to come online.
// pvarPending [OUT] - Catches the pending state. True if the
// resource was not online when the timeout
// expired.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::Online(
IN long nTimeout,
OUT VARIANT * pvarPending
)
{
//ASSERT( pvarPending != NULL );
HRESULT _hr = E_POINTER;
if ( pvarPending != NULL )
{
pvarPending->vt = VT_BOOL;
pvarPending->boolVal = VARIANT_FALSE;
if ( m_hResource != NULL )
{
HCLUSTER hCluster = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
BOOL bPending = FALSE;
_hr = ::HrWrapOnlineClusterResource( hCluster, m_hResource, nTimeout, (long *) &bPending );
if ( SUCCEEDED( _hr ) )
{
if ( bPending )
{
pvarPending->boolVal = VARIANT_TRUE;
} // if: pending?
} // if: online resource succeeded
} // if: do we have a cluster handle?
} // if: do we have an open resource?
} // if: args not NULL
return _hr;
} //*** CClusResource::Online()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::Offline
//
// Description:
// Take this resource offline.
//
// Arguments:
// nTimeut [IN] - How long in seconds to wait for the resource
// to go offline.
// pvarPending [OUT] - Catches the pending state. True if the
// resource was not offline when the timeout
// expired.
//
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::Offline(
IN long nTimeout,
OUT VARIANT * pvarPending
)
{
//ASSERT( pvarPending != NULL );
HRESULT _hr = E_POINTER;
if ( pvarPending != NULL )
{
pvarPending->vt = VT_BOOL;
pvarPending->boolVal = VARIANT_FALSE;
if ( m_hResource != NULL )
{
HCLUSTER hCluster = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
BOOL bPending = FALSE;
_hr = ::HrWrapOfflineClusterResource( hCluster, m_hResource, nTimeout, (long *) &bPending );
if ( SUCCEEDED( _hr ) )
{
if ( bPending )
{
pvarPending->boolVal = VARIANT_TRUE;
} // if: pending?
} // if: offline resource succeeded
} // if: do we have a cluster handle?
} // if: do we have an open resource?
} // if: args not NULL
return _hr;
} //*** CClusResource::Offline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::ChangeResourceGroup
//
// Description:
// Move this resource into the passed in group.
//
// Arguments:
// pResourceGroup [IN] - the group to move to.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::ChangeResourceGroup(
IN ISClusResGroup * pResourceGroup
)
{
//ASSERT( pResourceGroup != NULL );
HRESULT _hr = E_POINTER;
if ( pResourceGroup != NULL )
{
HGROUP hGroup = 0;
_hr = pResourceGroup->get_Handle( (ULONG_PTR *) &hGroup );
if ( SUCCEEDED( _hr ) )
{
DWORD _sc = ::ChangeClusterResourceGroup( m_hResource, hGroup );
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::ChangeResourceGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::AddResourceNode
//
// Description:
// Add the passed in node to this resources list of possible owners.
//
// Arguments:
// pNode [IN] - the node to add to the possible owners.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::AddResourceNode( IN ISClusNode * pNode )
{
//ASSERT( pNode != NULL );
HRESULT _hr = E_POINTER;
if ( pNode != NULL )
{
HNODE hNode = 0;
_hr = pNode->get_Handle( (ULONG_PTR *) &hNode );
if ( SUCCEEDED( _hr ) )
{
DWORD _sc = ::AddClusterResourceNode( m_hResource, hNode );
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::AddResourceNode()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::RemoveResourceNode
//
// Description:
// remove the passed in node from this resources list of possible owners.
//
// Arguments:
// pNode [IN] - the node to remove from the possible owners.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::RemoveResourceNode( IN ISClusNode * pNode )
{
//ASSERT( pNode != NULL );
HRESULT _hr = E_POINTER;
if ( pNode != NULL )
{
HNODE hNode = 0;
_hr = pNode->get_Handle( (ULONG_PTR *) &hNode );
if ( SUCCEEDED( _hr ) )
{
DWORD _sc = ::RemoveClusterResourceNode( m_hResource, hNode );
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::RemoveResourceNode()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::CanResourceBeDependent
//
// Description:
// Determines if this resource can be dependent upon the passed in
// resource.
//
// Arguments:
// pResource [in] - The resource upon which this resource may
// depend.
// pvarDependent [OUT] - catches whether or not this resource can become
// dependent.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::CanResourceBeDependent(
IN ISClusResource * pResource,
OUT VARIANT * pvarDependent
)
{
//ASSERT( pResource != NULL );
//ASSERT( pvarDependent != NULL );
HRESULT _hr = E_POINTER;
if ( ( pvarDependent != NULL ) && ( pResource != NULL ) )
{
HRESOURCE hResourceDep = NULL;
_hr = pResource->get_Handle( (ULONG_PTR *) &hResourceDep );
if ( SUCCEEDED( _hr ) )
{
BOOL bDependent = FALSE;
bDependent = ::CanResourceBeDependent( m_hResource, hResourceDep );
pvarDependent->vt = VT_BOOL;
if ( bDependent )
{
pvarDependent->boolVal = VARIANT_TRUE;
} // if: can the passed in resource be dependent?
else
{
pvarDependent->boolVal = VARIANT_FALSE;
} // else: no it cannot...
}
}
return _hr;
} //*** CClusResource::CanResourceBeDependent()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_PossibleOwnerNodes
//
// Description:
// Returns the possible owner nodes collection for this resource.
//
// Arguments:
// ppOwnerNodes [OUT] - Catches the collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_PossibleOwnerNodes(
OUT ISClusResPossibleOwnerNodes ** ppOwnerNodes
)
{
//ASSERT( ppOwnerNodes != NULL );
HRESULT _hr = E_POINTER;
if ( ppOwnerNodes != NULL )
{
CComObject< CClusResPossibleOwnerNodes > * pClusterNodes = NULL;
*ppOwnerNodes = NULL;
_hr = CComObject< CClusResPossibleOwnerNodes >::CreateInstance( &pClusterNodes );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResPossibleOwnerNodes > > ptrClusterNodes( pClusterNodes );
_hr = ptrClusterNodes->Create( ptrRefObject, m_hResource );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrClusterNodes->Refresh();
if ( SUCCEEDED( _hr ) )
{
_hr = ptrClusterNodes->QueryInterface( IID_ISClusResPossibleOwnerNodes, (void **) ppOwnerNodes );
}
}
}
}
return _hr;
} //*** CClusResource::get_PossibleOwnerNodes()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Dependencies
//
// Description:
// Get the collection of this resources dependency resources.
//
// Arguments:
// ppResources [OUT] - Catches the collection of dependencies.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Dependencies(
OUT ISClusResDependencies ** ppResources
)
{
//ASSERT( ppResources != NULL );
HRESULT _hr = E_POINTER;
if ( ppResources != NULL )
{
CComObject< CClusResDependencies > * pResources = NULL;
*ppResources = NULL;
_hr = CComObject< CClusResDependencies >::CreateInstance( &pResources );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResDependencies > > ptrResources( pResources );
_hr = ptrResources->Create( ptrRefObject, m_hResource );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResources->Refresh();
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResources->QueryInterface( IID_ISClusResDependencies, (void **) ppResources );
}
}
}
}
return _hr;
} //*** CClusResource::get_Dependencies()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Dependents
//
// Description:
// Get the collection of this resources dependent resources.
//
// Arguments:
// ppResources [OUT] - Catches the collection of dependents.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Dependents(
OUT ISClusResDependents ** ppResources
)
{
//ASSERT( ppResources != NULL );
HRESULT _hr = E_POINTER;
if ( ppResources != NULL )
{
CComObject< CClusResDependents > * pResources = NULL;
*ppResources = NULL;
_hr = CComObject< CClusResDependents >::CreateInstance( &pResources );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResDependents > > ptrResources( pResources );
_hr = ptrResources->Create( ptrRefObject, m_hResource );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResources->Refresh();
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResources->QueryInterface( IID_ISClusResDependents, (void **) ppResources );
}
}
}
}
return _hr;
} //*** CClusResource::get_Dependents()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_CommonProperties
//
// Description:
// Get this object's (Resource) common properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::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;
} //*** CClusResource::get_CommonProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_PrivateProperties
//
// Description:
// Get this object's (Resource) private properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::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;
} //*** CClusResource::get_PrivateProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_CommonROProperties
//
// Description:
// Get this object's (Resource) common read only properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::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;
} //*** CClusResource::get_CommonROProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_PrivateROProperties
//
// Description:
// Get this object's (Resource) private read only properties collection.
//
// Arguments:
// ppProperties [OUT] - Catches the properties collection.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::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;
} //*** CClusResource::get_PrivateROProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Group
//
// Description:
// Get this resource's owning group.
//
// Arguments:
// ppGroup [OUT] - Catches the owning group.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Group( OUT ISClusResGroup ** ppGroup )
{
//ASSERT( ppGroup != NULL );
HRESULT _hr = E_POINTER;
if ( ppGroup != NULL )
{
LPWSTR pwszGroupName = NULL;
CLUSTER_RESOURCE_STATE cState = ClusterResourceStateUnknown;
cState = ::WrapGetClusterResourceState( m_hResource, NULL, &pwszGroupName );
if ( cState != ClusterResourceStateUnknown )
{
CComObject< CClusResGroup > * pGroup = NULL;
_hr = CComObject< CClusResGroup >::CreateInstance( &pGroup );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResGroup > > ptrGroup( pGroup );
BSTR bstr = NULL;
bstr = SysAllocString( pwszGroupName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
}
else
{
_hr = ptrGroup->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrGroup->QueryInterface( IID_ISClusResGroup, (void **) ppGroup);
}
SysFreeString( bstr );
}
}
::LocalFree( pwszGroupName );
pwszGroupName = NULL;
}
else
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::get_Group()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_OwnerNode
//
// Description:
// Returns this resource's owning node.
//
// Arguments:
// ppNode [OUT] - Catches the owning node.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_OwnerNode( OUT ISClusNode ** ppNode )
{
//ASSERT( ppNode != NULL );
HRESULT _hr = E_POINTER;
if ( ppNode != NULL )
{
LPWSTR pwszNodeName = NULL;
CLUSTER_RESOURCE_STATE cState = ClusterResourceStateUnknown;
cState = ::WrapGetClusterResourceState( m_hResource, &pwszNodeName, NULL );
if ( cState != ClusterResourceStateUnknown )
{
CComObject< CClusNode > * pNode = NULL;
_hr = CComObject< CClusNode >::CreateInstance( &pNode );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusNode > > ptrNode( pNode );
BSTR bstr = NULL;
bstr = SysAllocString( pwszNodeName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
}
else
{
_hr = ptrNode->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrNode->QueryInterface( IID_ISClusNode, (void **) ppNode);
}
SysFreeString( bstr );
}
}
::LocalFree( pwszNodeName );
pwszNodeName = NULL;
}
else
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
return _hr;
} //*** CClusResource::get_OwnerNode()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Cluster
//
// Description:
// Returns the cluster where this resource resides.
//
// Arguments:
// ppCluster [OUT] - Catches the cluster.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Cluster( OUT ISCluster ** ppCluster )
{
return ::HrGetCluster( ppCluster, m_pClusRefObject );
} //*** CClusResource::get_Cluster()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::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 CClusResource::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_RESOURCE_GET_RO_PRIVATE_PROPERTIES :
CLUSCTL_RESOURCE_GET_RO_COMMON_PROPERTIES;
}
else
{
_dwControlCode = bPrivate
? CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES
: CLUSCTL_RESOURCE_GET_COMMON_PROPERTIES;
}
_sc = rcplPropList.ScGetResourceProperties( m_hResource, _dwControlCode );
_hr = HRESULT_FROM_WIN32( _sc );
return _hr;
} //*** CClusResource::HrLoadProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::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:
// ERROR_SUCCESS if successful, or other Win32 error if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusResource::ScWriteProperties(
const CClusPropList & rcplPropList,
BOOL bPrivate
)
{
DWORD dwControlCode = bPrivate ? CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES : CLUSCTL_RESOURCE_SET_COMMON_PROPERTIES;
DWORD nBytesReturned = 0;
DWORD _sc = ERROR_SUCCESS;
_sc = ClusterResourceControl(
m_hResource,
NULL,
dwControlCode,
rcplPropList,
rcplPropList.CbBufferSize(),
0,
0,
&nBytesReturned
);
return _sc;
} //*** CClusResource::ScWriteProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_ClassInfo
//
// Description:
// Returns the class info for this resource.
//
// Arguments:
// prcClassInfo [OUT] - Catches the class info.
//
// Return Value:
// S_OK if successful, E_POINTER, or other Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_ClassInfo(
OUT CLUSTER_RESOURCE_CLASS * prcClassInfo
)
{
ASSERT( prcClassInfo != NULL );
HRESULT _hr = E_POINTER;
if ( prcClassInfo != NULL )
{
if ( m_hResource != NULL )
{
CLUS_RESOURCE_CLASS_INFO ClassInfo;
DWORD _sc = ERROR_SUCCESS;
DWORD cbData;
_sc = ::ClusterResourceControl(
m_hResource,
NULL,
CLUSCTL_RESOURCE_GET_CLASS_INFO,
NULL,
0,
&ClassInfo,
sizeof( CLUS_RESOURCE_CLASS_INFO ),
&cbData
);
_hr = HRESULT_FROM_WIN32( _sc );
if ( SUCCEEDED( _hr ) )
{
*prcClassInfo = ClassInfo.rc;
} // if:
} // if:
} // if:
return _hr;
} //*** CClusResource::get_ClassInfo
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Disk
//
// Description:
// Request the disk information for this physical disk resource.
//
// Arguments:
// ppDisk [OUT] - catches the disk information.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Disk(
OUT ISClusDisk ** ppDisk
)
{
// ASSERT( ppDisk != NULL );
HRESULT _hr = E_POINTER;
if ( ppDisk != NULL )
{
if ( m_hResource != NULL )
{
CComObject< CClusDisk > * pDisk = NULL;
_hr = CComObject< CClusDisk >::CreateInstance( &pDisk );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< CComObject< CClusDisk > > ptrDisk( pDisk );
_hr = ptrDisk->Create( m_hResource );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrDisk->QueryInterface( IID_ISClusDisk, (void **) ppDisk);
} // if:
} // if:
} // if:
} // if:
return _hr;
} //*** CClusResource::get_Disk
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_RegistryKeys
//
// Description:
// Get the collection of registry keys.
//
// Arguments:
// ppRegistryKeys [OUT] - catches the registry keys collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_RegistryKeys(
OUT ISClusRegistryKeys ** ppRegistryKeys
)
{
return ::HrCreateResourceCollection< CClusResourceRegistryKeys, ISClusRegistryKeys, HRESOURCE >(
m_hResource,
ppRegistryKeys,
IID_ISClusRegistryKeys
);
} //*** CClusResource::get_RegistryKeys()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_CryptoKeys
//
// Description:
// Get the collection of crypto keys.
//
// Arguments:
// ppCryptoKeys [OUT] - catches the crypto keys collection.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_CryptoKeys(
OUT ISClusCryptoKeys ** ppCryptoKeys
)
{
#if CLUSAPI_VERSION >= 0x0500
return ::HrCreateResourceCollection< CClusResourceCryptoKeys, ISClusCryptoKeys, HRESOURCE >(
m_hResource,
ppCryptoKeys,
IID_ISClusCryptoKeys
);
#else
return E_NOTIMPL;
#endif // CLUSAPI_VERSION >= 0x0500
} //*** CClusResource::get_CryptoKeys()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_TypeName
//
// Description:
// Get the resource type name of this resource.
//
// Arguments:
// pbstrTypeName [OUT] - Catches the resource type name.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_TypeName( OUT BSTR * pbstrTypeName )
{
//ASSERT( pbstrTypeName != NULL );
HRESULT _hr = E_POINTER;
if ( pbstrTypeName != NULL )
{
LPWSTR _psz;
DWORD _sc;
_sc = ScGetResourceTypeName( &_psz );
_hr = HRESULT_FROM_WIN32( _sc );
if ( SUCCEEDED( _hr ) )
{
*pbstrTypeName = ::SysAllocString( _psz );
if ( *pbstrTypeName == NULL )
{
_hr = E_OUTOFMEMORY;
}
::LocalFree( _psz );
} // if:
} // if: arg is not NULL
return _hr;
} //*** CClusResource::get_TypeName()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::get_Type
//
// Description:
// Get the resource type object for this resource.
//
// Arguments:
// ppResourceType [OUT] - Catches the resource type object.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResource::get_Type( OUT ISClusResType ** ppResourceType )
{
//ASSERT( ppResourceType != NULL );
HRESULT _hr = E_POINTER;
if ( ppResourceType != NULL )
{
LPWSTR _psz;
DWORD _sc;
_sc = ScGetResourceTypeName( &_psz );
_hr = HRESULT_FROM_WIN32( _sc );
if ( SUCCEEDED( _hr ) )
{
CComObject< CClusResType > * _pResourceType = NULL;
_hr = CComObject< CClusResType >::CreateInstance( &_pResourceType );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > _ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResType > > _ptrResourceType( _pResourceType );
BSTR _bstr = NULL;
_bstr = SysAllocString( _psz );
if ( _bstr == NULL )
{
_hr = E_OUTOFMEMORY;
}
else
{
_hr = _ptrResourceType->Open( _ptrRefObject, _bstr );
if ( SUCCEEDED( _hr ) )
{
_hr = _ptrResourceType->QueryInterface( IID_ISClusResType, (void **) ppResourceType );
} // if: the resource type could be opened
SysFreeString( _bstr );
}
} // if: CreateInstance OK
::LocalFree( _psz );
} // if: we got the resource type name for this resource
} // if: arg is not NULL
return _hr;
} //*** CClusResource::get_Type()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResource::ScGetResourceTypeName
//
// Description:
// Get the resource type name for this resource.
//
// Arguments:
// ppwszResourceTypeName [OUT] - Catches the resource type name.
//
// Return Value:
// ERROR_SUCCESS if successful, or other Win32 error.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusResource::ScGetResourceTypeName(
OUT LPWSTR * ppwszResourceTypeName
)
{
ASSERT( ppwszResourceTypeName != NULL );
LPWSTR _psz = NULL;
DWORD _cb = 512;
DWORD _sc = ERROR_SUCCESS;
_psz = (LPWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cb );
if ( _psz != NULL )
{
DWORD _cbData = 0;
_sc = ::ClusterResourceControl(
m_hResource,
NULL,
CLUSCTL_RESOURCE_GET_RESOURCE_TYPE,
NULL,
0,
_psz,
_cb,
&_cbData
);
if ( _sc == ERROR_MORE_DATA )
{
::LocalFree( _psz );
_psz = NULL;
_cb = _cbData;
_psz = (LPWSTR) ::LocalAlloc( LMEM_ZEROINIT, _cb );
if ( _psz != NULL )
{
_cbData = 0;
_sc = ::ClusterResourceControl(
m_hResource,
NULL,
CLUSCTL_RESOURCE_GET_RESOURCE_TYPE,
NULL,
0,
_psz,
_cb,
&_cbData
);
} // if: alloc ok
else
{
_sc = ::GetLastError();
} // else: if alloc failed
} // if: buffer not big enough...
if ( _sc == ERROR_SUCCESS )
{
*ppwszResourceTypeName = _psz;
} // if:
} // if: alloc ok
else
{
_sc = ::GetLastError();
} // else: if alloc failed
return _sc;
} //*** CClusResource::ScGetResourceTypeName()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CResources class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::CResources
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CResources::CResources( void )
{
m_pClusRefObject = NULL;
} //*** CResources::CResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::~CResources
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CResources::~CResources( void )
{
Clear();
if ( m_pClusRefObject != NULL )
{
m_pClusRefObject->Release();
m_pClusRefObject = NULL;
} // if:
} //*** CResources::~CResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::Create
//
// Description:
// Finish creating the object by doing things that cannot be done in
// a light weight constructor.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
//
// Return Value:
// S_OK if successful or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::Create(
IN ISClusRefObject * pClusRefObject
)
{
ASSERT( pClusRefObject != NULL );
HRESULT _hr = E_POINTER;
if ( pClusRefObject != NULL )
{
m_pClusRefObject = pClusRefObject;
m_pClusRefObject->AddRef();
_hr = S_OK;
}
return _hr;
} //*** CResources::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::Clear
//
// Description:
// Release the objects in the vector and clean up the vector.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CResources::Clear( void )
{
::ReleaseAndEmptyCollection< ResourceList, CComObject< CClusResource > >( m_Resources );
} //*** CResources::Clear()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::FindItem
//
// Description:
// Find the passed in resource in the vector and return its index.
//
// Arguments:
// pszResourceName [IN] - The item to find.
// pnIndex [OUT] - Catches the node's index.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::FindItem(
IN LPWSTR pszResourceName,
OUT UINT * pnIndex
)
{
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( pnIndex != NULL )
{
CComObject< CClusResource > * _pResource = NULL;
size_t _cMax = m_Resources.size();
size_t _index;
_hr = E_INVALIDARG;
for( _index = 0; _index < _cMax; _index++ )
{
_pResource = m_Resources[ _index ];
if ( ( _pResource != NULL ) &&
( lstrcmpi( pszResourceName, _pResource->Name() ) == 0 ) )
{
*pnIndex = _index;
_hr = S_OK;
break;
}
}
}
return _hr;
} //*** CResources::FindItem( pszResourceName )
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::FindItem
//
// Description:
// Find the passed in resource in the vector and return its index.
//
// Arguments:
// pResource [IN] - The item to find.
// pnIndex [OUT] - Catches the node's index.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::FindItem(
IN ISClusResource * pResource,
OUT UINT * pnIndex
)
{
//ASSERT( pResource != NULL );
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( ( pResource != NULL ) && ( pnIndex != NULL ) )
{
CComBSTR bstrName;
_hr = pResource->get_Name( &bstrName );
if ( SUCCEEDED( _hr ) )
{
_hr = FindItem( bstrName, pnIndex );
}
}
return _hr;
} //*** CResources::FindItem( pResource )
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::GetIndex
//
// Description:
// Convert the passed in variant index into the real index in the
// collection.
//
// Arguments:
// varIndex [IN] - The index to convert.
// pnIndex [OUT] - Catches the index.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::GetIndex(
IN VARIANT varIndex,
OUT UINT * pnIndex
)
{
//ASSERT( pnIndex != NULL );
HRESULT _hr = E_POINTER;
if ( pnIndex != NULL )
{
CComVariant v;
UINT 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 ) )
{
_hr = FindItem( v.bstrVal, &nIndex );
}
}
if ( SUCCEEDED( _hr ) )
{
if ( nIndex < m_Resources.size() )
{
*pnIndex = nIndex;
}
else
{
_hr = E_INVALIDARG;
}
}
}
return _hr;
} //*** CResources::GetIndex()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::GetResourceItem
//
// Description:
// Return the object (Resource) at the passed in index.
//
// Arguments:
// varIndex [IN] - Contains the index requested.
// ppResource [OUT] - Catches the item.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::GetResourceItem(
IN VARIANT varIndex,
OUT ISClusResource ** ppResource
)
{
//ASSERT( ppResource != NULL );
HRESULT _hr = E_POINTER;
if ( ppResource != NULL )
{
CComObject< CClusResource > * pResource = NULL;
UINT nIndex = 0;
*ppResource = NULL ;
_hr = GetIndex( varIndex, &nIndex );
if ( SUCCEEDED( _hr ) )
{
pResource = m_Resources[ nIndex ];
_hr = pResource->QueryInterface( IID_ISClusResource, (void **) ppResource );
}
}
/*
if ( _hr == S_OK )
{
OutputDebugStringW( L"CResources::GetResourceItem() succeeded.\n" );
} // if: success!
else
{
WCHAR sz[ 256 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CResources::GetResourceItem() failed. (hr = %#08x)\n", _hr );
OutputDebugStringW( sz );
} // else: failure...
*/
return _hr;
} //*** CResources::GetResourceItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::RemoveAt
//
// Description:
// Remove the item at the passed in index from the collection.
//
// Arguments:
// pos [IN] - Index to remove.
//
// Return Value:
// S_OK if successful, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::RemoveAt( IN size_t pos )
{
CComObject<CClusResource> * pResource = NULL;
ResourceList::iterator first = m_Resources.begin();
ResourceList::iterator last = m_Resources.end();
HRESULT _hr = E_INVALIDARG;
for ( size_t t = 0; ( t < pos ) && ( first != last ); t++, first++ );
if ( first != last )
{
pResource = *first;
if ( pResource )
{
pResource->Release();
}
m_Resources.erase( first );
_hr = S_OK;
}
return _hr;
} //*** CResources::RemoveAt()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CResources::DeleteItem
//
// Description:
// Delete the resource at the passed in index from the collection and
// the cluster.
//
// Arguments:
// varIndex [IN] - Contains the index of the resource to delete.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CResources::DeleteItem( IN VARIANT varIndex )
{
HRESULT _hr = S_FALSE;
UINT nIndex = 0;
_hr = GetIndex( varIndex, &nIndex );
if ( SUCCEEDED( _hr ) )
{
ISClusResource * pClusterResource = (ISClusResource *) m_Resources[ nIndex ];
_hr = pClusterResource->Delete();
if ( SUCCEEDED( _hr ) )
{
_hr = RemoveAt( nIndex );
}
}
/*
if ( _hr == S_OK )
{
OutputDebugStringW( L"CResources::RefreshNode() succeeded.\n" );
} // if: success!
else
{
WCHAR sz[ 128 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CResources::DeleteItem() failed. (hr = %#08x)\n", _hr );
OutputDebugStringW( sz );
} // else: failure...
*/
return _hr;
} //*** CResources::DeleteItem()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResources class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::CClusResources
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResources::CClusResources( void )
{
m_piids = (const IID *) iidCClusResources;
m_piidsSize = ARRAYSIZE( iidCClusResources );
} //*** CClusResources::CClusResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::~CClusResources
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResources::~CClusResources( void )
{
CResources::Clear();
} //*** CClusResources::~CClusResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::get_Count
//
// Description:
// Return the count of objects (Resource) in the collection.
//
// Arguments:
// plCount [OUT] - Catches the count.
//
// Return Value:
// S_OK if successful, or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResources::get_Count( OUT long * plCount )
{
//ASSERT( plCount != NULL );
HRESULT _hr = E_POINTER;
if ( plCount != NULL )
{
*plCount = m_Resources.size();
_hr = S_OK;
}
return _hr;
} //*** CClusResources::get_Count()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::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 CClusResources::get__NewEnum( OUT IUnknown ** ppunk )
{
return ::HrNewIDispatchEnum< ResourceList, CComObject< CClusResource > >( ppunk, m_Resources );
} //*** CClusResources::get__NewEnum()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::CreateItem
//
// Description:
// Create a new item and add it to the collection.
//
// Arguments:
// bstrResourceName [IN] - The name of the resource to create.
// bstrResourceType [IN] - The type of the resource to create.
// bstrGroupName [IN] - The group to create it in.
// dwFlags [IN] - Resource monitor flag.
// ppClusterResource [OUT] - Catches the new resource.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResources::CreateItem(
IN BSTR bstrResourceName,
IN BSTR bstrResourceType,
IN BSTR bstrGroupName,
IN CLUSTER_RESOURCE_CREATE_FLAGS dwFlags,
IN ISClusResource ** ppClusterResource
)
{
//ASSERT( bstrResourceName != NULL );
//ASSERT( bstrResourceType != NULL );
//ASSERT( bstrGroupName != NULL );
//ASSERT( ppClusterResource != NULL );
HRESULT _hr = E_POINTER;
if ( ( ppClusterResource != NULL ) &&
( bstrResourceName != NULL ) &&
( bstrResourceType != NULL ) &&
( bstrGroupName != NULL ) )
{
*ppClusterResource = NULL;
//
// Fail if no valid cluster handle.
//
if ( m_pClusRefObject != NULL )
{
UINT nIndex;
_hr = FindItem( bstrResourceName, &nIndex );
if ( FAILED( _hr ) ) // don't allow duplicates
{
HCLUSTER hCluster = NULL;
HGROUP hGroup = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
hGroup = OpenClusterGroup( hCluster, bstrGroupName );
if ( hGroup != NULL )
{
CComObject< CClusResource > * pClusterResource = NULL;
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
_hr = ptrResource->Create( ptrRefObject, hGroup, bstrResourceName, bstrResourceType, dwFlags );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
}
}
}
::CloseClusterGroup( hGroup );
}
else
{
DWORD _sc = 0;
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
}
else
{
CComObject<CClusResource> * pClusterResource = NULL;
pClusterResource = m_Resources[ nIndex ];
_hr = pClusterResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
}
}
}
/*
if ( _hr == S_OK )
{
OutputDebugStringW( L"ClusResources::CreateItem() succeeded.\n" );
} // if: success
else
{
WCHAR sz[ 256 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CClusResources::CreateItem() failed. (hr = %#08x)\n", _hr );
OutputDebugStringW( sz );
} // else: failure
*/
return _hr;
} //*** CClusResources::CreateItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::DeleteItem
//
// Description:
// Delete the resource at the passed in index from the collection and
// the cluster.
//
// Arguments:
// varIndex [IN] - Contains the index of the resource to delete.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResources::DeleteItem( IN VARIANT varIndex )
{
return CResources::DeleteItem( varIndex );
} //*** CClusResources::DeleteItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::Refresh
//
// Description:
// Load the collection from the cluster database.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResources::Refresh( void )
{
HRESULT _hr = E_POINTER;
HCLUSENUM _hEnum = NULL;
DWORD _sc = ERROR_SUCCESS;
HCLUSTER hCluster = NULL;
ASSERT( m_pClusRefObject != NULL );
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
_hEnum = ::ClusterOpenEnum( hCluster, CLUSTER_ENUM_RESOURCE );
if ( _hEnum != NULL )
{
int _nIndex = 0;
DWORD dwType;
LPWSTR pszName = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
CResources::Clear();
for ( _nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); _nIndex++ )
{
_sc = ::WrapClusterEnum( _hEnum, _nIndex, &dwType, &pszName );
if ( _sc == ERROR_NO_MORE_ITEMS )
{
_hr = S_OK;
break;
} // if: enum is empty. Time to leave...
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
BSTR bstr = NULL;
bstr = SysAllocString( pszName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
} // if: could not allocate a bstr
else
{
_hr = ptrResource->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
} // if: successfully opened the resource
else if ( HRESULT_CODE( _hr ) == ERROR_RESOURCE_NOT_FOUND )
{
//
// It is possible for the resource to have been deleted from the cluster
// in the time between creating the enum and opening the resource. When
// that happens we need to simply skip that resource and continue
// enumerating.
//
_hr = S_FALSE; // success code to keep us in the loop
} // else if: the cluster resource was not found
SysFreeString( bstr );
} // else: successfully allocated a new bstr
} // if: successfully created a new resource instance
::LocalFree( pszName );
pszName = NULL;
} // else if: successfully got the resource from the enumerator
else
{
_hr = HRESULT_FROM_WIN32( _sc );
} // else: failed to get the resource from the enumerator
} // for: each resource in the enumerator
::ClusterCloseEnum( _hEnum );
} // if: opened cluster resource enumerator
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
} // else: could not open cluster resource enumerator
} // if: got the cluster handle from the ref counted container
/*
if ( _hr == S_OK )
{
OutputDebugStringW( L"CClusResources::Refresh() succeeded.\n" );
} // if: success!
else
{
WCHAR sz[ 128 ];
_snwprintf( sz, RTL_NUMBER_OF( sz ), L"CClusResources::Refresh() failed. (hr = %#08x)\n", _hr );
OutputDebugStringW( sz );
} // else: failure...
*/
return _hr;
} //*** CClusResources::Refresh()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResources::get_Item
//
// Description:
// Return the object (Resource) at the passed in index.
//
// Arguments:
// varIndex [IN] - Contains the index requested.
// ppResource [OUT] - Catches the item.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResources::get_Item(
IN VARIANT varIndex,
OUT ISClusResource ** ppResource
)
{
return GetResourceItem( varIndex, ppResource );
} //*** CClusResources::get_Item()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResDepends class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::CClusResDepends
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResDepends::CClusResDepends( void )
{
m_hResource = NULL;
} //*** CClusResDepends::CClusResDepends()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::~CClusResDepends
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResDepends::~CClusResDepends( void )
{
Clear();
} //*** CClusResDepends::~CClusResDepends()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::get_Count
//
// Description:
// Return the count of objects (Resource) in the collection.
//
// Arguments:
// plCount [OUT] - Catches the count.
//
// Return Value:
// S_OK if successful, or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::get_Count( OUT long * plCount )
{
//ASSERT( plCount != NULL );
HRESULT _hr = E_POINTER;
if ( plCount != NULL )
{
*plCount = m_Resources.size();
_hr = S_OK;
}
return _hr;
} //*** CClusResDepends::get_Count()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::Create
//
// Description:
// Finish creating the object by doing things that cannot be done in
// a light weight constructor.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// hResource [IN] - The resource this collection belongs to.
//
// Return Value:
// S_OK if successful or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResDepends::Create(
IN ISClusRefObject * pClusRefObject,
IN HRESOURCE hResource
)
{
HRESULT _hr = E_POINTER;
_hr = CResources::Create( pClusRefObject );
if ( SUCCEEDED( _hr ) )
{
m_hResource = hResource;
} // if:
return _hr;
} //*** CClusResDepends::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::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 CClusResDepends::get__NewEnum( OUT IUnknown ** ppunk )
{
return ::HrNewIDispatchEnum< ResourceList, CComObject< CClusResource > >( ppunk, m_Resources );
} //*** CClusResDepends::get__NewEnum()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::DeleteItem
//
// Description:
// Delete the resource at the passed in index from the collection and
// the cluster.
//
// Arguments:
// varIndex [IN] - Contains the index of the resource to delete.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::DeleteItem( IN VARIANT varIndex )
{
return CResources::DeleteItem( varIndex );
} //*** CClusResDepends::DeleteItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::get_Item
//
// Description:
// Return the object (Resource) at the passed in index.
//
// Arguments:
// varIndex [IN] - Contains the index requested.
// ppResource [OUT] - Catches the item.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::get_Item(
IN VARIANT varIndex,
OUT ISClusResource ** ppResource
)
{
return GetResourceItem( varIndex, ppResource );
} //*** CClusResDepends::get_Item()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::HrRefresh
//
// Description:
// Load the collection from the cluster database.
//
// Arguments:
// cre [IN] - Type of enumeration to perform.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResDepends::HrRefresh( IN CLUSTER_RESOURCE_ENUM cre )
{
HRESENUM _hEnum = NULL;
HRESULT _hr = S_OK;
DWORD _sc = ERROR_SUCCESS;
_hEnum = ::ClusterResourceOpenEnum( m_hResource, cre );
if ( _hEnum != NULL )
{
int _nIndex = 0;
DWORD dwType;
LPWSTR pszName = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
Clear();
for( _nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); _nIndex++ )
{
_sc = ::WrapClusterResourceEnum( _hEnum, _nIndex, &dwType, &pszName );
if ( _sc == ERROR_NO_MORE_ITEMS )
{
_hr = S_OK;
break;
}
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
BSTR bstr = NULL;
bstr = SysAllocString( pszName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
}
else
{
_hr = ptrResource->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
}
else if ( HRESULT_CODE( _hr ) == ERROR_RESOURCE_NOT_FOUND )
{
//
// It is possible for the resource to have been deleted from the cluster
// in the time between creating the enum and opening the resource. When
// that happens we need to simply skip that resource and continue
// enumerating.
//
_hr = S_FALSE; // success code to keep us in the loop
} // else if: the cluster resource was not found
SysFreeString( bstr );
}
}
::LocalFree( pszName );
pszName = NULL;
}
else
{
_hr = HRESULT_FROM_WIN32( _sc );
}
}
::ClusterResourceCloseEnum( _hEnum );
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
return _hr;
} //*** CClusResDepends::HrRefresh()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::CreateItem
//
// Description:
// Create a new item and add it to the collection.
//
// Arguments:
// bstrResourceName [IN] - The name of the resource to create.
// bstrResourceType [IN] - The type of the resource to create.
// dwFlags [IN] - Resource monitor flag.
// ppClusterResource [OUT] - Catches the new resource.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::CreateItem(
IN BSTR bstrResourceName,
IN BSTR bstrResourceType,
IN CLUSTER_RESOURCE_CREATE_FLAGS dwFlags,
OUT ISClusResource ** ppClusterResource
)
{
//ASSERT( bstrResourceName != NULL );
//ASSERT( bstrResourceType != NULL );
//ASSERT( ppClusterResource != NULL );
ASSERT( m_pClusRefObject != NULL );
HRESULT _hr = E_POINTER;
if ( ( ppClusterResource != NULL ) &&
( bstrResourceName != NULL ) &&
( bstrResourceType != NULL ) )
{
DWORD _sc = ERROR_SUCCESS;
*ppClusterResource = NULL;
if ( m_pClusRefObject != NULL )
{
UINT _nIndex;
_hr = FindItem( bstrResourceName, &_nIndex );
if ( FAILED( _hr ) )
{
HCLUSTER hCluster = NULL;
HGROUP hGroup = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
LPWSTR pwszGroupName = NULL;
CLUSTER_RESOURCE_STATE cState = ClusterResourceStateUnknown;
cState = WrapGetClusterResourceState( m_hResource, NULL, &pwszGroupName );
if ( cState != ClusterResourceStateUnknown )
{
hGroup = ::OpenClusterGroup( hCluster, pwszGroupName );
if ( hGroup != NULL )
{
CComObject< CClusResource > * pClusterResource = NULL;
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
_hr = ptrResource->Create( ptrRefObject, hGroup, bstrResourceName, bstrResourceType, dwFlags );
if ( SUCCEEDED( _hr ) )
{
HRESOURCE hDependsRes = NULL;
_hr = ptrResource->get_Handle( (ULONG_PTR *) &hDependsRes );
if ( SUCCEEDED( _hr ) )
{
_sc = ScAddDependency( m_hResource, hDependsRes );
if ( _sc == ERROR_SUCCESS )
{
_hr = ptrResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
}
}
else
{
_hr = HRESULT_FROM_WIN32( _sc );
}
}
}
}
::CloseClusterGroup( hGroup );
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
::LocalFree( pwszGroupName );
pwszGroupName = NULL;
} // if: WrapGetClusterResourceState
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
}
}
else
{
CComObject< CClusResource > * pClusterResource = NULL;
pClusterResource = m_Resources[ _nIndex ];
_hr = pClusterResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
}
}
}
return _hr;
} //*** CClusResDepends::CreateItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::AddItem
//
// Description:
// Make this resource dependent upon the passed in resource.
//
// Arguments:
// pResouce [IN] - Resource to add to the dependencies list.
//
// Return Value:
// S_OK if successful, or other HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::AddItem( IN ISClusResource * pResource )
{
//ASSERT( pResource != NULL );
HRESULT _hr = E_POINTER;
if ( pResource != NULL )
{
// Fail if duplicate
UINT _nIndex = 0;
_hr = FindItem( pResource, &_nIndex );
if ( FAILED( _hr ) )
{
HRESOURCE hResourceDep = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
_hr = pResource->get_Handle( (ULONG_PTR *) &hResourceDep );
if ( SUCCEEDED( _hr ) )
{
DWORD _sc = ScAddDependency( m_hResource, hResourceDep );
_hr = HRESULT_FROM_WIN32( _sc );
if ( SUCCEEDED( _hr ) )
{
CComObject< CClusResource > * _pResource = NULL;
_hr = pResource->QueryInterface( IID_CClusResource, (void **) &_pResource );
if ( SUCCEEDED( _hr ) )
{
_pResource->AddRef();
m_Resources.insert( m_Resources.end(), _pResource );
pResource->Release();
} // if:
}
}
}
else
{
_hr = E_INVALIDARG;
}
}
return _hr;
} //*** CClusResDepends::AddItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDepends::RemoveItem
//
// Description:
// Remove the dependency on the resource at the passed in index.
//
// Arguments:
// varIndex [IN] - The index of the item whose dependency should
// be removed.
//
// Return Value:
// S_OK if successful, or other Win32 error as HRESULT if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResDepends::RemoveItem( IN VARIANT varIndex )
{
HRESULT _hr = S_OK;
UINT _nIndex = 0;
_hr = GetIndex( varIndex, &_nIndex );
if ( SUCCEEDED( _hr ) )
{
ISClusResource * pClusterResource = (ISClusResource *) m_Resources[ _nIndex ];
HRESOURCE hResourceDep = NULL;
_hr = pClusterResource->get_Handle( (ULONG_PTR *) &hResourceDep );
if ( SUCCEEDED( _hr ) )
{
DWORD _sc = ScRemoveDependency( m_hResource, hResourceDep );
_hr = HRESULT_FROM_WIN32( _sc );
if ( SUCCEEDED( _hr ) )
{
_hr = RemoveAt( _nIndex );
}
}
}
return _hr;
} //*** CClusResDepends::RemoveItem()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResDependencies class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDependencies::CClusResDependencies
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResDependencies::CClusResDependencies( void )
{
m_piids = (const IID *) iidCClusResDependencies;
m_piidsSize = ARRAYSIZE( iidCClusResDependencies );
} //*** CClusResDependencies::CClusResDependencies()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResDependents class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResDependents::CClusResDependents
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResDependents::CClusResDependents( void )
{
m_piids = (const IID *) iidCClusResDependents;
m_piidsSize = ARRAYSIZE( iidCClusResDependents );
} //*** CClusResDependents::CClusResDependents()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResGroupResources class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::CClusResGroupResources
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroupResources::CClusResGroupResources( void )
{
m_piids = (const IID *) iidCClusResGroupResources;
m_piidsSize = ARRAYSIZE( iidCClusResGroupResources );
} //*** CClusResGroupResources::CClusResGroupResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::~CClusResGroupResources
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResGroupResources::~CClusResGroupResources( void )
{
Clear();
} //*** CClusResGroupResources::~CClusResGroupResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::get_Count
//
// Description:
// Return the count of objects (Resource) in the collection.
//
// Arguments:
// plCount [OUT] - Catches the count.
//
// Return Value:
// S_OK if successful, or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroupResources::get_Count( OUT long * plCount )
{
//ASSERT( plCount != NULL );
HRESULT _hr = E_POINTER;
if ( plCount != NULL )
{
*plCount = m_Resources.size();
_hr = S_OK;
}
return _hr;
} //*** CClusResGroupResources::get_Count()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::Create
//
// Description:
// Finish creating the object by doing things that cannot be done in
// a light weight constructor.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// hGroup [IN] - The group this collection belongs to.
//
// Return Value:
// S_OK if successful or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResGroupResources::Create(
IN ISClusRefObject * pClusRefObject,
IN CRefcountedHGROUP hGroup
)
{
HRESULT _hr = E_POINTER;
_hr = CResources::Create( pClusRefObject );
if ( SUCCEEDED( _hr ) )
{
m_hGroup = hGroup;
} // if:
return _hr;
} //*** CClusResGroupResources::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::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 CClusResGroupResources::get__NewEnum( OUT IUnknown ** ppunk )
{
return ::HrNewIDispatchEnum< ResourceList, CComObject< CClusResource > >( ppunk, m_Resources );
} //*** CClusResGroupResources::get__NewEnum()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::CreateItem
//
// Description:
// Create a new item and add it to the collection.
//
// Arguments:
// bstrResourceName [IN] - The name of the resource to create.
// bstrResourceType [IN] - The type of the resource to create.
// dwFlags [IN] - Resource monitor flag.
// ppClusterResource [OUT] - Catches the new resource.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroupResources::CreateItem(
IN BSTR bstrResourceName,
IN BSTR bstrResourceType,
IN CLUSTER_RESOURCE_CREATE_FLAGS dwFlags,
OUT ISClusResource ** ppClusterResource
)
{
//ASSERT( bstrResourceName != NULL );
//ASSERT( bstrResourceType != NULL );
//ASSERT( ppClusterResource != NULL );
HRESULT _hr = E_POINTER;
if ( ( bstrResourceName != NULL ) &&
( bstrResourceType != NULL ) &&
( ppClusterResource != NULL ) )
{
*ppClusterResource = NULL;
if ( m_pClusRefObject != NULL )
{
UINT _nIndex = 0;
_hr = FindItem( bstrResourceName, &_nIndex );
if ( FAILED( _hr ) )
{
HCLUSTER hCluster = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
_hr = ptrResource->Create( ptrRefObject, m_hGroup->get_Handle(), bstrResourceName, bstrResourceType, dwFlags );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
}
}
}
}
}
else
{
CComObject< CClusResource > * pClusterResource = NULL;
pClusterResource = m_Resources[ _nIndex ];
_hr = pClusterResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
}
}
}
return _hr;
} //*** CClusResGroupResources::CreateItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::DeleteItem
//
// Description:
// Delete the resource at the passed in index from the collection and
// the cluster.
//
// Arguments:
// varIndex [IN] - Contains the index of the resource to delete.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroupResources::DeleteItem( VARIANT varIndex )
{
return CResources::DeleteItem( varIndex );
} //*** CClusResGroupResources::DeleteItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::Refresh
//
// Description:
// Load the collection from the cluster database.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroupResources::Refresh( void )
{
HGROUPENUM hEnum = NULL;
DWORD _sc = ERROR_SUCCESS;
HRESULT _hr = S_OK;
hEnum = ::ClusterGroupOpenEnum( m_hGroup->get_Handle(), CLUSTER_GROUP_ENUM_CONTAINS );
if ( hEnum != NULL )
{
int _nIndex = 0;
DWORD dwType;
LPWSTR pszName = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
Clear();
for( _nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); _nIndex++ )
{
_sc = ::WrapClusterGroupEnum( hEnum, _nIndex, &dwType, &pszName );
if ( _sc == ERROR_NO_MORE_ITEMS )
{
_hr = S_OK;
break;
}
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
BSTR bstr = NULL;
bstr = SysAllocString( pszName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
}
else
{
_hr = ptrResource->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
}
else if ( HRESULT_CODE( _hr ) == ERROR_RESOURCE_NOT_FOUND )
{
//
// It is possible for the resource to have been deleted from the cluster
// in the time between creating the enum and opening the resource. When
// that happens we need to simply skip that resource and continue
// enumerating.
//
_hr = S_FALSE; // success code to keep us in the loop
} // else if: the cluster resource was not found
SysFreeString( bstr );
}
}
::LocalFree( pszName );
pszName = NULL;
}
else
{
_hr = HRESULT_FROM_WIN32( _sc );
}
}
::ClusterGroupCloseEnum( hEnum );
}
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
return _hr;
} //*** CClusResGroupResources::Refresh()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResGroupResources::get_Item
//
// Description:
// Return the object (Resource) at the passed in index.
//
// Arguments:
// varIndex [IN] - Contains the index requested.
// ppResource [OUT] - Catches the item.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResGroupResources::get_Item(
IN VARIANT varIndex,
OUT ISClusResource ** ppResource
)
{
return GetResourceItem( varIndex, ppResource );
} //*** CClusResGroupResources::get_Item()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// CClusResTypeResources class
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::CClusResTypeResources
//
// Description:
// Constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResTypeResources::CClusResTypeResources( void )
{
m_piids = (const IID *) iidCClusResTypeResources;
m_piidsSize = ARRAYSIZE( iidCClusResTypeResources );
} //*** CClusResTypeResources::CClusResTypeResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::~CClusResTypeResources
//
// Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CClusResTypeResources::~CClusResTypeResources( void )
{
Clear();
} //*** CClusResTypeResources::~CClusResTypeResources()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::get_Count
//
// Description:
// Return the count of objects (Resource) in the collection.
//
// Arguments:
// plCount [OUT] - Catches the count.
//
// Return Value:
// S_OK if successful, or E_POINTER.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResTypeResources::get_Count( OUT long * plCount )
{
//ASSERT( plCount != NULL );
HRESULT _hr = E_POINTER;
if ( plCount != NULL )
{
*plCount = m_Resources.size();
_hr = S_OK;
}
return _hr;
} //*** CClusResTypeResources::get_Count()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::Create
//
// Description:
// Finish creating the object by doing things that cannot be done in
// a light weight constructor.
//
// Arguments:
// pClusRefObject [IN] - Wraps the cluster handle.
// bstrResTypeName [IN] - The name of the resource type this collection
// belongs to.
//
// Return Value:
// S_OK if successful or E_POINTER if not.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CClusResTypeResources::Create(
IN ISClusRefObject * pClusRefObject,
IN BSTR bstrResTypeName
)
{
HRESULT _hr = E_POINTER;
_hr = CResources::Create( pClusRefObject );
if ( SUCCEEDED( _hr ) )
{
m_bstrResourceTypeName = bstrResTypeName;
} // if:
return _hr;
} //*** CClusResTypeResources::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::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 CClusResTypeResources::get__NewEnum( OUT IUnknown ** ppunk )
{
return ::HrNewIDispatchEnum< ResourceList, CComObject< CClusResource > >( ppunk, m_Resources );
} //*** CClusResTypeResources::get__NewEnum()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::CreateItem
//
// Description:
// Create a new item and add it to the collection.
//
// Arguments:
// bstrResourceName [IN] - The name of the resource to create.
// bstrGroupName [IN] - The group to create it in.
// dwFlags [IN] - Resource monitor flag.
// ppClusterResource [OUT] - Catches the new resource.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResTypeResources::CreateItem(
IN BSTR bstrResourceName,
IN BSTR bstrGroupName,
IN CLUSTER_RESOURCE_CREATE_FLAGS dwFlags,
OUT ISClusResource ** ppClusterResource
)
{
//ASSERT( bstrResourceName != NULL );
//ASSERT( bstrGroupName != NULL );
//ASSERT( ppClusterResource != NULL );
HRESULT _hr = E_POINTER;
if ( ( bstrResourceName != NULL ) &&
( bstrGroupName != NULL ) &&
( ppClusterResource != NULL ) )
{
*ppClusterResource = NULL;
// Fail if no valid cluster handle.
if ( m_pClusRefObject != NULL )
{
UINT _nIndex;
_hr = FindItem( bstrResourceName, &_nIndex );
if ( FAILED( _hr ) ) // duplicates are not allowed
{
HCLUSTER hCluster = NULL;
HGROUP hGroup = NULL;
CComObject< CClusResource > * pClusterResource = NULL;
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
hGroup = OpenClusterGroup( hCluster, bstrGroupName );
if ( hGroup != NULL )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
_hr = ptrResource->Create( ptrRefObject, hGroup, bstrResourceName, m_bstrResourceTypeName, dwFlags );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
if ( SUCCEEDED( _hr ) )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
} // if: QI ok
} // if: Create ok
} // if: CreateInstance ok
CloseClusterGroup( hGroup );
} // if: OpenClusterGroup ok
else
{
DWORD _sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
}
} // if: get_Handle ok
} // if: FindIndex failed. No duplicate entries
else
{
CComObject<CClusResource> * pClusterResource = NULL;
pClusterResource = m_Resources[ _nIndex ];
_hr = pClusterResource->QueryInterface( IID_ISClusResource, (void **) ppClusterResource );
} // else: found a duplicate
} // if: m_pClusRefObject is not NULL
} // if: any NULL argument pointers
return _hr;
} //*** CClusResTypeResources::CreateItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::DeleteItem
//
// Description:
// Delete the resource at the passed in index from the collection and
// the cluster.
//
// Arguments:
// varIndex [IN] - Contains the index of the resource to delete.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 as HRESULT error.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResTypeResources::DeleteItem( IN VARIANT varIndex )
{
return CResources::DeleteItem( varIndex );
} //*** CClusResTypeResources::DeleteItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::Refresh
//
// Description:
// Load the collection from the cluster database.
//
// Arguments:
// None.
//
// Return Value:
// S_OK if successful, E_POINTER, or Win32 error as HRESULT.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResTypeResources::Refresh( void )
{
DWORD _sc = ERROR_SUCCESS;
HRESULT _hr = E_POINTER;
HCLUSTER hCluster = NULL;
HCLUSENUM hEnum = NULL;
ASSERT( m_pClusRefObject != NULL );
_hr = m_pClusRefObject->get_Handle( (ULONG_PTR *) &hCluster );
if ( SUCCEEDED( _hr ) )
{
hEnum = ::ClusterOpenEnum( hCluster, CLUSTER_ENUM_RESOURCE );
if ( hEnum != NULL )
{
int _nIndex = 0;
DWORD dwType = 0;
LPWSTR pszName = NULL;
HRESOURCE hResource = NULL;
WCHAR strResType[1024];
DWORD dwData = 0;
CComObject< CClusResource > * pClusterResource = NULL;
Clear();
for( _nIndex = 0, _hr = S_OK; SUCCEEDED( _hr ); _nIndex++ )
{
_sc = ::WrapClusterEnum( hEnum, _nIndex, &dwType, &pszName );
if ( _sc == ERROR_NO_MORE_ITEMS )
{
_hr = S_OK;
break;
} // if: Enumerator is empty. Time to leave.
else if ( _sc == ERROR_SUCCESS )
{
_hr = CComObject< CClusResource >::CreateInstance( &pClusterResource );
if ( SUCCEEDED( _hr ) )
{
CSmartPtr< ISClusRefObject > ptrRefObject( m_pClusRefObject );
CSmartPtr< CComObject< CClusResource > > ptrResource( pClusterResource );
BSTR bstr = NULL;
bstr = SysAllocString( pszName );
if ( bstr == NULL )
{
_hr = E_OUTOFMEMORY;
} // if: failed to allocated a bstr
else
{
_hr = ptrResource->Open( ptrRefObject, bstr );
if ( SUCCEEDED( _hr ) )
{
_hr = ptrResource->get_Handle( (ULONG_PTR *) &hResource );
if ( SUCCEEDED( _hr ) )
{
_sc = ClusterResourceControl(
hResource,
NULL,
CLUSCTL_RESOURCE_GET_RESOURCE_TYPE,
NULL,
0,
strResType,
sizeof( strResType ),
&dwData
);
if ( _sc == ERROR_SUCCESS )
{
if ( lstrcmpi( strResType, m_bstrResourceTypeName ) == 0 )
{
ptrResource->AddRef();
m_Resources.insert( m_Resources.end(), ptrResource );
} // if: the resource is of this resource type
} // if: successfully got the resource's resource type
else
{
_hr = HRESULT_FROM_WIN32( _sc );
} // else: failed to get the resoruce's resource type
} // if: successfully got the resource's handle
} // if: successfully opened the resource
else if ( HRESULT_CODE( _hr ) == ERROR_RESOURCE_NOT_FOUND )
{
//
// It is possible for the resource to have been deleted from the cluster
// in the time between creating the enum and opening the resource. When
// that happens we need to simply skip that resource and continue
// enumerating.
//
_hr = S_FALSE; // success code to keep us in the loop
} // else if: the cluster resource was not found
SysFreeString( bstr );
} // else: successfully created a bstr
} // if: successfully created a resource object instance
::LocalFree( pszName );
pszName = NULL;
} // if: successfully got a resource from the enumerator
else
{
_hr = HRESULT_FROM_WIN32( _sc );
} // else: failed to get a resource from the enumerator
} // for: each resource in the enumerator
::ClusterCloseEnum( hEnum );
} // if: successfully created a resource enumerator
else
{
_sc = GetLastError();
_hr = HRESULT_FROM_WIN32( _sc );
} // else: failed to create a resource enumerator
} // if: successfully got the cluster handle
return _hr;
} //*** CClusResTypeResources::Refresh()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusResTypeResources::get_Item
//
// Description:
// Return the object (Resource) at the passed in index.
//
// Arguments:
// varIndex [IN] - Contains the index requested.
// ppResource [OUT] - Catches the item.
//
// Return Value:
// S_OK if successful, E_POINTER, or E_INVALIDARG.
//
//--
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CClusResTypeResources::get_Item(
IN VARIANT varIndex,
OUT ISClusResource ** ppResource
)
{
return GetResourceItem( varIndex, ppResource );
} //*** CClusResTypeResources::get_Item()