archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/base/cluster/admin/cluadmin/group.cpp

2747 lines
80 KiB
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-2002 Microsoft Corporation
//
// Module Name:
// Group.cpp
//
// Abstract:
// Implementation of the CGroup class.
//
// Author:
// David Potter (davidp) May 3, 1996
//
// Revision History:
//
// Notes:
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CluAdmin.h"
#include "ConstDef.h"
#include "Group.h"
#include "ClusItem.inl"
#include "GrpProp.h"
#include "ExcOper.h"
#include "TraceTag.h"
#include "Cluster.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// Global Variables
/////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
CTraceTag g_tagGroup(_T("Document"), _T("GROUP"), 0);
CTraceTag g_tagGroupRead(_T("Document"), _T("GROUP READ"), 0);
CTraceTag g_tagGroupDrag(_T("Drag&Drop"), _T("GROUP DRAG"), 0);
CTraceTag g_tagGroupMenu(_T("Menu"), _T("GROUP MENU"), 0);
CTraceTag g_tagGroupNotify(_T("Notify"), _T("GROUP NOTIFY"), 0);
CTraceTag g_tagGroupRegNotify(_T("Notify"), _T("GROUP REG NOTIFY"), 0);
#endif
/////////////////////////////////////////////////////////////////////////////
// CGroup
/////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CGroup, CClusterItem)
/////////////////////////////////////////////////////////////////////////////
// Message Maps
/////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CGroup, CClusterItem)
//{{AFX_MSG_MAP(CGroup)
ON_UPDATE_COMMAND_UI(ID_FILE_BRING_ONLINE, OnUpdateBringOnline)
ON_UPDATE_COMMAND_UI(ID_FILE_TAKE_OFFLINE, OnUpdateTakeOffline)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP, OnUpdateMoveGroup)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_1, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_DELETE, OnUpdateDelete)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_2, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_3, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_4, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_5, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_6, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_7, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_8, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_9, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_10, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_11, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_12, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_13, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_14, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_15, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_GROUP_16, OnUpdateMoveGroupRest)
ON_UPDATE_COMMAND_UI(ID_FILE_PROPERTIES, OnUpdateProperties)
ON_COMMAND(ID_FILE_BRING_ONLINE, OnCmdBringOnline)
ON_COMMAND(ID_FILE_TAKE_OFFLINE, OnCmdTakeOffline)
ON_COMMAND(ID_FILE_MOVE_GROUP, OnCmdMoveGroup)
ON_COMMAND(ID_FILE_DELETE, OnCmdDelete)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::CGroup
//
// Routine Description:
// Default constructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CGroup::CGroup(void) : CClusterItem(NULL, IDS_ITEMTYPE_GROUP)
{
CommonConstruct();
} //*** CGroup::CGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::CGroup
//
// Routine Description:
// Default constructor.
//
// Arguments:
// bDocObj [IN] TRUE = object is part of the document.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CGroup::CGroup(IN BOOL bDocObj) : CClusterItem(NULL, IDS_ITEMTYPE_GROUP)
{
CommonConstruct();
m_bDocObj = bDocObj;
} //*** CGroup::CGroup(bDocObj)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::CommonConstruct
//
// Routine Description:
// Common construction.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::CommonConstruct(void)
{
m_idmPopupMenu = IDM_GROUP_POPUP;
m_hgroup = NULL;
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;
m_pciOwner = NULL;
m_plpcires = NULL;
m_plpcinodePreferredOwners = NULL;
// Set the object type image.
m_iimgObjectType = GetClusterAdminApp()->Iimg(IMGLI_GROUP);
// Setup the property array.
{
m_rgProps[epropName].Set(CLUSREG_NAME_GRP_NAME, m_strName, m_strName);
m_rgProps[epropDescription].Set(CLUSREG_NAME_GRP_DESC, m_strDescription, m_strDescription);
m_rgProps[epropFailoverThreshold].Set(CLUSREG_NAME_GRP_FAILOVER_THRESHOLD, m_nFailoverThreshold, m_nFailoverThreshold);
m_rgProps[epropFailoverPeriod].Set(CLUSREG_NAME_GRP_FAILOVER_PERIOD, m_nFailoverPeriod, m_nFailoverPeriod);
m_rgProps[epropAutoFailbackType].Set(CLUSREG_NAME_GRP_FAILBACK_TYPE, (DWORD &) m_cgaftAutoFailbackType, (DWORD &) m_cgaftAutoFailbackType);
m_rgProps[epropFailbackWindowStart].Set(CLUSREG_NAME_GRP_FAILBACK_WIN_START, m_nFailbackWindowStart, m_nFailbackWindowStart);
m_rgProps[epropFailbackWindowEnd].Set(CLUSREG_NAME_GRP_FAILBACK_WIN_END, m_nFailbackWindowEnd, m_nFailbackWindowEnd);
} // Setup the property array
#ifdef _CLUADMIN_USE_OLE_
EnableAutomation();
#endif
// To keep the application running as long as an OLE automation
// object is active, the constructor calls AfxOleLockApp.
// AfxOleLockApp();
} //*** CGroup::CommonConstruct()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::~CGroup
//
// Routine Description:
// Destructor.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CGroup::~CGroup(void)
{
// Cleanup this object.
Cleanup();
delete m_plpcires;
delete m_plpcinodePreferredOwners;
// Close the group handle.
if (Hgroup() != NULL)
{
CloseClusterGroup(Hgroup());
}
// To terminate the application when all objects created with
// with OLE automation, the destructor calls AfxOleUnlockApp.
// AfxOleUnlockApp();
} //*** CGroup::~CGroup
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::Cleanup
//
// Routine Description:
// Cleanup the item.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::Cleanup(void)
{
// Delete the resource list.
if (m_plpcires != NULL)
{
m_plpcires->RemoveAll();
}
// Delete the PreferredOwners list.
if (m_plpcinodePreferredOwners != NULL)
{
m_plpcinodePreferredOwners->RemoveAll();
}
// If we are active on a node, remove ourselves from that active list.
if (PciOwner() != NULL)
{
if (BDocObj())
{
PciOwner()->RemoveActiveGroup(this);
}
PciOwner()->Release();
m_pciOwner = NULL;
} // if: there is an owner
// Remove the item from the group list.
if (BDocObj())
{
POSITION posPci;
posPci = Pdoc()->LpciGroups().Find(this);
if (posPci != NULL)
{
Pdoc()->LpciGroups().RemoveAt(posPci);
} // if: found in the document's list
} // if: this is a document object
} //*** CGroup::Cleanup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::Create
//
// Routine Description:
// Create a group.
//
// Arguments:
// pdoc [IN OUT] Document to which this item belongs.
// lpszName [IN] Name of the group.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CreateClusterResource.
// Any exceptions thrown by CResource::Init(), CResourceList::new(),
// or CNodeList::new().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::Create(IN OUT CClusterDoc * pdoc, IN LPCTSTR lpszName)
{
DWORD dwStatus;
HGROUP hgroup;
CString strName(lpszName); // Required if built non-Unicode
CWaitCursor wc;
ASSERT(Hgroup() == NULL);
ASSERT(Hkey() == NULL);
ASSERT_VALID(pdoc);
ASSERT(lpszName != NULL);
// Create the group.
hgroup = CreateClusterGroup(pdoc->Hcluster(), strName);
if (hgroup == NULL)
{
dwStatus = GetLastError();
ThrowStaticException(dwStatus, IDS_CREATE_GROUP_ERROR, lpszName);
} // if: error creating the cluster group
CloseClusterGroup(hgroup);
// Open the group.
Init(pdoc, lpszName);
} //*** CGroup::Create()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::Init
//
// Routine Description:
// Initialize the item.
//
// Arguments:
// pdoc [IN OUT] Document to which this item belongs.
// lpszName [IN] Name of the item.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from OpenClusterGroup() or GetClusterGroupKey().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::Init(IN OUT CClusterDoc * pdoc, IN LPCTSTR lpszName)
{
DWORD dwStatus = ERROR_SUCCESS;
LONG lResult;
CString strName(lpszName); // Required if built non-Unicode
CWaitCursor wc;
ASSERT(Hgroup() == NULL);
ASSERT(Hkey() == NULL);
// Call the base class method.
CClusterItem::Init(pdoc, lpszName);
try
{
// Open the group.
m_hgroup = OpenClusterGroup(Hcluster(), strName);
if (Hgroup() == NULL)
{
dwStatus = GetLastError();
ThrowStaticException(dwStatus, IDS_OPEN_GROUP_ERROR, lpszName);
} // if: error opening the cluster group
// Get the group registry key.
m_hkey = GetClusterGroupKey(Hgroup(), MAXIMUM_ALLOWED);
if (Hkey() == NULL)
{
ThrowStaticException(GetLastError(), IDS_GET_GROUP_KEY_ERROR, lpszName);
}
if (BDocObj())
{
ASSERT(Pcnk() != NULL);
Trace(g_tagClusItemNotify, _T("CGroup::Init() - Registering for group notifications (%08.8x) for '%s'"), Pcnk(), StrName());
// Register for group notifications.
lResult = RegisterClusterNotify(
GetClusterAdminApp()->HchangeNotifyPort(),
(CLUSTER_CHANGE_GROUP_STATE
| CLUSTER_CHANGE_GROUP_DELETED
| CLUSTER_CHANGE_GROUP_PROPERTY),
Hgroup(),
(DWORD_PTR) Pcnk()
);
if (lResult != ERROR_SUCCESS)
{
dwStatus = lResult;
ThrowStaticException(dwStatus, IDS_GROUP_NOTIF_REG_ERROR, lpszName);
} // if: error registering for group notifications
// Register for registry notifications.
if (Hkey() != NULL)
{
lResult = RegisterClusterNotify(
GetClusterAdminApp()->HchangeNotifyPort(),
(CLUSTER_CHANGE_REGISTRY_NAME
| CLUSTER_CHANGE_REGISTRY_ATTRIBUTES
| CLUSTER_CHANGE_REGISTRY_VALUE
| CLUSTER_CHANGE_REGISTRY_SUBTREE),
Hkey(),
(DWORD_PTR) Pcnk()
);
if (lResult != ERROR_SUCCESS)
{
dwStatus = lResult;
ThrowStaticException(dwStatus, IDS_GROUP_NOTIF_REG_ERROR, lpszName);
} // if: error registering for registry notifications
} // if: there is a key
} // if: document object
// Allocate lists.
m_plpcires = new CResourceList;
if ( m_plpcires == NULL )
{
AfxThrowMemoryException();
} // if: error allocating resource list
m_plpcinodePreferredOwners = new CNodeList;
if ( m_plpcinodePreferredOwners == NULL )
{
AfxThrowMemoryException();
} // if: error allocating preferred owners list
// Read the initial state.
UpdateState();
} // try
catch (CException *)
{
if (Hkey() != NULL)
{
ClusterRegCloseKey(Hkey());
m_hkey = NULL;
} // if: registry key opened
if (Hgroup() != NULL)
{
CloseClusterGroup(Hgroup());
m_hgroup = NULL;
} // if: group opened
m_bReadOnly = TRUE;
throw;
} // catch: CException
} //*** CGroup::Init()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::ReadItem
//
// Routine Description:
// Read the item parameters from the cluster database.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from CClusterItem::DwReadValue() or
// CGroup::ConstructList().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::ReadItem(void)
{
DWORD dwStatus;
DWORD dwRetStatus = ERROR_SUCCESS;
CWaitCursor wc;
ASSERT_VALID(this);
if (Hgroup() != NULL)
{
m_rgProps[epropDescription].m_value.pstr = &m_strDescription;
m_rgProps[epropFailoverThreshold].m_value.pdw = &m_nFailoverThreshold;
m_rgProps[epropFailoverPeriod].m_value.pdw = &m_nFailoverPeriod;
m_rgProps[epropAutoFailbackType].m_value.pdw = (DWORD *) &m_cgaftAutoFailbackType;
m_rgProps[epropFailbackWindowStart].m_value.pdw = &m_nFailbackWindowStart;
m_rgProps[epropFailbackWindowEnd].m_value.pdw = &m_nFailbackWindowEnd;
// Call the base class method.
CClusterItem::ReadItem();
Trace(g_tagGroupRead, _T("ReadItem() - Name before reading properties: '%s'"), StrName());
// Read and parse the common properties.
{
CClusPropList cpl;
dwStatus = cpl.ScGetGroupProperties(
Hgroup(),
CLUSCTL_GROUP_GET_COMMON_PROPERTIES
);
if (dwStatus == ERROR_SUCCESS)
{
dwStatus = DwParseProperties(cpl);
}
if (dwStatus != ERROR_SUCCESS)
{
dwRetStatus = dwStatus;
}
} // Read and parse the common properties
// Read and parse the read-only common properties.
if (dwRetStatus == ERROR_SUCCESS)
{
CClusPropList cpl;
dwStatus = cpl.ScGetGroupProperties(
Hgroup(),
CLUSCTL_GROUP_GET_RO_COMMON_PROPERTIES
);
if (dwStatus == ERROR_SUCCESS)
{
dwStatus = DwParseProperties(cpl);
}
if (dwStatus != ERROR_SUCCESS)
{
dwRetStatus = dwStatus;
}
} // if: no error yet
Trace(g_tagGroupRead, _T("ReadItem() - Name after reading properties: '%s'"), StrName());
// Read extension lists.
ReadExtensions();
if (dwRetStatus == ERROR_SUCCESS)
{
// Read the list of preferred owners.
ASSERT(m_plpcinodePreferredOwners != NULL);
ConstructList(*m_plpcinodePreferredOwners, CLUSTER_GROUP_ENUM_NODES);
} // if: no error reading properties
} // if: group is available
// Read the initial state.
UpdateState();
// Construct the list of resources contained in the group.
// ASSERT(m_plpcires != NULL);
// ConstructList(*m_plpcires, CLUSTER_GROUP_ENUM_CONTAINS);
// If any errors occurred, throw an exception.
if (dwRetStatus != ERROR_SUCCESS)
{
m_bReadOnly = TRUE;
if ( (dwRetStatus != ERROR_GROUP_NOT_AVAILABLE)
&& (dwRetStatus != ERROR_KEY_DELETED))
{
ThrowStaticException(dwRetStatus, IDS_READ_GROUP_PROPS_ERROR, StrName());
}
} // if: error reading properties
MarkAsChanged(FALSE);
} //*** CGroup::ReadItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::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 * CGroup::PlstrExtensions(void) const
{
return &Pdoc()->PciCluster()->LstrGroupExtensions();
} //*** CGroup::PlstrExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::ReadExtensions
//
// Routine Description:
// Read extension lists.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::ReadExtensions(void)
{
} //*** CGroup::ReadExtensions()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::ConstructList
//
// Routine Description:
// Construct a list of node items which are enumerable on the group.
//
// Arguments:
// rlpci [OUT] List to fill.
// dwType [IN] Type of objects.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from ClusterGroupOpenEnum or ClusterGroupEnum.
// Any exceptions thrown by new or CList::AddTail.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::ConstructList(
OUT CNodeList & rlpci,
IN DWORD dwType
)
{
DWORD dwStatus;
HGROUPENUM hgrpenum;
int ienum;
LPWSTR pwszName = NULL;
DWORD cchName;
DWORD cchmacName;
DWORD dwRetType;
CClusterNode * pciNode;
CWaitCursor wc;
ASSERT_VALID(Pdoc());
ASSERT(Hgroup() != NULL);
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Constructing node list"), Pdoc()->StrNode(), StrName(), this);
// Remove the previous contents of the list.
rlpci.RemoveAll();
if (Hgroup() != NULL)
{
// Open the enumeration.
hgrpenum = ClusterGroupOpenEnum(Hgroup(), dwType);
if (hgrpenum == NULL)
{
ThrowStaticException(GetLastError(), IDS_ENUM_PREFERRED_OWNERS_ERROR, StrName());
}
try
{
// Allocate a name buffer.
cchmacName = 128;
pwszName = new WCHAR[cchmacName];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating name buffer
// Loop through the enumeration and add each node to the list.
for (ienum = 0 ; ; ienum++)
{
// Get the next item in the enumeration.
cchName = cchmacName;
dwStatus = ClusterGroupEnum(hgrpenum, ienum, &dwRetType, pwszName, &cchName);
if (dwStatus == ERROR_MORE_DATA)
{
delete [] pwszName;
cchmacName = ++cchName;
pwszName = new WCHAR[cchmacName];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating name buffer
dwStatus = ClusterGroupEnum(hgrpenum, ienum, &dwRetType, pwszName, &cchName);
} // if: name buffer was too small
if (dwStatus == ERROR_NO_MORE_ITEMS)
{
break;
}
else if (dwStatus != ERROR_SUCCESS)
{
ThrowStaticException(dwStatus, IDS_ENUM_PREFERRED_OWNERS_ERROR, StrName());
}
ASSERT(dwRetType == dwType);
// Find the item in the list of nodes on the document.
pciNode = Pdoc()->LpciNodes().PciNodeFromName(pwszName);
ASSERT_VALID(pciNode);
// Add the node to the list.
if (pciNode != NULL)
{
rlpci.AddTail(pciNode);
} // if: found node in list
} // for: each item in the group
delete [] pwszName;
ClusterGroupCloseEnum(hgrpenum);
} // try
catch (CException *)
{
delete [] pwszName;
ClusterGroupCloseEnum(hgrpenum);
throw;
} // catch: any exception
} // if: resource is available
} //*** CGroup::ConstructList(CNodeList&)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::ConstructList
//
// Routine Description:
// Construct a list of resource items which are enumerable on the group.
//
// Arguments:
// rlpci [OUT] List to fill.
// dwType [IN] Type of objects.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors from ClusterGroupOpenEnum or ClusterGroupEnum.
// Any exceptions thrown by new or CList::AddTail.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::ConstructList(
OUT CResourceList & rlpci,
IN DWORD dwType
)
{
DWORD dwStatus;
HGROUPENUM hgrpenum;
int ienum;
LPWSTR pwszName = NULL;
DWORD cchName;
DWORD cchmacName;
DWORD dwRetType;
CResource * pciRes;
CWaitCursor wc;
ASSERT_VALID(Pdoc());
ASSERT(Hgroup() != NULL);
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Constructing resource list"), Pdoc()->StrNode(), StrName(), this);
// Remove the previous contents of the list.
rlpci.RemoveAll();
if (Hgroup() != NULL)
{
// Open the enumeration.
hgrpenum = ClusterGroupOpenEnum(Hgroup(), dwType);
if (hgrpenum == NULL)
{
ThrowStaticException(GetLastError(), IDS_ENUM_CONTAINS_ERROR, StrName());
}
try
{
// Allocate a name buffer.
cchmacName = 128;
pwszName = new WCHAR[cchmacName];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating name buffer
// Loop through the enumeration and add each resource to the list.
for (ienum = 0 ; ; ienum++)
{
// Get the next item in the enumeration.
cchName = cchmacName;
dwStatus = ClusterGroupEnum(hgrpenum, ienum, &dwRetType, pwszName, &cchName);
if (dwStatus == ERROR_MORE_DATA)
{
delete [] pwszName;
cchmacName = ++cchName;
pwszName = new WCHAR[cchmacName];
if ( pwszName == NULL )
{
AfxThrowMemoryException();
} // if: error allocating name buffer
dwStatus = ClusterGroupEnum(hgrpenum, ienum, &dwRetType, pwszName, &cchName);
} // if: name buffer was too small
if (dwStatus == ERROR_NO_MORE_ITEMS)
{
break;
}
else if (dwStatus != ERROR_SUCCESS)
{
ThrowStaticException(dwStatus, IDS_ENUM_CONTAINS_ERROR, StrName());
}
ASSERT(dwRetType == dwType);
// Find the item in the list of resources on the document.
pciRes = Pdoc()->LpciResources().PciResFromName(pwszName);
ASSERT_VALID(pciRes);
// Add the resource to the list.
if (pciRes != NULL)
{
rlpci.AddTail(pciRes);
} // if: found resource in list
} // for: each item in the group
delete [] pwszName;
ClusterGroupCloseEnum(hgrpenum);
} // try
catch (CException *)
{
delete [] pwszName;
ClusterGroupCloseEnum(hgrpenum);
throw;
} // catch: any exception
} // if: resource is available
} //*** CGroup::ConstructList(CResourceList&)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::ConstructPossibleOwnersList
//
// Routine Description:
// Construct the list of nodes on which this group can run.
//
// Arguments:
// rlpciNodes [OUT] List of nodes on which group can run.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::ConstructPossibleOwnersList(OUT CNodeList & rlpciNodes)
{
POSITION posNode;
POSITION posRes;
POSITION posResNode;
POSITION posCurResNode = NULL;
CClusterNode * pciNode;
CClusterNode * pciResNode;
CResource * pciRes;
CWaitCursor wc;
ASSERT_VALID(Pdoc());
// Remove the previous contents of the list.
rlpciNodes.RemoveAll();
posNode = Pdoc()->LpciNodes().GetHeadPosition();
while (posNode != NULL)
{
pciNode = (CClusterNode *) Pdoc()->LpciNodes().GetNext(posNode);
ASSERT_VALID(pciNode);
if (Lpcires().GetCount() != 0)
{
posRes = Lpcires().GetHeadPosition();
while (posRes != NULL)
{
pciRes = (CResource *) Lpcires().GetNext(posRes);
ASSERT_VALID(pciRes);
posResNode = pciRes->LpcinodePossibleOwners().GetHeadPosition();
while (posResNode != NULL)
{
posCurResNode = posResNode;
pciResNode = (CClusterNode *) pciRes->LpcinodePossibleOwners().GetNext(posResNode);
ASSERT_VALID(pciResNode);
if (pciNode->StrName() == pciResNode->StrName())
{
break;
}
posCurResNode = NULL;
} // while: more possible owners in the list
// If the node wasn't found, the group can't run here.
if (posCurResNode == NULL)
{
break;
}
} // while: more resources in the list
} // if: group has resources
// If the node was found on a resource, the group can run here.
if (posCurResNode != NULL)
{
rlpciNodes.AddTail(pciNode);
} // if: node found on a resource
} // while: more nodes in the document
} //*** CGroup::ConstructPossibleOwnersList()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::DeleteGroup
//
// Routine Description:
// Delete the group.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Any errors from DeleteClusterGroup.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::DeleteGroup(void)
{
CWaitCursor wc;
if (Hgroup() != NULL)
{
DWORD dwStatus;
CWaitCursor wc;
// Delete the group itself.
dwStatus = DeleteClusterGroup(Hgroup());
if (dwStatus != ERROR_SUCCESS)
{
ThrowStaticException(dwStatus, IDS_DELETE_GROUP_ERROR, StrName());
}
UpdateState();
} // if: group has been opened/created
} //*** CGroup::DeleteGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::AddResource
//
// Routine Description:
// Add a resource to the list of resources contained in this group.
//
// Arguments:
// pciRes [IN OUT] New resource.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::AddResource(IN OUT CResource * pciRes)
{
POSITION posPci;
ASSERT_VALID(pciRes);
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Adding resource '%s'"), Pdoc()->StrNode(), StrName(), this, pciRes->StrName());
// Make sure the resource is not already in the list.
VERIFY((posPci = Lpcires().Find(pciRes)) == NULL);
if (posPci == NULL)
{
POSITION posPtiGroup;
CTreeItem * ptiGroup;
// Loop through each tree item to update the group's list of resources.
posPtiGroup = LptiBackPointers().GetHeadPosition();
while (posPtiGroup != NULL)
{
ptiGroup = LptiBackPointers().GetNext(posPtiGroup);
ASSERT_VALID(ptiGroup);
// Add the new resource.
VERIFY(ptiGroup->PliAddChild(pciRes) != NULL);
} // while: more tree items for this group
m_plpcires->AddTail(pciRes);
} // if: resource not in the list yet
} //*** CGroup::AddResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::RemoveResource
//
// Routine Description:
// Remove a resource from the list of resources contained in this group.
//
// Arguments:
// pciRes [IN OUT] Resource that no is no longer contained in this group.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::RemoveResource(IN OUT CResource * pciRes)
{
POSITION posPci;
ASSERT_VALID(pciRes);
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Removing resource '%s'"), Pdoc()->StrNode(), StrName(), this, pciRes->StrName());
// Make sure the resource is in the list.
posPci = Lpcires().Find(pciRes);
if (posPci != NULL)
{
POSITION posPtiGroup;
CTreeItem * ptiGroup;
// Loop through each tree item to update the group's list of resources.
posPtiGroup = LptiBackPointers().GetHeadPosition();
while (posPtiGroup != NULL)
{
ptiGroup = LptiBackPointers().GetNext(posPtiGroup);
ASSERT_VALID(ptiGroup);
// Remove the resource.
ptiGroup->RemoveChild(pciRes);
} // while: more tree items for this group
m_plpcires->RemoveAt(posPci);
} // if: resource in the list
} //*** CGroup::RemoveResource()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::SetName
//
// Routine Description:
// Set the name of this group.
//
// Arguments:
// pszName [IN] New name of the group.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException IDS_RENAME_GROUP_ERROR - errors from
// SetClusterGroupName().
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::SetName(IN LPCTSTR pszName)
{
Rename(pszName);
} //*** CGroup::SetName()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::SetPreferredOwners
//
// Routine Description:
// Set the list of preferred owners of this group in the cluster database.
//
// Arguments:
// rlpci [IN] List of preferred owners (nodes).
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by CStringList::AddTail() or
// CNodeList::AddTail().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::SetPreferredOwners(IN const CNodeList & rlpci)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT(Hgroup() != NULL);
if (Hgroup() != NULL)
{
BOOL bChanged = TRUE;
// Determine if the list has changed.
if (rlpci.GetCount() == LpcinodePreferredOwners().GetCount())
{
POSITION posOld;
POSITION posNew;
CClusterNode * pciOldNode;
CClusterNode * pciNewNode;
bChanged = FALSE;
posOld = LpcinodePreferredOwners().GetHeadPosition();
posNew = rlpci.GetHeadPosition();
while (posOld != NULL)
{
pciOldNode = (CClusterNode *) LpcinodePreferredOwners().GetNext(posOld);
ASSERT_VALID(pciOldNode);
ASSERT(posNew != NULL);
pciNewNode = (CClusterNode *) rlpci.GetNext(posNew);
ASSERT_VALID(pciNewNode);
if (pciOldNode->StrName() != pciNewNode->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)
{
HNODE * phnode = NULL;
try
{
DWORD ipci;
POSITION posPci;
CClusterNode * pciNode;
// Allocate an array for all the node handles.
phnode = new HNODE[(DWORD)rlpci.GetCount()];
if (phnode == NULL)
{
ThrowStaticException(GetLastError());
} // if: error allocating the node handle array
// Copy the handle of all the nodes in the node list to the handle aray.
posPci = rlpci.GetHeadPosition();
for (ipci = 0 ; posPci != NULL ; ipci++)
{
pciNode = (CClusterNode *) rlpci.GetNext(posPci);
ASSERT_VALID(pciNode);
phnode[ipci] = pciNode->Hnode();
} // while: more nodes in the list
// Set the property.
dwStatus = SetClusterGroupNodeList(Hgroup(), (DWORD)rlpci.GetCount(), phnode);
if (dwStatus != ERROR_SUCCESS)
{
ThrowStaticException(dwStatus, IDS_SET_GROUP_NODE_LIST_ERROR, StrName());
}
// Update the PCI list.
m_plpcinodePreferredOwners->RemoveAll();
posPci = rlpci.GetHeadPosition();
while (posPci != NULL)
{
pciNode = (CClusterNode *) rlpci.GetNext(posPci);
m_plpcinodePreferredOwners->AddTail(pciNode);
} // while: more items in the list
} // try
catch (CException *)
{
delete [] phnode;
throw;
} // catch: CException
delete [] phnode;
} // if: list changed
} // if: key is available
} //*** CGroup::SetPreferredOwners(CNodeList*)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::SetCommonProperties
//
// Routine Description:
// Set the common properties for this resource in the cluster database.
//
// Arguments:
// rstrDesc [IN] Description string.
// nThreshold [IN] Failover threshold.
// nPeriod [IN] Failover period.
// cgaft [IN] Auto Failback Type.
// nStart [IN] Start of failback window.
// nEnd [IN] End of failback window.
// bValidateOnly [IN] Only validate the data.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// Any exceptions thrown by CClusterItem::SetCommonProperties().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::SetCommonProperties(
IN const CString & rstrDesc,
IN DWORD nThreshold,
IN DWORD nPeriod,
IN CGAFT cgaft,
IN DWORD nStart,
IN DWORD nEnd,
IN BOOL bValidateOnly
)
{
CNTException nte(ERROR_SUCCESS, 0, NULL, NULL, FALSE /*bAutoDelete*/);
m_rgProps[epropDescription].m_value.pstr = (CString *) &rstrDesc;
m_rgProps[epropFailoverThreshold].m_value.pdw = &nThreshold;
m_rgProps[epropFailoverPeriod].m_value.pdw = &nPeriod;
m_rgProps[epropAutoFailbackType].m_value.pdw = (DWORD *) &cgaft;
m_rgProps[epropFailbackWindowStart].m_value.pdw = &nStart;
m_rgProps[epropFailbackWindowEnd].m_value.pdw = &nEnd;
try
{
CClusterItem::SetCommonProperties(bValidateOnly);
} // try
catch (CNTException * pnte)
{
nte.SetOperation(
pnte->Sc(),
pnte->IdsOperation(),
pnte->PszOperArg1(),
pnte->PszOperArg2()
);
} // catch: CNTException
m_rgProps[epropDescription].m_value.pstr = &m_strDescription;
m_rgProps[epropFailoverThreshold].m_value.pdw = &m_nFailoverThreshold;
m_rgProps[epropFailoverPeriod].m_value.pdw = &m_nFailoverPeriod;
m_rgProps[epropAutoFailbackType].m_value.pdw = (DWORD *) &m_cgaftAutoFailbackType;
m_rgProps[epropFailbackWindowStart].m_value.pdw = &m_nFailbackWindowStart;
m_rgProps[epropFailbackWindowEnd].m_value.pdw = &m_nFailbackWindowEnd;
if (nte.Sc() != ERROR_SUCCESS)
ThrowStaticException(
nte.Sc(),
nte.IdsOperation(),
nte.PszOperArg1(),
nte.PszOperArg2()
);
} //*** CGroup::SetCommonProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::DwSetCommonProperties
//
// Routine Description:
// Set the common properties for this group in the cluster database.
//
// Arguments:
// rcpl [IN] Property list to set.
// bValidateOnly [IN] Only validate the data.
//
// Return Value:
// Any status returned by ClusterGroupControl().
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CGroup::DwSetCommonProperties(
IN const CClusPropList & rcpl,
IN BOOL bValidateOnly
)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT(Hgroup());
if ((rcpl.PbPropList() != NULL) && (rcpl.CbPropList() > 0))
{
DWORD cbProps;
DWORD dwControl;
if (bValidateOnly)
{
dwControl = CLUSCTL_GROUP_VALIDATE_COMMON_PROPERTIES;
}
else
{
dwControl = CLUSCTL_GROUP_SET_COMMON_PROPERTIES;
}
// Set private properties.
dwStatus = ClusterGroupControl(
Hgroup(),
NULL, // hNode
dwControl,
rcpl.PbPropList(),
static_cast< DWORD >( rcpl.CbPropList() ),
NULL, // lpOutBuffer
0, // nOutBufferSize
&cbProps
);
} // if: there is data to set
else
{
dwStatus = ERROR_SUCCESS;
}
return dwStatus;
} //*** CGroup::DwSetCommonProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::UpdateState
//
// Routine Description:
// Update the current state of the item.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::UpdateState(void)
{
CClusterAdminApp * papp = GetClusterAdminApp();
WCHAR * pwszOwner = NULL;
// This should probably be limited by MAX_COMPUTERNAME_LENGTH (31) for now, but
// if/when we go to DNS names we'll need at most 255 bytes for the name.
WCHAR rgwszOwner[256];
DWORD cchOwner = sizeof(rgwszOwner) / sizeof(WCHAR);
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Updating state"), Pdoc()->StrNode(), StrName(), this);
// Get the current state of the group.
if (Hgroup() == NULL)
{
m_cgs = ClusterGroupStateUnknown;
}
else
{
CWaitCursor wc;
m_cgs = GetClusterGroupState(Hgroup(), rgwszOwner, &cchOwner);
pwszOwner = rgwszOwner;
} // else: group is available
// Save the current state image index.
switch (Cgs())
{
case ClusterGroupStateUnknown:
m_iimgState = papp->Iimg(IMGLI_GROUP_UNKNOWN);
pwszOwner = NULL;
break;
case ClusterGroupOnline:
m_iimgState = papp->Iimg(IMGLI_GROUP);
break;
case ClusterGroupPartialOnline:
m_iimgState = papp->Iimg(IMGLI_GROUP_PARTIALLY_ONLINE);
break;
case ClusterGroupPending:
m_iimgState = papp->Iimg(IMGLI_GROUP_PENDING);
break;
case ClusterGroupOffline:
m_iimgState = papp->Iimg(IMGLI_GROUP_OFFLINE);
break;
case ClusterGroupFailed:
m_iimgState = papp->Iimg(IMGLI_GROUP_FAILED);
break;
default:
Trace(g_tagGroup, _T("(%s) (%s (%x)) - UpdateState: Unknown state '%d' for group '%s'"), Pdoc()->StrNode(), StrName(), this, Cgs(), StrName());
m_iimgState = (UINT) -1;
break;
} // switch: Cgs()
SetOwnerState(pwszOwner);
// Update the state of all resources owned by this group.
if (m_plpcires != NULL)
{
POSITION posRes;
CResource * pciRes;
posRes = Lpcires().GetHeadPosition();
while (posRes != NULL)
{
pciRes = (CResource *) Lpcires().GetNext(posRes);
ASSERT_VALID(pciRes);
pciRes->UpdateState();
} // while: more items in the list
} // if: resource list exists
// Call the base class method.
CClusterItem::UpdateState();
} //*** CGroup::UpdateState()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::SetOwnerState
//
// Routine Description:
// Set a new owner for this group.
//
// Arguments:
// pszNewOwner [IN] Name of the new owner.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::SetOwnerState(IN LPCTSTR pszNewOwner)
{
CClusterNode * pciOldOwner = PciOwner();
CClusterNode * pciNewOwner;
Trace(g_tagGroup, _T("(%s) (%s (%x)) - Setting owner to '%s'"), Pdoc()->StrNode(), StrName(), this, pszNewOwner);
if (pszNewOwner == NULL)
{
pciNewOwner = NULL;
}
else
{
pciNewOwner = Pdoc()->LpciNodes().PciNodeFromName(pszNewOwner);
}
if (pciNewOwner != pciOldOwner)
{
#ifdef _DEBUG
if (g_tagGroup.BAny())
{
CString strMsg;
CString strMsg2;
strMsg.Format(_T("(%s) (%s (%x)) - Changing owner from "), Pdoc()->StrNode(), StrName(), this);
if (pciOldOwner == NULL)
{
strMsg += _T("nothing ");
}
else
{
strMsg2.Format(_T("'%s' "), pciOldOwner->StrName());
strMsg += strMsg2;
} // else: previous owner
if (pciNewOwner == NULL)
{
strMsg += _T("to nothing");
}
else
{
strMsg2.Format(_T("to '%s'"), pciNewOwner->StrName());
strMsg += strMsg2;
} // else: new owner
Trace(g_tagGroup, strMsg);
} // if: trace tag turned on
#endif
m_strOwner = pszNewOwner;
m_pciOwner = pciNewOwner;
// Update reference counts.
if (pciOldOwner != NULL)
{
pciOldOwner->Release();
}
if (pciNewOwner != NULL)
{
pciNewOwner->AddRef();
}
if (BDocObj())
{
if (pciOldOwner != NULL)
{
pciOldOwner->RemoveActiveGroup(this);
}
if (pciNewOwner != NULL)
{
pciNewOwner->AddActiveGroup(this);
}
} // if: this is a document object
} // if: owner changed
else if ((pszNewOwner != NULL) && (StrOwner() != pszNewOwner))
{
m_strOwner = pszNewOwner;
}
} //*** CGroup::SetOwnerState()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnFinalRelease
//
// Routine Description:
// Called when the last OLE reference to or from the object is released.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnFinalRelease(void)
{
// When the last reference for an automation object is released
// OnFinalRelease is called. The base class will automatically
// deletes the object. Add additional cleanup required for your
// object before calling the base class.
CClusterItem::OnFinalRelease();
} //*** CGroup::OnFinalRelease()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::BGetColumnData
//
// Routine Description:
// Returns a string with the column data.
//
// Arguments:
// colid [IN] Column ID.
// rstrText [OUT] String in which to return the text for the column.
//
// Return Value:
// TRUE Column data returned.
// FALSE Column ID not recognized.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::BGetColumnData(IN COLID colid, OUT CString & rstrText)
{
BOOL bSuccess;
switch (colid)
{
case IDS_COLTEXT_OWNER:
rstrText = StrOwner();
bSuccess = TRUE;
break;
case IDS_COLTEXT_STATE:
GetStateName(rstrText);
bSuccess = TRUE;
break;
default:
bSuccess = CClusterItem::BGetColumnData(colid, rstrText);
break;
} // switch: colid
return bSuccess;
} //*** CGroup::BGetColumnData()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::GetTreeName
//
// Routine Description:
// Returns a string to be used in a tree control.
//
// Arguments:
// rstrName [OUT] String in which to return the name.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
#ifdef _DISPLAY_STATE_TEXT_IN_TREE
void CGroup::GetTreeName(OUT CString & rstrName) const
{
CString strState;
GetStateName(strState);
rstrName.Format(_T("%s (%s)"), StrName(), strState);
} //*** CGroup::GetTreeName()
#endif
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::GetStateName
//
// Routine Description:
// Returns a string with the name of the current state.
//
// Arguments:
// rstrState [OUT] String in which to return the name of the current state.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::GetStateName(OUT CString & rstrState) const
{
switch (Cgs())
{
case ClusterGroupStateUnknown:
rstrState.LoadString(IDS_UNKNOWN);
break;
case ClusterGroupOnline:
rstrState.LoadString(IDS_ONLINE);
break;
case ClusterGroupPartialOnline:
rstrState.LoadString(IDS_PARTIAL_ONLINE);
break;
case ClusterGroupPending:
rstrState.LoadString(IDS_PENDING);
break;
case ClusterGroupOffline:
rstrState.LoadString(IDS_OFFLINE);
break;
case ClusterGroupFailed:
rstrState.LoadString(IDS_FAILED);
break;
default:
rstrState.Empty();
break;
} // switch: Cgs()
} //*** CGroup::GetStateName()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::BCanBeEdited
//
// Routine Description:
// Determines if the resource can be renamed.
//
// Arguments:
// None.
//
// Return Value:
// TRUE Resource can be renamed.
// FALSE Resource cannot be renamed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::BCanBeEdited(void) const
{
BOOL bCanBeEdited;
if ( (Cgs() == ClusterGroupStateUnknown)
|| BReadOnly())
{
bCanBeEdited = FALSE;
}
else
{
bCanBeEdited = TRUE;
}
return bCanBeEdited;
} //*** CGroup::BCanBeEdited()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::Rename
//
// Routine Description:
// Rename the group.
//
// Arguments:
// pszName [IN] New name to give to the group.
//
// Return Value:
// None.
//
// Exceptions Thrown:
// CNTException Errors returned from SetClusterGroupName().
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::Rename(IN LPCTSTR pszName)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT(Hgroup() != NULL);
if (StrName() != pszName)
{
dwStatus = SetClusterGroupName(Hgroup(), pszName);
if (dwStatus != ERROR_SUCCESS)
{
ThrowStaticException(dwStatus, IDS_RENAME_GROUP_ERROR, StrName(), pszName);
}
m_strName = pszName;
} // if: the name changed
} //*** CGroup::Rename()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::Move
//
// Routine Description:
// Move the group to another node.
//
// Arguments:
// pciNode [IN] Node to move the group to.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::Move(IN const CClusterNode * pciNode)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT_VALID(pciNode);
// Do this in case this object is deleted while we are operating on it.
AddRef();
if (pciNode->StrName() == StrOwner())
{
CString strMsg;
strMsg.FormatMessage(IDS_CANT_MOVE_GROUP_TO_SAME_NODE, StrName(), StrOwner());
AfxMessageBox(strMsg, MB_OK | MB_ICONSTOP);
} // if: trying to move to the same node
else
{
// Move the group.
dwStatus = MoveClusterGroup(Hgroup(), pciNode->Hnode());
if ( (dwStatus != ERROR_SUCCESS)
&& (dwStatus != ERROR_IO_PENDING))
{
CNTException nte(dwStatus, IDS_MOVE_GROUP_ERROR, StrName(), NULL, FALSE /*bAutoDelete*/);
nte.ReportError();
} // if: error moving the group
} // else: trying to move to a different node
Release();
} //*** CGroup::Move()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::BCanBeDropTarget
//
// Routine Description:
// Determine if the specified item can be dropped on this item.
//
// Arguments:
// pci [IN OUT] Item to be dropped on this item.
//
// Return Value:
// TRUE Can be drop target.
// FALSE Can NOT be drop target.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::BCanBeDropTarget(IN const CClusterItem * pci) const
{
BOOL bCan;
// This group can be a drop target only if the specified item
// is a resource and it is not already a member of this group.
if (pci->IdsType() == IDS_ITEMTYPE_RESOURCE)
{
CResource * pciRes = (CResource *) pci;
ASSERT_KINDOF(CResource, pciRes);
if (pciRes->StrGroup() != StrName())
{
bCan = TRUE;
}
else
{
bCan = FALSE;
}
Trace(g_tagGroupDrag, _T("(%s) BCanBeDropTarget() - Dragging resource '%s' (%x) (group = '%s' (%x)) over group '%s' (%x)"), Pdoc()->StrNode(), pciRes->StrName(), pciRes, pciRes->StrGroup(), pciRes->PciGroup(), StrName(), this);
} // if: resource item
else
{
bCan = FALSE;
}
return bCan;
} //*** CGroup::BCanBeDropTarget()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::DropItem
//
// Routine Description:
// Process an item being dropped on this item.
//
// Arguments:
// pci [IN OUT] Item dropped on this item.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::DropItem(IN OUT CClusterItem * pci)
{
if (BCanBeDropTarget(pci))
{
POSITION pos;
UINT imenu;
UINT idMenu;
CGroup * pciGroup;
CResource * pciRes;
// Calculate the ID of this group.
pos = Pdoc()->LpciGroups().GetHeadPosition();
for (imenu = 0, idMenu = ID_FILE_MOVE_RESOURCE_1
; pos != NULL
; idMenu++)
{
pciGroup = (CGroup *) Pdoc()->LpciGroups().GetNext(pos);
ASSERT_VALID(pciGroup);
if (pciGroup == this)
{
break;
}
} // for: each group
ASSERT(imenu < (UINT) Pdoc()->LpciGroups().GetCount());
// Change the group of the specified resource.
pciRes = (CResource *) pci;
ASSERT_KINDOF(CResource, pci);
ASSERT_VALID(pciRes);
pciRes->OnCmdMoveResource(idMenu);
} // if: item can be dropped on this item
else if (pci->IdsType() == IDS_ITEMTYPE_RESOURCE)
{
CString strMsg;
#ifdef _DEBUG
CResource * pciRes = (CResource *) pci;
ASSERT_KINDOF(CResource, pci);
ASSERT_VALID(pciRes);
ASSERT(pciRes->StrGroup() == StrName());
#endif // _DEBUG
strMsg.FormatMessage(
IDS_CANT_MOVE_RES_TO_GROUP,
pci->StrName(),
StrName()
);
AfxMessageBox(strMsg, MB_OK | MB_ICONSTOP);
} // else if: dropped item is a resource
else
{
CClusterItem::DropItem(pci);
}
} //*** CGroup::DropItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdMsg
//
// Routine Description:
// Processes command messages.
//
// Arguments:
// nID [IN] Command ID.
// nCode [IN] Notification code.
// pExtra [IN OUT] Used according to the value of nCode.
// pHandlerInfo [OUT] ???
//
// Return Value:
// TRUE Message has been handled.
// FALSE Message has NOT been handled.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::OnCmdMsg(
UINT nID,
int nCode,
void * pExtra,
AFX_CMDHANDLERINFO * pHandlerInfo
)
{
BOOL bHandled = FALSE;
// If this is a MOVE_GROUP command, process it here.
if ((ID_FILE_MOVE_GROUP_1 <= nID) && (nID <= ID_FILE_MOVE_GROUP_16))
{
Trace(g_tagGroup, _T("(%s) OnCmdMsg() %s (%x) - ID = %d, code = %d"), Pdoc()->StrNode(), StrName(), this, nID, nCode);
if (nCode == 0)
{
OnCmdMoveGroup(nID);
bHandled = TRUE;
} // if: code = 0
} // if: move resource
if (!bHandled)
{
bHandled = CClusterItem::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
}
return bHandled;
} //*** CGroup::OnCmdMsg()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateBringOnline
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_BRING_ONLINE
// should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnUpdateBringOnline(CCmdUI * pCmdUI)
{
if ( (Cgs() != ClusterGroupOnline)
&& (Cgs() != ClusterGroupPending)
&& (Cgs() != ClusterGroupStateUnknown))
{
pCmdUI->Enable(TRUE);
}
else
{
pCmdUI->Enable(FALSE);
}
} //*** CGroup::OnUpdateBringOnline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateTakeOffline
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_TAKE_OFFLINE
// should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnUpdateTakeOffline(CCmdUI * pCmdUI)
{
if ( (Cgs() == ClusterGroupOnline)
|| (Cgs() == ClusterGroupPartialOnline))
{
pCmdUI->Enable(TRUE);
}
else
{
pCmdUI->Enable(FALSE);
}
} //*** CGroup::OnUpdateTakeOffline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateMoveGroup
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_MOVE_GROUP
// should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnUpdateMoveGroup(CCmdUI * pCmdUI)
{
if ( (pCmdUI->m_pSubMenu == NULL)
&& (pCmdUI->m_pParentMenu == NULL))
{
if ( (Cgs() == ClusterGroupStateUnknown)
|| (Cgs() == ClusterGroupPending)
|| (Pdoc()->LpciNodes().GetCount() < 2))
{
pCmdUI->Enable(FALSE);
}
else
{
pCmdUI->Enable(TRUE);
}
} // if: nested menu is being displayed
else
{
BOOL bEnabled;
CString strMenuName;
if (pCmdUI->m_pMenu != NULL)
{
pCmdUI->m_pMenu->GetMenuString(0, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) pMenu(0) = '%s'"), Pdoc()->StrNode(), strMenuName);
pCmdUI->m_pMenu->GetMenuString(pCmdUI->m_nIndex, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) pMenu(%d) = '%s'"), Pdoc()->StrNode(), pCmdUI->m_nIndex, strMenuName);
} // if: main menu
if (pCmdUI->m_pSubMenu != NULL)
{
pCmdUI->m_pSubMenu->GetMenuString(0, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) pSubMenu(0) = '%s'"), Pdoc()->StrNode(), strMenuName);
pCmdUI->m_pSubMenu->GetMenuString(pCmdUI->m_nIndex, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) pSubMenu(%d) = '%s'"), Pdoc()->StrNode(), pCmdUI->m_nIndex, strMenuName);
} // if: submenu
// Handle the menu item based on whether it is on the main menu
// or on the submenu.
if (pCmdUI->m_pSubMenu == NULL)
{
bEnabled = OnUpdateMoveGroupItem(pCmdUI);
pCmdUI->Enable(bEnabled);
} // if: on the main menu
else
{
bEnabled = OnUpdateMoveGroupSubMenu(pCmdUI);
} // else: on the submenu
// Enable or disable the Move menu.
pCmdUI->m_pMenu->EnableMenuItem(
pCmdUI->m_nIndex,
MF_BYPOSITION
| (bEnabled ? MF_ENABLED : MF_GRAYED)
);
} // else: top-level menu is being displayed
} //*** CGroup::OnUpdateMoveGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateMoveGroupItem
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_MOVE_GROUP
// that are not popups should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// TRUE Item should be enabled.
// FALSE Item should be disabled.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::OnUpdateMoveGroupItem(CCmdUI * pCmdUI)
{
BOOL bEnabled;
// If there are more than two nodes, make the menu item a submenu.
if ( (Cgs() == ClusterGroupStateUnknown)
|| (Cgs() == ClusterGroupPending)
|| (Pdoc()->LpciNodes().GetCount() < 2))
{
bEnabled = FALSE;
}
else if (Pdoc()->LpciNodes().GetCount() == 2)
{
bEnabled = TRUE;
}
else
{
UINT idMenu;
POSITION pos;
CClusterNode * pciNode;
CString strMenuName;
CMenu menuMove;
CMenu * pmenu = pCmdUI->m_pMenu;
// Load the Move submenu.
VERIFY(menuMove.LoadMenu(IDM_MOVE_GROUP) != 0);
ASSERT(menuMove.GetMenuItemCount() == 2);
// Add all the nodes in the cluster to the end of the menu.
pos = Pdoc()->LpciNodes().GetHeadPosition();
for (idMenu = ID_FILE_MOVE_GROUP_1
; pos != NULL
; idMenu++)
{
pciNode = (CClusterNode *) Pdoc()->LpciNodes().GetNext(pos);
ASSERT_VALID(pciNode);
VERIFY(menuMove.AppendMenu(
MF_BYPOSITION | MF_STRING,
idMenu,
pciNode->StrName()
));
} // for: each node
// Get the name of the menu.
pmenu->GetMenuString(pCmdUI->m_nIndex, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) Making item '%s' a submenu"), Pdoc()->StrNode(), strMenuName);
// Modify this menu item.
VERIFY(pmenu->ModifyMenu(
pCmdUI->m_nIndex,
MF_BYPOSITION | MF_STRING | MF_POPUP,
(UINT_PTR) menuMove.m_hMenu,
strMenuName
));
// Detach the menu from the class since we don't own it anymore.
menuMove.Detach();
bEnabled = TRUE;
} // else: more than two nodes in the cluster
return bEnabled;
} //*** CGroup::OnUpdateMoveGroupItem()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateMoveGroupSubMenu
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_MOVE_GROUP
// that are on popups should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// TRUE Item should be enabled.
// FALSE Item should be disabled.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CGroup::OnUpdateMoveGroupSubMenu(CCmdUI * pCmdUI)
{
BOOL bEnabled;
// If there are not more than two nodes, make the menu item a normal item.
if (Pdoc()->LpciNodes().GetCount() > 2)
{
bEnabled = TRUE;
}
else
{
CString strMenuName;
CMenu * pmenu = pCmdUI->m_pMenu;
// Get the name of the menu.
pmenu->GetMenuString(pCmdUI->m_nIndex, strMenuName, MF_BYPOSITION);
Trace(g_tagGroupMenu, _T("(%s) Making item '%s' a non-submenu"), Pdoc()->StrNode(), strMenuName);
// Modify this menu item.
// We should be able to just modify the menu, but for some reason
// this doesn't work. So, instead, we will remove the previous item
// and add a new item.
#ifdef NEVER
VERIFY(pmenu->ModifyMenu(
pCmdUI->m_nIndex,
MF_BYPOSITION | MF_STRING,
ID_FILE_MOVE_GROUP,
strMenuName
));
#else
VERIFY(pmenu->DeleteMenu(pCmdUI->m_nIndex, MF_BYPOSITION));
VERIFY(pmenu->InsertMenu(
pCmdUI->m_nIndex,
MF_BYPOSITION | MF_STRING,
ID_FILE_MOVE_GROUP,
strMenuName
));
#endif
if ( (Cgs() == ClusterGroupStateUnknown)
|| (Cgs() == ClusterGroupPending)
|| (Pdoc()->LpciNodes().GetCount() < 2))
{
bEnabled = FALSE;
}
else
{
bEnabled = TRUE;
}
AfxGetMainWnd()->DrawMenuBar();
} // else: not more than two nodes in the cluster
return bEnabled;
} //*** CGroup::OnUpdateMoveGroupSubMenu()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateMoveGroupRest
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_MOVE_GROUP_1
// through ID_FILE_MOVE_GROUP_16 should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnUpdateMoveGroupRest(CCmdUI * pCmdUI)
{
if ( (Cgs() == ClusterGroupStateUnknown)
|| (Cgs() == ClusterGroupPending))
{
pCmdUI->Enable(FALSE);
}
else
{
pCmdUI->Enable(TRUE);
}
} //*** CGroup::OnUpdateMoveGroupRest()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnUpdateDelete
//
// Routine Description:
// Determines whether menu items corresponding to ID_FILE_DELETE
// should be enabled or not.
//
// Arguments:
// pCmdUI [IN OUT] Command routing object.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnUpdateDelete(CCmdUI * pCmdUI)
{
if ( (Cgs() != ClusterGroupStateUnknown)
&& (Cgs() != ClusterGroupPending)
&& Lpcires().IsEmpty())
{
pCmdUI->Enable(TRUE);
}
else
{
pCmdUI->Enable(FALSE);
}
} //*** CGroup::OnUpdateDelete()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdBringOnline
//
// Routine Description:
// Processes the ID_FILE_BRING_ONLINE menu command.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnCmdBringOnline(void)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT(Hgroup() != NULL);
// Do this in case this object is deleted while we are operating on it.
AddRef();
dwStatus = OnlineClusterGroup(Hgroup(), NULL);
if ( (dwStatus != ERROR_SUCCESS)
&& (dwStatus != ERROR_IO_PENDING))
{
CNTException nte(dwStatus, IDS_BRING_GROUP_ONLINE_ERROR, StrName(), NULL, FALSE /*bAutoDelete*/);
nte.ReportError();
} // if: error bringing the group online
UpdateState();
Release();
} //*** CGroup::OnCmdBringOnline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdTakeOffline
//
// Routine Description:
// Processes the ID_FILE_TAKE_OFFLINE menu command.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnCmdTakeOffline(void)
{
DWORD dwStatus;
CWaitCursor wc;
ASSERT(Hgroup() != NULL);
// Do this in case this object is deleted while we are operating on it.
AddRef();
dwStatus = OfflineClusterGroup(Hgroup());
if ( (dwStatus != ERROR_SUCCESS)
&& (dwStatus != ERROR_IO_PENDING))
{
CNTException nte(dwStatus, IDS_TAKE_GROUP_OFFLINE_ERROR, StrName(), NULL, FALSE /*bAUtoDelete*/);
nte.ReportError();
} // if: error taking the group offline
UpdateState();
Release();
} //*** CGroup::OnCmdTakeOffline()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdMoveGroup
//
// Routine Description:
// Processes the ID_FILE_MOVE_GROUP menu command.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnCmdMoveGroup(void)
{
OnCmdMoveGroup((UINT) -1);
} //*** CGroup::OnCmdMoveGroup()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdMoveGroup
//
// Routine Description:
// Processes the ID_FILE_MOVE_GROUP_1 through ID_FILE_MOVE_GROUP_16 menu
// commands.
//
// Arguments:
// nID [IN] Command ID.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnCmdMoveGroup(IN UINT nID)
{
DWORD dwStatus;
HNODE hnode;
CClusterNode * pciNode;
CWaitCursor wc;
ASSERT(Hgroup() != NULL);
// Do this in case this object is deleted while we are operating on it.
AddRef();
// Get the handle of the node to move the group to.
if ((int) nID >= 0)
{
int ipci;
ipci = (int) (nID - ID_FILE_MOVE_GROUP_1);
ASSERT(ipci < Pdoc()->LpciNodes().GetCount());
if (ipci < Pdoc()->LpciNodes().GetCount())
{
POSITION pos;
// Get the node.
pos = Pdoc()->LpciNodes().FindIndex(ipci);
ASSERT(pos);
pciNode = (CClusterNode *) Pdoc()->LpciNodes().GetAt(pos);
ASSERT_VALID(pciNode);
hnode = pciNode->Hnode();
} // if: valid node index
else
{
goto Cleanup;
}
} // if: non-default ID specified
else
{
hnode = NULL;
pciNode = NULL;
} // else: default ID specified
// Move the group.
dwStatus = MoveClusterGroup(Hgroup(), hnode);
if ( (dwStatus != ERROR_SUCCESS)
&& (dwStatus != ERROR_IO_PENDING))
{
CNTException nte(dwStatus, IDS_MOVE_GROUP_ERROR, StrName(), NULL, FALSE /*bAutoDelete*/);
nte.ReportError();
} // if: error moving the group
UpdateState();
Cleanup:
Release();
} //*** CGroup::OnCmdMoveGroup(nID)
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnCmdDelete
//
// Routine Description:
// Processes the ID_FILE_DELETE menu command.
//
// Arguments:
// None.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CGroup::OnCmdDelete(void)
{
ASSERT(Hgroup() != NULL);
// Do this in case this object is deleted while we are operating on it.
AddRef();
// Verify that the user really wants to delete this resource.
{
CString strMsg;
strMsg.FormatMessage(IDS_VERIFY_DELETE_GROUP, StrName());
if (AfxMessageBox(strMsg, MB_YESNO | MB_ICONEXCLAMATION) == IDNO)
{
goto Cleanup;
}
} // Verify that the user really wants to delete this resource
try
{
DeleteGroup();
} // try
catch (CNTException * pnte)
{
if (pnte->Sc() != ERROR_GROUP_NOT_AVAILABLE)
pnte->ReportError();
pnte->Delete();
} // catch: CNTException
catch (CException * pe)
{
pe->ReportError();
pe->Delete();
} // catch: CException
Cleanup:
Release();
} //*** CGroup::OnCmdDelete()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::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 CGroup::OnUpdateProperties(CCmdUI * pCmdUI)
{
pCmdUI->Enable(TRUE);
} //*** CGroup::OnUpdateProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::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 CGroup::BDisplayProperties(IN BOOL bReadOnly)
{
BOOL bChanged = FALSE;
CGroupPropSheet 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();
}
// Display the property sheet.
try
{
sht.SetReadOnly(bReadOnly);
if (sht.BInit(this, IimgObjectType()))
{
bChanged = ((sht.DoModal() == IDOK) && !bReadOnly);
}
} // try
catch (CException * pe)
{
pe->Delete();
} // catch: CException
Release();
return bChanged;
} //*** CGroup::BDisplayProperties()
/////////////////////////////////////////////////////////////////////////////
//++
//
// CGroup::OnClusterNotify
//
// Routine Description:
// Handler for the WM_CAM_CLUSTER_NOTIFY message.
// Processes cluster notifications for this object.
//
// Arguments:
// pnotify [IN OUT] Object describing the notification.
//
// Return Value:
// Value returned from the application method.
//
//--
/////////////////////////////////////////////////////////////////////////////
LRESULT CGroup::OnClusterNotify(IN OUT CClusterNotify * pnotify)
{
ASSERT(pnotify != NULL);
ASSERT_VALID(this);
try
{
switch (pnotify->m_dwFilterType)
{
case CLUSTER_CHANGE_GROUP_STATE:
Trace(g_tagGroupNotify, _T("(%s) - Group '%s' (%x) state changed (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName);
UpdateState();
break;
case CLUSTER_CHANGE_GROUP_DELETED:
Trace(g_tagGroupNotify, _T("(%s) - Group '%s' (%x) deleted (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName);
if (Pdoc()->BClusterAvailable())
Delete();
break;
case CLUSTER_CHANGE_GROUP_PROPERTY:
Trace(g_tagGroupNotify, _T("(%s) - Group '%s' (%x) properties changed (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName);
if (Pdoc()->BClusterAvailable())
ReadItem();
break;
case CLUSTER_CHANGE_REGISTRY_NAME:
Trace(g_tagGroupRegNotify, _T("(%s) - Registry namespace '%s' changed (%s %s (%x))"), Pdoc()->StrNode(), pnotify->m_strName, StrType(), StrName(), this);
MarkAsChanged();
break;
case CLUSTER_CHANGE_REGISTRY_ATTRIBUTES:
Trace(g_tagGroupRegNotify, _T("(%s) - Registry attributes for '%s' changed (%s %s (%x))"), Pdoc()->StrNode(), pnotify->m_strName, StrType(), StrName());
MarkAsChanged();
break;
case CLUSTER_CHANGE_REGISTRY_VALUE:
Trace(g_tagGroupRegNotify, _T("(%s) - Registry value at '%s' changed (%s %s (%x))"), Pdoc()->StrNode(), pnotify->m_strName, StrType(), StrName(), this);
MarkAsChanged();
break;
default:
Trace(g_tagGroupNotify, _T("(%s) - Unknown group notification (%x) for '%s' (%x) (%s)"), Pdoc()->StrNode(), pnotify->m_dwFilterType, StrName(), this, pnotify->m_strName);
} // switch: dwFilterType
} // try
catch (CException * pe)
{
// Don't display anything on notification errors.
// If it's really a problem, the user will see it when
// refreshing the view.
//pe->ReportError();
pe->Delete();
} // catch: CException
delete pnotify;
return 0;
} //*** CGroup::OnClusterNotify()
//*************************************************************************//
/////////////////////////////////////////////////////////////////////////////
// Global Functions
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//++
//
// DeleteAllItemData
//
// Routine Description:
// Deletes all item data in a CList.
//
// Arguments:
// rlp [IN OUT] List whose data is to be deleted.
//
// Return Value:
// None.
//
//--
/////////////////////////////////////////////////////////////////////////////
#ifdef NEVER
void DeleteAllItemData(IN OUT CGroupList & rlp)
{
POSITION pos;
CGroup * pci;
// Delete all the items in the list.
pos = rlp.GetHeadPosition();
while (pos != NULL)
{
pci = rlp.GetNext(pos);
ASSERT_VALID(pci);
// Trace(g_tagClusItemDelete, _T("DeleteAllItemData(rlpcigrp) - Deleting group cluster item '%s' (%x)"), pci->StrName(), pci);
pci->Delete();
} // while: more items in the list
} //*** DeleteAllItemData()
#endif