//////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 2000-2002 Microsoft Corporation
//
//  Module Name:
//      ClusCfgClient.idl
//
//  Description:
//      This file is the IDL file for the middler tier framework for the
//      Cluster Configuration Wizard.
//
//////////////////////////////////////////////////////////////////////////////


// Comments for generated files
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )
cpp_quote( "//" )
cpp_quote( "// Copyright (c) 2000 Microsoft Corporation" )
cpp_quote( "//" )
cpp_quote( "// Remarks:" )
cpp_quote( "//     Generated file. See file ClusCfgClient.idl for more details." )
cpp_quote( "//" )
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )


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

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


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

interface INotifyUI;
interface IObjectManager;
interface INotificationManager;
interface ITaskManager;
interface IDoTask;
interface ITaskGetDomains;
interface ITaskGetDomainsCallback;
interface ITaskAnalyzeCluster;
interface ITaskCommitClusterChanges;
interface ITaskVerifyIPAddress;
interface IStandardInfo;
interface IConnectionManager;
interface IConnectionInfo;
interface IGatherData;
interface IConfigurationConnection;
interface ITaskGatherNodeInfo;
interface ITaskGatherInformation;
interface IEnumNodes;
interface ITaskCompareAndPushInformation;
interface ITaskGatherClusterInfo;
interface IEnumCookies;
interface ITaskPollingCallback;
interface ILogManager;
interface ILogger;

//////////////////////////////////////////////////////////////////////////////
// Type Definitions
//////////////////////////////////////////////////////////////////////////////


typedef DWORD   OBJECTCOOKIE;


//////////////////////////////////////////////////////////////////////////////
// Interface Definitions
//////////////////////////////////////////////////////////////////////////////


//****************************************************************************
//++
//
//  interface INotifyUI
//
//  Description:
//      TODO:   gpease  10-MAR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( E5E8D401-1A37-4fbf-880C-826CC89516FD ),
    pointer_default( unique )
]
interface INotifyUI : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  INotifyUI::ObjectChanged(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Notifies the UI layer that the object "cookieIn"has changed. The
    //      object implementing this interface must marshall the data.
    //
    //  Arguments:
    //      cookieIn
    //          Data Manager cookie to the object that changed.
    //
    //  Return Value:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ObjectChanged(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interace INotifyUI

//****************************************************************************
//++
//
//  interface IDoTask
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 0230C9F8-EE7F-4307-98DB-726EBCAE55D6 ),
    pointer_default( unique )
]
interface
IDoTask : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IDoTask::BeginTask( void )
    //
    //  Description:
    //      Entry method for a task object.
    //
    //  Arguments:
    //      None. You should describe a private interface to communicate
    //      parameters to your task.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        BeginTask( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IDoTask::StopTask( void )
    //
    //  Description:
    //      Entry method to stop/cancel and running task.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StopTask( void );

}; //*** interface IDoTask

//****************************************************************************
//++
//
//  interface INotificationManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 95531501-8782-4845-901D-312F36BA6C6E ),
    pointer_default( unique )
]
interface
INotificationManager : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  INotificationManager::AddConnectionPoint(
    //        REFIID                riidIn
    //      , IConnectionPoint *    pcpIn
    //      )
    //
    //  Description:
    //      Adds a connection point for the notification manager to manage
    //      for a particular interface. There can only be one registration
    //      for a particular interface.
    //
    //  Arguments:
    //      riidIn
    //          The IID of the interface.
    //
    //      pcpIn
    //          Interface to the connection point.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      CO_E_OBJISREG
    //          The interface for the connection point is already registered.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        AddConnectionPoint(
              [ in ] REFIID             riidIn
            , [ in ] IConnectionPoint * pcpIn
            );

}; //*** interface INotificationManager

//****************************************************************************
//++
//
//  interface IConnectionManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( C0017768-1BF3-4352-8D6C-3A8C1D0FB477 ),
    pointer_default( unique )
]
interface
IConnectionManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  GetConnectionToObject(
    //        OBJECTCOOKIE  cookieIn
    //      , IUnknown **   ppunkOut
    //      )
    //
    //  Description:
    //      Establishes a connection to the object referenced by "cookieIn."
    //
    //  Arguments:
    //      cookieIn
    //          An object reference cookie from the Object Manager.
    //
    //      ppunkOut
    //          Interface pointer to the object.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetConnectionToObject(
              [ in ]  OBJECTCOOKIE  cookieIn
            , [ out ] IUnknown **   ppunkOut
            );

}; //*** interface IConnectionManager


