/////////////////////////////////////////////////////////////////////////////
//
//	Copyright (c) 1996-1999 Microsoft Corporation
//
//	Module Name:
//		ClusObj.h
//
//	Implementation File:
//		ClusObj.h (this file) and ClusObj.cpp
//
//	Description:
//		Definition of the CClusterObject classes.
//
//	Author:
//		David Potter (davidp)	April 7, 1998
//
//	Revision History:
//
//	Notes:
//
/////////////////////////////////////////////////////////////////////////////

#ifndef __CLUSOBJ_H_
#define __CLUSOBJ_H_

/////////////////////////////////////////////////////////////////////////////
// Forward Class Declarations
/////////////////////////////////////////////////////////////////////////////

class CClusterObject;
class CClusterInfo;
class CClusNodeInfo;
class CClusGroupInfo;
class CClusResInfo;
class CClusResTypeInfo;
class CClusNetworkInfo;
class CClusNetIFInfo;

/////////////////////////////////////////////////////////////////////////////
// External Class Declarations
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
// Include Files
/////////////////////////////////////////////////////////////////////////////

#ifndef _LIST_
#include <list>			// for std::list
#endif

#ifndef _CLUSTER_API_
#include <ClusApi.h>	// for cluster types
#endif

#ifndef __cluadmex_h__
#include "CluAdmEx.h"	// for CLUADMEX_OBJECT_TYPE
#endif

#ifndef _CLUSUDEF_H_
#include "ClusUDef.h"	// for default values
#endif

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

typedef std::list< CClusterObject * >	CClusObjPtrList;
typedef std::list< CClusterInfo * >		CClusterPtrList;
typedef std::list< CClusNodeInfo * >	CClusNodePtrList;
typedef std::list< CClusGroupInfo * >	CClusGroupPtrList;
typedef std::list< CClusResInfo * >		CClusResPtrList;
typedef std::list< CClusResTypeInfo * >	CClusResTypePtrList;
typedef std::list< CClusNetworkInfo * >	CClusNetworkPtrList;
typedef std::list< CClusNetIFInfo * >	CClusNetIFPtrList;

union CLUSTER_REQUIRED_DEPENDENCY
{
	CLUSTER_RESOURCE_CLASS	rc;
	LPWSTR					pszTypeName;
};

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusterObject
//
//	Description:
//		Base class for all cluster object classes.  Provides base
//		functionality.
//
//	Inheritance:
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusterObject( IN CLUADMEX_OBJECT_TYPE cot )
	{
		ATLASSERT( cot > CLUADMEX_OT_NONE );

		m_nReferenceCount = 0;
		Reset( NULL, NULL, cot );

	} //*** CClusterObject()

	// Constructor taking group name
	CClusterObject(
		IN CLUADMEX_OBJECT_TYPE	cot,
		IN CClusterInfo *		pci,
		IN LPCTSTR				pszName
		)
	{
		ATLASSERT( cot > CLUADMEX_OT_NONE );

		m_nReferenceCount = 0;
		Reset( pci, pszName, cot );

	} //*** CClusterObject(pszName)

	virtual ~CClusterObject( void )
	{
	} //*** ~CClusterObject()

	// Copy another object into this one.
	void Copy( IN const CClusterObject & rco )
	{
		m_pci = rco.m_pci;
		m_bQueried = rco.m_bQueried;
		m_bCreated = rco.m_bCreated;
		m_cot = rco.m_cot;
		m_strName = rco.m_strName;
		m_strDescription = rco.m_strDescription;

	} //*** Copy()

	// Reset the data back to default values
	void Reset(
		IN CClusterInfo *		pci,
		IN LPCTSTR				pszName = NULL,
		IN CLUADMEX_OBJECT_TYPE	cot = CLUADMEX_OT_NONE
		)
	{
		m_pci = pci;

		m_bQueried = FALSE;
		m_bCreated = FALSE;

		if ( cot != CLUADMEX_OT_NONE )
		{
			m_cot = cot;
		} // if:  valid object type specified

		if ( pszName == NULL )
		{
			m_strName.Empty();
		} // if:  no name specified
		else
		{
			m_strName = pszName;
		} // else:  name specified

		m_strDescription.Empty();

	} //*** Reset()

protected:
	//
	// Reference counting properties.
	//

	ULONG		m_nReferenceCount;

public:
	//
	// Reference counting methods.
	//

	// Get the current count of references
	ULONG NReferenceCount( void ) const { return m_nReferenceCount; }

	// Add a reference to this object
	ULONG AddRef( void )
	{
		ATLASSERT( m_nReferenceCount != (ULONG) -1 );
		return ++m_nReferenceCount;

	} //*** AddRef()

	// Release a reference to this object
	ULONG Release( void )
	{
		ULONG nReferenceCount;

		ATLASSERT( m_nReferenceCount != 0 );

		nReferenceCount = --m_nReferenceCount;
		if ( m_nReferenceCount == 0 )
		{
			delete this;
		} // if:  no more references

		return nReferenceCount;

	} //*** Release()

protected:
	//
	// Properties of a cluster object.
	//

	CClusterInfo *	m_pci;

	BOOL			m_bQueried;
	BOOL			m_bCreated;

	CLUADMEX_OBJECT_TYPE
					m_cot;

	CString			m_strName;
	CString			m_strDescription;

	// Set query state
	BOOL BSetQueried( BOOL bQueried = TRUE )
	{
		BOOL bPreviousValue = m_bQueried;
		m_bQueried = bQueried;
		return bPreviousValue;

	} //*** BSetQueried()

	// Set created state
	BOOL BSetCreated( BOOL bCreated = TRUE )
	{
		BOOL bPreviousValue = m_bCreated;
		m_bCreated = bCreated;
		return bPreviousValue;

	} //*** BSetCreated()

