able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/public/sdk/inc/cluscfgserver.idl

4051 lines
122 KiB
Plaintext
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2001 Microsoft Corporation
//
// Module Name:
// ClusCfgServer.idl
//
// Description:
// This file is the IDL file for the IClusCfgServer interface of the
// Cluster Setup application.
//
// The IClusCfgServer interface provides the functions required to gather
// information about storage devices, networks, the operating
// system, etc. on a computer. It also has functions to form a cluster
// on this computer, to add this node to a cluster, to remove this node
// from a cluster, etc.
//
//////////////////////////////////////////////////////////////////////////////
// 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 ClusCfgServer.idl for more details." )
cpp_quote( "//" )
cpp_quote( "//////////////////////////////////////////////////////////////////////////////" )
//////////////////////////////////////////////////////////////////////////////
// Imported Files
//////////////////////////////////////////////////////////////////////////////
// For IUnknown
import "unknwn.idl";
////////////////////////////////////////////////////////////////////////////
// Forward Declarations
//////////////////////////////////////////////////////////////////////////////
interface IClusCfgNodeInfo;
interface IEnumClusCfgManagedResources;
interface IClusCfgManagedResourceInfo;
interface IEnumClusCfgNetworks;
interface IEnumClusCfgPartitions;
interface IClusCfgPartitionInfo;
interface IEnumClusCfgIPAddresses;
interface IClusCfgIPAddressInfo;
interface IClusCfgNetworkInfo;
interface IClusCfgClusterInfo;
interface IClusCfgInitialize;
interface IClusCfgCallback;
interface IClusCfgCredentials;
interface IClusCfgCapabilities;
interface IClusCfgManagedResourceCfg;
interface IClusCfgResourcePreCreate;
interface IClusCfgResourceCreate;
interface IClusCfgResourcePostCreate;
interface IClusCfgGroupCfg;
interface IClusCfgResourceTypeInfo;
interface IClusCfgResourceTypeCreate;
interface IClusCfgMemberSetChangeListener;
interface IClusCfgEvictCleanup;
interface IClusCfgStartupListener;
//////////////////////////////////////////////////////////////////////////////
// Type Definitions
//////////////////////////////////////////////////////////////////////////////
//
// This enumeration is used to indicate the differetnt usage
// states of a drive letter.
//
typedef enum
{
dluUNKNOWN = 0,
dluNO_ROOT_DIRECTORY,
dluREMOVABLE_DISK,
dluFIXED_DISK,
dluNETWORK_DRIVE,
dluCOMPACT_DISC,
dluRAM_DISK,
dluSYSTEM,
dluUNUSED,
dluMAX
} EDriveLetterUsage;
typedef struct _DRIVELETTERMAPPING {
EDriveLetterUsage dluDrives[ 26 ];
} SDriveLetterMapping;
//
// This enumeration is used to indicate the mode of the ClusCfgServer commit operation.
//
typedef enum
{
cmUNKNOWN = 0,
cmCREATE_CLUSTER,
cmADD_NODE_TO_CLUSTER,
cmCLEANUP_NODE_AFTER_EVICT,
cmMAX
} ECommitMode;
//////////////////////////////////////////////////////////////////////////////
// Constant Definitions
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// Interface Definitions
//////////////////////////////////////////////////////////////////////////////
//****************************************************************************
//++
//
// interface IClusCfgNodeInfo
//
// Description:
// This interface contains information about the node configuration.
//
//--
//****************************************************************************
[
object,
uuid( E4B5FA15-DD07-439e-A623-8823524E3D19 ),
async_uuid( 4F3BB40B-DF27-40a0-B31A-BA18324CEB9D ),
pointer_default( unique )
]
interface IClusCfgNodeInfo : IUnknown
{
//
// Name
//
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetName(
// [ out ] BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves the node's fully qualified domain name. e.g.
// cluster1.ntdev.microsoft.com.
//
// Parameter:
// pbstrNameOut
// Pointer to the name of the node. This should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// The call succeeded.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Stores the new name for the node. This does not take effect until after
// the changes have been commited. This is stubbed out for future
// functionality.
//
// Parameter:
// pcszNameIn
// The new name for the node.
//
// Return Values:
// E_NOTIMPL
// The call is not implemented.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//
// Membership?
//
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsMemberOfCluster( void )
//
// Description:
// Call this to determine if the node is part of a cluster.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
IsMemberOfCluster( void );
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetClusterConfigInfo(
// [ out ] IClusCfgClusterInfo ** ppClusCfgClusterInfoOut
// )
//
// Description:
// If it is a member, use this method to obtain an interface to
// IClusCfgClusterInfo.
//
// Parameter:
// ppClusCfgClusterInfoOut
// Pointer to the IClusCfgClusterInfo interface.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
GetClusterConfigInfo( [ out ] IClusCfgClusterInfo ** ppClusCfgClusterInfoOut );
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetOSVersion(
// [ out ] DWORD * pdwMajorVersionOut,
// [ out ] DWORD * pdwMinorVersionOut,
// [ out ] WORD * pwSuiteMaskOut,
// [ out ] BYTE * pbProductTypeOut,
// [ out ] BSTR * pbstrCSDVersionOut
// )
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
GetOSVersion(
[ out ] DWORD * pdwMajorVersionOut,
[ out ] DWORD * pdwMinorVersionOut,
[ out ] WORD * pwSuiteMaskOut,
[ out ] BYTE * pbProductTypeOut,
[ out ] BSTR * pbstrCSDVersionOut
);
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetClusterVersion(
// [ out ] DWORD * pdwNodeHighestVersion,
// [ out ] DWORD * pdwNodeLowestVersion
// )
//
// Description:
// Retrieves the version of the cluster.
//
// Parameters:
// pdwNodeHighestVersion
// The highest version in the cluster.
//
// pdwNodeLowestVersion
// The lowest version in the cluster.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
GetClusterVersion(
[ out ] DWORD * pdwNodeHighestVersion,
[ out ] DWORD * pdwNodeLowestVersion
);
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetDriveLetterMappings(
// [ out ] SDriveLetterMapping dlmDriveLetterUsageOut
// )
//
// Description:
// Retrieves the drive letter mappings on the node.
//
// Parameter:
// rgDriveLetterUsage
// An array of flags representing A: thru Z: (26) drive mappings to
// the device. See SDriveLetterMapping for flag values.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterUsageOut );
}; //*** interface IClusCfgNodeInfo
//****************************************************************************
//++
//
// interface IEnumClusCfgManagedResources
//
// Description:
// This interface enumerates all resources on this computer that the
// cluster service can manage.
//
//--
//****************************************************************************
[
object,
uuid( 7DBE11EB-A5DF-4534-ABF6-8BAC7B53FC95 ),
async_uuid( B138483F-9695-4fa6-A98F-0DE2FB355449 ),
pointer_default( unique )
]
interface IEnumClusCfgManagedResources : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Next(
// [ in ] ULONG cNumberRequestedIn,
// [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgManagedResourceInfo ** rgpManagedResourceInfoOut,
// [ out ] ULONG * pcNumberFetchedOut
// );
//
// Description:
// Retrieves the next cNumberRequestedIn items in the enumeration sequence.
// If there are fewer than the requested number of elements left in the
// sequence, it retrieves the remaining elements. The number of elements
// actually retrieved is returned through pcNumberFetchedOut (unless the
// caller passed in NULL for that parameter).
//
// Parameters:
// cNumberRequestedIn
// number of elements being requested.
//
// rgpManagedResourceInfoOut
// Array of size cNumberRequestedIn (or larger) of the elements of interest.
// The type of this parameter depends on the item being enumerated.
//
// pcNumberFetchedOut
// Pointer to the number of elements actually supplied in
// rgpManagedResourceInfoOut. Caller can pass in NULL if cNumberRequestedIn
// is one.
//
// Return Values:
// S_OK
// The number of elements supplied is cNumberRequestedIn
//
// S_FALSE
// The number of elements supplied is not cNumberRequestedIn
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Next(
[ in ] ULONG cNumberRequestedIn,
[ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgManagedResourceInfo ** rgpManagedResourceInfoOut,
[ out ] ULONG * pcNumberFetchedOut
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Reset( void );
//
// Description:
// Reset the enumeration sequence to the beginning.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Reset( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Skip(
// [ in ] ULONG cNumberToSkip
// );
//
// Description:
// Skips over the next specified number of elements in the enumeration sequence.
//
// Parameter:
// cNumberToSkip
// The number of elements to be skipped.
//
// Return Value:
// S_OK
// The number of elements skipped is cNumberToSkip.
//
// S_FALSE
// Success, but you're past the last element.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Skip( [ in ] ULONG cNumberToSkip );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Clone(
// [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResources
// );
//
// Description:
// Creates another enumerator that contains the same enumeration state
// as the current one. Using this function, a client can record a
// particular point in the enumeration sequence, and then return to
// that point at a later time. The new enumerator supports the same
// interface as the original one.
//
// Return Values:
// E_INVALIDARG
// ppEnumManagedResources is invalid.
//
// E_OUTOFMEMORY
// Out of memory.
//
// E_UNEXPECTED
// Unknown error (it's in the EnumXXXX docs).
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Clone( [ out ] IEnumClusCfgManagedResources ** ppEnumManagedResourcesOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Count(
// [ out, ref ] DWORD * pnCountOut
// );
//
// Description:
// Returns the size (possibly zero) of the enumerator's collection.
//
// Return Values:
// E_POINTER
// pnCountOut was null.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Count( [ out, ref ] DWORD * pnCountOut );
}; //*** interface IEnumClusCfgManagedResources
//****************************************************************************
//++
//
// interface IEnumClusCfgNetworks
//
// Description:
// This interface enumerates the networks on this computer.
//
//--
//****************************************************************************
[
object,
uuid( CF3FAED8-1322-4bcb-9923-B5B745A69E36 ),
async_uuid( F56B9B0D-E7B8-49ec-A843-5475076B947D ),
pointer_default( unique )
]
interface IEnumClusCfgNetworks : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Next(
// [ in ] ULONG cNumberRequestedIn,
// [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgNetworkInfo ** rgpNetworkInfoOut,
// [ out ] ULONG * pcNumberFetchedOut
// );
//
// Description:
// Retrieves the next cNumberRequestedIn items in the enumeration sequence.
// If there are fewer than the requested number of elements left in the
// sequence, it retrieves the remaining elements. The number of elements
// actually retrieved is returned through pcNumberFetchedOut (unless the
// caller passed in NULL for that parameter).
//
// Parameters:
// cNumberRequestedIn
// number of elements being requested.
//
// rgpNetworkInfoOut
// Array of size cNumberRequestedIn (or larger) of the elements of interest.
// The type of this parameter depends on the item being enumerated.
//
// pcNumberFetchedOut
// Pointer to the number of elements actually supplied in
// rgpNetworkInfoOut. Caller can pass in NULL if cNumberRequestedIn
// is one.
//
// Return Values:
// S_OK
// The number of elements supplied is cNumberRequestedIn
//
// S_FALSE
// The number of elements supplied is not cNumberRequestedIn.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Next(
[ in ] ULONG cNumberRequestedIn,
[ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgNetworkInfo ** rgpNetworkInfoOut,
[ out ] ULONG * pcNumberFetchedOut
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Skip(
// [ in ] ULONG cNumberToSkip
// );
//
// Description:
// Skips over the next specified number of elements in the enumeration sequence.
//
// Parameter:
// cNumberToSkip
// The number of elements to be skipped.
//
// Return Value:
// S_OK
// The number of elements skipped is cNumberToSkip.
//
// S_FALSE
// Success, but you've past the last element.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Skip( [ in ] ULONG cNumberToSkipIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Reset( void );
//
// Description:
// Reset the enumeration sequence to the beginning.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Reset( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Clone(
// [ out ] IEnumClusCfgNetworks ** ppEnumNetworksOut
// );
//
// Description:
// Creates another enumerator that contains the same enumeration state
// as the current one. Using this function, a client can record a
// particular point in the enumeration sequence, and then return to
// that point at a later time. The new enumerator supports the same
// interface as the original one.
//
// Parameter:
// ppEnumNetworksOut
// Address of IEnumClusCfgManagedResources * pointer variable that receives
// the interface pointer to the enumeration object. If the method is
// unsuccessful, the value of this output variable is undefined.
//
// Return Values:
// E_INVALIDARG
// ppEnumNetworksOut is invalid.
//
// E_OUTOFMEMORY
// Out of memory.
//
// E_UNEXPECTED
// Unknown error (it's in the EnumXXXX docs).
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Clone( [ out ] IEnumClusCfgNetworks ** ppEnumNetworksOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Count(
// [ out, ref ] DWORD * pnCountOut
// );
//
// Description:
// Returns the size (possibly zero) of the enumerator's collection.
//
// Return Values:
// E_POINTER
// pnCountOut was null.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Count( [ out, ref ] DWORD * pnCountOut );
}; //*** interface IEnumClusCfgNetworks
//****************************************************************************
//++
//
// interface IClusCfgManagedResourceInfo
//
// Description:
// This interface encapsulates a manageable resource on this computer.
//
//--
//****************************************************************************
[
object,
uuid( E0324847-1520-41b0-B960-54198DA5F8AF ),
async_uuid( 73616028-1243-4749-AD84-0B5EB358FFA0 ),
pointer_default( unique )
]
interface IClusCfgManagedResourceInfo : IUnknown
{
//
// UID
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetUID(
// [ out ] BSTR * pbstrUIDOut
// )
//
// Description:
// Retrieve the Unique IDentifier for this device. This is not a Universally
// Unique IDentifier (UUID or GUID). This indentifer should match identifiers
// that can be generated on other nodes that can see this device from a shared
// bus (such as a SCSI device).
//
// Parameters:
// pbstrUIDOut
// Pointer to the UID string. pbstrUIDOut should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetUID( [ out ] BSTR * pbstrUIDOut );
//
// Name
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetName(
// [ out ] BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves a "user friendly" name of the device.
//
// Parameter:
// pbstrNameOut
// Pointer to device name. This should be freed by the caller by calling
// SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Stores a new name for the device to be set when the cluster
// configuration is commited.
//
// Parameter:
// pcszNameIn
// The name of the user wants to assigned the device.
//
// Return Value:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//
// Managed by cluster?
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsManaged( void )
//
// Description:
// Call this to determine if the device is/will be managed by the cluster.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsManaged( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetManaged(
// [ in ] BOOL fIsManagedIn
// )
//
// Description:
// Setting this flag will cause the device to be configured as being managed
// by the cluster.
//
// Parameter:
// fIsManagedIn
// If TRUE, the device will be marked as being managed by the cluster.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetManaged( [ in ] BOOL fIsManagedIn );
//
// Quorum Device?
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsQuorumDevice( void )
//
// Description:
// Call this to determine if the device is/will be set as the quorum
// device.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsQuorumDevice( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetQuorumedDevice(
// [ in ] BOOL fIsQuorumDeviceIn
// )
//
// Description:
// Setting this flag will cause the device to be configured as the
// quorum device in the cluster.
//
// Parameter:
// fIsQuorumDeviceIn
// If TRUE, the device will be marked to be the quorum device.
//
// Return Value:
// S_OK
// Success.
//
// E_UNEXPECTED
// You tried to set a device to be the quorum when the device is not
// capable of being a quorum device.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetQuorumedDevice( [ in ] BOOL fIsQuorumDeviceIn );
//
// Quorum Capable?
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsQuorumCapable( void )
//
// Description:
// Call this to determine if the device is capable be set as the quorum
// device.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsQuorumCapable( void );
//
// Drive Letter Mapping
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetDriveLetterMappings(
// [ out ] SDriveLetterMapping dlmDriveLetterMappingsOut
// )
//
// Description:
// Retrieves the drive mappings for the device (if any).
//
// Parameter:
// rgDriveLetterMappings
// An array of flags representing A: thru Z: (26) drive mappings to
// the device. See SDriveLetterMapping for flag values.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterMappingOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetDriveLetterMappings(
// [ in ] SDriveLetterMapping dlmDriveLetterMappingIn
// )
//
// Description:
// Stores the drive mappings for the device. The change will not take
// effect until the configuration has been committed.
//
// Parameter:
// rgDriveLetterMappings
// An array of flags representing A: thru Z: (26) drive mappings to
// the device. See EDriveLetterUsage for flag values.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDriveLetterMappings( [ in ] SDriveLetterMapping dlmDriveLetterMappingIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsDeviceJoinable( void )
//
// Description:
// Call this to determine if the quorum capable device allows other nodes
// to join.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsDeviceJoinable( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetDeviceJoinable(
// [ in ] BOOL fJoinableIn
// )
//
// Description:
// Call this to set the joinable flag.
//
// Return Values:
// S_OK
// Call succeeded
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDeviceJoinable( [ in ] BOOL fJoinableIn );
}; //*** interface IClusCfgManagedResourceInfo
//****************************************************************************
//++
//
// interface IEnumClusCfgPartitions
//
// Description:
// This interface enumerates the partitions on a storage device that the
// cluster service can manage.
//
//--
//****************************************************************************
[
object,
uuid( 4440BB6A-B0AC-479d-B534-7265A31D6C55 ),
async_uuid( 4440BB6A-B0AC-479d-B534-7265A31D6C56 ),
pointer_default( unique )
]
interface IEnumClusCfgPartitions : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Next(
// [ in ] ULONG cNumberRequestedIn,
// [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgPartitionInfo ** rgpPartitionInfoOut,
// [ out ] ULONG * pcNumberFetchedOut
// );
//
// Description:
// Retrieves the next cNumberRequestedIn items in the enumeration sequence.
// If there are fewer than the requested number of elements left in the
// sequence, it retrieves the remaining elements. The number of elements
// actually retrieved is returned through pcNumberFetchedOut (unless the
// caller passed in NULL for that parameter).
//
// Parameters:
// cNumberRequestedIn
// number of elements being requested.
//
// rgpPartitionInfoOut
// Array of size cNumberRequestedIn (or larger) of the elements of interest.
// The type of this parameter depends on the item being enumerated.
//
// pcNumberFetchedOut
// Pointer to the number of elements actually supplied in
// rgpPartitionInfoOut. Caller can pass in NULL if cNumberRequestedIn
// is one.
//
// Return Values:
// S_OK
// The number of elements supplied is cNumberRequestedIn
//
// S_FALSE
// The number of elements supplied is not cNumberRequestedIn
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Next(
[ in ] ULONG cNumberRequestedIn,
[ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgPartitionInfo ** rgpPartitionInfoOut,
[ out ] ULONG * pcNumberFetchedOut
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Reset( void );
//
// Description:
// Reset the enumeration sequence to the beginning.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Reset( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Skip(
// [ in ] ULONG cNumberToSkip
// );
//
// Description:
// Skips over the next specified number of elements in the enumeration sequence.
//
// Parameter:
// cNumberToSkip
// The number of elements to be skipped.
//
// Return Value:
// S_OK
// The number of elements skipped is cNumberToSkip.
//
// S_FALSE
// Success, but you've past the last element.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Skip( [ in ] ULONG cNumberToSkip );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Clone(
// [ out ] IEnumClusCfgPartitions ** ppEnumPartitions
// );
//
// Description:
// Creates another enumerator that contains the same enumeration state
// as the current one. Using this function, a client can record a
// particular point in the enumeration sequence, and then return to
// that point at a later time. The new enumerator supports the same
// interface as the original one.
//
// Return Values:
// E_INVALIDARG
// ppEnumPartitions is invalid.
//
// E_OUTOFMEMORY
// Out of memory.
//
// E_UNEXPECTED
// Unknown error (it's in the EnumXXXX docs).
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Clone( [ out ] IEnumClusCfgPartitions ** ppEnumPartitions );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Count(
// [ out, ref ] DWORD * pnCountOut
// );
//
// Description:
// Returns the size (possibly zero) of the enumerator's collection.
//
// Return Values:
// E_POINTER
// pnCountOut was null.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Count( [ out, ref ] DWORD * pnCountOut );
}; //*** interface IEnumClusCfgPartitions
//****************************************************************************
//++
//
// interface IClusCfgPartitionInfo
//
// Description:
// This interface provides the partition info.
//
//--
//****************************************************************************
[
object,
uuid( EC1EBD9F-5866-4846-8952-EC36C3961EEE ),
async_uuid( EC1EBD9F-5866-4846-8952-EC36C3961EEF ),
pointer_default( unique )
]
interface IClusCfgPartitionInfo : IUnknown
{
//
// UID
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetUID(
// [ out ] BSTR * pbstrUIDOut
// )
//
// Description:
// Retrieve the "Unique IDentifier" for this partition. This is not a Universally
// Unique IDentifier (UUID or GUID). This indentifer should match identifiers
// that can be generated on other nodes, but must be unique for the partition
// the interface (NIC) is on.
//
// Parameters:
// pbstrUIDOut
// Pointer to the UID string. pbstrUIDOut should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetUID( [ out ] BSTR * pbstrUIDOut );
//
// Name
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetName(
// [ out ] BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves a "user friendly" name of the interface.
//
// Parameter:
// pbstrNameOut
// Pointer to partition interface name. This should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Stores a new name of the partition interface to be set when the cluster
// configuration is commited.
//
// Parameter:
// pcszNameIn
// The name of the user wants to assigned the interface.
//
// Return Value:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//
// Description
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetDescription(
// [ out ] BSTR * pbstrDescriptionOut
// )
//
// Description:
// Retrieves the description string for a partition interface.
//
// Parameter:
// pbstrDescription
// Pointer to the description of the partition. This should be freed
// by the caller by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetDescription( [ out ] BSTR * pbstrDescriptionOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetDescription(
// [ in ] LPCWSTR pcszDescriptionIn
// )
//
// Description:
// Stores a new name of the partition interface to be set when the cluster
// configuration is commited.
//
// Parameter:
// pcszDescriptionIn
// The description the user wants to assign to the interface.
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDescription(
[ in, pointer_default( unique ) ] LPCWSTR pcszDescriptionIn
);
//
// Drive Letter Mapping
//
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetDriveLetterMappings(
// [ out ] SDriveLetterMapping dlmDriveLetterUsageOut
// )
//
// Description:
// Retrieves the drive letter mappings of the partition.
//
// Parameter:
// rgDriveLetterUsage
// An array of flags representing A: thru Z: (26) drive mappings to
// the device. See SDriveLetterMapping for flag values.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetDriveLetterMappings( [ out ] SDriveLetterMapping * pdlmDriveLetterUsageOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetDriveLetterMappings(
// [ in ] SDriveLetterMapping dlmDriveLetterMappingIn
// )
//
// Description:
// Stores the drive mappings for the device. The change will not take
// effect until the configuration has been committed.
//
// Parameter:
// rgDriveLetterMappings
// An array of flags representing A: thru Z: (26) drive mappings to
// the device. See EDriveLetterUsage for flag values.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDriveLetterMappings( [ in ] SDriveLetterMapping dlmDriveLetterMappingIn );
//
// Partition Size
//
//////////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetSize(
// [ out ] ULONG * pcMegaBytes
// )
//
// Description:
// Retrieves the size of the partition in Megabytes.
//
// Parameter:
// pcMegaBytes
// Retrieves the partition size.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetSize( [ out ] ULONG * pcMegaBytes );
}; //*** interface IClusCfgPartitionInfo
//****************************************************************************
//++
//
// interface IEnumClusCfgIPAddresses
//
// Description:
// This interface enumerates the IP addresses on this adapter.
//
//--
//****************************************************************************
[
object,
uuid( BD5F35BA-0BC0-455f-926D-C3D356419486 ),
async_uuid( BD5F35BA-0BC0-455f-926D-C3D356419487 ),
pointer_default( unique )
]
interface IEnumClusCfgIPAddresses : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Next(
// [ in ] ULONG cNumberRequestedIn,
// [ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgIPAddressInfo ** rgpIPAddressInfoOut,
// [ out ] ULONG * pcNumberFetchedOut
// );
//
// Description:
// Retrieves the next cNumberRequestedIn items in the enumeration sequence.
// If there are fewer than the requested number of elements left in the
// sequence, it retrieves the remaining elements. The number of elements
// actually retrieved is returned through pcNumberFetchedOut (unless the
// caller passed in NULL for that parameter).
//
// Parameters:
// cNumberRequestedIn
// number of elements being requested.
//
// rgpIPAddressInfoOut
// Array of size cNumberRequestedIn (or larger) of the elements of interest.
// The type of this parameter depends on the item being enumerated.
//
// pcNumberFetchedOut
// Pointer to the number of elements actually supplied in
// rgpIPAddressInfoOut. Caller can pass in NULL if cNumberRequestedIn
// is one.
//
// Return Values:
// S_OK
// The number of elements supplied is cNumberRequestedIn
//
// S_FALSE
// The number of elements supplied is not cNumberRequestedIn.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Next(
[ in ] ULONG cNumberRequestedIn,
[ out, size_is( cNumberRequestedIn ), length_is(*pcNumberFetchedOut) ] IClusCfgIPAddressInfo ** rgpIPAddressInfoOut,
[ out ] ULONG * pcNumberFetchedOut
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Skip(
// [ in ] ULONG cNumberToSkip
// );
//
// Description:
// Skips over the next specified number of elements in the enumeration sequence.
//
// Parameter:
// cNumberToSkip
// The number of elements to be skipped.
//
// Return Value:
// S_OK
// The number of elements skipped is cNumberToSkip.
//
// S_FALSE
// Success, but you've past the last element.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Skip( [ in ] ULONG cNumberToSkipIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Reset( void );
//
// Description:
// Reset the enumeration sequence to the beginning.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Reset( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Clone(
// [ out ] IEnumClusCfgIPAddresses ** ppEnumIPAddressesOut
// );
//
// Description:
// Creates another enumerator that contains the same enumeration state
// as the current one. Using this function, a client can record a
// particular point in the enumeration sequence, and then return to
// that point at a later time. The new enumerator supports the same
// interface as the original one.
//
// Parameter:
// ppEnumIPAddressesOut
// Address of IEnumClusCfgManagedResources * pointer variable that receives
// the interface pointer to the enumeration object. If the method is
// unsuccessful, the value of this output variable is undefined.
//
// Return Values:
// E_INVALIDARG
// ppEnumIPAddressesOut is invalid.
//
// E_OUTOFMEMORY
// Out of memory.
//
// E_UNEXPECTED
// Unknown error (it's in the EnumXXXX docs).
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Clone( [ out ] IEnumClusCfgIPAddresses ** ppEnumIPAddressesOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Count(
// [ out, ref ] DWORD * pnCountOut
// );
//
// Description:
// Returns the size (possibly zero) of the enumerator's collection.
//
// Return Values:
// E_POINTER
// pnCountOut was null.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Count( [ out, ref ] DWORD * pnCountOut );
}; //*** interface IEnumClusCfgIPAddresses
//****************************************************************************
//++
//
// interface IClusCfgIPAddressInfo
//
// Description:
// This interface encapsulates the info about an IP address.
//
//--
//****************************************************************************
[
object,
uuid( AAEAF0A5-E310-4604-A55E-2F9DDC4157A8 ),
async_uuid( AAEAF0A5-E310-4604-A55E-2F9DDC4157A9 ),
pointer_default( unique )
]
interface IClusCfgIPAddressInfo : IUnknown
{
//
// UID
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetUID(
// [ out ] BSTR * pbstrUIDOut
// )
//
// Description:
// Retrieve the "Unique IDentifier" for this IP address. This is not a Universally
// Unique IDentifier (UUID or GUID). This indentifer should match identifiers
// that can be generated on other nodes, but must be unique for the network
// the interface (NIC) is on.
//
// Parameters:
// pbstrUIDOut
// Pointer to the UID string. pbstrUIDOut should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetUID( [ out ] BSTR * pbstrUIDOut );
//
// IP Address
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetIPAddress(
// [ out ] ULONG * pulDottedQuadOut
// )
//
// Description:
// Retrieves an IP Address for the network inteface.
//
// Paramater:
// pulDottedQuadOut
// The IP address of the interface in dotted quad format.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetIPAddress( [ out ] ULONG * pulDottedQuadOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetIPAddress(
// [ in ] ULONG ulDottedQuadIn
// )
//
// Description:
// Stores an IP Address of the network interface to be set when the cluster
// configuration is committed.
//
// Parameter:
// ulDottedQuadIn
// The IP address of the interface to be stored in dotted quad format.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetIPAddress( [ in ] ULONG ulDottedQuadIn );
//
// Subnet Mask
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetSubnetMask(
// [ out ] ULONG * pulDottedQuadOut
// )
//
// Description:
// Retrieves a subnet mask for the network interface.
//
// Parameter:
// ulDottedQuadOut
// The subnet mask of the interface in dotted quad format.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetSubnetMask( [ out ] ULONG * pulDottedQuadOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetSubnetMask(
// [ in ] ULONG ulDottedQuadIn
// )
//
// Description:
// Stores a subnet mask for the network interface to be set when the cluster
// configuration is committed.
//
// Parameter:
// ulDottedQuadIn
// The subnet mask of the interface to be stored in dotted quad format.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetSubnetMask( [ in ] ULONG ulDottedQuadIn );
}; //*** interface IClusCfgIPAddressInfo
//****************************************************************************
//++
//
// interface IClusCfgNetworkInfo
//
// Description:
// This interface enumerates the networks on this computer.
//
//--
//****************************************************************************
[
object,
uuid( 19FC7580-950A-44a6-966E-74B14B20918F ),
async_uuid( ED71FD2D-AD02-4dfc-B376-5FFA5F5A7C2C ),
pointer_default( unique )
]
interface IClusCfgNetworkInfo : IUnknown
{
//
// UID
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetUID(
// [ out ] BSTR * pbstrUIDOut
// )
//
// Description:
// Retrieve the "Unique IDentifier" for this network. This is not a Universally
// Unique IDentifier (UUID or GUID). This indentifer should match identifiers
// that can be generated on other nodes, but must be unique for the network
// the interface (NIC) is on.
//
// Parameters:
// pbstrUIDOut
// Pointer to the UID string. pbstrUIDOut should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetUID( [ out ] BSTR * pbstrUIDOut );
//
// Name
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetName(
// [ out ] BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves a "user friendly" name of the interface.
//
// Parameter:
// pbstrNameOut
// Pointer to network interface name. This should be freed by the caller
// by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Stores a new name of the network interface to be set when the cluster
// configuration is commited.
//
// Parameter:
// pcszNameIn
// The name of the user wants to assigned the interface.
//
// Return Value:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//
// Description
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetDescription(
// [ out ] BSTR * pbstrDescriptionOut
// )
//
// Description:
// Retrieves the description string for a network interface.
//
// Parameter:
// pbstrDescription
// Pointer to the description of the network. This should be freed
// by the caller by calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetDescription( [ out ] BSTR * pbstrDescriptionOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetDescription(
// [ in ] LPCWSTR pcszDescriptionIn
// )
//
// Description:
// Stores a new name of the network interface to be set when the cluster
// configuration is commited.
//
// Parameter:
// pcszDescriptionIn
// The description the user wants to assign to the interface.
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDescription(
[ in, pointer_default( unique ) ] LPCWSTR pcszDescriptionIn
);
//
// Network Address
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetPrimaryNetworkAddress(
// [ out ] IClusCfgIPAddressInfo ** ppIPAddressOut
// )
//
// Description:
// Get the primary network address.
//
// Parameter:
// ppIPAddressOut
// Pointer to the IClusCfgIPAddressInfo interface.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetPrimaryNetworkAddress( [ out ] IClusCfgIPAddressInfo ** ppIPAddressOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetPrimaryNetworkAddress(
// [ in ] IClusCfgIPAddressInfo * pIPAddressIn
// )
//
// Description:
// Set the primary network address.
//
// Parameter:
// pIPAddressIn
// Pointer to the IClusCfgIPAddressInfo interface.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPrimaryNetworkAddress( [ in ] IClusCfgIPAddressInfo * pIPAddressIn );
//
// Public?
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsPublic( void )
//
// Description:
// Call this to determine if the network has been configured to be a
// public network. Note that an interface can be both public and private.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
//
// S_FALSE
// Call succeeded and the result is "FALSE."
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsPublic( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetPublic(
// [ in ] BOOL fIsPublicIn
// )
//
// Description:
// Sets the "public property" of a network interface. The change will not
// take effect until the configuration has been committed.
//
// Parameter:
// fIsPublicIn
// If TRUE, the interface will be marked to be a public interface.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPublic( [ in ] BOOL fIsPublicIn );
//
// Private?
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IsPrivate( void )
//
// Description:
// Call this to determine if the network has been configured to be a
// private network. Note that an interface can be both public and private.
//
// Return Values:
// S_OK
// Call succeeded and the result is "TRUE."
// S_FALSE
// Call succeeded and the result is "FALSE."
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
IsPrivate( void );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetPrivate(
// [ in ] BOOL fIsPrivateIn
// )
//
// Description:
// Sets the "private property" of a network interface. The change will not
// take effect until the configuration has been committed.
//
// Parameter:
// fIsPrivateIn
// Value to set the flag to. If TRUE the interface will be marked as
// a private interface. If FALSE the interface will be marked as NOT
// a private interface.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPrivate( [ in ] BOOL fIsPrivateIn );
}; //*** interface IClusCfgNetworkInfo
//****************************************************************************
//++
//
// interface IClusCfgClusterInfo
//
// Description:
// This interface contains information about the cluster configuration.
//
//--
//****************************************************************************
[
object,
uuid( 85B4BBC0-DDC4-4ae7-8268-F4850BB2A6EE ),
async_uuid( 8BDBA247-04F5-4114-837E-B263412A4B64 ),
pointer_default( unique )
]
interface IClusCfgClusterInfo : IUnknown
{
//
// CommitChanges Mode
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetCommitMode(
// [ in ] ECommitMode ecmNewModeIn
// )
//
// Description:
// Sets the CommitChanges processing to be the new mode that
/// is passed in.
//
// Parameter:
// eccbNewModeIn
// The new mode to set the CommitChanges processing to.
//
// Return Values:
// S_OK
// Call succeed.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetCommitMode( [ in ] ECommitMode ecmNewModeIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetCommitMode(
// [ out ] ECommitMode * pecmCurrentModeOut
// )
//
// Description:
// Call this to determine the operation that will be done when
// CommitChanges is invoked.
//
// Parameter:
// pecmCurrentModeOut
// The current mode for CommitChanges processing.
//
// Return Values:
// S_OK
// Call succeeded.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetCommitMode( [ out ] ECommitMode * pecmCurrentModeOut );
//
// Cluster Name
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetName(
// [ out ] BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves the name of the cluster to be formed or joined.
//
// Notes:
// Name (Fully Qualified Domiain Name) e.g. cluster1.ntdev.microsoft.com
//
// In Forming the cluster, this is the resulting cluster name.
// In Joining the cluster, this is the sponsers cluster name.
//
// Parameter:
// pbstrNameOut
// Pointer to device name. This should be freed by the caller by calling
// SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Stores a new name for the cluster to be set when the cluster
// configuration is commited. If the node is joining, then this will
/// will be the cluster to be joined.
//
// Notes:
// Name (Fully Qualified Domiain Name) e.g. cluster1.ntdev.microsoft.com
//
// In Forming the cluster, this is the resulting cluster name.
// In Joining the cluster, this is the sponsers cluster name.
//
// Parameter:
// pcszNameIn
// The name of the user wants to assigned the device.
//
// Return Value:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//
// Cluster IP Address
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetIPAddress(
// [ out ] ULONG * pulDottedQuadOut
// )
//
// Description:
// Retrieves the IP address of the cluster.
//
// Parameter:
// pulDottedQuadOut
// The IP address of the cluster in dotted quad format.
//
// Return Value:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetIPAddress( [ out ] ULONG * pulDottedQuadOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetIPAddress(
// [ in ] ULONG ulDottedQuadIn
// )
//
// Description:
// Stores the IP address to be used to form the cluster. If joining,
// this is the IP address of the sponsor.
//
// Parameter:
// ulDottedQuadIn
// IP address in dotted quad format.
//
// Return Value:
// S_OK
// The call succeeded.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetIPAddress( [ in ] ULONG ulDottedQuadIn );
//
// Cluster Subnet Mask
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetSubnetMask(
// [ out ] ULONG * pulDottedQuadOut
// )
//
// Description:
// Retrieves the subnet mask to be used for the cluster.
//
// Parameter:
// pulDottedQuadOut
// Subnet mask of the cluster in dotted quad format.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetSubnetMask( [ out ] ULONG * pulDottedQuadOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetSubnetMask(
// [ in ] ULONG ulDottedQuadIn
// )
//
// Description:
// Stores the subnet mask to be used to form the cluster. If joining,
// this is the subnet mask of the sponsor.
//
// Parameter:
// ulDottedQuadIn
// Subnet mask in dotted quad format.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetSubnetMask( [ in ] ULONG ulDottedQuadIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetNetworkInfo(
// [ out ] IClusCfgNetworkInfo ** ppiccniOut
// )
//
// Description:
// Retrieves the network to be used for the cluster IP address
// and name.
//
// Parameter:
// ppiccniOut
// Pointer of the network to use for the cluster IP address
// and name.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetNetworkInfo( [ out ] IClusCfgNetworkInfo ** ppiccniOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetNetworkInfo(
// [ in ] IClusCfgNetworkInfo * piccniIn
// )
//
// Description:
// Stores the network to be used for the cluster IP address and name.
//
// Parameter:
// piccniIn
// Pointer to the network to use for the cluster IP address
// and name.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetNetworkInfo( [ in ] IClusCfgNetworkInfo * piccniIn );
//
// Cluster Service Account
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetClusterServiceAccountCredentials(
// [ out ] IClusCfgCredentials ** ppicccCredentialsOut
// )
//
// Description:
// Retrieves the cluster service account credentials used by the
// cluster for authenication. The password is not available from the
// sponsor node and must be supplied by the user. Once supplied, it can
// be retrieved by calling this method.
//
// Parameters:
// ppicccCredentialsOut
// An IClusCfgCredentials * that contains the cluster
// service account credentials.
//
// Return Values:
// S_OK
// The called succeeded.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetClusterServiceAccountCredentials(
[ out ] IClusCfgCredentials ** ppicccCredentialsOut
);
//
// Cluster Binding String
//
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetBindingString(
// [ out ] BSTR * pbstrBindingStringOut
// )
//
// Description:
// Retrieves the binding string (IP address) of the cluster to be
// formed or joined.
//
// Notes:
//
// Parameter:
// pbstrBindingStringOut
// Pointer to a BSTR. This should be freed by the caller by
// calling SysFreeString( ).
//
// Return Values:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetBindingString( [ out ] BSTR * pbstrBindingStringOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetBindingString(
// [ in ] LPCWSTR pcszBindingStringIn
// )
//
// Description:
// Stores the binding string for the cluster.
//
// Notes:
//
// Parameter:
// pcszBindingStringIn
// The binding string to use when connecting to this cluster.
//
// Return Value:
// S_OK
// Success.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULT
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetBindingString(
[ in, pointer_default( unique ) ] LPCWSTR pcszBindingStringIn
);
}; //*** interface IClusCfgClusterInfo
//****************************************************************************
//++
//
// interface IClusCfgInitialize
//
// Description:
// This interface is used to initialize a configuration object.
//
//--
//****************************************************************************
[
object,
uuid( 2A0EB82D-F878-492a-951E-AE000918C4A6 ),
async_uuid( 2A0EB82E-F878-492a-951E-AE000918C4A6 ),
pointer_default( unique )
]
interface IClusCfgInitialize : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// Initialize(
// [ in ] IUnknown * punkCallbackIn,
// [ in ] LCID lcidIn
// )
//
// Description:
// Register callbacks, locale id, etc.
//
// Parameters:
// punkCallbackIn
// The callback interface.
//
// lcidIn
// The locale ID to be used for strings that are passed.
//
// Return Values:
// S_OK
// The initialization succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Initialize(
[ in ] IUnknown * punkCallbackIn,
[ in ] LCID lcidIn
);
}; //*** interface IClusCfgInitialize
//****************************************************************************
//++
//
// interface IClusCfgCallback
//
// 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( 238DCA63-E2EF-4f32-A24D-ACBF975BE842 ),
async_uuid( EBCE8945-AC69-4b3a-865D-E2D4EB33E41B ),
pointer_default( unique )
]
interface IClusCfgCallback : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SendStatusReport(
// [ in ] LPCWSTR pcszNodeNameIn,
// [ in ] CLSID clsidTaskMajorIn
// [ in ] CLSID clsidTaskMinorIn,
// [ in ] ULONG ulMinIn,
// [ in ] ULONG ulMaxIn,
// [ in ] ULONG ulCurrentIn,
// [ in ] HRESULT hrStatusIn,
// [ in ] LPCWSTR pcszDescriptionIn,
// [ in ] FILETIME * pftTimeIn,
// [ in ] LPCWSTR pcszReferenceIn
// )
//
// Description:
// Send a status report back to the user interface/script.
//
// Parameters:
// pcszNodeNameIn
// The name of the node (server) that sent the report.
//
// clsidTaskMajorIn
// 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.
//
// clsidTaskMinorIn
// CLSID of the minor task to give status about. These should be
// unique to each sub-task and message.
//
// ulMinIn
// The min value of progress.
//
// ulMaxIn
// The max value of progress.
//
// ulCurrentIn
// The current value of progress.
//
// hrStatusIn
// The current status.
//
// pcszDescriptionIn
// The description of the status. Can be NULL to indicate that nothing
// needs to be passed.
//
// pftTimeIn
// UTC time of when this event was generated.
//
// pcszReference
// 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
SendStatusReport(
[ in, pointer_default( unique ) ] LPCWSTR pcszNodeNameIn,
[ in ] CLSID clsidTaskMajorIn,
[ in ] CLSID clsidTaskMinorIn,
[ in ] ULONG ulMinIn,
[ in ] ULONG ulMaxIn,
[ in ] ULONG ulCurrentIn,
[ in ] HRESULT hrStatusIn,
[ in, pointer_default( unique ) ] LPCWSTR pcszDescriptionIn,
[ in ] FILETIME * pftTimeIn,
[ in, pointer_default( unique ) ] LPCWSTR pcszReferenceIn
);
}; //*** interface IClusCfgCallback
//****************************************************************************
//++
//
// interface IClusCfgCredentials
//
// Description:
// The IClusCfgCredentials interface provides the functions
// for getting and setting user credentials.
//
//--
//****************************************************************************
[
object,
uuid( 54AA9406-A409-4b49-B314-5F0A0CE4C88E ),
async_uuid( 54AA9406-A409-4b49-B314-5F0A0CE4C88F ),
pointer_default( unique )
]
interface IClusCfgCredentials : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// SetCredentials(
// [ in ] LPCWSTR pcszUserIn,
// [ in ] LPCWSTR pcszDomainIn,
// [ in ] LPCWSTR pcszPasswordIn
// )
//
// Description:
// Set the credentials.
//
// Parameters:
// pcszUserIn
// The user name.
//
// pcszDomainIn
// The domain name.
//
// pcszPasswordIn
// The user's password.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetCredentials(
[ in, pointer_default( unique ) ] LPCWSTR pcszUserIn
, [ in, pointer_default( unique ) ] LPCWSTR pcszDomainIn
, [ in, pointer_default( unique ) ] LPCWSTR pcszPasswordIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// GetCredentials(
// [ out ] BSTR * pbstrUserOut,
// [ out ] BTSR * pbstrDomainOut,
// [ out ] BTSR * pbstrPasswordOut
// )
//
// Description:
// Get the credentials.
//
// Parameters:
// pbstrUserOut
// Catches the user name.
//
// pbstrDomainOut
// Catches the domain name.
//
// pbstrPasswordOut
// Catches the user's password.
//
// Return Values:
// S_OK
// The call succeeded.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetCredentials(
[ out ] BSTR * pbstrUserOut
, [ out ] BSTR * pbstrDomainOut
, [ out ] BSTR * pbstrPasswordOut
);
}; //*** interface IClusCfgCredentials
//****************************************************************************
//++
//
// interface IClusCfgCapabilities
//
// Description:
// The IClusCfgCapabilities interface provides the functions
// for determining the capabilities of a node.
//
//--
//****************************************************************************
[
object,
uuid( D94AB253-36C7-41c1-B52E-26B451975C8D ),
pointer_default( unique )
]
interface IClusCfgCapabilities : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// CanNodeBeClustered( void )
//
// Description:
// Determines if a node can be clustered.
//
// Parameters:
// None.
//
// Return Values:
// S_OK
// The call succeeded. The node can be clustered.
//
// S_FALSE
// The call succeeded. The node can not be clustered.
//
// E_NOTIMPL
// The call failed. This is treated as a "don't care."
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
CanNodeBeClustered( void );
}; //*** interface IClusCfgCapabilities
//****************************************************************************
//++
//
// interface IClusCfgManagedResourceCfg
//
// Description:
// TODO: gpease 06-JUN-2000
// Write a description.
//
//--
//****************************************************************************
[
object,
uuid( 60300A0F-77E1-440c-BD94-6BFB0DBFDB3A ),
local,
pointer_default( unique )
]
interface IClusCfgManagedResourceCfg : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgManagedResourceCfg::PreCreate(
// IUnknown * punkServicesIn
// )
//
// Description:
// This method is called by the post configuration manager to
// determine the requirements of the resource. Querying the
// punkServicesIn allows the managed resource to use services
// provided by the manager.
//
// Arguments:
// punkServicesIn
// The resource should QI this interface for services provided
// by the post configuration manager and to set its dependencies.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
PreCreate( [ in ] IUnknown * punkServicesIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgManagedResourceCfg::Create(
// IUnknown * punkServicesIn
// )
//
// Description:
// This method is called by the post configuration manager to
// have the resource create an instance of itself. Querying the
// punkServicesIn allows the managed resource to use services
// provided by the manager.
//
// Arguments:
// punkServicesIn
// The resource should QI this interface for services provided
// by the post configuration manager and to create itself.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Create( [ in ] IUnknown * punkServicesIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgManagedResourceCfg::PostCreate(
// IUnknown * punkServicesIn
// )
//
// Description:
// This method is called by the post configuration manager to allow
// resources to perform any post-creation configuration that may be
// needed. At this point the cluster is fully configured. Querying
// the punkServicesIn allows the managed resource to use services
// provided by the manager.
//
// Arguments:
// punkServicesIn
// The resource should QI this interface for services provided
// by the post configuration manager.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
PostCreate( [ in ] IUnknown * punkServicesIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgManagedResourceCfg::Evict(
// IUnknown * punkServicesIn
// )
//
// Description:
// This method is called by the post configuration manager to alert
// the resource that this node was evicted from the cluster. The
// resource should do whatever cleanup it needs to do revert to a
// non-clustered state. Querying the punkServicesIn allows the
// managed resource to uses services provided by the post
// configuration manager.
//
// Arguments:
// punkServicesIn
// The resource should QI this interface for services provided
// by the post configuration manager.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed. Errors are ignored and do not prevent a node
// from being evicted.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Evict( [ in ] IUnknown * punkServicesIn );
}; //*** interface IClusCfgManagedResourceCfg
//****************************************************************************
//++
//
// interface IClusCfgResourcePreCreate
//
// Description:
// TODO: gpease 06-JUN-2000
// Write a description.
//
//--
//****************************************************************************
[
object,
uuid( 4240F6A1-9D49-427e-8F3D-09384E1F59E4 ),
local,
pointer_default( unique )
]
interface IClusCfgResourcePreCreate : IUnknown
{
typedef
[
uuid( 1DAF9692-6662-43b1-AD45-D50F7849B0CD ),
helpstring("Resource dependency flags")
]
enum EDependencyFlags {
[helpstring("Unknown access")] dfUNKNOWN = 0,
[helpstring("Shared access resource")] dfSHARED = 1,
[helpstring("Exclusive access resource")] dfEXCLUSIVE = 2,
} EDependencyFlags;
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourcePreCreate::SetDependency(
// LPCLSID pclsidDepResTypeIn,
// EDependencyFlags dflagIn
// )
//
// Description:
// Informs the post configuration manager that a resource has a
// dependency on another type of resource and if the resource needs
// the resource for shared access or exclusive access.
//
// Arguments:
// pclsidDepResTypeIn
// The CLSID of the type of resource that a resource is
// requesting a dependency on. These are documented in the SDK
// or by the 3rd party resource.
//
// dfIn
// Flags to modify the dependency relationship. The following
// are defined flags:
//
// dfSHARED - the dependent resource can be shared.
// dfEXCLUSIVE - the dependent resource can not be shared.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetDependency(
[ in ] LPCLSID pclsidDepResTypeIn
, [ in ] DWORD dfIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourcePreCreate::GetType(
// CLSID * pclsidIn
// )
//
// Description:
// A managed resource MUST call this to indicate its resource type.
// Failure to call this during PreCreate will result in your
// resource not being created.
//
// Arguments:
// pclsidIn
// Pointer to the GUID of the resource type.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetType( [ in ] CLSID * pclsidIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourcePreCreate::SetClassType(
// CLSID * pclsidIn
// )
//
// Description:
// A managed resource sets this to indicate that its resource type
// can be considered to be of a class of resource. You may call this
// multiple times to indicate all the classes you belong to.
//
// Arguments:
// pclsidIn
// Pointer to the GUID of the resource class type.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetClassType( [ in ] CLSID * pclsidIn );
}; //*** interface IClusCfgResourcePreCreate
//****************************************************************************
//++
//
// interface IClusCfgResourceCreate
//
// Description:
// TODO: gpease 06-JUN-2000
// Write a description.
//
//--
//****************************************************************************
[
object,
uuid( 0647B41A-C777-443c-9432-02CCCF4FF443 ),
local,
pointer_default( unique )
]
interface IClusCfgResourceCreate : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyBinary(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const DWORD cbSizeIn
// , [ in ] const BYTE * pbyteIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyBinary(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const DWORD cbSizeIn
, [ in ] const BYTE * pbyteIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyDWORD(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const DWORD dwDWORDIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyDWORD(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const DWORD dwDWORDIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyString(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] LPCWSTR pcszStringIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyString(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in, pointer_default( unique ) ] LPCWSTR pcszStringIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyExpandString(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] LPCWSTR pcszStringIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyExpandString(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in, pointer_default( unique ) ] LPCWSTR pcszStringIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyMultiString(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const DWORD cbMultiStringIn
// , [ in ] LPCWSTR pcszMultiStringIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyMultiString(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const DWORD cbMultiStringIn
, [ in, pointer_default( unique ) ] LPCWSTR pcszMultiStringIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyUnsignedLargeInt(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const ULARGE_INTEGER ulIntIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyUnsignedLargeInt(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const ULARGE_INTEGER ulIntIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyLong(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const LONG lLongIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyLong(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const LONG lLongIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertySecurityDescriptor(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const SECURITY_DESCRIPTOR * pcsdIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertySecurityDescriptor(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const SECURITY_DESCRIPTOR * pcsdIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SetPropertyLargeInt(
// [ in ] LPCWSTR pcszNameIn
// , [ in ] const LARGE_INTEGER lIntIn
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetPropertyLargeInt(
[ in, pointer_default( unique ) ] LPCWSTR pcszNameIn
, [ in ] const LARGE_INTEGER lIntIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SendResourceControl(
// [ in ] DWORD dwControlCode
// , [ in ] LPVOID lpInBuffer
// , [ in ] DWORD cbInBufferSize
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SendResourceControl(
[ in ] DWORD dwControlCodeIn
, [ in ] LPVOID lpBufferIn
, [ in ] DWORD cbBufferSizeIn
);
}; //*** interface IClusCfgResourceCreate
//****************************************************************************
//++
//
// interface IClusCfgResourcePostCreate
//
// Description:
// TODO: gpease 06-JUN-2000
// Write a description.
//
//--
//****************************************************************************
[
object,
uuid( 72A9BF54-13B6-451f-910D-6913EBF025AB ),
local,
pointer_default( unique )
]
interface IClusCfgResourcePostCreate : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourcePostCreate::ChangeName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Changes the name of the resource.
//
// Arguments:
// pcszNameIn
// The name to assign the group.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
ChangeName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceCreate::SendResourceControl(
// [ in ] DWORD dwControlCode
// , [ in ] LPVOID lpInBuffer
// , [ in ] DWORD cbInBufferSize
// , [ in ] LPVOID lpOutBuffer
// , [ in ] DWORD cbOutBufferSize
// , [ out ] LPDWORD lpcbBytesReturned
// )
//
// Description:
//
// Arguments:
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SendResourceControl(
[ in ] DWORD dwControlCodeIn
, [ in ] LPVOID lpBufferIn
, [ in ] DWORD cbBufferSizeIn
, [ in ] LPVOID lBufferInout
, [ in ] DWORD cbOutBufferSizeIn
, [ out ] LPDWORD lpcbBytesReturnedOut
);
}; //*** interface IClusCfgResourcePostCreate
//****************************************************************************
//++
//
// interface IClusCfgGroupCfg
//
// Description:
// TODO: gpease 06-JUN-2000
// Write a description.
//
//--
//****************************************************************************
[
object,
uuid( DCB6D3D2-A55F-49e5-A64A-0CCFEB01ED3A ),
local,
pointer_default( unique )
]
interface IClusCfgGroupCfg : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgGroupCfg::SetName(
// [ in ] LPCWSTR pcszNameIn
// )
//
// Description:
// Changes the name of the group in which the resource was created.
// Note that the last resource to set the name wins. The ordering
// of the last resource is the resource that doesn't have anything
// depending on it.
//
// Arguments:
// pcszNameIn
// The name to assign the group.
//
// Return Value:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SetName( [ in, pointer_default( unique ) ] LPCWSTR pcszNameIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgGroupCfg::GetName(
// BSTR * pbstrNameOut
// )
//
// Description:
// Retrieves the name of the group in which the resource was created.
// Note that the last resource to set the name wins. The ordering
// of the last resource is the resource that doesn't have anything
// depending on it. Do not cache this value as the name may change
// after control has been returned to the manager.
//
// Arguments:
// pbstrNameOut
// The name to assign the group.
//
// Return Value:
// S_OK
// Success.
//
// HRESULT_FROM_WIN32( ERROR_MORE_DATA )
// The buffer size specified is too small.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetName( [ out ] BSTR * pbstrNameOut );
}; //*** interface IClusCfgGroupCfg
//****************************************************************************
//++
//
// interface IClusCfgMemberSetChangeListener
//
// Description:
// This interface is implemented by an component that wishes to be notified
// of when the local computer becomes part of a cluster or when it leaves
// a cluster - in other words, when the member set of a cluster changes
// as a result of a cluster configuration operation on the local computer.
//
//--
//****************************************************************************
[
object,
uuid( 2B64534F-2643-4ABC-A4E5-824D881B7582 ),
async_uuid( 2B645350-2643-4ABC-A4E5-824D881B7582 ),
pointer_default( unique )
]
interface IClusCfgMemberSetChangeListener : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgMemberSetChangeListener::Notify(
// [ in ] IUnknown * punkClusterInfoIn
// )
//
// Description:
// This method is called to notify a component that this computer has
// either joined or left a cluster. During this call, a component typically
// performs operations that are required to switch it from the "clustered"
// to "non-clustered" mode or vice versa. For example, an application
// that implements this interface could use this function to create
// its resource type when the local computer joins a cluster.
//
// If the node has just become part of a cluster, the cluster
// service is guaranteed to be running when this method is called.
// Querying the punkClusterInfoIn allows the listener to get more
// information about the event that caused the listener to be notified.
//
// Arguments:
// punkClusterInfoIn
// The resource should QI this interface for services provided
// by the caller of this function. Typically, the component that
// this punk refers to also implements the IClusCfgClusterInfo
// interface.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Notify( [ in ] IUnknown * punkClusterInfoIn );
}; //*** interface IClusCfgMemberSetChangeListener
//****************************************************************************
//++
//
// interface IClusCfgResourceTypeInfo
//
// Description:
// This interface is implemented by components that wish to configure
// ( create, delete, etc. ) resource types during cluster configuration
// ( cluster formation, node addition, node eviction, etc. ).
//
//--
//****************************************************************************
[
object,
uuid( C649A281-C847-4F5C-9841-D2F73B5AA71D ),
async_uuid( C649A282-C847-4F5C-9841-D2F73B5AA71D ),
pointer_default( unique )
]
interface IClusCfgResourceTypeInfo : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceTypeInfo::CommitChanges(
// [ in ] IUnknown * punkClusterInfoIn
// )
//
// Description:
// A component that wishes to participate in the configuration of
// cluster resource types should perform the configuration steps
// necessary for its resource type in this method.
//
// This method is called by the cluster configuration server when
// the local computer becomes part of a cluster. The cluster service
// is guaranteed to be running at this stage. This method is also
// called when the local computer is evicted from a cluster - the
// cluster service will not be running if this is the case.
//
// Typically, a component will create a resource type in this method
// during cluster formation and join and will perform any cleanup
// required during node evict.
//
// Arguments:
// punkClusterInfoIn
// The resource type should QI this interface for services provided
// by the caller of this function. Typically, the component that
// this punk refers to also implements the IClusCfgClusterInfo
// interface.
//
// punkResTypeServicesIn
// Pointer to the IUnknown interface of a component that provides
// methods that help configuring a resource type. For example,
// during a join or a form, this punk can be queried for the
// IClusCfgResourceTypeCreate interface, which provides methods
// for resource type creation.
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
CommitChanges(
[ in ] IUnknown * punkClusterInfoIn,
[ in ] IUnknown * punkResTypeServicesIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceTypeInfo::GetTypeName(
// [ out ] BSTR * pbstrTypeNameOut
// )
//
// Description:
// Get the resource type name of this resource type.
//
// Arguments:
// pbstrTypeNameOut
// Pointer to the BSTR that holds the name of the resource type.
// This BSTR has to be freed by the caller using the function
// SysFreeString().
//
// Return Values:
// S_OK
// The call succeeded.
//
// E_OUTOFMEMORY
// Out of memory.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetTypeName( [ out ] BSTR * pbstrTypeNameOut );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceTypeInfo::GetTypeGUID(
// [ out ] GUID * pguidGUIDOut
// )
//
// Description:
// Get the globally unique identifier of this resource type.
//
// Arguments:
// pguidGUIDOut
// Pointer to the GUID object which will receive the GUID of this
// resource type.
//
// Return Values:
// S_OK
// The call succeeded and the *pguidGUIDOut contains the type GUID.
//
// S_FALSE
// The call succeeded but this resource type does not have a GUID.
// The value of *pguidGUIDOut is undefined after this call.
//
// other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
GetTypeGUID( [ out ] GUID * pguidGUIDOut );
}; //*** interface IClusCfgResourceTypeInfo
//****************************************************************************
//++
//
// interface IClusCfgResourceTypeCreate
//
// Description:
// This interface provides functions that help create a resource type
// during cluster configuration. A pointer to this interface is provided
// to components that participate in resource type configuration during
// cluster configuration.
//
//--
//****************************************************************************
[
object,
uuid( 3AFCE3B8-5F3E-4DDF-A8F4-4B4FCBF28F8F ),
async_uuid( 3AFCE3B9-5F3E-4DDF-A8F4-4B4FCBF28F8F ),
pointer_default( unique )
]
interface IClusCfgResourceTypeCreate : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceTypeCreate::Create(
// [in, string ] const WCHAR * pcszResTypeNameIn,
// [in, string ] const WCHAR * pcszResTypeDisplayNameIn,
// [in, string ] const WCHAR * pcszResDllNameIn,
// [in] DWORD dwLooksAliveIntervalIn,
// [in] DWORD dwIsAliveIntervalIn
// )
//
// Description:
// This method creates a cluster resource type.
//
// Arguments:
// pcszResTypeNameIn
// Name of the resource type
//
// pcszResTypeDisplayNameIn
// Display name of the resource type
//
// pcszResDllNameIn
// Name (with or without path information) of DLL of the resource type.
//
// dwLooksAliveIntervalIn
// Looks-alive interval for the resource type (in milliseconds).
//
// dwIsAliveIntervalIn
// Is-alive interval for the resource type (in milliseconds).
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Create(
[in, string ] const WCHAR * pcszResTypeNameIn,
[in, string ] const WCHAR * pcszResTypeDisplayNameIn,
[in, string ] const WCHAR * pcszResDllNameIn,
[in] DWORD dwLooksAliveIntervalIn,
[in] DWORD dwIsAliveIntervalIn
);
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgResourceTypeCreate::RegisterAdminExtensions(
// [in, string ] const WCHAR * pcszResDllNameIn,
// [in] ULONG cExtClsidCountIn,
// [in, size_is( cExtClsidCountIn ) ] const CLSID * rgclsidExtClsidsIn
// )
//
// Description:
// This method registers the cluster administrator extensions for
// a resource type.
//
// Arguments:
// pcszResTypeNameIn
// Name of the resource type against for the extensions are to be
// registered.
//
// cExtClsidCountIn
// Number of extension class ids in the next parameter.
//
// rgclsidExtClsidsIn
// Pointer to an array of class ids of cluster administrator extensions.
// This can be NULL if cExtClsidCountIn is 0.
//
//
// Return Values:
// S_OK
// Success.
//
// other HRESULTs.
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
RegisterAdminExtensions(
[in, string ] const WCHAR * pcszResTypeNameIn,
[in] ULONG cExtClsidCountIn,
[in, size_is( cExtClsidCountIn ) ] const CLSID * rgclsidExtClsidsIn
);
}; //*** interface IClusCfgResourceTypeCreate
//****************************************************************************
//++
//
// interface IClusCfgEvictCleanup
//
// Description:
// This interface can be used to cleanup a node that has been evicted from
// a cluster.
//
//--
//****************************************************************************
[
object,
uuid( 6FE3E361-D373-4C5F-A0AF-1DFE8493C655 ),
async_uuid( 6FE3E362-D373-4C5F-A0AF-1DFE8493C655 ),
pointer_default( unique )
]
interface
IClusCfgEvictCleanup : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgEvictCleanup::CleanupLocal( [ in ] DWORD dwDelayIn )
//
// Description:
// This method performs the clean up actions on the local node after
// it has been evicted from a cluster, so that the node can go back
// to its "pre-clustered" state.
//
// Arguments:
// DWORD dwDelayIn
// Number of milliseconds that this method will wait before starting
// cleanup. If some other process cleans up this node while this thread
// is waiting, the wait is terminated. If this value is zero, this method
// will attempt to clean up this node immediately.
//
// Return Values:
// S_OK
// Success.
//
// Other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
CleanupLocalNode( [ in ] DWORD dwDelayIn );
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgEvictCleanup::CleanupRemoteNode(
// const WCHAR * pcszEvicteeNodeNameIn
// , DWORD dwDelayIn
// )
//
// Description:
// This method performs the clean up actions on a remote node after
// it has been evicted from a cluster, so that the node can go back
// to its "pre-clustered" state.
//
// Arguments:
// const WCHAR * pcszEvictedNodeNameIn
// Name of the node that has just been evicted. This can be the
// NetBios name of the node, the fully qualified domain name or
// the node IP address.
//
// DWORD dwDelayIn
// Number of milliseconds that this method will wait before starting
// cleanup. If some other process cleans up this node while this thread
// is waiting, the wait is terminated. If this value is zero, this method
// will attempt to clean up this node immediately.
//
// Return Values:
// S_OK
// Success.
//
// Other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
CleanupRemoteNode(
[ in, string ] const WCHAR * pcszEvictedNodeNameIn
, [ in ] DWORD dwDelayIn
);
}; // interface IClusCfgEvictCleanup
//****************************************************************************
//++
//
// interface IClusCfgStartupListener
//
// Description:
// This interface is implemented by a component that wishes to be notified
// when the cluster service has started.
//
//--
//****************************************************************************
[
object,
uuid( D282CAEF-2EDE-4ab9-A5D5-F7BDE3D23F0F ),
async_uuid( D282CAF0-2EDE-4ab9-A5D5-F7BDE3D23F10 ),
pointer_default( unique )
]
interface
IClusCfgStartupListener : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgStartupListener::Notify( [ in ] IUnknown * punkIn )
//
// Description:
// This method is called to inform a component that the cluster service
// has started on the local node.
//
// Arguments:
// IUnknown * punkIn
// The component that implements this Punk may also provide services
// that are useful to the implementor of this method. For example,
// this component usually implements the IClusCfgResourceTypeCreate
// interface.
//
// Return Values:
// S_OK
// Success.
//
// Other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
Notify( [ in ] IUnknown * punkIn );
}; // interface IClusCfgStartupListener
//****************************************************************************
//++
//
// interface IClusCfgStartupNotify
//
// Description:
// This interface is implemented by a component that the cluster service
// instantiates. When the cluster service calls the only method on this
// interface, this component will enumerate the startup listeners and
// inform them that the cluster service has started on the local node.
//
//--
//****************************************************************************
[
object,
uuid( C2B0D069-6353-4EE1-B253-6B0D75DB2CD3 ),
async_uuid( C2B0D06A-6353-4EE1-B253-6B0D75DB2CD3 ),
pointer_default( unique )
]
interface
IClusCfgStartupNotify : IUnknown
{
//////////////////////////////////////////////////////////////////////////
//
// STDMETHOD
// IClusCfgStartupNotify::SendNotifications( [ in ] IUnknown * punkIn )
//
// Description:
// This method is called by the Cluster Service to inform the implementor
// of this interface to send out notification of cluster service startup
// to interested listeners. If this method is being called for the first
// time, the method waits till the post configuration steps are complete
// before sending out the notifications.
//
// Arguments:
// None.
//
// Return Values:
// S_OK
// Success.
//
// Other HRESULTs
// The call failed.
//
//////////////////////////////////////////////////////////////////////////
HRESULT
SendNotifications( void );
}; // interface IClusCfgStartupNotify
Reference in a new issue Copy permalink