windows-server-2003/base/cluster/mgmt/cluscfg/inc/cluscfgprivate.idl

//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2000-2002 Microsoft Corporation
//
//  Module Name:
//      ClusCfgPrivate.idl
//
//  Description:
//      This file is the IDL file for private interfaces between components
//      of the Cluster Configuration Wizard.
//
//
//  Maintained By:
//      Galen Barbee  (GalenB)  29-JUN-2000
//
//////////////////////////////////////////////////////////////////////////////


// Comments for generated files
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// Copyright (c) 2000-2002 Microsoft Corporation" )
cpp_quote( "//" )
cpp_quote( "// Remarks:" )
cpp_quote( "//     These are private interfaces and should not be published outside of Microsoft!" )
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )


//////////////////////////////////////////////////////////////////////////////
// Imported Files
//////////////////////////////////////////////////////////////////////////////

import "unknwn.idl";
import "objidl.idl";
import "ClusCfgServer.idl";
import "ClusCfgClient.idl";


//////////////////////////////////////////////////////////////////////////////
// Forward Declarations
//////////////////////////////////////////////////////////////////////////////

interface   IClusCfgServer;
interface   IClusCfgPollingCallback;
interface   IClusCfgPollingCallbackInfo;
interface   IExtendObjectManager;
interface   IClusCfgResTypeServicesInitialize;
interface   IClusCfgClusterConnection;
interface   IClusCfgSetCredentials;
interface   IClusCfgVerify;
interface   IClusCfgClusterConnection;
interface   IClusCfgBaseCluster;