public:
	//
	// Accessor functions for cluster object properties.
	//

	CClusterInfo *	Pci( void ) const				{ ATLASSERT( m_pci != NULL ); return m_pci; }

	BOOL BQueried( void ) const						{ return m_bQueried; }
	BOOL BCreated( void ) const						{ return m_bCreated; }

	CLUADMEX_OBJECT_TYPE Cot( void ) const			{ return m_cot; }

	const CString & RstrName( void ) const			{ return m_strName; }
	const CString & RstrDescription( void ) const	{ return m_strDescription; }

	// Set the cluster info pointer
	void SetClusterInfo( IN CClusterInfo * pci )
	{
		ATLASSERT( pci != NULL );
		ATLASSERT( m_pci == NULL );
		m_pci = pci;

	} //*** SetClusterInfo()

	// Set the name of the cluster object.
	void SetName( IN LPCTSTR pszName )
	{
		ATLASSERT( pszName != NULL );
		m_strName = pszName;

	} //*** SetName()

	// Set the description of the cluster object
	void SetDescription( IN LPCTSTR pszDescription )
	{
		ATLASSERT( pszDescription != NULL );
		m_strDescription = pszDescription;

	} //*** SetDescription()

	// Return the list of extensions for this object
	virtual const std::list< CString > * PlstrAdminExtensions( void ) const { return NULL; }

}; //*** class CClusterObject

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusterInfo
//
//	Description:
//		Class for the information about the cluster object itself.  Treats
//		the cluster as an object like other objects.
//
//	Inheritance:
//		CClusterInfo
//		CClusterObject
//
//	Notes:
//		1)  m_hCluster is not owned by this class.
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusterInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusterInfo( void )
		: CClusterObject( CLUADMEX_OT_CLUSTER )
	{
		Reset();

	} //*** CClusterInfo()

	// Constructor taking cluster name
	CClusterInfo( IN LPCTSTR pszName )
		: CClusterObject( CLUADMEX_OT_CLUSTER, NULL, pszName )
	{
		Reset( pszName );

	} //*** CClusterInfo( pszName )

	// Copy another object into this one.
	void Copy( IN const CClusterInfo & rci )
	{
		CClusterObject::Copy( rci );
		m_hCluster = rci.m_hCluster;

	} //*** Copy()

	// Reset the data back to default values
	void Reset( IN LPCTSTR pszName = NULL )
	{
		CClusterObject::Reset( NULL, pszName, CLUADMEX_OT_CLUSTER );
		m_hCluster = NULL;

	} //*** Reset()

protected:
	//
	// Properties of a cluster.
	//

	HCLUSTER m_hCluster;
	std::list< CString >	m_lstrClusterAdminExtensions;
	std::list< CString >	m_lstrNodesAdminExtensions;
	std::list< CString >	m_lstrGroupsAdminExtensions;
	std::list< CString >	m_lstrResourcesAdminExtensions;
	std::list< CString >	m_lstrResTypesAdminExtensions;
	std::list< CString >	m_lstrNetworksAdminExtensions;
	std::list< CString >	m_lstrNetInterfacesAdminExtensions;

public:
	//
	// Accessor functions for cluster properties.
	//

	HCLUSTER Hcluster( void )
	{
		ATLASSERT( m_hCluster != NULL );
		return m_hCluster;

	} //*** Hcluster()

	// Set the cluster handle managed by this object
	void SetClusterHandle( IN HCLUSTER hCluster )
	{
		ATLASSERT( hCluster != NULL );
		m_hCluster = hCluster;

	} //*** SetClusterHandle()

	const std::list< CString > * PlstrAdminExtensions( void ) const					{ return &m_lstrClusterAdminExtensions; }
	const std::list< CString > * PlstrNodesAdminExtensions( void ) const			{ return &m_lstrNodesAdminExtensions; }
	const std::list< CString > * PlstrGroupsAdminExtensions( void ) const			{ return &m_lstrGroupsAdminExtensions; }
	const std::list< CString > * PlstrResourcesAdminExtensions( void ) const		{ return &m_lstrResourcesAdminExtensions; }
	const std::list< CString > * PlstrResTypesAdminExtensions( void ) const			{ return &m_lstrResTypesAdminExtensions; }
	const std::list< CString > * PlstrNetworksAdminExtensions( void ) const			{ return &m_lstrNetworksAdminExtensions; }
	const std::list< CString > * PlstrNetInterfacesAdminExtensions( void ) const	{ return &m_lstrNetInterfacesAdminExtensions; }

}; //*** class CClusterInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusNodeInfo
//
//	Description:
//		Cluster node object.
//
//	Inheritance:
//		CClusNodeInfo
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusNodeInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusNodeInfo( void )
		: CClusterObject( CLUADMEX_OT_NODE )
		, m_hNode( NULL )
	{
		Reset( NULL );

	} //*** CClusNodeInfo()

	// Constructor taking cluster info pointer
	CClusNodeInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_NODE, pci, pszName )
		, m_hNode( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusNodeInfo( pci )

	~CClusNodeInfo( void )
	{
		Close();

	} //*** ~CClusNodeInfo()

	// Operator = is not allowed
	CClusNodeInfo & operator=( IN const CClusNodeInfo & rni )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_NODE );

	} //*** Reset()

protected:
	//
	// Properties of a node.
	//

	HNODE m_hNode;