//****************************************************************************
//++
//
//  interface ITaskManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 16116694-DFC5-470b-AC12-46FBB01CEF10 ),
    pointer_default( unique )
]
interface
ITaskManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskManager::CreateTask(
    //        REFIID        clsidIn
    //      , IUnknown **   ppunkOut
    //      )
    //
    //  Description:
    //      Submits a task to the Action Manager.
    //
    //  Arguments:
    //      pTask
    //          Task to submit.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call fails.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        CreateTask(
              [ in ]  REFIID        clsidIn
            , [ out ] IUnknown **   ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskManager::SubmitTask(
    //      IDoTask *   pTask
    //      )
    //
    //  Description:
    //      Submits a task to the Action Manager.
    //
    //  Arguments:
    //      pTask
    //          Task to submit.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call fails.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SubmitTask(
            [ in ] IDoTask * pTask
            );

}; //*** interface ITaskManager


//****************************************************************************
//++
//
//  interface ITaskManager
//
//  Description:
//      TODO:   gpease  15-APR-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( D51351DF-6394-4236-9783-65ED05631068 ),
    pointer_default( unique )
]
interface
IObjectManager : IUnknown
{

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::FindObject(
    //        REFCLSID          rclsidTypeIn
    //      , OBJECTCOOKIE      cookieParentIn
    //      , LPCWSTR           pcszNameIn
    //      , REFCLSID          rclsidFormatIn
    //      , OBJECTCOOKIE *    pcookieOut
    //      , LPUNKNOWN *       ppunkOut
    //      )
    //
    //  Description:
    //      Looks up and retrieves information about an object that has the
    //      type "rclsidTypeIn" and has the name "pcszNameIn". It will return
    //      an object that contains data in the format specified by
    //      "rclsidFormatIn". It will also return "pcookieOut" that can be
    //      used to identify the object in future requests.
    //
    //  Arguments:
    //      rclsidTypeIn
    //          The type of the object to find.
    //
    //      cookieParentIn
    //          Cookie of the cluster. NULL looking for a cluster.
    //
    //      pcszNameIn
    //          The name of the object to find.
    //
    //      rclsidFormatIn
    //          The format of the data to retrieve about the object.
    //
    //      pcookieOut
    //          A value that represents the object.
    //
    //      ppunkOut
    //          The requested data. NULL in indicates no data returned.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      S_PENDING
    //          Data being retrieved; ask again later using the cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        FindObject(
              [ in ]                            REFCLSID        rclsidTypeIn
            , [ in ]                            OBJECTCOOKIE    cookieClusterIn
            , [ in, pointer_default( unique ) ] LPCWSTR         pcszNameIn
            , [ in ]                            REFCLSID        rclsidFormatIn
            , [ out ]                           OBJECTCOOKIE *  pcookieOut
            , [ out, iid_is( rclsidFormatIn ) ] LPUNKNOWN *     ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::GetObject(
    //        REFCLSID      rclsidFormatIn
    //      , OBJECTCOOKIE  cookieIn
    //      , LPUNKNOWN *   ppunkOut
    //      )
    //
    //  Description:
    //      Lookups and retrieves information about the object using "cookieIn"
    //      as a reference. It will return an object that contains data in the
    //      format specified by "rclsidFormatIn".
    //
    //  Arguments:
    //      rclsidFormatIn
    //          The format of the data to retrieve about the object.
    //
    //      pcookieIn
    //          The value of the object to retrieve data from.
    //
    //      ppunkOut
    //          The requested data. NULL in indicates no data returned.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      S_PENDING
    //          Data being retrieved; ask again later using the cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetObject(
              [ in ]  REFCLSID                              rclsidFormatIn
            , [ in ]  OBJECTCOOKIE                          cookieIn
            , [ out, iid_is( rclsidFormatIn ) ] LPUNKNOWN * ppunkOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::RemoveObject(
    //      OBJECTCOOKIE    cookieIn
    //      )
    //
    //  Description:
    //      Removes an object from the object cache and requests deletion all
    //      existing data format objects. This will also remove all children
    //      of the object (if any).
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the object to be removed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        RemoveObject(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IObjectManager::SetObjectStatus(
    //        OBJECTCOOKIE  cookieIn
    //      , HRESULT       hrIn
    //      )
    //
    //  Description:
    //      Sets the status on an object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the object.
    //
    //      hrIn
    //          Status to set.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetObjectStatus(
              [ in ] OBJECTCOOKIE   cookieIn
            , [ in ] HRESULT        hrIn
            );

}; //*** interface IObjectManager


//
//  Task Interfaces
//

//****************************************************************************
//++
//
//  interface ITaskGetDomains
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( DFCB4ACD-C4DB-4db4-8EBB-1DD07A9D5B82 ),
    pointer_default( unique )
]
interface
ITaskGetDomains : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGetDomains::SetCallback(
    //      ITaskGetDomainsCallback * pResultsCallbackIn
    //      )
    //
    //  Description:
    //      Stores the ITaskGetDomainsCallback that will be used to send
    //      status and names for this task.
    //
    //  Arguments:
    //      pResultsCallbackIn
    //          The ITaskGetDomainsCallback interface of the object that will
    //          receive the status information as well as the names that are
    //          enumerated.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCallback(
            [ in ] ITaskGetDomainsCallback * pResultsCallbackIn
            );

}; // *** interface ITaskGetDomains

//****************************************************************************
//++
//
//  interface ITaskGetDomainsCallback
//
//  Description:
//      TODO:   gpease  15-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 85402E44-6834-41df-8590-01827D124E1B ),
    pointer_default( unique )
]
interface
ITaskGetDomainsCallback : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    // STDMETHOD
    // ITaskGetDomainsCallback::ReceiveDomainResult(
    //      HRESULT hrIn
    //      )
    //
    // Description:
    //      Callback used to tell the invoker of TaskGetDomains the results
    //      of the enumeration. This will be only called if there is a
    //      problem.
    //
    // Arguments:
    //      hrIn
    //          The HRESULT result code of the login attempt.
    //
    // Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed - this will abort the enumeration.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ReceiveDomainResult( [ in ] HRESULT hrIn );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGetDomainsCallback::ReceiveDomainName(
    //      LPCWSTR    pcszDomainIn
    //      )
    //
    //  Description:
    //      This method will be called by the TaskGetDomains to send an
    //      enumerated name back to the UI layer.
    //
    //  Arguments:
    //      pcszDomainIn
    //          The next enumerated domain name.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs
    //          The call failed - this will abort the enumeration.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ReceiveDomainName(
            [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn
            );

}; //*** interface ITaskGetDomainsCallback

