able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/admin/cluadmin/cluster.cpp

1527 lines
45 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-2000 Microsoft Corporation
//
// Module Name:
// Cluster.cpp
//
// Abstract:
// Implementation of the CCluster class.
//
// Author:
// David Potter (davidp) May 13, 1996
//
// Revision History:
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CluAdmin.h"
#include "ConstDef.h"
#include "Cluster.h"
#include "CASvc.h"
#include "ClusDoc.h"
#include "ClusProp.h"
#include "ExcOper.h"
#include "ClusItem.inl"
#include "resource.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// Global Variables
/////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
CTraceTag g_tagCluster( _T("Document"), _T("CLUSTER"), 0 );
#endif
/////////////////////////////////////////////////////////////////////////////
// CCluster
/////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE( CCluster, CClusterItem )
/////////////////////////////////////////////////////////////////////////////
// Message Maps
/////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP( CCluster, CClusterItem )
//{{AFX_MSG_MAP(CCluster)
ON_UPDATE_COMMAND_UI(ID_FILE_PROPERTIES, OnUpdateProperties)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::CCluster
//
// Routine Description:
// Default construtor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CCluster::CCluster( void ) : CClusterItem( NULL, IDS_ITEMTYPE_CLUSTER )
{
m_idmPopupMenu = IDM_CLUSTER_POPUP;
ZeroMemory( &m_cvi, sizeof( m_cvi ) );
m_nMaxQuorumLogSize = 0;
m_plpciNetworkPriority = NULL;
// Set the object type and state images.
m_iimgObjectType = GetClusterAdminApp()->Iimg( IMGLI_CLUSTER );
m_iimgState = m_iimgObjectType;
// Setup the property array.
{
m_rgProps[epropDefaultNetworkRole].Set(CLUSREG_NAME_CLUS_DEFAULT_NETWORK_ROLE, m_nDefaultNetworkRole, m_nDefaultNetworkRole);
m_rgProps[epropDescription].Set(CLUSREG_NAME_CLUS_DESC, m_strDescription, m_strDescription);
m_rgProps[epropEnableEventLogReplication].Set(CLUSREG_NAME_CLUS_EVTLOG_PROPAGATION, m_bEnableEventLogReplication, m_bEnableEventLogReplication);
m_rgProps[epropQuorumArbitrationTimeMax].Set(CLUSREG_NAME_QUORUM_ARBITRATION_TIMEOUT, m_nQuorumArbitrationTimeMax, m_nQuorumArbitrationTimeMax);
m_rgProps[epropQuorumArbitrationTimeMin].Set(CLUSREG_NAME_QUORUM_ARBITRATION_EQUALIZER, m_nQuorumArbitrationTimeMin, m_nQuorumArbitrationTimeMin);
} // Setup the property array
} //*** CCluster::CCluster()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::~CCluster
//
// Routine Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CCluster::~CCluster( void )
{
Cleanup();
} //*** CCluster::~CCluster()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::Cleanup
//
// Routine Description:
// Cleanup the item.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::Cleanup( void )
{
// Delete the NetworkPriority list.
if ( m_plpciNetworkPriority != NULL )
{
m_plpciNetworkPriority->RemoveAll();
delete m_plpciNetworkPriority;
m_plpciNetworkPriority = NULL;
} // if: NetworkPriority list exists
m_hkey = NULL;
} //*** CCluster::Cleanup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::Init
//
// Routine Description:
// Initialize the item.
//
// Arguments:
// pdoc [IN OUT] Document to which this item belongs.
// lpszName [IN] Name of the item.
// hOpenedCluster [IN] Handle to cluster to use that is already open.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from OpenCluster(), GetClusterKey(), or
// CreateClusterNotifyPort().
// Any exceptions thrown by CCluster::ReadClusterInfo().
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::Init(
IN OUT CClusterDoc * pdoc,
IN LPCTSTR lpszName,
IN HCLUSTER hOpenedCluster // = NULL
)
{
CWaitCursor wc;
TCHAR szClusterName[ MAX_PATH ];
ASSERT( Hkey() == NULL );
ASSERT( lstrlen( lpszName ) < sizeof( szClusterName ) / sizeof( TCHAR ) );
try
{
// If connecting the local machine, get its name.
if ( lstrcmp( lpszName, _T(".") ) == 0 )
{
DWORD nSize = sizeof( szClusterName ) / sizeof( TCHAR );
GetComputerName( szClusterName, &nSize );
} // if: connecting to the local machine
else
{
lstrcpy( szClusterName, lpszName );
} // else: not connecting to the local machine
// Open the cluster.
if ( hOpenedCluster == NULL )
{
pdoc->m_hcluster = HOpenCluster( lpszName );
if ( pdoc->m_hcluster == NULL )
{
ThrowStaticException( GetLastError(), IDS_OPEN_CLUSTER_ERROR, szClusterName );
} // if: error opening the cluster
} // if: no opened cluster passed in
else
{
pdoc->m_hcluster = hOpenedCluster;
} // if: cluster already opened
// Get the cluster registry key.
pdoc->m_hkeyCluster = GetClusterKey( pdoc->m_hcluster, MAXIMUM_ALLOWED );
if ( pdoc->m_hkeyCluster == NULL )
{
ThrowStaticException( GetLastError(), IDS_GET_CLUSTER_KEY_ERROR, szClusterName );
} // if: error opening the cluster key
// Call the base class method. We can use Hcluster() after calling this.
CClusterItem::Init( pdoc, szClusterName );
// Get the cluster registry key.
m_hkey = pdoc->m_hkeyCluster;
// Register this cluster with the notification port.
{
HCHANGE hchange;
// We want these notifications to go to the document, not us.
ASSERT( Pcnk() != NULL );
m_pcnk->m_cnkt = cnktDoc;
m_pcnk->m_pdoc = pdoc;
Trace( g_tagClusItemNotify, _T("CCluster::Init() - Registering for cluster notifications (%08.8x)"), Pcnk() );
// Create the notification port.
hchange = CreateClusterNotifyPort(
GetClusterAdminApp()->HchangeNotifyPort(),
Hcluster(),
(CLUSTER_CHANGE_NODE_ADDED
| CLUSTER_CHANGE_GROUP_ADDED
| CLUSTER_CHANGE_RESOURCE_ADDED
| CLUSTER_CHANGE_RESOURCE_TYPE_ADDED
| CLUSTER_CHANGE_RESOURCE_TYPE_DELETED
| CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY
| CLUSTER_CHANGE_NETWORK_ADDED
| CLUSTER_CHANGE_NETINTERFACE_ADDED
| CLUSTER_CHANGE_QUORUM_STATE
| CLUSTER_CHANGE_CLUSTER_STATE
| CLUSTER_CHANGE_CLUSTER_PROPERTY
| CLUSTER_CHANGE_REGISTRY_NAME
| CLUSTER_CHANGE_REGISTRY_ATTRIBUTES
| CLUSTER_CHANGE_REGISTRY_VALUE
| CLUSTER_CHANGE_REGISTRY_SUBTREE),
(DWORD_PTR) Pcnk()
);
if ( hchange == NULL )
{
ThrowStaticException( GetLastError(), IDS_CLUSTER_NOTIF_REG_ERROR, szClusterName );
} // if: error creating the notify port
ASSERT( hchange == GetClusterAdminApp()->HchangeNotifyPort() );
} // Register this cluster with the notification port
// Get the name of the cluster as recorded by the cluster.
ReadClusterInfo();
// Allocate lists.
m_plpciNetworkPriority = new CNetworkList;
if ( m_plpciNetworkPriority == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the network list
// Read the initial state.
UpdateState();
} // try
catch ( CException * )
{
if ( pdoc->m_hkeyCluster != NULL )
{
ClusterRegCloseKey( pdoc->m_hkeyCluster );
pdoc->m_hkeyCluster = NULL;
m_hkey = NULL;
} // if: registry key opened
if ( ( pdoc->m_hcluster != NULL ) && ( pdoc->m_hcluster != hOpenedCluster ) )
{
CloseCluster( Hcluster() );
pdoc->m_hcluster = NULL;
} // if: group opened
m_bReadOnly = TRUE;
throw;
} // catch: CException
} //*** CCluster::Init()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadItem
//
// Routine Description:
// Read the item parameters from the cluster database.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue() or
// CClusterItem::ReadItem().
// Any exceptions thrown by CCluster::ReadExtensions().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadItem( void )
{
DWORD dwStatus;
DWORD dwRetStatus = ERROR_SUCCESS;
CWaitCursor wc;
ASSERT( Hcluster() != NULL );
ASSERT( Hkey() != NULL );
if ( Hcluster() != NULL )
{
m_rgProps[epropDefaultNetworkRole].m_value.pdw = &m_nDefaultNetworkRole;
m_rgProps[epropDescription].m_value.pstr = &m_strDescription;
m_rgProps[epropEnableEventLogReplication].m_value.pb = &m_bEnableEventLogReplication;
m_rgProps[epropQuorumArbitrationTimeMax].m_value.pdw = &m_nQuorumArbitrationTimeMax;
m_rgProps[epropQuorumArbitrationTimeMin].m_value.pdw = &m_nQuorumArbitrationTimeMin;
// Call the base class method.
try
{
CClusterItem::ReadItem();
} // try
catch ( CNTException * pnte )
{
dwRetStatus = pnte->Sc();
pnte->Delete();
} // catch: CNTException
// Get the name of the cluster as recorded by the cluster.
ReadClusterInfo();
// Read and parse the common properties.
{
CClusPropList cpl;
Trace( g_tagCluster, _T("(%x) - CCluster::ReadItem() - Getting common properties"), this );
dwStatus = cpl.ScGetClusterProperties(
Hcluster(),
CLUSCTL_CLUSTER_GET_COMMON_PROPERTIES
);
if (dwStatus == ERROR_SUCCESS)
{
Trace( g_tagCluster, _T("(%x) - CCluster::ReadItem() - Parsing common properties"), this );
dwStatus = DwParseProperties(cpl);
} // if: properties read successfully
if (dwStatus != ERROR_SUCCESS)
{
Trace( g_tagError, _T("(%x) - CCluster::ReadItem() - Error 0x%08.8x getting or parsing common properties"), this, dwStatus );
// PROCNUM_OUT_OF_RANGE occurs when the server side
// (clussvc.exe) doesn't support the ClusterControl( )
// API. In this case, read the data using the cluster
// registry APIs.
if ( dwStatus == RPC_S_PROCNUM_OUT_OF_RANGE )
{
if ( Hkey() != NULL )
{
// Read the Description
dwStatus = DwReadValue( CLUSREG_NAME_CLUS_DESC, m_strDescription );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
dwRetStatus = dwStatus;
} // if: error reading the value
} // if: key is available
} // if: must be talking to an NT4 node
else
{
dwRetStatus = dwStatus;
} // else: not talking to an NT4 node
} // if: error reading or parsing properties
} // Read and parse the common properties
// Get quorum resource information.
{
LPWSTR pwszQResName = NULL;
LPWSTR pwszQuorumPath = NULL;
DWORD cchQResName;
DWORD cchQuorumPath;
// Get the size of the resource name.
cchQResName = 0;
cchQuorumPath = 0;
dwStatus = GetClusterQuorumResource(
Hcluster(),
NULL,
&cchQResName,
NULL,
&cchQuorumPath,
&m_nMaxQuorumLogSize
);
if ( ( dwStatus == ERROR_SUCCESS ) || ( dwStatus == ERROR_MORE_DATA ) )
{
// Allocate enough space for the data.
cchQResName++; // Don't forget the final null-terminator.
pwszQResName = new WCHAR[ cchQResName ];
cchQuorumPath++;
pwszQuorumPath = new WCHAR[ cchQuorumPath ];
ASSERT( pwszQResName != NULL && pwszQuorumPath != NULL );
// Read the resource name.
dwStatus = GetClusterQuorumResource(
Hcluster(),
pwszQResName,
&cchQResName,
pwszQuorumPath,
&cchQuorumPath,
&m_nMaxQuorumLogSize
);
} // if: got the size successfully
if ( dwStatus != ERROR_SUCCESS )
{
dwRetStatus = dwStatus;
} // if: error occurred
else
{
m_strQuorumResource = pwszQResName;
m_strQuorumPath = pwszQuorumPath;
ASSERT( m_strQuorumPath[ m_strQuorumPath.GetLength() - 1 ] == _T('\\') );
} // else: quorum resource info retrieved successfully
delete [] pwszQResName;
delete [] pwszQuorumPath;
} // Get the quorum resource name
// Read the FQDN for the cluster.
{
DWORD cbReturned;
DWORD cbFQDN;
LPWSTR pszFQDN = NULL;
pszFQDN = m_strFQDN.GetBuffer( 256 );
cbFQDN = 256 * sizeof( WCHAR );
dwStatus = ClusterControl(
Hcluster(),
NULL,
CLUSCTL_CLUSTER_GET_FQDN,
NULL,
NULL,
pszFQDN,
cbFQDN,
&cbReturned
);
if ( dwStatus == ERROR_MORE_DATA )
{
cbFQDN = cbReturned + sizeof( WCHAR );
pszFQDN = m_strFQDN.GetBuffer( ( cbReturned / sizeof( WCHAR ) ) + 1 );
dwStatus = ClusterControl(
Hcluster(),
NULL,
CLUSCTL_CLUSTER_GET_FQDN,
NULL,
NULL,
pszFQDN,
cbFQDN,
&cbReturned
);
} // if: buffer not large enough
if ( dwStatus != ERROR_SUCCESS )
{
// Handle the case where the API doesn't exist (e.g. NT4).
// also
// Handle the case where the control code is not known (e.g. Win2K)
if ( ( dwStatus == RPC_S_PROCNUM_OUT_OF_RANGE )
|| ( dwStatus == ERROR_INVALID_FUNCTION ) )
{
lstrcpy( pszFQDN, StrName() );
m_strFQDN.ReleaseBuffer();
}
else
{
dwRetStatus = dwStatus;
}
}
else
{
m_strFQDN.ReleaseBuffer();
} // else: data retrieved successfully
} // if: no error yet
} // if: cluster is available
// If any errors occurred, throw an exception.
if ( dwRetStatus != ERROR_SUCCESS )
{
ThrowStaticException( dwRetStatus, IDS_READ_CLUSTER_PROPS_ERROR, StrName() );
} // if: error occurred
// Read extension lists.
ReadClusterExtensions();
ReadNodeExtensions();
ReadGroupExtensions();
ReadResourceExtensions();
ReadResTypeExtensions();
ReadNetworkExtensions();
ReadNetInterfaceExtensions();
// Read the initial state.
UpdateState();
MarkAsChanged( FALSE );
} //*** CCluster::ReadItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::PlstrExtensions
//
// Routine Description:
// Return the list of admin extensions.
//
// Arguments:
// None.
//
// Return Value:
// plstr List of extensions.
// NULL No extension associated with this object.
//
// Exceptions Thrown:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
const CStringList * CCluster::PlstrExtensions( void ) const
{
return &LstrClusterExtensions();
} //*** CCluster::PlstrExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadClusterInfo
//
// Routine Description:
// Get the name of the cluster as recorded by the cluster and the
// version of the cluster software.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by new.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadClusterInfo( void )
{
DWORD dwStatus;
LPWSTR pwszName = NULL;
DWORD cchName = 128;
CWaitCursor wc;
try
{
pwszName = new WCHAR[ cchName ];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the name buffer
m_cvi.dwVersionInfoSize = sizeof( m_cvi );
dwStatus = GetClusterInformation( Hcluster(), pwszName, &cchName, &m_cvi );
if ( dwStatus == ERROR_MORE_DATA )
{
delete [] pwszName;
cchName++;
pwszName = new WCHAR[ cchName ];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the name buffer
dwStatus = GetClusterInformation( Hcluster(), pwszName, &cchName, &m_cvi );
} // if: buffer is too small
if ( dwStatus == ERROR_SUCCESS )
{
Pdoc()->m_strName = pwszName;
} // if: error occurred
else
{
TraceError( _T("CCluster::Init() calling GetClusterInformation"), dwStatus );
} // else: no error occurred
m_strName = pwszName;
delete [] pwszName;
} // try
catch (CException *)
{
delete [] pwszName;
throw;
} // catch: CException
} //*** CCluster::ReadClusterInfo()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadClusterExtensions
//
// Routine Description:
// Read the extension list for the cluster object.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadClusterExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Cluster extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, m_lstrClusterExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrClusterExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadClusterExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadNodeExtensions
//
// Routine Description:
// Read the extension list for all nodes.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadNodeExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Nodes extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_NODES, m_lstrNodeExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrNodeExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadNodeExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadGroupExtensions
//
// Routine Description:
// Read the extension list for all groups.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadGroupExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Groups extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_GROUPS, m_lstrGroupExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrGroupExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadGroupExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadResourceExtensions
//
// Routine Description:
// Read the extension list for all resources.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadResourceExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Resources extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_RESOURCES, m_lstrResourceExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrResourceExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadResourceExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadResTypeExtensions
//
// Routine Description:
// Read the extension list for all resouce types.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadResTypeExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Resource Types extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_RESOURCE_TYPES, m_lstrResTypeExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrResTypeExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadResTypeExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadNetworkExtensions
//
// Routine Description:
// Read the extension list for all networks.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadNetworkExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Networks extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_NETWORKS, m_lstrNetworkExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrNetworkExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadNetworkExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::ReadNetInterfaceExtensions
//
// Routine Description:
// Read the extension list for all network interfaces.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::ReadNetInterfaceExtensions( void )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hkey() != NULL );
if ( Hkey() != NULL )
{
// Read the Network Intefaces extension string.
dwStatus = DwReadValue( CLUSREG_NAME_ADMIN_EXT, CLUSREG_KEYNAME_NETINTERFACES, m_lstrNetInterfaceExtensions );
if ( ( dwStatus != ERROR_SUCCESS )
&& ( dwStatus != ERROR_FILE_NOT_FOUND ) )
{
ThrowStaticException( dwStatus );
} // if: error reading the value
} // if: key is available
else
{
m_lstrNetInterfaceExtensions.RemoveAll();
} // else: key is not available
} //*** CCluster::ReadNetInterfaceExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::CollecNetworkPriority
//
// Routine Description:
// Construct the network priority list.
//
// Arguments:
// plpci [IN OUT] List to fill.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from ClusterOpenEnum() or ClusterEnum().
// Any exceptions thrown by new or CList::AddTail().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::CollectNetworkPriority( IN OUT CNetworkList * plpci )
{
DWORD dwStatus;
HCLUSENUM hclusenum;
int ienum;
LPWSTR pwszName = NULL;
DWORD cchName;
DWORD cchmacName;
DWORD dwRetType;
CNetwork * pciNet;
CWaitCursor wc;
ASSERT_VALID( Pdoc() );
ASSERT( Hcluster() != NULL );
if ( plpci == NULL )
{
plpci = m_plpciNetworkPriority;
} // if: no list specified
ASSERT( plpci != NULL );
// Remove the previous contents of the list.
plpci->RemoveAll();
if ( Hcluster() != NULL )
{
// Open the enumeration.
hclusenum = ClusterOpenEnum( Hcluster(), (DWORD) CLUSTER_ENUM_INTERNAL_NETWORK );
if ( hclusenum == NULL )
{
ThrowStaticException( GetLastError(), IDS_ENUM_NETWORK_PRIORITY_ERROR, StrName() );
} // if: error opening the enmeration
try
{
// Allocate a name buffer.
cchmacName = 128;
pwszName = new WCHAR[ cchmacName ];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the name buffer
// Loop through the enumeration and add each network to the list.
for ( ienum = 0 ; ; ienum++ )
{
// Get the next item in the enumeration.
cchName = cchmacName;
dwStatus = ClusterEnum( hclusenum, ienum, &dwRetType, pwszName, &cchName );
if ( dwStatus == ERROR_MORE_DATA )
{
delete [] pwszName;
cchmacName = ++cchName;
pwszName = new WCHAR[ cchmacName ];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating the name buffer
dwStatus = ClusterEnum( hclusenum, ienum, &dwRetType, pwszName, &cchName );
} // if: name buffer was too small
if ( dwStatus == ERROR_NO_MORE_ITEMS )
{
break;
} // if: done with the enumeraiton
else if ( dwStatus != ERROR_SUCCESS )
{
ThrowStaticException( dwStatus, IDS_ENUM_NETWORK_PRIORITY_ERROR, StrName() );
} // else if: error getting the next enumeration value
ASSERT( dwRetType == CLUSTER_ENUM_INTERNAL_NETWORK );
// Find the item in the list of networks on the document.
pciNet = Pdoc()->LpciNetworks().PciNetworkFromName( pwszName );
ASSERT_VALID( pciNet );
// Add the network to the list.
if ( pciNet != NULL )
{
plpci->AddTail( pciNet );
} // if: found network in list
} // for: each item in the group
ClusterCloseEnum( hclusenum );
} // try
catch ( CException * )
{
delete [] pwszName;
ClusterCloseEnum( hclusenum );
throw;
} // catch: any exception
} // if: cluster is available
delete [] pwszName;
} //*** CCluster::CollecNetworkPriority()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::OnUpdateProperties
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_PROPERTIES
// should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::OnUpdateProperties( CCmdUI * pCmdUI )
{
pCmdUI->Enable(TRUE);
} //*** CCluster::OnUpdateProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::BDisplayProperties
//
// Routine Description:
// Display properties for the object.
//
// Arguments:
// bReadOnly [IN] Don't allow edits to the object properties.
//
// Return Value:
// TRUE OK pressed.
// FALSE OK not pressed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CCluster::BDisplayProperties( IN BOOL bReadOnly )
{
BOOL bChanged = FALSE;
CClusterPropSheet sht( AfxGetMainWnd() );
// Do this in case this object is deleted while we are operating on it.
AddRef();
// If the object has changed, read it.
if ( BChanged() )
{
ReadItem();
} // if: object changed
// Display the property sheet.
try
{
sht.SetReadOnly( bReadOnly );
if ( sht.BInit( this, IimgObjectType() ) )
{
bChanged = ( ( sht.DoModal() == IDOK ) && ! bReadOnly );
} // if: initialized successfully
} // try
catch ( CException * pe )
{
pe->Delete();
} // catch: CException
Release();
return bChanged;
} //*** CCluster::BDisplayProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::SetName
//
// Routine Description:
// Set the name of the cluster.
//
// Arguments:
// pszName [IN] New name of the cluster.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by WriteItem().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::SetName( IN LPCTSTR pszName )
{
Rename( pszName );
} //*** CCluster::SetName()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::SetDescription
//
// Routine Description:
// Set the description in the cluster database.
//
// Arguments:
// pszDesc [IN] Description to set.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by WriteItem().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::SetDescription( IN LPCTSTR pszDesc )
{
ASSERT( Hkey() != NULL );
if ( ( Hkey() != NULL ) && ( m_strDescription != pszDesc ) )
{
WriteValue( CLUSREG_NAME_CLUS_DESC, NULL, pszDesc );
m_strDescription = pszDesc;
} // if: a change occured
} //*** CCluster::SetDescription()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::SetQuorumResource
//
// Routine Description:
// Set the quorum resource for the cluster.
//
// Arguments:
// pszResource [IN] Name of resource to make the quorum resource.
// pszQuorumPath [IN] Path for storing cluster files.
// nMaxLogSize [IN] Maximum size of the quorum log.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException IDS_SET_QUORUM_RESOURCE_ERROR - errors from
// SetClusterQuorumResource().
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::SetQuorumResource(
IN LPCTSTR pszResource,
IN LPCTSTR pszQuorumPath,
IN DWORD nMaxLogSize
)
{
DWORD dwStatus;
CResource * pciRes;
CString strRes( pszResource ); // Required if built non-Unicode
CWaitCursor wc;
ASSERT( pszResource != NULL );
if ( ( StrQuorumResource() != pszResource )
|| ( StrQuorumPath() != pszQuorumPath )
|| ( NMaxQuorumLogSize() != nMaxLogSize ) )
{
// Find the resource.
pciRes = Pdoc()->LpciResources().PciResFromName( pszResource );
ASSERT_VALID( pciRes );
ASSERT( pciRes->Hresource() != NULL );
if ( pciRes->Hresource() != NULL )
{
// Change the quorum resource.
dwStatus = SetClusterQuorumResource( pciRes->Hresource(), pszQuorumPath, nMaxLogSize );
if ( dwStatus != ERROR_SUCCESS )
{
ThrowStaticException( dwStatus, IDS_SET_QUORUM_RESOURCE_ERROR, pciRes->StrName() );
} // if: error setting the quorum resource
m_strQuorumResource = pszResource;
m_strQuorumPath = pszQuorumPath;
m_nMaxQuorumLogSize = nMaxLogSize;
} // if: resource is available
} // if: the quorum resource changed
} //*** CCluster::SetQuorumResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::SetNetworkPriority
//
// Routine Description:
// Set the network priority list.
//
// Arguments:
// rlpci [IN] List of networks in priority order.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by HNETWORK::new.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::SetNetworkPriority( IN const CNetworkList & rlpci )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hcluster() != NULL );
if ( Hcluster() != NULL )
{
BOOL bChanged = TRUE;
// Determine if the list has changed.
if ( rlpci.GetCount() == LpciNetworkPriority().GetCount() )
{
POSITION posOld;
POSITION posNew;
CNetwork * pciOldNet;
CNetwork * pciNewNet;
bChanged = FALSE;
posOld = LpciNetworkPriority().GetHeadPosition();
posNew = rlpci.GetHeadPosition();
while ( posOld != NULL )
{
pciOldNet = (CNetwork *) LpciNetworkPriority().GetNext( posOld );
ASSERT_VALID( pciOldNet );
ASSERT( posNew != NULL );
pciNewNet = (CNetwork *) rlpci.GetNext( posNew );
ASSERT_VALID( pciNewNet );
if ( pciOldNet->StrName() != pciNewNet->StrName() )
{
bChanged = TRUE;
break;
} // if: name is not the same
} // while: more items in the old list
} // if: same number of items in the list
if ( bChanged )
{
HNETWORK * phnetwork = NULL;
try
{
DWORD ipci;
POSITION posPci;
CNetwork * pciNet;
// Allocate an array for all the node handles.
phnetwork = new HNETWORK[ (DWORD) rlpci.GetCount() ];
if ( phnetwork == NULL )
{
ThrowStaticException( GetLastError() );
} // if: error allocating network handle array
// Copy the handle of all the networks in the networks list to the handle aray.
posPci = rlpci.GetHeadPosition();
for ( ipci = 0 ; posPci != NULL ; ipci++ )
{
pciNet = (CNetwork *) rlpci.GetNext( posPci );
ASSERT_VALID( pciNet );
phnetwork[ ipci ] = pciNet->Hnetwork();
} // while: more networks in the list
// Set the property.
dwStatus = SetClusterNetworkPriorityOrder( Hcluster(), (DWORD) rlpci.GetCount(), phnetwork );
if ( dwStatus != ERROR_SUCCESS )
{
ThrowStaticException( dwStatus, IDS_SET_NET_PRIORITY_ERROR, StrName() );
} // if: error setting network priority
// Update the PCI list.
m_plpciNetworkPriority->RemoveAll();
posPci = rlpci.GetHeadPosition();
while ( posPci != NULL )
{
pciNet = (CNetwork *) rlpci.GetNext( posPci );
m_plpciNetworkPriority->AddTail( pciNet );
} // while: more items in the list
} // try
catch ( CException * )
{
delete [] phnetwork;
throw;
} // catch: CException
delete [] phnetwork;
} // if: list changed
} // if: key is available
} //*** CCluster::SetNetworkPriority(CNetworkList*)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::Rename
//
// Routine Description:
// Change the name of the cluster..
//
// Arguments:
// pszName [IN] New name to give to the cluster.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors returned from SetClusterName().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::Rename( IN LPCTSTR pszName )
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT( Hcluster() != NULL );
if ( StrName() != pszName )
{
// Set the name.
dwStatus = SetClusterName( Hcluster(), pszName );
if ( dwStatus != ERROR_SUCCESS )
{
if ( dwStatus == ERROR_RESOURCE_PROPERTIES_STORED )
{
AfxMessageBox( IDS_RESTART_CLUSTER_NAME, MB_OK | MB_ICONEXCLAMATION );
} // if: properties stored but not in use yet
else
{
ThrowStaticException( dwStatus, IDS_RENAME_CLUSTER_ERROR, StrName(), pszName );
} // else: error occurred
} // if: error occurred setting cluster name
m_strName = pszName;
} // if: the name changed
} //*** CCluster::Rename()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::BIsLabelEditValueValid
//
// Routine Description:
// Validate the label edit value as a cluster name
//
// Arguments:
// pszName [IN] New name to give to the cluster.
//
// Return Value:
// TRUE name is valid
// FALSE name is invalid
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CCluster::BIsLabelEditValueValid( IN LPCTSTR pszName )
{
BOOL bSuccess = TRUE;
if ( StrName() != pszName )
{
CLRTL_NAME_STATUS cnStatus;
UINT idsError;
// Validate the name.
if ( ! ClRtlIsNetNameValid( pszName, &cnStatus, FALSE /*CheckIfExists*/ ) )
{
switch ( cnStatus )
{
case NetNameTooLong:
idsError = IDS_INVALID_CLUSTER_NAME_TOO_LONG;
break;
case NetNameInvalidChars:
idsError = IDS_INVALID_CLUSTER_NAME_INVALID_CHARS;
break;
case NetNameInUse:
idsError = IDS_INVALID_CLUSTER_NAME_IN_USE;
break;
case NetNameDNSNonRFCChars:
idsError = IDS_INVALID_CLUSTER_NAME_INVALID_DNS_CHARS;
break;
case NetNameSystemError:
{
DWORD scError = GetLastError();
ThrowStaticException( scError, IDS_ERROR_VALIDATING_NETWORK_NAME, pszName );
}
default:
idsError = IDS_INVALID_CLUSTER_NAME;
break;
} // switch: cnStatus
if ( idsError == IDS_INVALID_CLUSTER_NAME_INVALID_DNS_CHARS )
{
int id = AfxMessageBox(IDS_INVALID_CLUSTER_NAME_INVALID_DNS_CHARS, MB_YESNO | MB_DEFBUTTON2 | MB_ICONEXCLAMATION );
if ( id == IDNO )
{
bSuccess = FALSE;
}
}
else
{
bSuccess = FALSE;
}
} // if: error validating the name
} // if: the name changed
return bSuccess;
} //*** CCluster::BIsLabelEditValueValid()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::OnBeginLabelEdit
//
// Routine Description:
// Prepare an edit control in a view for editing the cluster name.
//
// Arguments:
// pedit [IN OUT] Edit control to prepare.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::OnBeginLabelEdit( IN OUT CEdit * pedit )
{
ASSERT_VALID(pedit);
pedit->SetLimitText( MAX_CLUSTERNAME_LENGTH );
pedit->ModifyStyle( 0 /*dwRemove*/, ES_UPPERCASE | ES_OEMCONVERT /*dwAdd*/ );
} //*** CCluster::OnBeginLabelEdit()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CCluster::UpdateState
//
// Routine Description:
// Update the current state of the item.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CCluster::UpdateState( void )
{
// NOTENOTE: not referneced
//CClusterAdminApp * papp = GetClusterAdminApp();
CString strTitle;
GetClusterAdminApp();
Trace( g_tagCluster, _T("(%s) - Updating state"), StrName() );
// Update the title of the document.
ASSERT_VALID( Pdoc() );
try
{
Pdoc()->UpdateTitle();
} // try
catch ( CException * pe )
{
pe->Delete();
} // catch: CException
// Call the base class method.
CClusterItem::UpdateState();
} //*** CCluster::UpdateState()
Reference in a new issue Copy permalink