public:
	//
	// Accessor functions for node properties.
	//

	HNODE Hnode( void ) { return m_hNode; }

	// Return the list of extensions for nodes
	const std::list< CString > * PlstrAdminExtensions( void ) const
	{
		ATLASSERT( Pci() != NULL );
		return Pci()->PlstrNodesAdminExtensions();

	} //*** PlstrAdminExtensions()

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hNode == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Open a handle to the object.
		//
		m_hNode = OpenClusterNode( m_pci->Hcluster(), m_strName );
		if ( m_hNode == NULL )
		{
			sc = GetLastError();
		} // if:  error opening the object

		return sc;

	} //*** ScOpen()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusNodeInfo & rni )
	{
		ATLASSERT( rni.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rni );

		//
		// Initialize the object.
		//
		if ( rni.m_hNode != NULL )
		{
			sc = ScOpen();
		} // if:  source object had the object opened

		return sc;

	} //*** ScCopy()

	// Close the object
	void Close( void )
	{
		if ( m_hNode != NULL )
		{
			CloseClusterNode( m_hNode );
		} // if:  node is open
		m_hNode = NULL;
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close()

}; //*** class CClusNodeInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusGroupInfo
//
//	Description:
//		Cluster group object.
//
//	Inheritance:
//		CClusGroupInfo
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusGroupInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusGroupInfo( void )
		: CClusterObject( CLUADMEX_OT_GROUP )
		, m_hGroup( NULL )
	{
		Reset( NULL );

	} //*** CClusGroupInfo()

	// Constructor taking cluster info pointer
	CClusGroupInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_GROUP, pci, pszName )
		, m_hGroup( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusGroupInfo( pci )

	// Destructor
	~CClusGroupInfo( void )
	{
		Close();

	} //*** ~CClusGroupInfo()

	// Operator = is not allowed
	CClusGroupInfo & operator=( IN const CClusGroupInfo & rgi )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_GROUP );

		m_bCollectedOwners = FALSE;
		m_bCollectedResources = FALSE;

		m_lpniPreferredOwners.erase( m_lpniPreferredOwners.begin(), m_lpniPreferredOwners.end() );
		m_lpriResources.erase( m_lpriResources.begin(), m_lpriResources.end() );

		m_bHasIPAddress = FALSE;
		m_bHasNetName = FALSE;

		m_nPersistentState = 0;
		m_nFailoverThreshold = CLUSTER_GROUP_DEFAULT_FAILOVER_THRESHOLD;
		m_nFailoverPeriod = CLUSTER_GROUP_DEFAULT_FAILOVER_PERIOD;
		m_cgaftAutoFailbackType = CLUSTER_GROUP_DEFAULT_AUTO_FAILBACK_TYPE;
		m_nFailbackWindowStart = CLUSTER_GROUP_DEFAULT_FAILBACK_WINDOW_START;
		m_nFailbackWindowEnd = CLUSTER_GROUP_DEFAULT_FAILBACK_WINDOW_END;

	} //*** Reset()

protected:
	//
	// Properties of a group.
	//

	HGROUP				m_hGroup;

	BOOL				m_bHasIPAddress;
	BOOL				m_bHasNetName;

	DWORD				m_nPersistentState;
	DWORD				m_nFailoverThreshold;
	DWORD				m_nFailoverPeriod;
	CGAFT				m_cgaftAutoFailbackType;
	DWORD				m_nFailbackWindowStart;
	DWORD				m_nFailbackWindowEnd;

	CString				m_strNetworkName;
	CString				m_strIPAddress;
	CString				m_strNetwork;

	BOOL				m_bCollectedOwners;
	BOOL				m_bCollectedResources;
	CClusNodePtrList	m_lpniPreferredOwners;
	CClusResPtrList		m_lpriResources;

	// Set virtual server properties
	void SetVirtualServerProperties(
		IN LPCWSTR pszNetworkName,
		IN LPCWSTR pszIPAddress,
		IN LPCWSTR pszNetwork
		)
	{
		if ( pszNetworkName != NULL )
		{
			m_strNetworkName = pszNetworkName;
		} // if:  network name specified

		if ( pszIPAddress != NULL )
		{
			m_strIPAddress = pszIPAddress;
		} // if:  IP address specified

		if ( pszNetwork != NULL )
		{
			m_strNetwork = pszNetwork;
		} // if:  network specified

	} //*** SetVirtualServerProperties()