//****************************************************************************
//++
//
//  interface ITaskAnalyzeCluster
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 795737A1-E13A-45eb-8DFD-8185C4B7AD4E ),
    pointer_default( unique )
]
interface
ITaskAnalyzeCluster : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetJoiningMode( void )
    //
    //  Description:
    //      Changes this task to joining mode.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoiningMode( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskAnalyzeCluster::SetClusterCookie(
    //      OBJECTCOOKIE cookieClusterIn
    //      )
    //
    //  Description:
    //      Stores the cookie of the cluster configuration object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the cluster to configure.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClusterCookie(
            [ in ] OBJECTCOOKIE cookieClusterIn
            );

}; //*** interface ITaskAnalyzeCluster


//****************************************************************************
//++
//
//  interface ITaskCommitClusterChanges
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 1BF12DDE-F8B0-49b1-A458-6747DB788A47 ),
    pointer_default( unique )
]
interface
ITaskCommitClusterChanges : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetClusterCookie(
    //      OBJECTCOOKIE cookieClusterIn
    //      )
    //
    //  Description:
    //      Stores the cookie of the cluster configuration object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the cluster to configure.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClusterCookie(
            [ in ] OBJECTCOOKIE cookieClusterIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCommitClusterChanges::SetJoining( void )
    //
    //  Description:
    //      Sets the task into joining mode.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoining( void );

}; //*** interface ITaskCommitClusterChanges

