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.
990 lines
25 KiB
990 lines
25 KiB
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 1999-2002 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// CreateClusterWizard.cpp
|
|
//
|
|
// Description:
|
|
// Implementation of CCreateClusterWizard class.
|
|
//
|
|
// Maintained By:
|
|
// John Franco (jfranco) 17-APR-2002
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Include Files
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "Pch.h"
|
|
#include "CreateClusterWizard.h"
|
|
|
|
//****************************************************************************
|
|
//
|
|
// CCreateClusterWizard
|
|
//
|
|
//****************************************************************************
|
|
|
|
DEFINE_THISCLASS( "CCreateClusterWizard" )
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::S_HrCreateInstance
|
|
//
|
|
// Description:
|
|
// Creates a CCreateClusterWizard instance.
|
|
//
|
|
// Arguments:
|
|
// ppunkOut - The IUnknown interface of the new object.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Success.
|
|
// E_OUTOFMEMORY - Not enough memory to create the object.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CCreateClusterWizard::S_HrCreateInstance( IUnknown ** ppunkOut )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr = S_OK;
|
|
CCreateClusterWizard * pccw = NULL;
|
|
|
|
Assert( ppunkOut != NULL );
|
|
if ( ppunkOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
pccw = new CCreateClusterWizard();
|
|
if ( pccw == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( pccw->HrInit() );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( pccw->TypeSafeQI( IUnknown, ppunkOut ) );
|
|
if ( FAILED ( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if ( pccw != NULL )
|
|
{
|
|
pccw->Release();
|
|
}
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::S_HrCreateInstance
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::CCreateClusterWizard
|
|
//
|
|
// Description:
|
|
// Default constructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CCreateClusterWizard::CCreateClusterWizard( void )
|
|
: m_pccw( NULL )
|
|
, m_bstrFirstNodeInCluster( NULL )
|
|
, m_cRef( 1 )
|
|
{
|
|
} //*** CCreateClusterWizard::CCreateClusterWizard
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::~CCreateClusterWizard
|
|
//
|
|
// Description:
|
|
// Destructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
CCreateClusterWizard::~CCreateClusterWizard( void )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
if ( m_pccw != NULL )
|
|
{
|
|
m_pccw->Release();
|
|
}
|
|
|
|
TraceSysFreeString( m_bstrFirstNodeInCluster );
|
|
TraceFuncExit();
|
|
|
|
} //*** CCreateClusterWizard::~CCreateClusterWizard
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CAddNodesWizard::HrInit
|
|
//
|
|
// Description:
|
|
// Initialize the object instance.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
HRESULT
|
|
CCreateClusterWizard::HrInit( void )
|
|
{
|
|
TraceFunc( "" );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Initialize the IDispatch handler to support the scripting interface.
|
|
//
|
|
hr = THR( TDispatchHandler< IClusCfgCreateClusterWizard >::HrInit( LIBID_ClusCfgWizard ) );
|
|
if ( FAILED ( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Create the wizard object.
|
|
//
|
|
hr = THR( CClusCfgWizard::S_HrCreateInstance( &m_pccw ) );
|
|
if ( FAILED ( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::HrInit
|
|
|
|
|
|
//****************************************************************************
|
|
//
|
|
// IUnknown
|
|
//
|
|
//****************************************************************************
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::QueryInterface
|
|
//
|
|
// Description:
|
|
// Query this object for the passed in interface.
|
|
//
|
|
// Arguments:
|
|
// riidIn
|
|
// Id of interface requested.
|
|
//
|
|
// ppvOut
|
|
// Pointer to the requested interface.
|
|
//
|
|
// Return Value:
|
|
// S_OK
|
|
// If the interface is available on this object.
|
|
//
|
|
// E_NOINTERFACE
|
|
// If the interface is not available.
|
|
//
|
|
// E_POINTER
|
|
// ppvOut was NULL.
|
|
//
|
|
// Remarks:
|
|
// None.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::QueryInterface(
|
|
REFIID riidIn
|
|
, PVOID * ppvOut
|
|
)
|
|
{
|
|
TraceQIFunc( riidIn, ppvOut );
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
//
|
|
// Validate arguments.
|
|
//
|
|
|
|
Assert( ppvOut != NULL );
|
|
if ( ppvOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Handle known interfaces.
|
|
//
|
|
|
|
if ( IsEqualIID( riidIn, IID_IUnknown ) )
|
|
{
|
|
*ppvOut = static_cast< IUnknown * >( this );
|
|
} // if: IUnknown
|
|
else if ( IsEqualIID( riidIn, IID_IClusCfgCreateClusterWizard ) )
|
|
{
|
|
*ppvOut = TraceInterface( __THISCLASS__, IClusCfgCreateClusterWizard, this, 0 );
|
|
} // else if: IClusCfgCreateClusterWizard
|
|
else if ( IsEqualIID( riidIn, IID_IDispatch ) )
|
|
{
|
|
*ppvOut = TraceInterface( __THISCLASS__, IDispatch, this, 0 );
|
|
} // else if: IDispatch
|
|
else
|
|
{
|
|
*ppvOut = NULL;
|
|
hr = E_NOINTERFACE;
|
|
} // else
|
|
|
|
//
|
|
// Add a reference to the interface if successful.
|
|
//
|
|
|
|
if ( SUCCEEDED( hr ) )
|
|
{
|
|
((IUnknown *) *ppvOut)->AddRef();
|
|
} // if: success
|
|
|
|
Cleanup:
|
|
|
|
QIRETURN_IGNORESTDMARSHALLING( hr, riidIn );
|
|
|
|
} //*** CCreateClusterWizard::QueryInterface
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::AddRef
|
|
//
|
|
// Description:
|
|
// Add a reference to this instance.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// New reference count.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
ULONG
|
|
CCreateClusterWizard::AddRef( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
InterlockedIncrement( &m_cRef );
|
|
|
|
CRETURN( m_cRef );
|
|
|
|
} //*** CCreateClusterWizard::AddRef
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::Release
|
|
//
|
|
// Description:
|
|
// Release a reference to this instance. If it is the last reference
|
|
// the object instance will be deallocated.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Values:
|
|
// New reference count.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
ULONG
|
|
CCreateClusterWizard::Release( void )
|
|
{
|
|
TraceFunc( "[IUnknown]" );
|
|
|
|
LONG cRef;
|
|
|
|
cRef = InterlockedDecrement( &m_cRef );
|
|
|
|
if ( cRef == 0 )
|
|
{
|
|
delete this;
|
|
}
|
|
|
|
CRETURN( cRef );
|
|
|
|
} //*** CCreateClusterWizard::Release
|
|
|
|
|
|
//****************************************************************************
|
|
//
|
|
// IClusCfgCreateClusterWizard
|
|
//
|
|
//****************************************************************************
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_ClusterName
|
|
//
|
|
// Description:
|
|
// Set the cluster name to create.
|
|
//
|
|
// Arguments:
|
|
// bstrClusterNameIn - The name of the cluster.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_ClusterName( BSTR bstrClusterNameIn )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrClusterLabel = NULL;
|
|
PCWSTR pwcszClusterLabel = NULL;
|
|
|
|
if ( bstrClusterNameIn == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// If the name is fully-qualified, split out just the label for validity test;
|
|
// otherwise, use the given name in the validity test.
|
|
//
|
|
hr = STHR( HrIsValidFQN( bstrClusterNameIn, true ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
else if ( hr == S_OK )
|
|
{
|
|
//
|
|
// Name is fully-qualified.
|
|
//
|
|
hr = THR( HrExtractPrefixFromFQN( bstrClusterNameIn, &bstrClusterLabel ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
pwcszClusterLabel = bstrClusterLabel;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Name is NOT fully-qualified.
|
|
//
|
|
pwcszClusterLabel = bstrClusterNameIn;
|
|
}
|
|
|
|
//
|
|
// Can't use an IP address for cluster name when creating;
|
|
// also, cluster label must be compatible with netbios.
|
|
//
|
|
hr = HrValidateClusterNameLabel( pwcszClusterLabel, true ); // don't trace; name might not be valid.
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( m_pccw->put_ClusterName( bstrClusterNameIn ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
TraceSysFreeString( bstrClusterLabel );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_ClusterName
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ClusterName
|
|
//
|
|
// Description:
|
|
// Return the name of the cluster to create. This will be either the
|
|
// cluster name specified in a call to put_ClusterName or one entered
|
|
// by the user.
|
|
//
|
|
// Arguments:
|
|
// pbstrClusterNameOut - Cluster name used by the wizard.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ClusterName( BSTR * pbstrClusterNameOut )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ClusterName( pbstrClusterNameOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ClusterName
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_ServiceAccountName
|
|
//
|
|
// Description:
|
|
// Set the name of the cluster service account.
|
|
//
|
|
// Arguments:
|
|
// bstrServiceAccountNameIn - Cluster service account name.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_ServiceAccountName( BSTR bstrServiceAccountNameIn )
|
|
{
|
|
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->put_ServiceAccountUserName( bstrServiceAccountNameIn ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_ServiceAccountName
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ServiceAccountName
|
|
//
|
|
// Description:
|
|
// Get the name of the cluster service account.
|
|
//
|
|
// Arguments:
|
|
// pbstrServiceAccountNameIn - Cluster service account name.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ServiceAccountName( BSTR * pbstrServiceAccountNameOut )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ServiceAccountUserName( pbstrServiceAccountNameOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ServiceAccountName
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_ServiceAccountDomain
|
|
//
|
|
// Description:
|
|
// Set the domain name of the cluster service account.
|
|
//
|
|
// Arguments:
|
|
// bstrServiceAccountDomainIn - Cluster service account domain name.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_ServiceAccountDomain( BSTR bstrServiceAccountDomainIn )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->put_ServiceAccountDomainName( bstrServiceAccountDomainIn ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_ServiceAccountDomain
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ServiceAccountDomain
|
|
//
|
|
// Description:
|
|
// Get the domain name of the cluster service account.
|
|
//
|
|
// Arguments:
|
|
// pbstrServiceAccountDomainOut - Cluster service account domain name.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ServiceAccountDomain( BSTR * pbstrServiceAccountDomainOut )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ServiceAccountDomainName( pbstrServiceAccountDomainOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ServiceAccountDomain
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_ServiceAccountPassword
|
|
//
|
|
// Description:
|
|
// Set the cluster service account password.
|
|
//
|
|
// Arguments:
|
|
// bstrPasswordIn - Cluster service account password.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_ServiceAccountPassword( BSTR bstrPasswordIn )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->put_ServiceAccountPassword( bstrPasswordIn ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_ServiceAccountPassword
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_ClusterIPAddress
|
|
//
|
|
// Description:
|
|
// Set the IP address to use for the cluster name.
|
|
//
|
|
// Arguments:
|
|
// bstrClusterIPAddressIn - Cluster IP address in string form.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_ClusterIPAddress( BSTR bstrClusterIPAddressIn )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->put_ClusterIPAddress( bstrClusterIPAddressIn ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_ClusterIPAddress
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ClusterIPAddress
|
|
//
|
|
// Description:
|
|
// Get the IP address to use for the cluster name.
|
|
//
|
|
// Arguments:
|
|
// pbstrClusterIPAddressOut - Cluster IP address in string form.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ClusterIPAddress( BSTR * pbstrClusterIPAddressOut )
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ClusterIPAddress( pbstrClusterIPAddressOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ClusterIPAddress
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ClusterIPSubnet
|
|
//
|
|
// Description:
|
|
// Get the IP address subnet mask for the cluster name calculated by
|
|
// the wizard.
|
|
//
|
|
// Arguments:
|
|
// pbstrClusterIPSubnetOut - Cluster IP address subnet mask in string form.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ClusterIPSubnet(
|
|
BSTR * pbstrClusterIPSubnetOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ClusterIPSubnet( pbstrClusterIPSubnetOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ClusterIPSubnet
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_ClusterIPAddressNetwork
|
|
//
|
|
// Description:
|
|
// Get the name of the network connection (cluster network) on which the
|
|
// cluster IP address is published.
|
|
//
|
|
// Arguments:
|
|
// pbstrClusterNetworkNameOut - Network connection name.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_ClusterIPAddressNetwork(
|
|
BSTR * pbstrClusterNetworkNameOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = THR( m_pccw->get_ClusterIPAddressNetwork( pbstrClusterNetworkNameOut ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_ClusterIPAddressNetwork
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_FirstNodeInCluster
|
|
//
|
|
// Description:
|
|
// Set the name of the first node in the cluster.
|
|
//
|
|
// Arguments:
|
|
// bstrFirstNodeInClusterIn - Name of the first node.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_FirstNodeInCluster(
|
|
BSTR bstrFirstNodeInClusterIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
HRESULT hr = S_OK;
|
|
BSTR bstrNode = NULL;
|
|
|
|
if ( m_bstrFirstNodeInCluster != NULL )
|
|
{
|
|
hr = THR( m_pccw->ClearComputerList() );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
TraceSysFreeString( m_bstrFirstNodeInCluster );
|
|
m_bstrFirstNodeInCluster = NULL;
|
|
}
|
|
|
|
if ( SysStringLen( bstrFirstNodeInClusterIn ) > 0 )
|
|
{
|
|
bstrNode = TraceSysAllocString( bstrFirstNodeInClusterIn );
|
|
if ( bstrNode == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( m_pccw->AddComputer( bstrFirstNodeInClusterIn ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
m_bstrFirstNodeInCluster = bstrNode;
|
|
bstrNode = NULL;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
TraceSysFreeString( bstrNode );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_FirstNodeInCluster
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_FirstNodeInCluster
|
|
//
|
|
// Description:
|
|
// Get the name of the first node in the cluster.
|
|
//
|
|
// Arguments:
|
|
// pbstrFirstNodeInClusterIn - Name of the first node.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_FirstNodeInCluster(
|
|
BSTR * pbstrFirstNodeInClusterOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( pbstrFirstNodeInClusterOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
*pbstrFirstNodeInClusterOut = NULL;
|
|
|
|
if ( m_bstrFirstNodeInCluster != NULL )
|
|
{
|
|
*pbstrFirstNodeInClusterOut = SysAllocString( m_bstrFirstNodeInCluster );
|
|
if ( *pbstrFirstNodeInClusterOut == NULL )
|
|
{
|
|
hr = THR( E_OUTOFMEMORY );
|
|
goto Cleanup;
|
|
}
|
|
} // if: first node has been set
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_FirstNodeInCluster
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::put_MinimumConfiguration
|
|
//
|
|
// Description:
|
|
// Specify whether the wizard should operate in full or minimum
|
|
// configuration mode.
|
|
//
|
|
// Arguments:
|
|
// fMinConfigIn
|
|
// VARIANT_TRUE - Put wizard in Minimum Configuration mode.
|
|
// VARIANT_FALSE - Put wizard in Full Configuration mode.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::put_MinimumConfiguration(
|
|
VARIANT_BOOL fMinConfigIn
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL fMinConfig = ( fMinConfigIn == VARIANT_TRUE? TRUE: FALSE );
|
|
|
|
hr = THR( m_pccw->put_MinimumConfiguration( fMinConfig ) );
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::put_MinimumConfiguration
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::get_MinimumConfiguration
|
|
//
|
|
// Description:
|
|
// Get the current configuration mode of the wizard.
|
|
//
|
|
// Arguments:
|
|
// pfMinConfigOut
|
|
// Configuration mode of the wizard:
|
|
// VARIANT_TRUE - Minimum Configuration mode.
|
|
// VARIANT_FALSE - Full Configuration mode.
|
|
// This value could have been set either by a call to the
|
|
// put_MinimumConfiguration method or by the user in the wizard.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::get_MinimumConfiguration(
|
|
VARIANT_BOOL * pfMinConfigOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL fMinConfig = FALSE;
|
|
|
|
if ( pfMinConfigOut == NULL )
|
|
{
|
|
hr = THR( E_POINTER );
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( m_pccw->get_MinimumConfiguration( &fMinConfig ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
*pfMinConfigOut = ( fMinConfig? VARIANT_TRUE: VARIANT_FALSE );
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::get_MinimumConfiguration
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CCreateClusterWizard::ShowWizard
|
|
//
|
|
// Description:
|
|
// Show the wizard.
|
|
//
|
|
// Arguments:
|
|
// lParentWindowHandleIn
|
|
// The parent window handle represented as a LONG value.
|
|
//
|
|
// pfCompletedOut
|
|
// Return status of the wizard operation itself:
|
|
// VARIANT_TRUE - Wizard was completed.
|
|
// VARIANT_FALSE - Wizard was cancelled.
|
|
//
|
|
// Return Values:
|
|
// S_OK - Operation completed successfully.
|
|
// Other HRESULTs.
|
|
//
|
|
//--
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
STDMETHODIMP
|
|
CCreateClusterWizard::ShowWizard(
|
|
long lParentWindowHandleIn
|
|
, VARIANT_BOOL * pfCompletedOut
|
|
)
|
|
{
|
|
TraceFunc( "[IClusCfgCreateClusterWizard]" );
|
|
|
|
HRESULT hr = S_OK;
|
|
BOOL fCompleted = FALSE;
|
|
HWND hwndParent = reinterpret_cast< HWND >( LongToHandle( lParentWindowHandleIn ) );
|
|
|
|
if ( ( hwndParent != NULL ) && ( IsWindow( hwndParent ) == FALSE ) )
|
|
{
|
|
hr = THR( E_INVALIDARG );
|
|
goto Cleanup;
|
|
}
|
|
|
|
hr = THR( m_pccw->CreateCluster( hwndParent, &fCompleted ) );
|
|
if ( FAILED( hr ) )
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
if ( pfCompletedOut != NULL )
|
|
{
|
|
*pfCompletedOut = ( fCompleted ? VARIANT_TRUE : VARIANT_FALSE );
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
HRETURN( hr );
|
|
|
|
} //*** CCreateClusterWizard::ShowWizard
|