public:
	//
	// Accessor functions for group properties.
	//

	HGROUP Hgroup( void ) const					{ return m_hGroup; }

	BOOL BHasIPAddress( void ) const			{ return m_bHasIPAddress; }
	BOOL BHasNetName( void ) const				{ return m_bHasNetName; }

	DWORD NPersistentState( void ) const		{ return m_nPersistentState; }
	DWORD NFailoverThreshold( void ) const		{ return m_nFailoverThreshold; }
	DWORD NFailoverPeriod( void ) const			{ return m_nFailoverPeriod; }
	CGAFT CgaftAutoFailbackType( void ) const	{ return m_cgaftAutoFailbackType; }
	DWORD NFailbackWindowStart( void ) const	{ return m_nFailbackWindowStart; }
	DWORD NFailbackWindowEnd( void ) const		{ return m_nFailbackWindowEnd; }

	const CString & RstrNetworkName( void ) const	{ return m_strNetworkName; }
	const CString & RstrIPAddress( void ) const		{ return m_strIPAddress; }
	const CString & RstrNetwork( void ) const		{ return m_strNetwork; }

	BOOL BCollectedOwners( void ) const				{ return m_bCollectedOwners; }
	CClusNodePtrList * PlpniPreferredOwners( void )	{ return &m_lpniPreferredOwners; }
	CClusResPtrList * PlpriResources( void )		{ return &m_lpriResources; }

	// Returns whether the group is a virtual server or not
	BOOL BIsVirtualServer( void ) const
	{
		return m_bQueried && m_bHasIPAddress & m_bHasNetName;

	} //*** BIsVirtualServer()

	// Set failover properties for the group
	BOOL BSetFailoverProperties(
		IN DWORD nFailoverThreshold,
		IN DWORD nFailoverPeriod
		)
	{
		BOOL bChanged = FALSE;

		if ( m_nFailoverThreshold != nFailoverThreshold )
		{
			m_nFailoverThreshold = nFailoverThreshold;
			bChanged = TRUE;
		} // if:  threshold changed

		if ( m_nFailoverPeriod != nFailoverPeriod )
		{
			m_nFailoverPeriod = nFailoverPeriod;
			bChanged = TRUE;
		} // if:  period changed

		return bChanged;

	} //*** BSetFailoverProperties()

	// Set failback properties for the group
	BOOL BSetFailbackProperties(
		IN CGAFT cgaft,
		IN DWORD nFailbackWindowStart,
		IN DWORD nFailbackWindowEnd
		)
	{
		BOOL bChanged = FALSE;

		if ( m_cgaftAutoFailbackType != cgaft )
		{
			m_cgaftAutoFailbackType = cgaft;
			bChanged = TRUE;
		} // if:  autofailback type changed

		if ( m_nFailbackWindowStart != nFailbackWindowStart )
		{
			m_nFailbackWindowStart = nFailbackWindowStart;
			bChanged = TRUE;
		} // if:  failback start window changed

		if ( m_nFailbackWindowEnd != nFailbackWindowEnd )
		{
			m_nFailbackWindowEnd = nFailbackWindowEnd;
			bChanged = TRUE;
		} // if:  failback end window changed

		return bChanged;

	} //*** BSetFailbackProperties()

	// Return the list of extensions for groups
	const std::list< CString > * PlstrAdminExtensions( void ) const
	{
		ATLASSERT( Pci() != NULL );
		return Pci()->PlstrGroupsAdminExtensions();

	} //*** PlstrAdminExtensions()

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hGroup == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Open a handle to the object.
		//
		m_hGroup = OpenClusterGroup( m_pci->Hcluster(), m_strName );
		if ( m_hGroup == NULL )
		{
			sc = GetLastError();
		} // if:  error opening the object

		return sc;

	} //*** ScOpen()

	// Create the object
	DWORD ScCreate( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hGroup == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Create the object.
		//
		m_hGroup = CreateClusterGroup( m_pci->Hcluster(), m_strName );
		if ( m_hGroup == NULL )
		{
			sc = GetLastError();
		} // if:  error creating the object

		return sc;

	} //*** ScCreate()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusGroupInfo & rgi )
	{
		ATLASSERT( rgi.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rgi );

		m_bHasIPAddress = rgi.m_bHasIPAddress;
		m_bHasNetName = rgi.m_bHasNetName;
		m_nPersistentState = rgi.m_nPersistentState;
		m_nFailoverThreshold = rgi.m_nFailoverThreshold;
		m_nFailoverPeriod = rgi.m_nFailoverPeriod;
		m_cgaftAutoFailbackType = rgi.m_cgaftAutoFailbackType;
		m_nFailbackWindowStart = rgi.m_nFailbackWindowStart;
		m_nFailbackWindowEnd = rgi.m_nFailbackWindowEnd;

		//
		// Copy the preferred owners and resources lists.
		//
		m_lpniPreferredOwners = rgi.m_lpniPreferredOwners;
		m_lpriResources = rgi.m_lpriResources;

		//
		// Initialize the object.
		//
		if ( rgi.m_hGroup != NULL )
		{
			sc = ScOpen();
		} // if:  source object had the object open

		return sc;

	} //*** ScCopy()

	// Delete the object
	DWORD ScDelete( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_hGroup != NULL );

		DWORD sc = ERROR_SUCCESS;

		sc = DeleteClusterGroup( m_hGroup );
		if ( sc == ERROR_SUCCESS )
		{
			Close();
			m_bCreated = FALSE;
		} // if:  objected deleted successfully

		return sc;

	} //*** ScDelete()

	// Close the object
	void Close( void )
	{
		if ( m_hGroup != NULL )
		{
			CloseClusterGroup( m_hGroup );
		} // if:  group is open
		m_hGroup = NULL;
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close()

}; //*** class CClusGroupInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusResTypeInfo
//
//	Description:
//		Cluster resource type object.
//
//	Inheritance:
//		CClusResTypeInfo
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////
class CClusResTypeInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusResTypeInfo( void )
		: CClusterObject( CLUADMEX_OT_RESOURCETYPE )
		, m_pcrd( NULL )
	{
		Reset( NULL );

	} //*** CClusResTypeInfo()

	// Constructor taking cluster info pointer
	CClusResTypeInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_RESOURCETYPE, pci, pszName )
		, m_pcrd( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusResTypeInfo( pci )

	// Destructor
	~CClusResTypeInfo( void )
	{
		Close();

		delete [] m_pcrd;
		m_pcrd = NULL;

	} //*** ~CClusGroupInfo()

	// Operator = is not allowed
	CClusResTypeInfo & operator=( IN const CClusResTypeInfo & rrti )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_RESOURCETYPE );

		m_strDisplayName.Empty();
		m_strResDLLName.Empty();

		m_lstrAdminExtensions.erase( m_lstrAdminExtensions.begin(), m_lstrAdminExtensions.end() );
		m_lstrAllAdminExtensions.erase( m_lstrAllAdminExtensions.begin(), m_lstrAllAdminExtensions.end() );
		m_lstrResourceAdminExtensions.erase( m_lstrResourceAdminExtensions.begin(), m_lstrResourceAdminExtensions.end() );

		m_nLooksAlive = CLUSTER_RESTYPE_DEFAULT_LOOKS_ALIVE;
		m_nIsAlive = CLUSTER_RESTYPE_DEFAULT_IS_ALIVE;
		m_rciResClassInfo.rc = CLUS_RESCLASS_UNKNOWN;
		m_rciResClassInfo.SubClass = 0;
		m_fCharacteristics = CLUS_CHAR_UNKNOWN;
		m_fFlags = 0;

		delete [] m_pcrd;
		m_pcrd = NULL;

	} //*** Reset()

protected:
	//
	// Properties of a resource type.
	//

	CString						m_strDisplayName;
	CString						m_strResDLLName;

	std::list< CString >		m_lstrAdminExtensions;
	std::list< CString >		m_lstrAllAdminExtensions;
	std::list< CString >		m_lstrResourceAdminExtensions;

	DWORD						m_nLooksAlive;
	DWORD						m_nIsAlive;
	CLUS_RESOURCE_CLASS_INFO	m_rciResClassInfo;
	DWORD						m_fCharacteristics;
	DWORD						m_fFlags;

	CLUSPROP_REQUIRED_DEPENDENCY *	m_pcrd;