//****************************************************************************
//++
//
//  interface IStandardInfo
//
//  Description:
//      TODO:   gpease  18-MAY-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( F1D9C1A5-9589-40dd-B63D-9BB0B38A1022 ),
    pointer_default( unique )
]
interface
IStandardInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetType(
    //      CLSID * pclsidTypeOut
    //      )
    //
    //  Description:
    //      Retrieves the type of object.
    //
    //  Arguments:
    //      pclsidTypeOut
    //          The CLSID representing the type.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetType(
            [ out ] CLSID * pclsidTypeOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetName(
    //      BSTR * pbstrNameOut
    //      )
    //
    //  Description:
    //      Retrieve the object's name.
    //
    //  Arguments:
    //      pbstrNameOut
    //          The name of the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetName(
            [ out ] BSTR * pbstrNameOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::SetName(
    //      LPCWSTR pcszNameIn
    //      )
    //
    //  Description:
    //      Sets the object's name.
    //
    //  Arguments:
    //      ppcszNameIn
    //          The name of the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetName(
            [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetParent(
    //      OBJECTCOOKIE * pcookieOut
    //      )
    //
    //  Description:
    //      Retrieve the parent object's cookie.
    //
    //  Arguments:
    //      pcookieOut
    //          The cookie for the parent object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetParent(
            [ out ] OBJECTCOOKIE * pcookieOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::GetStatus(
    //      HRESULT * phrOut
    //      )
    //
    //  Description:
    //      Retrieves the status of the object.
    //
    //  Arguments:
    //      phrOut
    //          The last HRESULT received for the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetStatus(
            [ out ] HRESULT * phrOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IStandardInfo::SetStatus(
    //      HRESULT hrIn
    //      )
    //
    //  Description:
    //      Sets the status of the object.
    //
    //  Arguments:
    //      hrIn
    //          Sets the last HRESULT for the object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetStatus(
            [ in ] HRESULT hrIn
            );

}; //*** interface IStandardInfo

//****************************************************************************
//++
//
//  interface ITaskVerifyIPAddress
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 0c95e1b1-0cff-4740-8abd-69912d105bd1 ),
    pointer_default( unique )
]
interface
ITaskVerifyIPAddress : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskVerifyIPAddress::SetIPAddress(
    //      DWORD   dwIPAddressIn
    //      )
    //
    //  Description:
    //      Stores the IP Address to verify.
    //
    //  Arguments:
    //      dwIPAddressIn
    //          Dotted-quad network-byte-order IP address to verify.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetIPAddress(
            [ in ] DWORD dwIPAddressIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskVerifyIPAddress::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskVerifyIPAddress

//****************************************************************************
//++
//
//  interface IConfigurationConnection
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( DDAD8191-66C5-4a30-A4DF-CB6C216704CA ),
    pointer_default( unique )
]
interface
IConfigurationConnection : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ConnectTo(
    //      LPVOID  cookieIn
    //      )
    //
    //  Description:
    //      Opens a connection a cluster "cookieIn".
    //
    //  Arguments:
    //      cookieIn        - cookie to the cluster to open.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ConnectTo(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ConnectToObject(
    //        LPVOID        cookieIn
    //      , REFIID        riidIn
    //      , LPUNKNOWN *   ppunkOut
    //      )
    //
    //  Description:
    //      Opens a connection a cluster "cookieIn".
    //
    //  Arguments:
    //      cookieIn        - cookie to the cluster to open.
    //      riidIn          - riid of the interface to get.
    //      ppunkOut        - the interface to the object requested.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        ConnectToObject(
              [ in ] OBJECTCOOKIE   cookieIn
            , [ in ] REFIID         riidIn
            , [ in ] LPUNKNOWN *    ppunkOut
            );

}; //*** interface IConfigurationConnection


//****************************************************************************
//++
//
//  interface IConnectionInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 15182CE3-82D7-473f-92DE-706E2BCEA902 ),
    pointer_default( unique )
]
interface
IConnectionInfo : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::GetConnection(
    //      IConfigurationConnection ** pccOut
    //      )
    //
    //  Description:
    //      Retrieves the cookie for the connection object that is used to
    //      communicate with the object in question.
    //
    //  Arguments:
    //      pccOut
    //          The interface to the connection object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetConnection(
            [ out ] IConfigurationConnection ** pccOut
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::SetConnection(
    //      IConfigurationConnection * pccIn
    //      )
    //
    //  Description:
    //      Stores the cookie for the connection object that is used to
    //      communicate with the object in question.
    //
    //  Arguments:
    //      pccIn
    //          The interface to the connection object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetConnection(
            [ in ] IConfigurationConnection * pccIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IConnectionInfo::GetParent(
    //      OBJECTCOOKIE * pcookieOut
    //      )
    //
    //  Description:
    //      Retrieve the parent object's cookie.
    //
    //  Arguments:
    //      pcookieOut
    //          The cookie for the parent object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      S_FALSE
    //          Success but there wasn't a cookie.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetParent(
            [ out ] OBJECTCOOKIE * pcookieOut
            );

}; //*** interface IConnectionInfo


//****************************************************************************
//++
//
//  interface IEnumCookies
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//  Documentation:
//      See IEnumXXXX in MSDN.
//
//--
//****************************************************************************
[
    object,
    uuid( 5E3E482E-3C22-482c-B664-693051AD0A5D ),
    pointer_default( unique )
]
interface
IEnumCookies : IUnknown
{
    HRESULT
        Next(
              [ in ]                                                    ULONG           celtIn
            , [ out, size_is( celtIn ), length_is( *pceltFetchedOut ) ] OBJECTCOOKIE *  rgcookieOut
            , [ out ]                                                   ULONG *         pceltFetchedOut
            );

    HRESULT
        Skip(
            [ in ] ULONG celtIn
            );

    HRESULT
        Reset( void );

    HRESULT
        Clone(
            [ out ] IEnumCookies ** ppenumOut
            );

    HRESULT
        Count(
            [ out, ref ] DWORD * pnCountOut
            );

}; //*** interface IEnumCookies


//****************************************************************************
//++
//
//  interface IEnumNodes
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//  Documentation:
//      See IEnumXXXX in MSDN.
//
//--
//****************************************************************************
[
    object,
    uuid( C477E363-AF0A-4203-A604-45CD607DD710 ),
    pointer_default( unique )
]
interface
IEnumNodes : IUnknown
{
    HRESULT
        Next(
              [ in ]                                                    ULONG               celtIn
            , [ out, size_is( celtIn ), length_is( *pceltFetchedOut ) ] IClusCfgNodeInfo ** rgccniOut
            , [ out ]                                                   ULONG *             pceltFetchedOut
            );

    HRESULT
        Skip(
            [ in ] ULONG celtIn
            );

    HRESULT
        Reset( void );

    HRESULT
        Clone(
            [ out ] IEnumNodes ** ppenumOut
            );

    HRESULT
        Count(
            [ out, ref ] DWORD * pnCountOut
            );

}; //*** interface IEnumNodes


//****************************************************************************
//++
//
//  interface ITaskGatherClusterInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( E167965C-C5D6-493c-A343-4C105C01DDE7 ),
    pointer_default( unique )
]
interface
ITaskGatherClusterInfo : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherClusterInfo::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      E_OUTOFMEMORY   - Out of memory.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherClusterInfo::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskGatherClusterInfo


//****************************************************************************
//++
//
//  interface IGatherData
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 65318F4A-B63C-4e21-ADDC-BDCFB969E181 ),
    pointer_default( unique )
]
interface
IGatherData : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  IGatherData::Gather(
    //      OBJECTCOOKIE cookieParentIn,
    //      IUnknown * punkIn
    //      )
    //
    //  Description:
    //      An object representation gathers the information from the punk.
    //
    //  Arguments:
    //      cookieParentIn
    //          The parent of the object.
    //
    //      punkIn
    //          The interface that can be used to gather information.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        Gather(
              [ in ] OBJECTCOOKIE   cookieParentIn
            , [ in ] IUnknown *     punkIn
            );

}; //*** interface IGatherData