//****************************************************************************
//++
//
//  interface IClusCfgServer
//
//  Description:
//      The IClusCfgServer interface provides the functions
//      required  to gather information about storage devices, networks
//      and the operating system on a computer. It also exposes functions
//      to form a cluster on this computer, to add this node to a cluster,
//      to remove this node from a cluster, etc.
//
//--
//****************************************************************************
[
    object,
    uuid( 4C06EAE6-990E-4051-8AA1-AD4B4EAE9CAF ),
    async_uuid( 2A1640AA-4561-4a08-B5D9-0AA38C6BE628 ),
    pointer_default( unique )
]
interface IClusCfgServer : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetClusterNodeInfo(
    //      [ out ] IClusCfgNodeInfo ** ppClusterNodeInfoOut
    //      )
    //
    //  Description:
    //      Get information about the computer on which this object is present.
    //
    //  Parameter:
    //      ppClusterNodeInfoOut
    //          Pointer to the IClusterNodeInfo interface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetClusterNodeInfo( [ out ] IClusCfgNodeInfo ** ppClusterNodeInfoOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetManagedResourcesEnum(
    //      [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResourcesOut
    //      )
    //
    //  Description:
    //      Get an enumeration of the resources on this computer that can be managed
    //      by the cluster service.  This is an enumeration of enumerators of the
    //      resources.
    //
    //  Parameter:
    //      ppEnumManagedResourcesEnumOut
    //          Pointer to the IEnumClusCfgManagedResources interface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetManagedResourcesEnum(
            [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResourcesOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetNetworksEnum(
    //      [ out ] IEnumClusCfgNetworks ** ppEnumNetworksOut
    //      )
    //
    //  Description:
    //      Get an enumeration of all the networks on this computer.
    //
    //  Parameter:
    //      ppEnumNetworksOut
    //          Pointer to the IEnumClusCfgNetworks inteface.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetNetworksEnum( [ out ] IEnumClusCfgNetworks ** ppEnumNetworksOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  CommitChanges( void )
    //
    //  Description:
    //      Commit the changes to the node and join/form the cluster.
    //
    //  Return Values:
    //      S_OK
    //          The commit succeeded.
    //
    //      other HRESULTs
    //          The commit failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CommitChanges( void );

    //
    //  Binding String
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetBindingString(
    //      [ out ] BSTR * pbstrBindingStringOut
    //      )
    //
    //  Description:
    //      Retrieves the binding string (IP address) used to connect
    //      to this server.
    //
    //  Notes:
    //      Retrieves the binding string used to connect to the remote server.
    //      If it returns NULL/S_FALSE, no binding was needed as it was a local
    //      connection.
    //
    //  Parameter:
    //      pbstrBindingStringOut
    //          Pointer to a BSTR. This should be freed by the caller by calling
    //          SysFreeString( ).
    //
    //  Return Values:
    //      S_OK
    //          Successly returned binding connection.
    //
    //      S_FALSE
    //          Local connection was established - no binding string available.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetBindingString( [ out ] BSTR * pbstrBindingStringOut );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetBindingString(
    //      [ in ] LPCWSTR pcszBindingStringIn
    //      )
    //
    //  Description:
    //      Stores the binding string for this server.
    //
    //  Notes:
    //
    //  Parameter:
    //      pcszBindingStringIn
    //          The binding string to use when connecting to this server.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULT
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetBindingString(
            [ in, pointer_default( unique ) ] LPCWSTR pcszBindingStringIn
            );

}; //*** interface IClusCfgServer


//****************************************************************************
//++
//
//  interface IClusCfgPollingCallback
//
//  Description:
//      This interface is used to callback to the client to indicate
//      status or progess (or both) about a task being completed on the
//      server.
//
//--
//****************************************************************************
[
    object,
    uuid( C72DB1FD-51A2-43e6-B708-D9DB7DA79630 ),
    async_uuid( FBE17C4B-3B3D-48c1-A8E8-C29098C9919B ),
    pointer_default( unique )
]
interface IClusCfgPollingCallback : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetStatusReport(
    //      [ out ] BSTR *      pbstrNodeNameOut,
    //      [ out ] CLSID *     pclsidTaskMajorOut,
    //      [ out ] CLSID *     pclsidTaskMinorOut,
    //      [ out ] ULONG *     pulMinOut,
    //      [ out ] ULONG *     pulMaxOut,
    //      [ out ] ULONG *     pulCurrentOut,
    //      [ out ] HRESULT *   phrStatusOut,
    //      [ out ] BSTR *      pbstrDescriptionOut,
    //      [ out ] FILETIME *  pftTimeOut,
    //      [ out ] BSTR *      pbstrReferenceOut
    //      )
    //
    //  Description:
    //      This method retreies a queued status report from the client.
    //
    //  Parameters:
    //      pbstrNodeNameOut
    //          The name of the node (server) that sent the report.
    //
    //      pclsidTaskMajorOut
    //          CLSID of the major task item to give status about. For the
    //          wizard, this indicates which node in the tree view control
    //          to publish this status message under. If clsidTaskMajorIn
    //          equals TASKID_Major_Client_Log, TASKID_Major_Server_Log, or
    //          TASKID_Major_Client_And_Server_Log, only a log entry will be
    //          made.
    //
    //      pclsidTaskMinorOut
    //          CLSID of the minor task to give status about. These should be
    //          unique to each sub-task and message.
    //
    //      pulMinOut
    //          The min value of progress.
    //
    //      pulMaxOut
    //          The max value of progress.
    //
    //      pulCurrentOut
    //          The current value of progress.
    //
    //      phrStatusOut
    //          The current status.
    //
    //      pbstrDescriptionOut
    //          The description of the status. Can be NULL to indicate that nothing
    //          needs to be passed.
    //
    //      pftTimeOut
    //          Time that this report was created.
    //
    //      pbstrReferenceOut
    //          Optional reference data, additional context, URL, etc. that
    //          might better help explain the problem is this is an error
    //          report.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetStatusReport(
            [ out ] BSTR *      pbstrNodeNameOut,
            [ out ] CLSID *     pclsidTaskMajorOut,
            [ out ] CLSID *     pclsidTaskMinorOut,
            [ out ] ULONG *     pulMinOut,
            [ out ] ULONG *     pulMaxOut,
            [ out ] ULONG *     pulCurrentOut,
            [ out ] HRESULT *   phrStatusOut,
            [ out ] BSTR *      pbstrDescriptionOut,
            [ out ] FILETIME *  pftTimeOut,
            [ out ] BSTR *      pbstrReferenceOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetHResult(
    //      [ in ]   HRESULT hrIn
    //      )
    //
    //  Description:
    //      Set the status of the SendStatusReport() back into the sender.
    //
    //  Parameters:
    //
    //      hrIn
    //          The status of this call from the SendStatusReport() in
    //          the middle tier.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetHResult(
            [ in ]   HRESULT hrIn
            );

}; //*** interface IClusCfgPollingCallback


//****************************************************************************
//++
//
//  interface IClusCfgPollingCallbackInfo
//
//  Description:
//      This interface is used to callback to the client to indicate
//      status or progess (or both) about a task being completed on the
//      server.
//
//--
//****************************************************************************
[
    object,
    uuid( 2AF55DA7-CB6F-40de-BB11-6673464B2C54 ),
    pointer_default( unique )
]
interface IClusCfgPollingCallbackInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetCallback(
    //      [ out ] IClusCfgPollingCallback ** ppiccpcOut
    //      )
    //
    //  Description:
    //      Get a pointer to the polling callback object.
    //
    //  Parameters:
    //      piccpcOut
    //          Pointer to the polling callback object.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetCallback(
            [ out ] IClusCfgPollingCallback ** ppiccpcOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetPollingMode(
    //      [ in ] BOOL fPollingModeIn
    //      )
    //
    //  Description:
    //      Set the polling mode of the callback.
    //
    //  Parameters:
    //      fPollingModeIn
    //          If true do polling, if false do not do polling.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetPollingMode(
            [ in ] BOOL fPollingModeIn
            );

}; //*** interface IClusCfgPollingCallbackInfo

//****************************************************************************
//++
//
//  interface IExtendObjectManager
//
//  Description:
//      TODO:   gpease  21-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( ca7bb0b9-700c-4dc5-991e-75f9e65ee975 ),
    local,
    pointer_default( unique )
]
interface
IExtendObjectManager : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IExtendObjectManager::FindObject(
    //            [ in ]    OBJECTCOOKIE    cookieIn
    //          , [ in ]    REFCLSID        rclsidTypeIn
    //          , [ in ]    LPCWSTR         pcszNameIn
    //          , [ out ]   LPUNKNOWN *     ppunkOut
    //          )
    //
    //  Description:
    //      Lookups and retrieves information about an object that has the
    //      type "dmtIn" and has the name "pcszName". It will return an
    //      interface for the format specified by "dmfIn".
    //
    //  Arguments:
    //      cookieIn
    //          Cookie that represents this object in the Object Manager.
    //
    //      dmtIn
    //          The type of the object to find.
    //
    //      pcszName
    //          The name of the object to find.
    //
    //      ppunkOut
    //          The requested data. NULL in indicates no data returned.
    //
    //  Return Values:
    //      S_OK
    //          Success. Data format initialized and ready.
    //
    //      S_FALSE
    //          Success. But the data format does not want to be persistent.
    //          This will cause the Object Manager to generate a new object
    //          everytime.
    //
    //      E_PENDING
    //          The interface returned is valid, but the data is not available
    //          yet. To indicate that the data is ready, send a notification
    //          updating the status of the cookie (cookieIn).
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        FindObject (
              [ in ]                            OBJECTCOOKIE    cookieIn
            , [ in ]                            REFCLSID        rclsidTypeIn
            , [ in, pointer_default( unique ) ] LPCWSTR         pcszNameIn
            , [ out ]                           LPUNKNOWN *     ppunkOut
            );

}; // interface IExtendObjectManager


//****************************************************************************
//++
//
//  interface IClusCfgResTypeServicesInitialize
//
//  Description:
//      This interface is used to initialize the resource type services component.
//
//--
//****************************************************************************
[
    object,
    uuid( 6E109698-DFC4-4471-ACE1-0414931B3BB3 ),
    pointer_default( unique )
]
interface IClusCfgResTypeServicesInitialize : IUnknown
{
    //////////////////////////////////////////////////////////////////////////////
    //++
    //
    //  IClusCfgResTypeServicesInitialize::SetParameters(
    //      [ in ] IClusCfgClusterInfo * pccciIn
    //      )
    //
    //  Description:
    //      Set the parameters required by this component.
    //
    //  Arguments:
    //      pccciIn
    //          Pointer to an interface that provides information about the cluster
    //          being configured.
    //
    //  Return Value:
    //      S_OK
    //          If the call succeeded
    //
    //      Other HRESULTs
    //          If the call failed.
    //
    //--
    //////////////////////////////////////////////////////////////////////////////
    HRESULT
        SetParameters(
            [ in ] IClusCfgClusterInfo * pccciIn
            );

}; //*** interface IClusCfgResTypeServicesInitialize


//****************************************************************************
//++
//
//  interface IClusCfgSetCredentials
//
//
//--
//****************************************************************************
[
    object,
    uuid( 58E6E5B9-4788-4d9a-8255-1E274E5DCCB0 ),
    pointer_default( unique )
]
interface IClusCfgSetCredentials : IUnknown
{
    HRESULT
        SetDomainCredentials(
            [ in, pointer_default( unique ) ] LPCWSTR pszCredentials
            );

} //*** IClusCfgSetCredentials


//****************************************************************************
//++
//
//  interface IClusCfgVerify
//
//  Description:
//      This interface is used to verify the connection to the server.
//
//--
//****************************************************************************

[
    object,
    uuid( D47BBEEC-2286-4514-AA90-7E88BD0FE543 ),
    pointer_default( unique )
]
interface IClusCfgVerify : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //      VerifyCredentials(
    //          [ in ] LPCWSTR pcszUserIn,
    //          [ in ] LPCWSTR pcszDomainIn,
    //          [ in ] LPCWSTR pcszPasswordIn
    //          )
    //
    //  Description:
    //      Validate the credentials.
    //
    //  Parameters:
    //      pcszUserIn
    //          The user name.
    //
    //      pcszDomainIn
    //          The domain name.
    //
    //      pcszPasswordIn
    //          The user's password.
    //
    //  Return Values:
    //      S_OK
    //          The credentials are valid.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        VerifyCredentials(
            [ in, pointer_default( unique ) ] LPCWSTR pcszUserIn,
            [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn,
            [ in, pointer_default( unique ) ] LPCWSTR pcszPasswordIn
            );

    ///////////////////////////////////////////////////////////////////////////
    //
    //  HRESULT
    //  VerifyConnectionToCluster(
    //      LPCWSTR pcszClusterNameIn
    //      )
    //
    //  Description:
    //      The client passes the connection name to the created server object.
    //      The server object will then verify that the client connected to
    //      the CLUSTER is was supposed to. We have to do this because the
    //      currently network situation can lead to unpredictable connections.
    //
    //  Arguments:
    //      pcszClusterNameIn
    //          This is the FDQN for the cluster we are looking for.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded and the client did connect to the correct
    //          node.
    //
    //      S_FALSE
    //          The call succeeded but the client connected to a different node.
    //
    //      other failure HRESULTs
    //          The call failed.
    //
    ///////////////////////////////////////////////////////////////////////////
    HRESULT
        VerifyConnectionToCluster(
            [ in, pointer_default( unique ) ] LPCWSTR pcszClusterNameIn
            );

    ///////////////////////////////////////////////////////////////////////////
    //
    //  HRESULT
    //  VerifyConnectionToNode(
    //      LPCWSTR pcszNodeNameIn
    //      )
    //
    //  Description:
    //      The client passes the connection name to the created server object.
    //      The server object will then verify that the client connected to
    //      the NODE is was supposed to. We have to do this because the
    //      currently network situation can lead to unpredictable connections.
    //
    //  Arguments:
    //      pcszNodeNameIn
    //          This is the FDQN for the node we are looking for.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded and the client did connect to the correct
    //          node.
    //
    //      S_FALSE
    //          The call succeeded but the client connected to a different node.
    //
    //      other failure HRESULTs
    //          The call failed.
    //
    ///////////////////////////////////////////////////////////////////////////
    HRESULT
        VerifyConnectionToNode(
            [ in, pointer_default( unique ) ] LPCWSTR pcszNodeNameIn
            );

} //*** IClusCfgVerify


//****************************************************************************
//++
//
//  interface IClusCfgClusterConnection
//
//  Description:
//      This interface is used for managing cluster connections.
//
//--
//****************************************************************************

[
    object,
    uuid( CE6EF90C-3602-41e7-95BD-AAFD37A676DF ),
    pointer_default( unique )
]
interface IClusCfgClusterConnection : IUnknown
{
    ///////////////////////////////////////////////////////////////////////////
    //
    //  HRESULT
    //  OpenConnection(
    //      LPCWSTR pcszClusterNameIn
    //      )
    //
    //  Description:
    //
    //  Arguments:
    //      pcszClusterNameIn
    //          This is the FDQN for the server we are looking for. This can
    //          be a node or cluster name.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other failure HRESULTs
    //          The call failed.
    //
    ///////////////////////////////////////////////////////////////////////////
    HRESULT
        OpenConnection(
            [ in, pointer_default( unique ) ] LPCWSTR pcszClusterNameIn
            );

} //*** IClusCfgClusterConnection

//****************************************************************************
//++
//
//  interface IClusCfgBaseCluster
//
//  Description:
//      The IClusCfgBaseCluster interface provides the functions
//      required to form a minimal cluster on a computer, join an existing
//      cluster, upgrade a node or cleanup a node.
//
//--
//****************************************************************************
[
    object,
    uuid( A8A5C613-2518-47f5-96CA-CAFA7FFBAF68 ),
    async_uuid( A8A5C614-2518-47f5-96CA-CAFA7FFBAF68 ),
    pointer_default( unique )
]
interface IClusCfgBaseCluster : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetCreate(
    //        [ in, string ]    const WCHAR *           pcszClusterNameIn
    //      , [ in, string ]    const WCHAR *           pcszClusterBindingStringIn
    //      , [ in ]            IClusCfgCredentials *   pcccServiceAccountIn
    //      , [ in, string ]    const WCHAR *           pcszClusterAccountPwdIn
    //      , [ in, string ]    const WCHAR *           pcszClusterAccountDomainIn
    //      , [ in ]            const DWORD             dwClusterIPAddressIn
    //      , [ in ]            const DWORD             dwClusterIPSubnetMaskIn
    //      , [ in, string ]    const WCHAR *           pcszClusterIPNetworkIn
    //      )
    //
    //  Description:
    //      Indicate that a cluster is to be created on this computer. This
    //      cluster has only three core resources, the network name resource,
    //      the IP address resource and the Local Quorum resource.
    //
    //  Parameters:
    //      pcszClusterNameIn
    //          Name of the cluster to be formed.
    //
    //      pcszClusterBindingStringIn
    //      pcccServiceAccountIn
    //          Information about the account to be used as the cluster service
    //          account.
    //
    //      dwClusterIPAddressIn
    //      dwClusterIPSubnetMaskIn
    //      pcszClusterIPNetworkIn
    //          Information about the cluster IP address.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCreate(
              [ in, string ]    const WCHAR *           pcszClusterNameIn
            , [ in, string ]    const WCHAR *           pcszClusterBindingStringIn
            , [ in ]            IClusCfgCredentials *   pcccServiceAccountIn
            , [ in ]            const DWORD             dwClusterIPAddressIn
            , [ in ]            const DWORD             dwClusterIPSubnetMaskIn
            , [ in, string ]    const WCHAR *           pcszClusterIPNetworkIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetAdd(
    //        [ in, string ]    const WCHAR *           pcszClusterNameIn
    //      , [ in, string ]    const WCHAR *           pcszClusterBindingStringIn
    //      , [ in ]            IClusCfgCredentials *   pcccServiceAccountIn
    //      )
    //
    //  Description:
    //      Indicate that this computer is to be added to a cluster.
    //
    //  Parameters:
    //      pcszClusterNameIn
    //          Name of the cluster to join.
    //
    //      pcszClusterBindingStringIn
    //      pcccServiceAccountIn
    //          Information about the account to be used as the cluster service
    //          account.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetAdd(
              [ in, string ]    const WCHAR *           pcszClusterNameIn
            , [ in, string ]    const WCHAR *           pcszClusterBindingStringIn
            , [ in ]            IClusCfgCredentials *   pcccServiceAccountIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  SetCleanup( void )
    //
    //  Description:
    //      Indicate that this node needs to be cleaned up. This method is
    //      called after the node has been evicted from a cluster to clean up
    //      the state left over from its erstwhile cluster membership. This
    //      method has to be called before the node can be a part of a cluster
    //      again. Note, the ClusSvc service should not be running when this
    //      action is committed.
    //
    //  Parameters:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCleanup( void );

    //
    //  MUSTDO: 04-APR-2000 VVasu
    //
    //  Declare the SetUpgrade method here.
    //

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Commit( void )
    //
    //  Description:
    //      This function actually performs the action indicated by a previous
    //      Setxxx call.
    //
    //  Parameters:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      E_FAIL
    //          If this commit has already been performed.
    //
    //      E_INVALIDARG
    //          If no action has been set using a SetXXX call.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Commit( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  Rollback( void )
    //
    //  Description:
    //      This function rolls back the action performed by a commit call.
    //
    //  Parameters:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          The call succeeded.
    //
    //      other HRESULTs
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Rollback( void );

}; //*** interface IClusCfgBaseCluster


//****************************************************************************
//++
//
//  interface IClusCfgClusterInfoEx
//
//  Description:
//      Additional information about a cluster not provided by IClusCfgClusterInfo.
//
//--
//****************************************************************************
[
    object,
    uuid( 30C3CFDC-CE08-4011-B2B4-861387EB5111 ),
    async_uuid( B6FFFF9D-4C21-4397-A71D-C42AED2C7C39 ),
    pointer_default( unique )
]
interface IClusCfgClusterInfoEx: IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  CheckJoiningNodeVersion(
    //      [ in ]        DWORD    dwNodeHighestVersionIn
    //    , [ in ]        DWORD    dwNodeLowestVersionIn
    //    )
    //
    //  Description:
    //      Check a joining node's version information against that of nodes
    //      already in the cluster, and provide the version required by the cluster.
    //
    //  Parameters:
    //      dwNodeHighestVersionIn
    //      dwNodeLowestVersionIn
    //          The node's version information, obtained from
    //          IClusCfgNodeInfo::GetClusterVersion.
    //
    //  Return Values:
    //      S_OK -- The node is compatible with the cluster.
    //
    //      HRESULT_FROM_WIN32( ERROR_CLUSTER_INCOMPATIBLE_VERSIONS )
    //          The node is not compatible with the cluster.
    //
    //      Other failures are possible.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CheckJoiningNodeVersion(
          [ in ]        DWORD    dwNodeHighestVersionIn
        , [ in ]        DWORD    dwNodeLowestVersionIn
        );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetNodeNames(
    //          [ out, ref ]                      long *   pnCountOut
    //        , [ out, size_is( , *pnCountOut ) ] BSTR **  prgbstrNodeNamesOut
    //    )
    //
    //  Description:
    //      Get the names of the nodes already in a cluster.
    //
    //  Parameters:
    //      pnCountOut
    //          On success, *pnCountOut returns the number of nodes in the cluster.
    //
    //      prgbstrNodeNamesOut
    //          On success, an array of BSTRs containing the node names.
    //          The caller must free each BSTR with SysFreeString, and free
    //          the array with CoTaskMemFree.
    //
    //  Return Values:
    //      S_OK
    //          The out parameters contain valid information and the caller
    //          must free the array and the BSTRs it contains.
    //
    //      E_OUTOFMEMORY, and other failures are possible.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetNodeNames(
          [ out, ref ]                      long *  pnCountOut
        , [ out, size_is( , *pnCountOut ) ] BSTR ** prgbstrNodeNamesOut
        );
        
}; //*** interface IClusCfgClusterInfoEx