public:
	//
	// Accessor functions for resource type properties
	//

	const CString & RstrDisplayName( void ) const	{ return m_strDisplayName; }
	const CString & RstrResDLLName( void ) const	{ return m_strResDLLName; }

	// Return list of extensions for this resource type
	const std::list< CString > * PlstrAdminExtensions( void )
	{
		//
		// If not done already, construct the complete list of extensions
		// from the extensions for this resource type and the extensions
		// for all resource types.
		//
		if ( m_lstrAllAdminExtensions.size() == 0 )
		{
			ATLASSERT( Pci() != NULL );
			m_lstrAllAdminExtensions = m_lstrAdminExtensions;
			m_lstrAllAdminExtensions.insert(
				m_lstrAllAdminExtensions.end(),
				Pci()->PlstrResTypesAdminExtensions()->begin(),
				Pci()->PlstrResTypesAdminExtensions()->end()
				);
		} // if:  full list not constructed yet

		return &m_lstrAllAdminExtensions;

	} //*** PlstrAdminExtensions()

	// Return list of extensions for resources of this type
	const std::list< CString > * PlstrResourceAdminExtensions( void )
	{
		//
		// If not done already, construct the complete list of extensions
		// from the extensions for this resource type and the extensions
		// for all resources.
		//
		if ( m_lstrResourceAdminExtensions.size() == 0 )
		{
			ATLASSERT( Pci() != NULL );
			m_lstrResourceAdminExtensions = m_lstrAdminExtensions;
			m_lstrResourceAdminExtensions.insert(
				m_lstrResourceAdminExtensions.end(),
				Pci()->PlstrResourcesAdminExtensions()->begin(),
				Pci()->PlstrResourcesAdminExtensions()->end()
				);
		} // if:  full list not constructed yet

		return &m_lstrResourceAdminExtensions;

	} //*** PlstrAdminExtensions()

	DWORD NLooksAlive( void ) const						{ return m_nLooksAlive; }
	DWORD NIsAlive( void ) const						{ return m_nIsAlive; }
	DWORD FCharacteristics( void ) const				{ return m_fCharacteristics; }
	DWORD FFlags( void ) const							{ return m_fFlags; }

	CLUS_RESOURCE_CLASS_INFO *	PrciResClassInfo( void )	{ return &m_rciResClassInfo; }
	CLUSTER_RESOURCE_CLASS		ResClass( void ) const		{ return m_rciResClassInfo.rc; }

	CLUSPROP_REQUIRED_DEPENDENCY * Pcrd( void )			{ return m_pcrd; }

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		return sc;

	} //*** ScOpen()

	// Create the object
	DWORD ScCreate( IN HGROUP hGroup, IN DWORD dwFlags )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_strName.GetLength() > 0 );
		ATLASSERT( m_strDisplayName.GetLength() > 0 );
		ATLASSERT( m_strResDLLName.GetLength() > 0 );
		ATLASSERT( m_nLooksAlive != 0 );
		ATLASSERT( m_nIsAlive != 0 );

		DWORD sc;

		//
		// Create the object.
		//
		sc = CreateClusterResourceType(
			Pci()->Hcluster(),
			m_strName,
			m_strDisplayName,
			m_strResDLLName,
			m_nLooksAlive,
			m_nIsAlive
			);

		return sc;

	} //*** ScCreate()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusResTypeInfo & rrti )
	{
		ATLASSERT( rrti.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rrti );

		m_strDisplayName = rrti.m_strDisplayName;
		m_strResDLLName = rrti.m_strResDLLName;

		m_lstrAdminExtensions = m_lstrAdminExtensions;
		m_lstrResourceAdminExtensions = rrti.m_lstrResourceAdminExtensions;

		m_nLooksAlive = rrti.m_nLooksAlive;
		m_nIsAlive = rrti.m_nIsAlive;
		m_rciResClassInfo.rc = rrti.m_rciResClassInfo.rc;
		m_rciResClassInfo.SubClass = rrti.m_rciResClassInfo.SubClass;
		m_fCharacteristics = rrti.m_fCharacteristics;
		m_fFlags = rrti.m_fFlags;

		//
		// Initialize the object.
		//
		// sc = ScOpen();

		return sc;

	} //*** ScCopy()

	// Close the object
	void Close( void )
	{
		// Dummy function to support similar semantics as other objects.
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close();

}; //*** class CClusResTypeInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusResInfo
//
//	Description:
//		Cluster resource object.
//
//	Inheritance:
//		CClusResInfo
//		CClusterObject
//
//	Notes:
//		1)	Must appear after definition of CClusResTypeInfo because
//			CClusResTypeInfo methods are referenced in this class's methods.
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusResInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusResInfo( void )
		: CClusterObject( CLUADMEX_OT_RESOURCE )
		, m_hResource( NULL )
	{
		Reset( NULL );

	} //*** CClusResInfo()

	// Constructor taking cluster info pointer
	CClusResInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_RESOURCE, pci, pszName )
		, m_hResource( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusResInfo( pci )

	~CClusResInfo( void )
	{
		Close();

	} //*** ~CClusResInfo()

	// Operator = is not allowed
	CClusResInfo & operator=( IN const CClusResInfo & rri )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_RESOURCE );

		m_prti = NULL;
		m_pgi = NULL;
		m_pniOwner = NULL;

		m_bCollectedOwners = FALSE;
		m_bCollectedDependencies = FALSE;

		m_lpniPossibleOwners.erase( m_lpniPossibleOwners.begin(), m_lpniPossibleOwners.end() );
		m_lpriDependencies.erase( m_lpriDependencies.begin(), m_lpriDependencies.end() );

		m_bSeparateMonitor = FALSE;
		m_nPersistentState = 0;
		m_nLooksAlive = CLUSTER_RESOURCE_DEFAULT_LOOKS_ALIVE;
		m_nIsAlive = CLUSTER_RESOURCE_DEFAULT_IS_ALIVE;
		m_crraRestartAction = CLUSTER_RESOURCE_DEFAULT_RESTART_ACTION;
		m_nRestartThreshold = CLUSTER_RESOURCE_DEFAULT_RESTART_THRESHOLD;
		m_nRestartPeriod = CLUSTER_RESOURCE_DEFAULT_RESTART_PERIOD;
		m_nPendingTimeout = CLUSTER_RESOURCE_DEFAULT_PENDING_TIMEOUT;

	} //*** Reset()