//****************************************************************************
//++
//
//  interface ITaskGatherNodeInfo
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( F19A2E01-2CB3-47b4-8F5D-B977176B45C8 ),
    pointer_default( unique )
]
interface
ITaskGatherNodeInfo : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherNodeInfo::SetCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      E_OUTOFMEMORY   - Out of memory.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherNodeInfo::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherNodeInfo::SetUserAddedNodeFlag(
    //      BOOL fUserAddedNodeIn
    //      )
    //
    //  Description:
    //      Stores the flag about whether this node a new Node being added/formed or not .
    //
    //  Arguments:
    //      fUserAddedNodeIn
    //
    //  Return Type:
    //      S_OK            - Success.
    //      other HRESULTs.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetUserAddedNodeFlag(
            [ in ] BOOL fUserAddedNodeIn
            );

}; //*** interface ITaskGatherNodeInfo

//****************************************************************************
//++
//
//  interface ITaskCompareAndPushInformation
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( D4F1C2AF-B370-49de-8768-4010B568636C ),
    pointer_default( unique )
]
interface
ITaskCompareAndPushInformation : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCompareAndPushInformation::SetNodeCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetNodeCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCompareAndPushInformation::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

}; //*** interface ITaskCompareAndPushInformation

//****************************************************************************
//++
//
//  interface ITaskGatherInformation
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( B9AAF3F8-238E-4993-BA31-14859804F92C ),
    pointer_default( unique )
]
interface
ITaskGatherInformation : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetNodeCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to the Node to retrieve information about.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the Node to retrieve information about.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetNodeCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie to signal when the task is completed.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie to signal when the task is completed.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetJoining( void )
    //
    //  Description:
    //      Sets the task to indicate that it going to be joining nodes.
    //
    //  Arguments:
    //      None.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetJoining( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskGatherInformation::SetMinimalConfiguration(
    //      BOOL    fMinimalConfigurationIn
    //      )
    //
    //  Description:
    //      Sets the task to indicate that a minimal configuration was
    //      selected.
    //
    //  Arguments:
    //      fMinimalConfigurationIn
    //          TRUE when minimal configuration was selected.
    //
    //  Return Values:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetMinimalConfiguration(
            [ in ] BOOL fMinimalConfigurationIn
            );

}; //*** interface ITaskGatherInformation