protected:
	//
	// Properties of a resource.
	//

	HRESOURCE			m_hResource;

	CClusResTypeInfo *	m_prti;
	CClusGroupInfo *	m_pgi;
	CClusNodeInfo *		m_pniOwner;

	BOOL				m_bSeparateMonitor;
	DWORD				m_nPersistentState;
	DWORD				m_nLooksAlive;
	DWORD				m_nIsAlive;
	CRRA				m_crraRestartAction;
	DWORD				m_nRestartThreshold;
	DWORD				m_nRestartPeriod;
	DWORD				m_nPendingTimeout;

	BOOL				m_bCollectedOwners;
	BOOL				m_bCollectedDependencies;
	CClusNodePtrList	m_lpniPossibleOwners;
	CClusResPtrList		m_lpriDependencies;

public:
	//
	// Accessor functions for resource properties
	//

	HRESOURCE Hresource( void ) const { return m_hResource; }

	CClusResTypeInfo * Prti( void ) const	{ ATLASSERT( m_prti != NULL ); return m_prti; }
	CClusGroupInfo * Pgi( void ) const		{ ATLASSERT( m_pgi != NULL ); return m_pgi; }
	CClusNodeInfo * PniOwner( void ) const	{ ATLASSERT( m_pniOwner != NULL ); return m_pniOwner; }

	BOOL BSeparateMonitor( void ) const		{ return m_bSeparateMonitor; }
	DWORD NPersistentState( void ) const	{ return m_nPersistentState; }
	DWORD NLooksAlive( void ) const			{ return m_nLooksAlive; }
	DWORD NIsAlive( void ) const			{ return m_nIsAlive; }
	CRRA CrraRestartAction( void ) const	{ return m_crraRestartAction; }
	DWORD NRestartThreshold( void ) const	{ return m_nRestartThreshold; }
	DWORD NRestartPeriod( void ) const		{ return m_nRestartPeriod; }
	DWORD NPendingTimeout( void ) const		{ return m_nPendingTimeout; }

	BOOL BCollectedOwners( void ) const			{ return m_bCollectedOwners; }
	BOOL BCollectedDependencies( void ) const	{ return m_bCollectedDependencies; }
	CClusNodePtrList *	PlpniPossibleOwners( void )	{ return &m_lpniPossibleOwners; }
	CClusResPtrList *	PlpriDependencies( void )	{ return &m_lpriDependencies; }

	CLUSTER_RESOURCE_CLASS ResClass( void ) const	{ return Prti()->ResClass(); }

	// Set the group
	void SetGroup( IN CClusGroupInfo * pgi )
	{
		ATLASSERT( pgi != NULL );

		m_pgi = pgi;

	} //*** SetGroup()

	// Set the resource type of the resource
	BOOL BSetResourceType( IN CClusResTypeInfo * prti )
	{
		ATLASSERT( prti != NULL );

		BOOL bChanged = FALSE;

		//
		// If the resource type changed, set it.
		//
		if ( m_prti != prti )
		{
			m_prti = prti;
			bChanged = TRUE;
		} // if:  resource type changed

		return bChanged;

	} //*** BSetResourceType()

	// Set the separate monitor property for the resource
	BOOL BSetSeparateMonitor( IN BOOL bSeparateMonitor )
	{
		BOOL bChanged = FALSE;

		if ( m_bSeparateMonitor != bSeparateMonitor )
		{
			m_bSeparateMonitor = bSeparateMonitor;
			bChanged = TRUE;
		} // if:  separate monitor changed

		return bChanged;

	} //*** BSetSeparateMonitor()

	// Set advanced properties for the resource
	BOOL BSetAdvancedProperties(
		IN CRRA crra,
		IN DWORD nRestartThreshold,
		IN DWORD nRestartPeriod,
		IN DWORD nLooksAlive,
		IN DWORD nIsAlive,
		IN DWORD nPendingTimeout
		)
	{
		BOOL bChanged = FALSE;

		if ( m_crraRestartAction != crra )
		{
			m_crraRestartAction = crra;
			bChanged = TRUE;
		} // if:  restart action changed

		if ( m_nRestartThreshold != nRestartThreshold )
		{
			m_nRestartThreshold = nRestartThreshold;
			bChanged = TRUE;
		} // if:  restart threshold changed

		if ( m_nRestartPeriod != nRestartPeriod )
		{
			m_nRestartPeriod = nRestartPeriod;
			bChanged = TRUE;
		} // if:  restart period changed

		if ( m_nLooksAlive != nLooksAlive )
		{
			m_nLooksAlive = nLooksAlive;
			bChanged = TRUE;
		} // if:  looks alive period changed

		if ( m_nIsAlive != nIsAlive )
		{
			m_nIsAlive = nIsAlive;
			bChanged = TRUE;
		} // if:  is alive period changed

		if ( m_nPendingTimeout != nPendingTimeout )
		{
			m_nPendingTimeout = nPendingTimeout;
			bChanged = TRUE;
		} // if:  pending timeout changed

		return bChanged;

	} //*** BSetAdvancedProperties()

	// Return the list of extensions for resources
	const std::list< CString > * PlstrAdminExtensions( void ) const
	{
		ATLASSERT( m_prti != NULL );
		return m_prti->PlstrResourceAdminExtensions();

	} //*** PlstrAdminExtensions()

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hResource == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Open a handle to the object.
		//
		m_hResource = OpenClusterResource( m_pci->Hcluster(), m_strName );
		if ( m_hResource == NULL )
		{
			sc = GetLastError();
		} // if:  error opening the object

		return sc;

	} //*** ScOpen()

	// Create the object
	DWORD ScCreate( IN HGROUP hGroup, IN DWORD dwFlags )
	{
		ATLASSERT( hGroup != NULL );
		ATLASSERT( Prti() != NULL );
		ATLASSERT( Prti()->RstrName().GetLength() > 0 );
		ATLASSERT( m_hResource == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		m_bSeparateMonitor = ( dwFlags & CLUSTER_RESOURCE_SEPARATE_MONITOR ) == CLUSTER_RESOURCE_SEPARATE_MONITOR;

		//
		// Create the object.
		//
		m_hResource = CreateClusterResource( hGroup, m_strName, Prti()->RstrName(), dwFlags );
		if ( m_hResource == NULL )
		{
			sc = GetLastError();
		} // if:  error creating the object

		return sc;

	} //*** ScCreate()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusResInfo & rri )
	{
		ATLASSERT( rri.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rri );

		m_prti = rri.m_prti;
		m_pgi = rri.m_pgi;
		m_pniOwner = rri.m_pniOwner;

		m_bSeparateMonitor = rri.m_bSeparateMonitor;
		m_nPersistentState = rri.m_nPersistentState;
		m_nLooksAlive = rri.m_nLooksAlive;
		m_nIsAlive = rri.m_nIsAlive;
		m_crraRestartAction = rri.m_crraRestartAction;
		m_nRestartThreshold = rri.m_nRestartThreshold;
		m_nRestartPeriod = rri.m_nRestartPeriod;
		m_nPendingTimeout = rri.m_nPendingTimeout;

		//
		// Copy the possible owners and dependencies lists.
		//
		m_lpniPossibleOwners = rri.m_lpniPossibleOwners;
		m_lpriDependencies = rri.m_lpriDependencies;

		//
		// Initialize the object.
		//
		if ( rri.m_hResource != NULL )
		{
			sc = ScOpen();
		} // if:  source object had the object open

		return sc;

	} //*** ScCopy()

	// Delete the object
	DWORD ScDelete( void )
	{
		ATLASSERT( m_hResource != NULL );

		DWORD sc = ERROR_SUCCESS;

		sc = DeleteClusterResource( m_hResource );
		if ( sc == ERROR_SUCCESS )
		{
			Close();
			m_bCreated = FALSE;
		} // if:  objected deleted successfully

		return sc;

	} //*** ScDelete()

	// Close the object
	void Close( void )
	{
		if ( m_hResource != NULL )
		{
			CloseClusterResource( m_hResource );
		} // if:  resource is open
		m_hResource = NULL;
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close()

	// Get network name of first Network Name resource we are dependent on
	BOOL BGetNetworkName(
		OUT WCHAR *		lpszNetName,
		IN OUT DWORD *	pcchNetName
		)
	{
		ATLASSERT( m_hResource != NULL );
		ATLASSERT( lpszNetName != NULL );
		ATLASSERT( pcchNetName != NULL );

		return GetClusterResourceNetworkName(
					m_hResource,
					lpszNetName,
					pcchNetName
					);

	} //*** BGetNetworkName()

	// Determine whether required dependencies are specified or not
	BOOL BRequiredDependenciesPresent(
		IN CClusResPtrList const *	plpri,
		OUT CString &				rstrMissing,
		OUT BOOL &					rbMissingTypeName
		);

}; //*** class CClusResInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusNetworkInfo
//
//	Description:
//		Cluster network object.
//
//	Inheritance:
//		CClusNetworkInfo
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusNetworkInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusNetworkInfo( void )
		: CClusterObject( CLUADMEX_OT_NETWORK )
		, m_hNetwork( NULL )
	{
		Reset( NULL );

	} //*** CClusNetworkInfo()

	// Constructor taking cluster info pointer
	CClusNetworkInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_NETWORK, pci, pszName )
		, m_hNetwork( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusNetworkInfo( pci )

	~CClusNetworkInfo( void )
	{
		Close();

	} //*** ~CClusterNetworkInfo()

	// Operator = is not allowed
	CClusNetworkInfo & operator=( IN const CClusNetworkInfo & rni )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_NETWORK );

		m_nRole = ClusterNetworkRoleNone;
		m_strAddress.Empty();
		m_strAddressMask.Empty();

		m_nAddress = 0;
		m_nAddressMask = 0;

	} //*** Reset()

protected:
	//
	// Properties of a network.
	//

	HNETWORK				m_hNetwork;

	CLUSTER_NETWORK_ROLE	m_nRole;
	CString					m_strAddress;
	CString					m_strAddressMask;

	DWORD					m_nAddress;
	DWORD					m_nAddressMask;

public:
	//
	// Accessor functions for network properties
	//

	HNETWORK Hnetwork( void ) const					{ return m_hNetwork; }

	CLUSTER_NETWORK_ROLE NRole( void ) const		{ return m_nRole; }
	const CString & RstrAddress( void ) const		{ return m_strAddress; }
	const CString & RstrAddressMask( void ) const	{ return m_strAddressMask; }

	DWORD NAddress( void ) const					{ return m_nAddress; }
	DWORD NAddressMask( void ) const				{ return m_nAddressMask; }

	// Returns whether the network is used for client access
	BOOL BIsClientNetwork( void ) const
	{
		return m_bQueried && (m_nRole & ClusterNetworkRoleClientAccess);

	} //*** BIsClientNetwork()

	// Returns whether the network is used for internal cluster use
	BOOL BIsInternalNetwork( void ) const
	{
		return m_bQueried && (m_nRole & ClusterNetworkRoleInternalUse);

	} //*** BIsInternalNetwork()

	// Return the list of extensions for networks
	const std::list< CString > * PlstrAdminExtensions( void ) const
	{
		ATLASSERT( Pci() != NULL );
		return Pci()->PlstrNetworksAdminExtensions();

	} //*** PlstrAdminExtensions()

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hNetwork == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Open a handle to the object.
		//
		m_hNetwork = OpenClusterNetwork( m_pci->Hcluster(), m_strName );
		if ( m_hNetwork == NULL )
		{
			sc = GetLastError();
		} // if:  error opening the object

		return sc;

	} //*** ScOpen()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusNetworkInfo & rni )
	{
		ATLASSERT( rni.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rni );

		m_nRole = rni.m_nRole;
		m_strAddress = rni.m_strAddress;
		m_strAddressMask = rni.m_strAddressMask;

		m_nAddress = rni.m_nAddress;
		m_nAddressMask = rni.m_nAddressMask;

		//
		// Initialize the object.
		//
		if ( rni.m_hNetwork != NULL )
		{
			sc = ScOpen();
		} // if:  source object had the object open

		return sc;

	} //*** ScCopy()

	// Close the object
	void Close( void )
	{
		if ( m_hNetwork != NULL )
		{
			CloseClusterNetwork( m_hNetwork );
		} // if:  network is open
		m_hNetwork = NULL;
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close()

}; //*** class CClusNetworkInfo