//****************************************************************************
//++
//
//  interface ITaskPollingCallback
//
//  Description:
//      TODO:   gpease  14-JUL-2000
//      Write a description.
//
//--
//****************************************************************************
[
    object,
    uuid( 49E92395-66AF-4add-A41E-43512CB519B3 ),
    pointer_default( unique )
]
interface
ITaskPollingCallback : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskPollingCallback::SetServerInfo(
    //        DWORD         dwRemoteServerObjectGITCookieIn
    //      , OBJECTCOOKIE  cookieLocalServerObjectIn
    //      )
    //
    //  Description:
    //      Passes the information needed by this task to communication with
    //      the ClusCfg server object on a remote server.
    //
    //  Arguments:
    //      dwRemoteServerObjectGITCookieIn
    //          The GIT cookie to the server side object used to obtain the
    //          polling callback interface.
    //
    //      cookieLocalServerObjectIn
    //          Object manager cookie to the client side server proxy object.
    //          Needed to get the standard info from that object.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetServerInfo(
              [ in ] DWORD          dwRemoteServerObjectGITCookieIn
            , [ in ] OBJECTCOOKIE   cookieLocalServerObjectIn
            );

}; //*** interface ITaskPollingCallback


//****************************************************************************
//++
//
//  interface ILogManager
//
//  Description:
//      Manage logging for all clients of the middle tier.
//
//--
//****************************************************************************
[
    object,
    uuid( 4759DC11-8DA0-4261-BBFB-EC321911D1C9 ),
    pointer_default( unique )
]
interface
ILogManager : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogManager::StartLogging( void )
    //
    //  Description:
    //      Starts logging IClusCfgCallback notifications to the log file.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StartLogging( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogManager::StopLogging( void )
    //
    //  Description:
    //      Stops logging IClusCfgCallback notifications to the log file.
    //
    //  Arguments:
    //      None.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        StopLogging( void );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogManager::GetLogger( ILogger ** ppLoggerOut )
    //
    //  Description:
    //      Returns a pointer to the ILogger instance to use for writing to
    //      the log file.
    //
    //  Arguments:
    //      ppLoggerOut - on success, a pointer to the ILogger instance.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        GetLogger( [ out ] ILogger ** ppLoggerOut );

}; //*** interface ILogManager

//****************************************************************************
//++
//
//  interface ILogger
//
//  Description:
//      Manage logging from multiple sources to the same log file.
//
//--
//****************************************************************************
[
    object,
    uuid( D9598418-304E-4f94-B6A1-E642FE95ED57 ),
    pointer_default( unique )
]
interface
ILogger : IUnknown
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ILogger::LogMsg(
    //      LPCWSTR pcszMsgIn
    //      )
    //
    //  Description:
    //      Logs a message to the log file.
    //
    //  Arguments:
    //      nLogEntryTypeIn - Log entry type.
    //      pcszMsgIn       - Message to log.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        LogMsg(
              [ in ] DWORD                              nLogEntryTypeIn
            , [ in, pointer_default( unique ) ] LPCWSTR pcszMsgIn
            );

}; //*** interface ILogger