/////////////////////////////////////////////////////////////////////////////
//++
//
//	class CClusNetIFInfo
//
//	Description:
//		Cluster network interface object.
//
//	Inheritance:
//		CClusNetIFInfo
//		CClusterObject
//
//--
/////////////////////////////////////////////////////////////////////////////

class CClusNetIFInfo : public CClusterObject
{
	friend class CWizardThread;

public:
	//
	// Construction.
	//

	// Default constructor
	CClusNetIFInfo( void )
		: CClusterObject( CLUADMEX_OT_NETINTERFACE )
		, m_hNetInterface( NULL )
	{
		Reset( NULL );

	} //*** CClusNetworkInfo()

	// Constructor taking cluster info pointer
	CClusNetIFInfo( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
		: CClusterObject( CLUADMEX_OT_NETINTERFACE, pci, pszName )
		, m_hNetInterface( NULL )
	{
		Reset( pci, pszName );

	} //*** CClusNetIFInfo( pci )

	~CClusNetIFInfo( void )
	{
		Close();

	} //*** ~CClusNetIFInfo()

	// Operator = is not allowed
	CClusNetIFInfo & operator=( IN const CClusNetIFInfo & rnii )
	{
		ATLASSERT( FALSE );
		return *this;

	} //*** operator=()

	// Reset the data back to default values
	void Reset( IN CClusterInfo * pci, IN LPCTSTR pszName = NULL )
	{
		Close();
		CClusterObject::Reset( pci, pszName, CLUADMEX_OT_NETINTERFACE );

	} //*** Reset()

protected:
	//
	// Properties of a network interface.
	//

	HNETINTERFACE m_hNetInterface;

public:
	//
	// Accessor functions for network properties
	//

	HNETINTERFACE Hnetinterface( void ) const { return m_hNetInterface; }

	// Return the list of extensions for network interfaces
	const std::list< CString > * PlstrAdminExtensions( void ) const
	{
		ATLASSERT( Pci() != NULL );
		return Pci()->PlstrNetInterfacesAdminExtensions();

	} //*** PlstrAdminExtensions()

public:
	//
	// Operations.
	//

	// Open the object
	DWORD ScOpen( void )
	{
		ATLASSERT( m_pci != NULL );
		ATLASSERT( m_pci->Hcluster() != NULL );
		ATLASSERT( m_hNetInterface == NULL );
		ATLASSERT( m_strName.GetLength() > 0 );

		DWORD sc = ERROR_SUCCESS;

		//
		// Open a handle to the object.
		//
		m_hNetInterface = OpenClusterNetInterface( m_pci->Hcluster(), m_strName );
		if ( m_hNetInterface == NULL )
		{
			sc = GetLastError();
		} // if:  error opening the object

		return sc;

	} //*** ScOpen()

	// Copy another object into this one.
	DWORD ScCopy( IN const CClusNetIFInfo & rnii )
	{
		ATLASSERT( rnii.m_pci != NULL );

		DWORD sc = ERROR_SUCCESS;

		Close();
		CClusterObject::Copy( rnii );

		//
		// Initialize the object.
		//
		if ( rnii.m_hNetInterface != NULL )
		{
			sc = ScOpen();
		} // if:  source object had the object open

		return sc;

	} //*** ScCopy()

	// Close the object
	void Close( void )
	{
		if ( m_hNetInterface != NULL )
		{
			CloseClusterNetInterface( m_hNetInterface );
		} // if:  network interface is open
		m_hNetInterface = NULL;
		m_bQueried = FALSE;
		m_bCreated = FALSE;

	} //*** Close()

}; //*** class CClusNetIFInfo

/////////////////////////////////////////////////////////////////////////////
// Global Template Functions
/////////////////////////////////////////////////////////////////////////////

// Delete all list items from a pointer list
template < class ListT, class ObjT >
void DeleteListItems( ListT * ppl )
{
	ListT::iterator it;
	for ( it = ppl->begin() ; it != ppl->end() ; it++ )
	{
		ObjT * pco = *it;
		delete pco;
	} // for:  each item in the list

} //*** DeleteListItems< ListT, ObjT >()

// Retrieve an object from a list by its name
template < class ObjT >
ObjT PobjFromName( std::list< ObjT > * pList, IN LPCTSTR pszName )
{
	ATLASSERT( pList != NULL );
	ATLASSERT( pszName != NULL );

	//
	// Get pointers to beginning and end of list.
	//
	std::list< ObjT >::iterator itCurrent = pList->begin();
	std::list< ObjT >::iterator itLast = pList->end();

	//
	// Loop through the list looking for the object with the specified name.
	//
	while ( itCurrent != itLast )
	{
		if ( (*itCurrent)->RstrName() == pszName )
		{
			return *itCurrent;
		} // if:  found a match
		itCurrent++;
	} // while:  more items in the list

	return NULL;

} //*** PobjFromName< ObjT >()

/////////////////////////////////////////////////////////////////////////////

#endif // __CLUSOBJ_H_