//****************************************************************************
//++
//
//  interface ITaskCancelCleanup
//
//  Description:
//
//
//--
//****************************************************************************
[
    object,
    uuid( FFE81BE7-34E8-4286-8A5F-B69814EA5720 ),
    pointer_default( unique )
]
interface
ITaskCancelCleanup : IDoTask
{
    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCancelCleanup::SetClusterCookie(
    //      OBJECTCOOKIE cookieClusterIn
    //      )
    //
    //  Description:
    //      Stores the cookie of the cluster configuration object.
    //
    //  Arguments:
    //      cookieIn
    //          The cookie of the cluster to run the cleanup task against.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetClusterCookie(
            [ in ] OBJECTCOOKIE cookieClusterIn
            );

    //////////////////////////////////////////////////////////////////////////
    //
    //  STDMETHOD
    //  ITaskCancelCleanup::SetCompletionCookie(
    //      OBJECTCOOKIE cookieIn
    //      )
    //
    //  Description:
    //      Stores the cookie that will be used to send the notification that the
    //      task has been completed.
    //
    //  Arguments:
    //      cookieIn
    //          A cookie that will be sent as notification that the task is done.
    //
    //  Return Type:
    //      S_OK
    //          Success.
    //
    //      E_OUTOFMEMORY
    //          Out of memory.
    //
    //      other HRESULTs.
    //          The call failed.
    //
    //////////////////////////////////////////////////////////////////////////
    HRESULT
        SetCompletionCookie(
            [ in ] OBJECTCOOKIE cookieCompletionIn
            );

}; //*** interface ITaskCancelCleanup


[
    uuid( a0cb3974-8681-46c1-b78b-599567bd385d ),
    version( 1.0 ),
    helpstring("Microsoft Cluster Configuration Client Library"),
    lcid( 0 )
]
library ClusCfgClient
{
    //////////////////////////////////////////////////////////////////////////////
    // Imported Files
    //////////////////////////////////////////////////////////////////////////////

    importlib("stdole2.tlb");

    //////////////////////////////////////////////////////////////////////////////
    // Interface Definitions
    //////////////////////////////////////////////////////////////////////////////


    //****************************************************************************
    //++
    //
    //  interface IClusCfgAsyncEvictCleanup
    //
    //  Description:
    //      This interface can be used to cleanup a node that has been evicted from
    //      a cluster. This interface can be used to cleanup both local and remote
    //      nodes. Note, you cannot use asynchronous COM with this interface, since
    //      it is an oleautomation interface.
    //
    //--
    //****************************************************************************
    [
        object,
        uuid( 52C80B95-C1AD-4240-8D89-72E9FA84025E ),
        dual,
        helpstring("IClusCfgAsyncEvictCleanup interface"),
        pointer_default( unique )
    ]
    interface
    IClusCfgAsyncEvictCleanup : IDispatch
    {
        //////////////////////////////////////////////////////////////////////
        //
        //  HRESULT
        //  CleanupNode(
        //        BSTR  bstrEvictedNodeNameIn
        //      , long  lDelayIn
        //      , long  lTimeoutIn
        //      )
        //
        //  Routine Description:
        //      Cleanup a node that has been evicted.
        //
        //  Arguments:
        //      bstrEvictedNodeNameIn
        //          Name of the node on which cleanup is to be initiated.  If
        //          this is NULL the local node is cleaned up.
        //
        //      nDelayIn
        //          Number of milliseconds that will elapse before cleanup is
        //          started on the target node.  If some other process cleans
        //          up the target node while delay is in progress, the delay
        //          is terminated. If this value is zero, the node is cleaned
        //          up immediately.
        //
        //      nTimeoutIn
        //          Number of milliseconds that this method will wait for
        //          cleanup to complete.  This timeout is independent of the
        //          delay above, so if dwDelayIn is greater than dwTimeoutIn,
        //          this method will most probably timeout.  Once initiated,
        //          however, cleanup will run to completion - this method just
        //          may not wait for it to complete.
        //
        //  Return Value:
        //      S_OK
        //          If the cleanup operations were successful
        //
        //      RPC_S_CALLPENDING
        //          If cleanup is not complete in dwTimeoutIn milliseconds
        //
        //      Other HRESULTS
        //          In case of error
        //
        //////////////////////////////////////////////////////////////////////
        HRESULT
            CleanupNode(
                  [ in ] BSTR  bstrEvictedNodeNameIn
                , [ in ] long  nDelayIn
                , [ in ] long  nTimeoutIn
                );

    }; //*** interface IClusCfgAsyncEvictCleanup

}; //*** library ClusCfgClient