///////////////////////////////////////////////////////////////////////////// // // Copyright (c) 1996-2002 Microsoft Corporation // // Module Name: // Res.cpp // // Abstract: // Implementation of the CResource class. // // Author: // David Potter (davidp) May 6, 1996 // // Revision History: // // Notes: // ///////////////////////////////////////////////////////////////////////////// #include "StdAfx.h" #include "CluAdmin.h" #include "ConstDef.h" #include "Res.h" #include "ClusItem.inl" #include "ResProp.h" #include "ExcOper.h" #include "TraceTag.h" #include "Cluster.h" #include "DelRes.h" #include "MoveRes.h" #include "WaitDlg.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif ///////////////////////////////////////////////////////////////////////////// // Global Variables ///////////////////////////////////////////////////////////////////////////// #ifdef _DEBUG CTraceTag g_tagResource(_T("Document"), _T("RESOURCE"), 0); CTraceTag g_tagResNotify(_T("Notify"), _T("RES NOTIFY"), 0); CTraceTag g_tagResRegNotify(_T("Notify"), _T("RES REG NOTIFY"), 0); #endif ///////////////////////////////////////////////////////////////////////////// // CResource ///////////////////////////////////////////////////////////////////////////// IMPLEMENT_DYNCREATE(CResource, CClusterItem) ///////////////////////////////////////////////////////////////////////////// // Message Maps BEGIN_MESSAGE_MAP(CResource, CClusterItem) //{{AFX_MSG_MAP(CResource) ON_UPDATE_COMMAND_UI(ID_FILE_BRING_ONLINE, OnUpdateBringOnline) ON_UPDATE_COMMAND_UI(ID_FILE_TAKE_OFFLINE, OnUpdateTakeOffline) ON_UPDATE_COMMAND_UI(ID_FILE_INITIATE_FAILURE, OnUpdateInitiateFailure) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_1, OnUpdateMoveResource1) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_2, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_3, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_4, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_5, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_6, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_7, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_8, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_9, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_10, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_11, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_12, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_13, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_14, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_15, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_16, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_17, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_18, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_19, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_MOVE_RESOURCE_20, OnUpdateMoveResourceRest) ON_UPDATE_COMMAND_UI(ID_FILE_DELETE, OnUpdateDelete) 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_INITIATE_FAILURE, OnCmdInitiateFailure) ON_COMMAND(ID_FILE_DELETE, OnCmdDelete) //}}AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CResource // // Routine Description: // Default constructor. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// CResource::CResource(void) : CClusterItem(NULL, IDS_ITEMTYPE_RESOURCE) { CommonConstruct(); } //*** CResoruce::CResource() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CResource // // Routine Description: // Constructor. // // Arguments: // bDocObj [IN] TRUE = object is part of the document. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// CResource::CResource(IN BOOL bDocObj) : CClusterItem(NULL, IDS_ITEMTYPE_RESOURCE) { CommonConstruct(); m_bDocObj = bDocObj; } //*** CResource::CResource(bDocObj) ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CommonConstruct // // Routine Description: // Common construction. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::CommonConstruct(void) { m_idmPopupMenu = IDM_RESOURCE_POPUP; m_bInitializing = FALSE; m_bDeleting = FALSE; m_hresource = NULL; m_bSeparateMonitor = FALSE; m_nLooksAlive = CLUSTER_RESOURCE_DEFAULT_LOOKS_ALIVE; m_nIsAlive = CLUSTER_RESOURCE_DEFAULT_IS_ALIVE; m_crraRestartAction = CLUSTER_RESOURCE_DEFAULT_RESTART_ACTION; m_nRestartThreshold = CLUSTER_RESOURCE_DEFAULT_RESTART_THRESHOLD; m_nRestartPeriod = CLUSTER_RESOURCE_DEFAULT_RESTART_PERIOD; m_nPendingTimeout = CLUSTER_RESOURCE_DEFAULT_PENDING_TIMEOUT; m_rciResClassInfo.rc = CLUS_RESCLASS_UNKNOWN; m_rciResClassInfo.SubClass = 0; m_dwCharacteristics = CLUS_CHAR_UNKNOWN; m_dwFlags = 0; m_pciOwner = NULL; m_pciGroup = NULL; m_pciResourceType = NULL; m_pcrd = NULL; m_plpciresDependencies = NULL; m_plpcinodePossibleOwners = NULL; // Set the object type image. m_iimgObjectType = GetClusterAdminApp()->Iimg(IMGLI_RES); // Setup the property array. { m_rgProps[epropName].Set(CLUSREG_NAME_RES_NAME, m_strName, m_strName); m_rgProps[epropType].Set(CLUSREG_NAME_RES_TYPE, m_strResourceType, m_strResourceType); m_rgProps[epropDescription].Set(CLUSREG_NAME_RES_DESC, m_strDescription, m_strDescription); m_rgProps[epropSeparateMonitor].Set(CLUSREG_NAME_RES_SEPARATE_MONITOR, m_bSeparateMonitor, m_bSeparateMonitor); m_rgProps[epropLooksAlive].Set(CLUSREG_NAME_RES_LOOKS_ALIVE, m_nLooksAlive, m_nLooksAlive); m_rgProps[epropIsAlive].Set(CLUSREG_NAME_RES_IS_ALIVE, m_nIsAlive, m_nIsAlive); m_rgProps[epropRestartAction].Set(CLUSREG_NAME_RES_RESTART_ACTION, (DWORD &) m_crraRestartAction, (DWORD &) m_crraRestartAction); m_rgProps[epropRestartThreshold].Set(CLUSREG_NAME_RES_RESTART_THRESHOLD, m_nRestartThreshold, m_nRestartThreshold); m_rgProps[epropRestartPeriod].Set(CLUSREG_NAME_RES_RESTART_PERIOD, m_nRestartPeriod, m_nRestartPeriod); m_rgProps[epropPendingTimeout].Set(CLUSREG_NAME_RES_PENDING_TIMEOUT, m_nPendingTimeout, m_nPendingTimeout); } // 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(); } //*** CResource::CommonConstruct() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::~CResource // // Routine Description: // Destructor. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// CResource::~CResource(void) { // Cleanup this object. Cleanup(); delete m_plpciresDependencies; delete m_plpcinodePossibleOwners; delete [] (PBYTE) m_pcrd; // Close the resource handle. if (Hresource() != NULL) { CloseClusterResource(Hresource()); m_hresource = NULL; } // if: resource is open // To terminate the application when all objects created with // with OLE automation, the destructor calls AfxOleUnlockApp. // AfxOleUnlockApp(); } //*** CResource::~CResource ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::Cleanup // // Routine Description: // Cleanup the item. // // Arguments: // None. // // Return Value: // None. // // Exceptions Thrown: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::Cleanup(void) { // Delete the Dependencies list. if (m_plpciresDependencies != NULL) { m_plpciresDependencies->RemoveAll(); } // Delete the PossibleOwners list. if (m_plpcinodePossibleOwners != NULL) { m_plpcinodePossibleOwners->RemoveAll(); } // If we are active on a node, remove ourselves from that active list. if (PciOwner() != NULL) { if (BDocObj()) { PciOwner()->RemoveActiveResource(this); } PciOwner()->Release(); m_pciOwner = NULL; } // if: there is an owner // Remove ourselves from the group's list. if (PciGroup() != NULL) { if (BDocObj()) { PciGroup()->RemoveResource(this); } PciGroup()->Release(); m_pciGroup = NULL; } // if: there is a group // Update the reference count to the resource type if (PciResourceType() != NULL) { PciResourceType()->Release(); m_pciResourceType = NULL; } // if: there is a resource type // Remove the item from the resource list. if (BDocObj()) { POSITION posPci; posPci = Pdoc()->LpciResources().Find(this); if (posPci != NULL) { Pdoc()->LpciResources().RemoveAt(posPci); } // if: found in the document's list } // if: this is a document object } //*** CResource::Cleanup() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::Create // // Routine Description: // Create a resource. // // Arguments: // pdoc [IN OUT] Document to which this item belongs. // lpszName [IN] Name of the resource. // lpszType [IN] Type of the resource. // lpszGroup [IN] Group in which to create the resource. // bSeparateMonitor [IN] TRUE = run resource in separate monitor. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from CreateClusterResource. // Any exceptions thrown by CResource::Init(), CResourceList::new(), // or CNodeList::new(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::Create( IN OUT CClusterDoc * pdoc, IN LPCTSTR lpszName, IN LPCTSTR lpszType, IN LPCTSTR lpszGroup, IN BOOL bSeparateMonitor ) { DWORD dwStatus; DWORD dwFlags; HRESOURCE hresource; CGroup * pciGroup; CString strName(lpszName); // Required if built non-Unicode CString strType(lpszType); // Required if built non-Unicode CWaitCursor wc; ASSERT(Hresource() == NULL); ASSERT(Hkey() == NULL); ASSERT_VALID(pdoc); ASSERT(lpszName != NULL); ASSERT(lpszType != NULL); ASSERT(lpszGroup != NULL); // Find the specified group. pciGroup = pdoc->LpciGroups().PciGroupFromName(lpszGroup); ASSERT_VALID(pciGroup); // Set the flags. if (bSeparateMonitor) { dwFlags = CLUSTER_RESOURCE_SEPARATE_MONITOR; } else { dwFlags = 0; } // Create the resource. hresource = CreateClusterResource(pciGroup->Hgroup(), strName, strType, dwFlags); if (hresource == NULL) { dwStatus = GetLastError(); ThrowStaticException(dwStatus, IDS_CREATE_RESOURCE_ERROR, lpszName); } // if: error creating the cluster resource CloseClusterResource(hresource); // Open the resource. Init(pdoc, lpszName); } //*** CResource::Create() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 OpenClusterResource or GetClusterResourceKey. // Any exceptions thrown by new. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::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(Hresource() == NULL); ASSERT(Hkey() == NULL); // Call the base class method. CClusterItem::Init(pdoc, lpszName); try { // Open the resource. m_hresource = OpenClusterResource(Hcluster(), strName); if (Hresource() == NULL) { dwStatus = GetLastError(); ThrowStaticException(dwStatus, IDS_OPEN_RESOURCE_ERROR, lpszName); } // if: error opening the cluster resource // Get the resource registry key. m_hkey = GetClusterResourceKey(Hresource(), MAXIMUM_ALLOWED); if (Hkey() == NULL) { ThrowStaticException(GetLastError(), IDS_GET_RESOURCE_KEY_ERROR, lpszName); } if (BDocObj()) { ASSERT(Pcnk() != NULL); Trace(g_tagClusItemNotify, _T("CResource::Init() - Registering for resource notifications (%08.8x) for '%s'"), Pcnk(), StrName()); // Register for resource notifications. lResult = RegisterClusterNotify( GetClusterAdminApp()->HchangeNotifyPort(), (CLUSTER_CHANGE_RESOURCE_STATE | CLUSTER_CHANGE_RESOURCE_DELETED | CLUSTER_CHANGE_RESOURCE_PROPERTY), Hresource(), (DWORD_PTR) Pcnk() ); if (lResult != ERROR_SUCCESS) { dwStatus = lResult; ThrowStaticException(dwStatus, IDS_RES_NOTIF_REG_ERROR, lpszName); } // if: error registering for resource 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_RES_NOTIF_REG_ERROR, lpszName); } // if: error registering for registry notifications } // if: there is a key } // if: document object // Allocate lists. m_plpciresDependencies = new CResourceList; if ( m_plpciresDependencies == NULL ) { AfxThrowMemoryException(); } // if: error allocating the dependency list m_plpcinodePossibleOwners = new CNodeList; if ( m_plpcinodePossibleOwners == NULL ) { AfxThrowMemoryException(); } // if: error allocating the possible owners list // Read the initial state. UpdateState(); } // try catch (CException *) { if (Hkey() != NULL) { ClusterRegCloseKey(Hkey()); m_hkey = NULL; } // if: registry key opened if (Hresource() != NULL) { CloseClusterResource(Hresource()); m_hresource = NULL; } // if: resource opened m_bReadOnly = TRUE; throw; } // catch: CException } //*** CResource::Init() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::ReadItem // // Routine Description: // Read the item parameters from the cluster database. // // Arguments: // None. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from CClusterItem::DwReadValue(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::ReadItem(void) { DWORD dwStatus; DWORD dwRetStatus = ERROR_SUCCESS; CWaitCursor wc; ASSERT_VALID(this); m_bInitializing = FALSE; if (Hresource() != NULL) { m_rgProps[epropDescription].m_value.pstr = &m_strDescription; m_rgProps[epropSeparateMonitor].m_value.pb = &m_bSeparateMonitor; m_rgProps[epropLooksAlive].m_value.pdw = &m_nLooksAlive; m_rgProps[epropIsAlive].m_value.pdw = &m_nIsAlive; m_rgProps[epropRestartAction].m_value.pdw = (DWORD *) &m_crraRestartAction; m_rgProps[epropRestartThreshold].m_value.pdw = &m_nRestartThreshold; m_rgProps[epropRestartPeriod].m_value.pdw = &m_nRestartPeriod; m_rgProps[epropPendingTimeout].m_value.pdw = &m_nPendingTimeout; // Call the base class method. Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Calling CClusterItem::ReadItem()"), Pdoc()->StrNode(), StrName(), this ); CClusterItem::ReadItem(); // Read and parse the common properties. { CClusPropList cpl; Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Getting common properties"), Pdoc()->StrNode(), StrName(), this ); dwStatus = cpl.ScGetResourceProperties( Hresource(), CLUSCTL_RESOURCE_GET_COMMON_PROPERTIES ); if (dwStatus == ERROR_SUCCESS) { Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Parsing common properties"), Pdoc()->StrNode(), StrName(), this ); dwStatus = DwParseProperties(cpl); } // if: properties read successfully if (dwStatus != ERROR_SUCCESS) { Trace( g_tagError, _T("(%s) (%s (%x)) - CResource::ReadItem() - Error 0x%08.8x getting or parsing common properties"), Pdoc()->StrNode(), StrName(), this, dwStatus ); dwRetStatus = dwStatus; } // if: error reading or parsing properties } // Read and parse the common properties // Read and parse the read-only common properties. if (dwRetStatus == ERROR_SUCCESS) { CClusPropList cpl; Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Getting common RO properties"), Pdoc()->StrNode(), StrName(), this ); dwStatus = cpl.ScGetResourceProperties( Hresource(), CLUSCTL_RESOURCE_GET_RO_COMMON_PROPERTIES ); if (dwStatus == ERROR_SUCCESS) { Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Parsing common RO properties"), Pdoc()->StrNode(), StrName(), this ); dwStatus = DwParseProperties(cpl); } // if: properties read successfully if (dwStatus != ERROR_SUCCESS) { Trace( g_tagError, _T("(%s) (%s (%x)) - CResource::ReadItem() - Error 0x%08.8x getting or parsing common RO properties"), Pdoc()->StrNode(), StrName(), this, dwStatus ); dwRetStatus = dwStatus; } // if: error reading or parsing properties } // if: no error yet // Find the resource type object. { CResourceType * pciResType; pciResType = Pdoc()->LpciResourceTypes().PciResTypeFromName(StrResourceType()); if (m_pciResourceType != NULL) { m_pciResourceType->Release(); } m_pciResourceType = pciResType; if (m_pciResourceType != NULL) { m_pciResourceType->AddRef(); } } // Find the resource type object // Read the required dependencies. if (dwRetStatus == ERROR_SUCCESS) { PCLUSPROP_REQUIRED_DEPENDENCY pcrd; Trace( g_tagResource, _T("(%s) (%s (%x)) - CResource::ReadItem() - Getting required dependencies"), Pdoc()->StrNode(), StrName(), this ); dwStatus = DwResourceControlGet(CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES, (PBYTE *) &pcrd); if (dwStatus != ERROR_SUCCESS) { Trace( g_tagError, _T("(%s) (%s (%x)) - CResource::ReadItem() - Error 0x%08.8x getting required dependencies"), Pdoc()->StrNode(), StrName(), this, dwStatus ); dwRetStatus = dwStatus; } // if: error getting required dependencies delete [] (PBYTE) m_pcrd; m_pcrd = pcrd; } // if: no error yet // Read the resource class. if (dwRetStatus == ERROR_SUCCESS) { DWORD cbReturned; dwStatus = ClusterResourceControl( Hresource(), NULL, CLUSCTL_RESOURCE_GET_CLASS_INFO, NULL, NULL, &m_rciResClassInfo, sizeof(m_rciResClassInfo), &cbReturned ); if (dwStatus != ERROR_SUCCESS) { dwRetStatus = dwStatus; } else { ASSERT(cbReturned == sizeof(m_rciResClassInfo)); } // else: data retrieved successfully } // if: no error yet // Read the characteristics. if (dwRetStatus == ERROR_SUCCESS) { DWORD cbReturned; dwStatus = ClusterResourceControl( Hresource(), NULL, CLUSCTL_RESOURCE_GET_CHARACTERISTICS, NULL, NULL, &m_dwCharacteristics, sizeof(m_dwCharacteristics), &cbReturned ); if (dwStatus != ERROR_SUCCESS) { dwRetStatus = dwStatus; } else { ASSERT(cbReturned == sizeof(m_dwCharacteristics)); } // else: data retrieved successfully } // if: no error yet // Read the flags. if (dwRetStatus == ERROR_SUCCESS) { DWORD cbReturned; dwStatus = ClusterResourceControl( Hresource(), NULL, CLUSCTL_RESOURCE_GET_FLAGS, NULL, NULL, &m_dwFlags, sizeof(m_dwFlags), &cbReturned ); if (dwStatus != ERROR_SUCCESS) { dwRetStatus = dwStatus; } else { ASSERT(cbReturned == sizeof(m_dwFlags)); } // else: data retrieved successfully } // if: no error yet // Construct the list of extensions. ReadExtensions(); if (dwRetStatus == ERROR_SUCCESS) { // Construct the lists. CollectPossibleOwners(NULL); CollectDependencies(NULL); } // if: no error reading properties } // if: resource is available // Read the initial state. UpdateState(); // If any errors occurred, throw an exception. if (dwRetStatus != ERROR_SUCCESS) { m_bReadOnly = TRUE; if ( (dwRetStatus != ERROR_RESOURCE_NOT_AVAILABLE) && (dwRetStatus != ERROR_KEY_DELETED)) { ThrowStaticException(dwRetStatus, IDS_READ_RESOURCE_PROPS_ERROR, StrName()); } } // if: error reading properties MarkAsChanged(FALSE); } //*** CResource::ReadItem() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::DwResourceControlGet // // Routine Description: // Send a control function to the resource to get information from it. // // Arguments: // dwFunctionCode [IN] Control function code. // pbInBuf [IN] Input buffer to pass to the resource. // cbInBuf [IN] Size of data in input buffer. // ppbOutBuf [OUT] Output buffer. // // Return Value: // Any status returned from ClusterResourceControl(). // //-- ///////////////////////////////////////////////////////////////////////////// DWORD CResource::DwResourceControlGet( IN DWORD dwFunctionCode, IN PBYTE pbInBuf, IN DWORD cbInBuf, OUT PBYTE * ppbOutBuf ) { DWORD dwStatus = ERROR_SUCCESS; DWORD cbOutBuf = 512; CWaitCursor wc; ASSERT(ppbOutBuf != NULL); *ppbOutBuf = NULL; // Allocate memory for the buffer. try { *ppbOutBuf = new BYTE[cbOutBuf]; if ( *ppbOutBuf == NULL ) { AfxThrowMemoryException(); } // if: error allocating the output buffer } // try catch (CMemoryException * pme) { *ppbOutBuf = NULL; dwStatus = ERROR_NOT_ENOUGH_MEMORY; pme->Delete(); } // catch: CMemoryException if (dwStatus != ERROR_SUCCESS) { return dwStatus; } // Call the control function to get the data. dwStatus = ClusterResourceControl( Hresource(), NULL, dwFunctionCode, pbInBuf, cbInBuf, *ppbOutBuf, cbOutBuf, &cbOutBuf ); if (dwStatus == ERROR_MORE_DATA) { // Allocate more memory for the buffer. try { dwStatus = ERROR_SUCCESS; delete [] *ppbOutBuf; *ppbOutBuf = new BYTE[cbOutBuf]; if ( *ppbOutBuf == NULL ) { AfxThrowMemoryException(); } // if: error allocating the output buffer } // try catch (CMemoryException * pme) { *ppbOutBuf = NULL; dwStatus = ERROR_NOT_ENOUGH_MEMORY; pme->Delete(); } // catch: CMemoryException if (dwStatus != ERROR_SUCCESS) { return dwStatus; } // Call the control function again to get the data. dwStatus = ClusterResourceControl( Hresource(), NULL, dwFunctionCode, pbInBuf, cbInBuf, *ppbOutBuf, cbOutBuf, &cbOutBuf ); } // if: our buffer is too small if ((dwStatus != ERROR_SUCCESS) || (cbOutBuf == 0)) { delete [] *ppbOutBuf; *ppbOutBuf = NULL; } // if: error getting data or no data returned return dwStatus; } //*** CResource::DwResourceControlGet() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::PlstrExtension // // 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 * CResource::PlstrExtensions(void) const { return &LstrCombinedExtensions(); } //*** CResource::PlstrExtensions() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::ReadExtensions // // Routine Description: // Read extension lists. // // Arguments: // None. // // Return Value: // None. // // Exceptions Thrown: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::ReadExtensions(void) { CWaitCursor wc; // Construct the list of extensions. { POSITION posStr; const CStringList * plstr; ASSERT_VALID(Pdoc()); m_lstrCombinedExtensions.RemoveAll(); // Add resource-specific extensions first. if (PciResourceType() != NULL) { ASSERT_VALID(PciResourceType()); plstr = &PciResourceType()->LstrAdminExtensions(); posStr = plstr->GetHeadPosition(); while (posStr != NULL) { m_lstrCombinedExtensions.AddTail(plstr->GetNext(posStr)); } // while: more extensions available } // if: valid resource type found // Add extensions for all resources next. plstr = &Pdoc()->PciCluster()->LstrResourceExtensions(); posStr = plstr->GetHeadPosition(); while (posStr != NULL) { m_lstrCombinedExtensions.AddTail(plstr->GetNext(posStr)); } // while: more extensions available } // Construct the list of extensions } //*** CResource::ReadExtensions() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CollecPossibleOwners // // Routine Description: // Construct a list of node items which are enumerable on the // resource. // // Arguments: // plpci [IN OUT] List to fill. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from ClusterResourceOpenEnum() or // ClusterResourceEnum(). // Any exceptions thrown by new or CList::AddTail(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::CollectPossibleOwners(IN OUT CNodeList * plpci) const { DWORD dwStatus; HRESENUM hresenum; int ienum; LPWSTR pwszName = NULL; DWORD cchName; DWORD cchmacName; DWORD dwRetType; CClusterNode * pciNode; CWaitCursor wc; ASSERT_VALID(Pdoc()); ASSERT(Hresource() != NULL); if (plpci == NULL) { plpci = m_plpcinodePossibleOwners; } ASSERT(plpci != NULL); // Remove the previous contents of the list. plpci->RemoveAll(); if (Hresource() != NULL) { // Open the enumeration. hresenum = ClusterResourceOpenEnum(Hresource(), CLUSTER_RESOURCE_ENUM_NODES); if (hresenum == NULL) { ThrowStaticException(GetLastError(), IDS_ENUM_POSSIBLE_OWNERS_ERROR, StrName()); } 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 dependent resource to the list. for (ienum = 0 ; ; ienum++) { // Get the next item in the enumeration. cchName = cchmacName; dwStatus = ClusterResourceEnum(hresenum, 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 = ClusterResourceEnum(hresenum, 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_POSSIBLE_OWNERS_ERROR, StrName()); } ASSERT(dwRetType == CLUSTER_RESOURCE_ENUM_NODES); // Find the item in the list of resources on the document. pciNode = Pdoc()->LpciNodes().PciNodeFromName(pwszName); ASSERT_VALID(pciNode); // Add the resource to the list. if (pciNode != NULL) { plpci->AddTail(pciNode); } // if: found node in list } // for: each item in the group delete [] pwszName; ClusterResourceCloseEnum(hresenum); } // try catch (CException *) { delete [] pwszName; ClusterResourceCloseEnum(hresenum); throw; } // catch: any exception } // if: resource is available } //*** CResource::CollecPossibleOwners() /* ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::RemoveNodeFromPossibleOwners // // Routine Description: // Remove the passed in node from the possible owners list. // // Arguments: // plpci [IN OUT] List to fill. // pNode [IN] The node to remove from the list // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CList. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::RemoveNodeFromPossibleOwners( IN OUT CNodeList * plpci, IN const CClusterNode * pNode ) { if (plpci == NULL) { plpci = m_plpcinodePossibleOwners; } // if: plpci is NULL ASSERT(plpci != NULL); POSITION _pos; CClusterNode * _pnode = plpci->PciNodeFromName(pNode->StrName(), &_pos); if ((_pnode != NULL) && (_pos != NULL)) { plpci->RemoveAt(_pos); } // if: node was found in the list } //*** CResource::RemoveNodeFromPossibleOwners() */ ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CollectDependencies // // Routine Description: // Collect the resources on which this resource is dependent. // // Arguments: // plpci [IN OUT] List to fill. // bFullTree [IN] TRUE = collect dependencies of dependencies. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from ClusterResourceOpenEnum() or // ClusterResourceEnum(). // Any exceptions thrown by new or CList::AddTail(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::CollectDependencies( IN OUT CResourceList * plpci, IN BOOL bFullTree ) const { DWORD dwStatus; HRESENUM hresenum; int ienum; LPWSTR pwszName = NULL; DWORD cchName; DWORD cchmacName; DWORD dwRetType; CResource * pciRes; CWaitCursor wc; ASSERT_VALID(Pdoc()); ASSERT(Hresource() != NULL); if (plpci == NULL) { plpci = m_plpciresDependencies; } ASSERT(plpci != NULL); // Remove the previous contents of the list. if (!bFullTree) { plpci->RemoveAll(); } if (Hresource() != NULL) { // Open the enumeration. hresenum = ClusterResourceOpenEnum(Hresource(), CLUSTER_RESOURCE_ENUM_DEPENDS); if (hresenum == NULL) { ThrowStaticException(GetLastError(), IDS_ENUM_DEPENDENCIES_ERROR, StrName()); } 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 dependent resource to the list. for (ienum = 0 ; ; ienum++) { // Get the next item in the enumeration. cchName = cchmacName; dwStatus = ClusterResourceEnum(hresenum, 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 = ClusterResourceEnum(hresenum, 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_DEPENDENCIES_ERROR, StrName()); } ASSERT(dwRetType == CLUSTER_RESOURCE_ENUM_DEPENDS); // Find the item in the list of resources on the document and // add its dependencies to the list. pciRes = Pdoc()->LpciResources().PciResFromName(pwszName); if (pciRes != NULL) { // Add this resource to the list. if (plpci->Find(pciRes) == NULL) { plpci->AddTail(pciRes); } // if: resource not in the list yet // Add the resources on which this resource is dependent to the list. if (bFullTree) { pciRes->CollectDependencies(plpci, bFullTree); } } // if: resource found in the list } // for: each item in the group delete [] pwszName; ClusterResourceCloseEnum(hresenum); } // try catch (CException *) { delete [] pwszName; if (hresenum != NULL) { ClusterResourceCloseEnum(hresenum); } throw; } // catch: any exception } // if: resource is available } //*** CResource::CollectDependencies() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CollectProvidesFor // // Routine Description: // Collect the list of resources which are dependent on this resource. // // Arguments: // plpci [IN OUT] List of resources. // bFullTree [IN] TRUE = collect dependencies of dependencies. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from ClusterResourceOpenEnum() or // ClusterResourceEnum(). // Any exceptions thrown by CList::AddHead(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::CollectProvidesFor( IN OUT CResourceList * plpci, IN BOOL bFullTree ) const { DWORD dwStatus; HRESENUM hresenum = NULL; WCHAR * pwszName = NULL; int ienum; DWORD cchName; DWORD cchmacName; DWORD dwType; CResource * pciRes; CWaitCursor wc; ASSERT_VALID(this); ASSERT(Hresource != NULL); ASSERT(plpci != NULL); // Remove the previous contents of the list. if (!bFullTree) { plpci->RemoveAll(); } if (Hresource() != NULL) { try { // Allocate a name buffer. cchmacName = 128; pwszName = new WCHAR[cchmacName]; if ( pwszName == NULL ) { AfxThrowMemoryException(); } // if: error allocating the name buffer // Open the enumeration. hresenum = ClusterResourceOpenEnum(Hresource(), CLUSTER_RESOURCE_ENUM_PROVIDES); if (hresenum == NULL) { ThrowStaticException(GetLastError(), IDS_ENUM_PROVIDES_FOR_ERROR, StrName()); } // Loop through the enumeration and add each one's providers to the list. for (ienum = 0 ; ; ienum++) { // Get the next item in the enumeration. cchName = cchmacName; dwStatus = ClusterResourceEnum(hresenum, ienum, &dwType, 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 = ClusterResourceEnum(hresenum, ienum, &dwType, pwszName, &cchName); } // if: name buffer was too small if (dwStatus == ERROR_NO_MORE_ITEMS) { break; } else if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_ENUM_PROVIDES_FOR_ERROR, StrName()); } ASSERT(dwType == CLUSTER_RESOURCE_ENUM_PROVIDES); // Find the item in the list of resources on the document and // add its providers to the list. pciRes = Pdoc()->LpciResources().PciResFromName(pwszName); if (pciRes != NULL) { // Add this resource to the list. if (plpci->Find(pciRes) == NULL) { plpci->AddHead(pciRes); } // if: resource not in the list yet // Add the resources this resource provides for to the list. if (bFullTree) { pciRes->CollectProvidesFor(plpci, bFullTree); } } // if: resource found in the list } // for: each dependent resource // Close the enumeration. delete [] pwszName; pwszName = NULL; ClusterResourceCloseEnum(hresenum); hresenum = NULL; } // try catch (CException *) { delete [] pwszName; if (hresenum != NULL) { ClusterResourceCloseEnum(hresenum); } throw; } // catch: CException } // if: resource is available } //*** CResource::CollectProvidesFor() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::CollectDependencyTree // // Routine Description: // Collect the resources on which this resource is dependent and which // are dependent on it. // // Arguments: // plpci [IN OUT] List to fill. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from ClusterResourceOpenEnum() or // ClusterResourceEnum(). // Any exceptions thrown by new or CList::AddTail(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::CollectDependencyTree( IN OUT CResourceList * plpci ) const { DWORD dwStatus; HRESENUM hresenum = NULL; int ienum; LPWSTR pwszName = NULL; DWORD cchName; DWORD cchmacName; DWORD dwRetType; CResource * pciRes; CWaitCursor wc; int iType; static DWORD rgdwType[] = { CLUSTER_RESOURCE_ENUM_DEPENDS, CLUSTER_RESOURCE_ENUM_PROVIDES }; static IDS rgidsTypeError[] = { IDS_ENUM_DEPENDENCIES_ERROR, IDS_ENUM_PROVIDES_FOR_ERROR }; ASSERT_VALID(Pdoc()); ASSERT(Hresource() != NULL); ASSERT(plpci != NULL); if (Hresource() != NULL) { try { // Allocate a name buffer. cchmacName = 128; pwszName = new WCHAR[cchmacName]; if ( pwszName == NULL ) { AfxThrowMemoryException(); } // if: error allocating the name buffer for (iType = 0 ; iType < sizeof(rgdwType) / sizeof(DWORD) ; iType++) { // Open the enumeration. hresenum = ClusterResourceOpenEnum(Hresource(), rgdwType[iType]); if (hresenum == NULL) { ThrowStaticException(GetLastError(), rgidsTypeError[iType], StrName()); } // Loop through the enumeration and add each dependent or // provider resource to the list. for (ienum = 0 ; ; ienum++) { // Get the next item in the enumeration. cchName = cchmacName; dwStatus = ClusterResourceEnum(hresenum, 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 = ClusterResourceEnum(hresenum, ienum, &dwRetType, pwszName, &cchName); } // if: name buffer was too small if (dwStatus == ERROR_NO_MORE_ITEMS) { break; } else if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, rgidsTypeError[iType], StrName()); } ASSERT(dwRetType == rgdwType[iType]); // Find the item in the list of resources on the document and // add its dependencies and providers to the list. pciRes = Pdoc()->LpciResources().PciResFromName(pwszName); if (pciRes != NULL) { // Add this resource to the list. if (plpci->Find(pciRes) == NULL) { plpci->AddTail(pciRes); pciRes->CollectDependencyTree(plpci); } // if: resource not in the list yet } // if: resource found in the list } // for: each item in the group ClusterResourceCloseEnum(hresenum); hresenum = NULL; } // for: each type of enumeration delete [] pwszName; } // try catch (CException *) { delete [] pwszName; if (hresenum != NULL) { ClusterResourceCloseEnum(hresenum); } throw; } // catch: any exception } // if: resource is available } //*** CResource::CollectDependencyTree() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetName // // Routine Description: // Set the name of this resource. // // Arguments: // pszName [IN] New name of the resource. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by Rename. //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetName(IN LPCTSTR pszName) { Rename(pszName); } //*** CResource::SetName() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetGroup // // Routine Description: // Set the group to which this resource belongs. // // Arguments: // pszGroup [IN] New group for the resource. // // Return Value: // None. // // Exceptions Thrown: // CNTException IDS_MOVE_RESOURCE_ERROR - errors from // ChangeClusterResourceGroup(). //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetGroup(IN LPCTSTR pszGroup) { DWORD dwStatus; CGroup * pciGroup; CString strGroup(pszGroup); // Required if built non-Unicode CWaitCursor wc; ASSERT(pszGroup != NULL); ASSERT(Hresource() != NULL); if ((Hresource() != NULL) && (StrGroup() != pszGroup)) { // Find the group. pciGroup = Pdoc()->LpciGroups().PciGroupFromName(pszGroup); ASSERT_VALID(pciGroup); // Change the group. dwStatus = ChangeClusterResourceGroup(Hresource(), pciGroup->Hgroup()); if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_MOVE_RESOURCE_ERROR, StrName(), pszGroup); } SetGroupState(pciGroup->StrName()); } // if: the name changed } //*** CResource::SetGroup() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetDependencies // // Routine Description: // Set the list of resources on which this resource depends on // in the cluster database. // // Arguments: // rlpci [IN] List of resources on which this resource depends on. // // Return Value: // None. // // Exceptions Thrown: // CNTException(dwStatus) Errors from AddClusterResourceDependency() // and RemoveClusterResourceDependency(). //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetDependencies(IN const CResourceList & rlpci) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource() != NULL); if (Hresource() != NULL) { // Add any entries that are in the new last but not in the old list as // new dependencies. { POSITION posPci; CResource * pciRes; posPci = rlpci.GetHeadPosition(); while (posPci != NULL) { pciRes = (CResource *) rlpci.GetNext(posPci); ASSERT_VALID(pciRes); if (LpciresDependencies().Find(pciRes) == NULL) { // Add the resource as a dependency of this one. dwStatus = AddClusterResourceDependency(Hresource(), pciRes->Hresource()); if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_ADD_DEPENDENCY_ERROR, pciRes->StrName(), StrName()); } // Add the resource into our list. m_plpciresDependencies->AddTail(pciRes); } // if: item not found in existing list } // while: more items in the list } // Add new dependencies // Delete any entries that are in the new old but not in the new list. { POSITION posPci; POSITION posPrev; CResource * pciRes; posPci = LpciresDependencies().GetHeadPosition(); while (posPci != NULL) { posPrev = posPci; pciRes = (CResource *) LpciresDependencies().GetNext(posPci); if (rlpci.Find(pciRes) == NULL) { // Remove the resource as a dependency of this one. dwStatus = RemoveClusterResourceDependency(Hresource(), pciRes->Hresource()); if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_REMOVE_DEPENDENCY_ERROR, pciRes->StrName(), StrName()); } // Remove the resource from our list. m_plpciresDependencies->RemoveAt(posPrev); } // if: item not found in new list } // while: more items in the list } // Remove old dependencies } // if: resource is available } //*** CResource::SetDependencies() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetPossibleOwners // // Routine Description: // Set the list of possible owners of this resource in the cluster // database. // // Arguments: // rlpci [IN] List of possible owners (nodes). // // Return Value: // None. // // Exceptions Thrown: // CNTException IDS_TAKE_RESOURCE_OFFLINE_ERROR. // CNTException(dwStatus) Errors from AddClusterResourceNode() // and RemoveClusterResourceNode(). //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetPossibleOwners(IN const CNodeList & rlpci) { DWORD dwStatus; CWaitCursor wc; POSITION posPci; POSITION posPrev; CClusterNode * pciNode; ASSERT( Hresource() != NULL ); if ( Hresource() == NULL ) { ThrowStaticException( ERROR_INVALID_HANDLE, IDS_MODIFY_RES_OWNER_ERROR, StrName() ); return; } // // Add any entries that are in the new list but not in the old list as // new owners. // posPci = rlpci.GetHeadPosition(); while (posPci != NULL) { pciNode = (CClusterNode *) rlpci.GetNext(posPci); ASSERT_VALID(pciNode); if (LpcinodePossibleOwners().Find(pciNode) == NULL) { // Add the node as an owner of this resource. dwStatus = AddClusterResourceNode(Hresource(), pciNode->Hnode()); if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_ADD_RES_OWNER_ERROR, pciNode->StrName(), StrName()); } // Add the node into our list. m_plpcinodePossibleOwners->AddTail(pciNode); } // if: item not found in existing list } // while: more items in the list to add // // Delete any entries that are in the old but not in the new list. // posPci = LpcinodePossibleOwners().GetHeadPosition(); while (posPci != NULL) { posPrev = posPci; pciNode = (CClusterNode *) LpcinodePossibleOwners().GetNext(posPci); if (rlpci.Find(pciNode) == NULL) { // Remove the node as an owner of this resource. dwStatus = RemoveClusterResourceNode(Hresource(), pciNode->Hnode()); if (dwStatus != ERROR_SUCCESS) { if ( dwStatus == ERROR_INVALID_STATE ) { ThrowStaticException(dwStatus, IDS_REMOVE_RES_OWNER_GROUP_STATE_ERROR, pciNode->StrName(), StrName()); } else { ThrowStaticException(dwStatus, IDS_REMOVE_RES_OWNER_ERROR, pciNode->StrName(), StrName()); } } // if: error removing node as owner // Remove the node from our list. m_plpcinodePossibleOwners->RemoveAt(posPrev); } // if: item not found in new list } // while: more items in the list to delete } //*** CResource::SetPossibleOwners() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetCommonProperties // // Routine Description: // Set the common properties for this resource in the cluster database. // // Arguments: // rstrDesc [IN] Description string. // bSeparate [IN] TRUE = run resource in separate monitor, FALSE = run with other resources. // nLooksAlive [IN] Looks Alive poll interval. // nIsAlive [IN] Is Alive poll interval. // crra [IN] Restart action. // nThreshold [IN] Restart threshold. // nPeriod [IN] Restart period. // nTimeout [IN] Pending timeout in minutes. // bValidateOnly [IN] Only validate the data. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CClusterItem::SetCommonProperties(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetCommonProperties( IN const CString & rstrDesc, IN BOOL bSeparate, IN DWORD nLooksAlive, IN DWORD nIsAlive, IN CRRA crra, IN DWORD nThreshold, IN DWORD nPeriod, IN DWORD nTimeout, IN BOOL bValidateOnly ) { CNTException nte(ERROR_SUCCESS, 0, NULL, NULL, FALSE /*bAutoDelete*/); m_rgProps[epropDescription].m_value.pstr = (CString *) &rstrDesc; m_rgProps[epropSeparateMonitor].m_value.pb = &bSeparate; m_rgProps[epropLooksAlive].m_value.pdw = &nLooksAlive; m_rgProps[epropIsAlive].m_value.pdw = &nIsAlive; m_rgProps[epropRestartAction].m_value.pdw = (DWORD *) &crra; m_rgProps[epropRestartThreshold].m_value.pdw = &nThreshold; m_rgProps[epropRestartPeriod].m_value.pdw = &nPeriod; m_rgProps[epropPendingTimeout].m_value.pdw = &nTimeout; 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[epropSeparateMonitor].m_value.pb = &m_bSeparateMonitor; m_rgProps[epropLooksAlive].m_value.pdw = &m_nLooksAlive; m_rgProps[epropIsAlive].m_value.pdw = &m_nIsAlive; m_rgProps[epropRestartAction].m_value.pdw = (DWORD *) &m_crraRestartAction; m_rgProps[epropRestartThreshold].m_value.pdw = &m_nRestartThreshold; m_rgProps[epropRestartPeriod].m_value.pdw = &m_nRestartPeriod; m_rgProps[epropPendingTimeout].m_value.pdw = &m_nPendingTimeout; if (nte.Sc() != ERROR_SUCCESS) { ThrowStaticException( nte.Sc(), nte.IdsOperation(), nte.PszOperArg1(), nte.PszOperArg2() ); } } //*** CResource::SetCommonProperties() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::DwSetCommonProperties // // Routine Description: // Set the common properties for this resource in the cluster database. // // Arguments: // rcpl [IN] Property list to set. // bValidateOnly [IN] Only validate the data. // // Return Value: // Any status returned by ClusterResourceControl(). // //-- ///////////////////////////////////////////////////////////////////////////// DWORD CResource::DwSetCommonProperties( IN const CClusPropList & rcpl, IN BOOL bValidateOnly ) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource()); if ((rcpl.PbPropList() != NULL) && (rcpl.CbPropList() > 0)) { DWORD cbProps; DWORD dwControl; if (bValidateOnly) { dwControl = CLUSCTL_RESOURCE_VALIDATE_COMMON_PROPERTIES; } else { dwControl = CLUSCTL_RESOURCE_SET_COMMON_PROPERTIES; } // Set common properties. dwStatus = ClusterResourceControl( Hresource(), 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; } //*** CResource::DwSetCommonProperties() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BRequiredDependenciesPresent // // Routine Description: // Determine if the specified list contains each required resource // for this type of resource. // // Arguments: // rlpciRes [IN] List of resources. // rstrMissing [OUT] String in which to return a missing resource // class name or type name. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CString::LoadString() or CString::operator=(). // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BRequiredDependenciesPresent( IN const CResourceList & rlpciRes, OUT CString & rstrMissing ) { POSITION pos; BOOL bFound = TRUE; const CResource * pciRes; CLUSPROP_BUFFER_HELPER props; if (Pcrd() == NULL) { return TRUE; } // Collect the list of required dependencies. props.pRequiredDependencyValue = Pcrd(); // Loop through each required dependency and make sure // there is a dependency on a resource of that type. while (props.pSyntax->dw != CLUSPROP_SYNTAX_ENDMARK) { bFound = FALSE; pos = rlpciRes.GetHeadPosition(); while (pos != NULL) { // Get the next resource. pciRes = (CResource *) rlpciRes.GetNext(pos); ASSERT_VALID(pciRes); ASSERT_KINDOF(CResource, pciRes); // If this is the right type, we've satisfied the // requirement so exit the loop. if (props.pSyntax->dw == CLUSPROP_SYNTAX_RESCLASS) { if (props.pResourceClassValue->rc == pciRes->ResClass()) { bFound = TRUE; props.pb += sizeof(*props.pResourceClassValue); } // if: match found } // if: resource class else if (props.pSyntax->dw == CLUSPROP_SYNTAX_NAME) { if (pciRes->StrRealResourceType().CompareNoCase(props.pStringValue->sz) == 0) { bFound = TRUE; props.pb += sizeof(*props.pStringValue) + ALIGN_CLUSPROP(props.pStringValue->cbLength); } // if: match found } // else if: resource name else { ASSERT(0); break; } // else: unknown data type if (bFound) { break; } } // while: more items in the list // If a match was not found, changes cannot be applied. if (!bFound) { if (props.pSyntax->dw == CLUSPROP_SYNTAX_RESCLASS) { if (!rstrMissing.LoadString(IDS_RESCLASS_UNKNOWN + props.pResourceClassValue->rc)) { rstrMissing.LoadString(IDS_RESCLASS_UNKNOWN); } } // if: resource class not found else if (props.pSyntax->dw == CLUSPROP_SYNTAX_NAME) { CResourceType * pciResType; // Find the resource type in our list. pciResType = (CResourceType *) Pdoc()->LpciResourceTypes().PciFromName(props.pStringValue->sz); if (pciResType != NULL) { rstrMissing = pciResType->StrDisplayName(); } else { rstrMissing = props.pStringValue->sz; } } // else if: resource type name not found break; } // if: not found } // while: more dependencies required return bFound; } //*** CResource::BRequiredDependenciesPresent() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::DeleteResource // // Routine Description: // Delete this resource and all dependent resources. // // Arguments: // rlpci [IN] List of resources to delete in addition to this one. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CResource::DeleteResource(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::DeleteResource(IN const CResourceList & rlpci) { CWaitCursor wc; // Delete each resource in the list. { POSITION pos; CResource * pciRes; pos = rlpci.GetHeadPosition(); while (pos != NULL) { pciRes = (CResource *) rlpci.GetNext(pos); if (pciRes != NULL) { pciRes->DeleteResource(); } } // while: more items in the list } // Delete each resource in the list // Delete this resource. DeleteResource(); } //*** CResource::DeleteResource(rlpci) ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::DeleteResource // // Routine Description: // Delete this resource. // // Arguments: // None. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from DeleteClusterResource(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::DeleteResource(void) { DWORD dwStatus; BOOL bWeTookOffline = FALSE; CWaitCursor wc; ASSERT(!BDeleting()); if (Hresource() != NULL) { // Make sure the resource is offline. if ( (Crs() != ClusterResourceOffline) && (Crs() != ClusterResourceFailed)) { dwStatus = OfflineClusterResource(Hresource()); if (dwStatus == ERROR_IO_PENDING) { WaitForOffline(); if ( (Crs() != ClusterResourceOffline) && (Crs() != ClusterResourceFailed)) { ThrowStaticException(IDS_DELETE_RESOURCE_ERROR_OFFLINE_PENDING, StrName()); } // if: resource still not offline } // if: offline pending else if ( (dwStatus != ERROR_SUCCESS) && (dwStatus != ERROR_FILE_NOT_FOUND) && (dwStatus != ERROR_RESOURCE_NOT_AVAILABLE)) { ThrowStaticException(dwStatus, IDS_TAKE_RESOURCE_OFFLINE_ERROR, StrName()); } bWeTookOffline = TRUE; } // if: resource is not offline // Delete the resource itself. Trace(g_tagResource, _T("(%s) DeleteResource() - Deleting '%s' (%x)"), Pdoc()->StrNode(), StrName(), this); dwStatus = DeleteClusterResource(Hresource()); if ( (dwStatus != ERROR_SUCCESS) && (dwStatus != ERROR_FILE_NOT_FOUND) && (dwStatus != ERROR_RESOURCE_NOT_AVAILABLE)) { if (bWeTookOffline) { OnlineClusterResource(Hresource()); } ThrowStaticException(dwStatus, IDS_DELETE_RESOURCE_ERROR, StrName()); } // if: error occurred m_bDeleting = TRUE; UpdateState(); } // if: resource has been opened/created } //*** CResource::DeleteResource() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::WaitForOffline // // Routine Description: // Wait for the resource to go offline. // // Arguments: // None. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CResource::Move(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::WaitForOffline( void ) { CWaitForResourceOfflineDlg dlg( this, AfxGetMainWnd() ); dlg.DoModal(); UpdateState(); } //*** CResource::WaitForOffline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::Move // // Routine Description: // Move this resource and all dependent and depending resources to // another group. // // Arguments: // pciGroup [IN] Group to move resources to. // rlpci [IN] List of resources to move in addition to this one. // // Return Value: // None. // // Exceptions Thrown: // Any exceptions thrown by CResource::Move(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::Move( IN const CGroup * pciGroup, IN const CResourceList & rlpci ) { CWaitCursor wc; // Move each resource in the list. { POSITION pos; CResource * pciRes; pos = rlpci.GetHeadPosition(); while (pos != NULL) { pciRes = (CResource *) rlpci.GetNext(pos); if (pciRes != NULL) { pciRes->Move(pciGroup); } } // while: more items in the list } // Move each resource in the list // Move this resource. Move(pciGroup); } //*** CResource::Move(rlpci) ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::Move // // Routine Description: // Move this resource. // // Arguments: // pciGroup [IN] Group to move resources to. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors from ChangeClusterResourceGroup(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::Move(IN const CGroup * pciGroup) { DWORD dwStatus; ASSERT_VALID(pciGroup); if ((Hresource() != NULL) && (pciGroup != NULL) && (pciGroup->Hgroup() != NULL)) { // Move the resource. Trace(g_tagResource, _T("(%s) Move() - moving '%s' (%x) from '%s' (%x) to '%s' (%x)"), Pdoc()->StrNode(), StrName(), this, StrGroup(), PciGroup(), pciGroup->StrName(), pciGroup); dwStatus = ChangeClusterResourceGroup(Hresource(), pciGroup->Hgroup()); if ((dwStatus != ERROR_SUCCESS) && (dwStatus != ERROR_FILE_NOT_FOUND)) ThrowStaticException(dwStatus, IDS_MOVE_RESOURCE_ERROR, StrName(), pciGroup->StrName()); UpdateState(); } // if: resource has been opened/created } //*** CResource::Move() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnFinalRelease // // Routine Description: // Called when the last OLE reference to or from the object is released. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::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(); } //*** CResource::OnFinalRelease() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BCanBeDependent // // Routine Description: // Determine whether this resource can be dependent on the specified one. // // Arguments: // pciRes [IN] Resource to check. // // Return Value: // TRUE Resource can be a dependent. // FALSE Resource can NOT be a dependent. // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BCanBeDependent(IN CResource * pciRes) { CWaitCursor wc; ASSERT_VALID(pciRes); if ((Hresource() != NULL) && (pciRes->Hresource() != NULL) && (pciRes != this) && (StrGroup() == pciRes->StrGroup()) ) { return ::CanResourceBeDependent(Hresource(), pciRes->Hresource()); } else { return FALSE; } } //*** CResource::BCanBeDependent() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BIsDependent // // Routine Description: // Determine whether this resource is dependent on the specified one. // // Arguments: // pciRes [IN] Resource to check. // // Return Value: // TRUE Resource is a dependent. // FALSE Resource is NOT a dependent. // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BIsDependent(IN CResource * pciRes) { ASSERT_VALID(pciRes); if ((m_plpciresDependencies != NULL) && (LpciresDependencies().Find(pciRes) != NULL)) { return TRUE; } else { return FALSE; } } //*** CResource::BIsDependent() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BGetNetworkName // // Routine Description: // Returns the name of the network name of the first Network Name // resource on which the specified resource depends. // // Arguments: // lpszNetName [OUT] String in which to return the network name. // pcchNetName [IN OUT] Points to a variable that specifies the // maximum size, in characters, of the buffer. This // value should be large enough to contain // MAX_COMPUTERNAME_LENGTH + 1 characters. Upon // return it contains the actual number of characters // copied. // // Return Value: // TRUE Resource is dependent on a network name resource. // FALSE Resource is NOT dependent on a network name resource. // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BGetNetworkName( OUT WCHAR * lpszNetName, IN OUT DWORD * pcchNetName ) { CWaitCursor wc; ASSERT_VALID(this); ASSERT(m_hresource != NULL); ASSERT(lpszNetName != NULL); ASSERT(pcchNetName != NULL); return GetClusterResourceNetworkName(m_hresource, lpszNetName, pcchNetName); } //*** CResource::BGetNetworkName() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BGetNetworkName // // Routine Description: // Returns the name of the network name of the first Network Name // resource on which the specified resource depends. // // Arguments: // rstrNetName [OUT] String in which to return the network name. // // Return Value: // TRUE Resource is dependent on a network name resource. // FALSE Resource is NOT dependent on a network name resource. // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BGetNetworkName(OUT CString & rstrNetName) { BOOL bSuccess; WCHAR szNetName[MAX_COMPUTERNAME_LENGTH + 1]; DWORD nSize = sizeof(szNetName) / sizeof(WCHAR); bSuccess = BGetNetworkName(szNetName, &nSize); if (bSuccess) { rstrNetName = szNetName; } else { rstrNetName = _T(""); } return bSuccess; } //*** CResource::BGetNetworkName() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::UpdateState // // Routine Description: // Update the current state of the item. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::UpdateState(void) { CClusterAdminApp * papp = GetClusterAdminApp(); WCHAR * pwszOwner = NULL; WCHAR * pwszGroup = NULL; WCHAR * prgwszOwner = NULL; WCHAR * prgwszGroup = NULL; DWORD cchOwner; DWORD cchGroup; DWORD sc; DWORD oldcchOwner; DWORD oldcchGroup; Trace(g_tagResource, _T("(%s) (%s (%x)) - Updating state"), Pdoc()->StrNode(), StrName(), this); // Get the current state of the resource. if (Hresource() == NULL) { m_crs = ClusterResourceStateUnknown; } else { CWaitCursor wc; cchOwner = 100; oldcchOwner = cchOwner; prgwszOwner = new WCHAR[cchOwner]; if ( prgwszOwner == NULL ) { AfxThrowMemoryException(); } // if: error allocating the buffer cchGroup = 100; oldcchGroup = cchGroup; prgwszGroup = new WCHAR[cchGroup]; if ( prgwszGroup == NULL ) { delete [] prgwszOwner; AfxThrowMemoryException(); } // if: error allocating the buffer m_crs = GetClusterResourceState(Hresource(), prgwszOwner, &cchOwner, prgwszGroup, &cchGroup); sc = GetLastError(); if ( sc == ERROR_MORE_DATA ) { // // Increment before the check. This way we'll know whether we'll need to resize the buffer, // and if not then we report it as being just big enough. // cchOwner++; if ( cchOwner > oldcchOwner ) { delete [] prgwszOwner; oldcchOwner = cchOwner; prgwszOwner = new WCHAR[cchOwner]; if( prgwszOwner == NULL ) { delete [] prgwszGroup; AfxThrowMemoryException(); } // if: error allocating the buffer } cchGroup++; if ( cchGroup > oldcchGroup ) { delete [] prgwszGroup; oldcchGroup = cchGroup; prgwszGroup = new WCHAR[cchGroup]; if ( prgwszGroup == NULL ) { delete [] prgwszOwner; AfxThrowMemoryException(); } // if: error allocating the buffer } // // Note that it's possible that the owning group or node changed since the last call to // GetClusterResourceState. In that case our buffers may still be too small. Hit F5 to refresh. // m_crs = GetClusterResourceState(Hresource(), prgwszOwner, &cchOwner, prgwszGroup, &cchGroup); } pwszOwner = prgwszOwner; pwszGroup = prgwszGroup; } // else: resource is available // Save the current state image index. switch (Crs()) { case ClusterResourceStateUnknown: m_iimgState = papp->Iimg(IMGLI_RES_UNKNOWN); pwszOwner = NULL; pwszGroup = NULL; break; case ClusterResourceOnline: m_iimgState = papp->Iimg(IMGLI_RES); break; case ClusterResourceOnlinePending: m_iimgState = papp->Iimg(IMGLI_RES_PENDING); break; case ClusterResourceOffline: m_iimgState = papp->Iimg(IMGLI_RES_OFFLINE); break; case ClusterResourceOfflinePending: m_iimgState = papp->Iimg(IMGLI_RES_PENDING); break; case ClusterResourceFailed: m_iimgState = papp->Iimg(IMGLI_RES_FAILED); break; default: Trace(g_tagResource, _T("(%s) (%s (%x)) - UpdateState: Unknown state '%d' for resource '%s'"), Pdoc()->StrNode(), StrName(), this, Crs(), StrName()); m_iimgState = (UINT) -1; break; } // switch: Crs() SetOwnerState(pwszOwner); SetGroupState(pwszGroup); if( NULL != prgwszOwner ) { delete [] prgwszOwner; } if( NULL != prgwszGroup ) { delete [] prgwszGroup; } // Call the base class method. CClusterItem::UpdateState(); } //*** CResource::UpdateState() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetOwnerState // // Routine Description: // Set a new owner for this resource. // // Arguments: // pszNewOwner [IN] Name of the new owner. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetOwnerState(IN LPCTSTR pszNewOwner) { CClusterNode * pciOldOwner = PciOwner(); CClusterNode * pciNewOwner; Trace(g_tagResource, _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_tagResource.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_tagResource, 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->RemoveActiveResource(this); } if (pciNewOwner != NULL) { pciNewOwner->AddActiveResource(this); } } // if: this is a document object } // if: owner changed else if ((pszNewOwner != NULL) && (StrOwner() != pszNewOwner)) { m_strOwner = pszNewOwner; } } //*** CResource::SetOwnerState() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::SetGroupState // // Routine Description: // Set a new group for this resource. // // Arguments: // pszNewGroup [IN] Name of the new group. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::SetGroupState(IN LPCTSTR pszNewGroup) { CGroup * pciOldGroup = PciGroup(); CGroup * pciNewGroup; Trace(g_tagResource, _T("(%s) (%s (%x)) - Setting group to '%s'"), Pdoc()->StrNode(), StrName(), this, (pszNewGroup == NULL ? _T("") : pszNewGroup)); if (pszNewGroup == NULL) { pciNewGroup = NULL; } else { pciNewGroup = Pdoc()->LpciGroups().PciGroupFromName(pszNewGroup); } if (pciNewGroup != pciOldGroup) { #ifdef _DEBUG if (g_tagResource.BAny()) { CString strMsg; CString strMsg2; strMsg.Format(_T("(%s) (%s (%x)) - Changing group from "), Pdoc()->StrNode(), StrName(), this); if (pciOldGroup == NULL) { strMsg += _T("nothing "); } else { strMsg2.Format(_T("'%s' "), pciOldGroup->StrName()); strMsg += strMsg2; } // else: previous group if (pciNewGroup == NULL) { strMsg += _T("to nothing"); } else { strMsg2.Format(_T("to '%s'"), pciNewGroup->StrName()); strMsg += strMsg2; } // else: new group Trace(g_tagResource, strMsg); } // if: trace tag turned on #endif m_strGroup = pszNewGroup; m_pciGroup = pciNewGroup; // Update reference counts. if (pciOldGroup != NULL) { pciOldGroup->Release(); } if (pciNewGroup != NULL) { pciNewGroup->AddRef(); } if (BDocObj()) { if (pciOldGroup != NULL) { pciOldGroup->RemoveResource(this); } if (pciNewGroup != NULL) { pciNewGroup->AddResource(this); } } // if: this is a document object } // if: owner changed else if ((pszNewGroup != NULL) && (StrGroup() != pszNewGroup)) { m_strGroup = pszNewGroup; } } //*** CResource::SetGroupState() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::BGetColumnData(IN COLID colid, OUT CString & rstrText) { BOOL bSuccess; switch (colid) { case IDS_COLTEXT_STATE: GetStateName(rstrText); bSuccess = TRUE; break; case IDS_COLTEXT_RESTYPE: rstrText = StrRealResourceTypeDisplayName(); bSuccess = TRUE; break; case IDS_COLTEXT_OWNER: rstrText = StrOwner(); bSuccess = TRUE; break; case IDS_COLTEXT_GROUP: if (PciGroup() == NULL) { rstrText = StrGroup(); } else { rstrText = PciGroup()->StrName(); } bSuccess = TRUE; break; case IDS_COLTEXT_RESOURCE: // This is for showing dependencies colid = IDS_COLTEXT_NAME; // FALL THROUGH default: bSuccess = CClusterItem::BGetColumnData(colid, rstrText); break; } // switch: colid return bSuccess; } //*** CResource::BGetColumnData() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::GetTreeName(OUT CString & rstrName) const { CString strState; GetStateName(strState); rstrName.Format(_T("%s (%s)"), StrName(), strState); } //*** CResource::GetTreeName() #endif ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::GetStateName(OUT CString & rstrState) const { switch (Crs()) { case ClusterResourceStateUnknown: rstrState.LoadString(IDS_UNKNOWN); break; case ClusterResourceOnline: rstrState.LoadString(IDS_ONLINE); break; case ClusterResourceOnlinePending: rstrState.LoadString(IDS_ONLINE_PENDING); break; case ClusterResourceOffline: rstrState.LoadString(IDS_OFFLINE); break; case ClusterResourceOfflinePending: rstrState.LoadString(IDS_OFFLINE_PENDING); break; case ClusterResourceFailed: rstrState.LoadString(IDS_FAILED); break; default: rstrState.Empty(); break; } // switch: Crs() } //*** CResource::GetStateName() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::BCanBeEdited(void) const { BOOL bCanBeEdited; if ( (Crs() == ClusterResourceStateUnknown) || BReadOnly()) { bCanBeEdited = FALSE; } else { bCanBeEdited = TRUE; } return bCanBeEdited; } //*** CResource::BCanBeEdited() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::Rename // // Routine Description: // Rename the resource. // // Arguments: // pszName [IN] New name to give to the resource. // // Return Value: // None. // // Exceptions Thrown: // CNTException Errors returned from SetClusterResourceName(). // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::Rename(IN LPCTSTR pszName) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource() != NULL); if (StrName() != pszName) { dwStatus = SetClusterResourceName(Hresource(), pszName); if (dwStatus != ERROR_SUCCESS) { ThrowStaticException(dwStatus, IDS_RENAME_RESOURCE_ERROR, StrName(), pszName); } m_strName = pszName; } // if: the name changed } //*** CResource::Rename() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnCmdMsg( UINT nID, int nCode, void * pExtra, AFX_CMDHANDLERINFO * pHandlerInfo ) { BOOL bHandled = FALSE; // If this is a MOVE_RESOURCE command, process it here. if ((ID_FILE_MOVE_RESOURCE_1 <= nID) && (nID <= ID_FILE_MOVE_RESOURCE_20)) { Trace(g_tagResource, _T("(%s) OnCmdMsg() %s (%x) - ID = %d, code = %d"), Pdoc()->StrNode(), StrName(), this, nID, nCode); if (nCode == 0) { OnCmdMoveResource(nID); bHandled = TRUE; } // if: code = 0 } // if: move resource if (!bHandled) { bHandled = CClusterItem::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo); } return bHandled; } //*** CResource::OnCmdMsg() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnUpdateBringOnline(CCmdUI * pCmdUI) { if ((Crs() != ClusterResourceOnline) && (Crs() != ClusterResourceOnlinePending) && (Crs() != ClusterResourceStateUnknown)) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } //*** CResource::OnUpdateBringOnline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnUpdateTakeOffline(CCmdUI * pCmdUI) { if (Crs() == ClusterResourceOnline) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } //*** CResource::OnUpdateTakeOffline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnUpdateInitiateFailure // // Routine Description: // Determines whether menu items corresponding to ID_FILE_INITIATE_FAILURE // should be enabled or not. // // Arguments: // pCmdUI [IN OUT] Command routing object. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnUpdateInitiateFailure(CCmdUI * pCmdUI) { if (Crs() == ClusterResourceOnline) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } //*** CResource::OnUpdateInitiateFailure() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnUpdateMoveResource1 // // Routine Description: // Determines whether menu items corresponding to // ID_FILE_MOVE_RESOURCE_1 should be enabled or not. // // Arguments: // pCmdUI [IN OUT] Command routing object. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnUpdateMoveResource1(CCmdUI * pCmdUI) { if (pCmdUI->m_pSubMenu == NULL) { CString strMenuName; if ((pCmdUI->m_pMenu != NULL) && (pCmdUI->m_pSubMenu == NULL)) { pCmdUI->m_pMenu->GetMenuString(pCmdUI->m_nID, strMenuName, MF_BYCOMMAND); } if ((strMenuName != StrGroup()) && ((Crs() == ClusterResourceOnline) || (Crs() == ClusterResourceOffline))) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } // if: nested menu is being displayed else { BOOL bEnabled; if (Pdoc()->LpciGroups().GetCount() < 2) { bEnabled = FALSE; } else { POSITION pos; UINT imenu; UINT idMenu; UINT cmenu; CGroup * pciGroup; CMenu * pmenu = pCmdUI->m_pSubMenu; bEnabled = TRUE; // Delete the items in the menu. cmenu = pmenu->GetMenuItemCount(); while (cmenu-- > 0) pmenu->DeleteMenu(0, MF_BYPOSITION); // Add each group to the menu. 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); pmenu->InsertMenu( imenu++, MF_BYPOSITION, idMenu, pciGroup->StrName() ); } // for: each group } // else: move user is available // 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 } //*** CResource::OnUpdateMoveResource1() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnUpdateMoveResourceRest // // Routine Description: // Determines whether menu items corresponding to // ID_FILE_MOVE_RESOURCE_2 through ID_FILE_MOVE_RESOURCE_20 // should be enabled or not. // // Arguments: // pCmdUI [IN OUT] Command routing object. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnUpdateMoveResourceRest(CCmdUI * pCmdUI) { CString strMenuName; if ((pCmdUI->m_pMenu != NULL) && (pCmdUI->m_pSubMenu == NULL)) { pCmdUI->m_pMenu->GetMenuString(pCmdUI->m_nID, strMenuName, MF_BYCOMMAND); } if ((strMenuName != StrGroup()) && ((Crs() == ClusterResourceOnline) || (Crs() == ClusterResourceOffline))) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } //*** CResource::OnUpdateMoveResourceRest() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnUpdateDelete(CCmdUI * pCmdUI) { if (Crs() != ClusterResourceStateUnknown) { pCmdUI->Enable(TRUE); } else { pCmdUI->Enable(FALSE); } } //*** CResource::OnUpdateDelete() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnCmdBringOnline // // Routine Description: // Processes the ID_FILE_BRING_ONLINE menu command. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnCmdBringOnline(void) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource() != NULL); // Do this in case this object is deleted while we are operating on it. AddRef(); // If there are no possible owners for this resource, display a message. if (LpcinodePossibleOwners().GetCount() == 0) { AfxMessageBox(IDS_NO_POSSIBLE_OWNERS, MB_OK | MB_ICONINFORMATION); } else { dwStatus = OnlineClusterResource(Hresource()); if ((dwStatus != ERROR_SUCCESS) && (dwStatus != ERROR_IO_PENDING)) { CNTException nte(dwStatus, IDS_BRING_RESOURCE_ONLINE_ERROR, StrName(), NULL, FALSE /*bAutoDelete*/); nte.ReportError(); } // if: error bringing the resource online UpdateState(); } // else: resource has at least one possible owner Release(); } //*** CResource::OnCmdBringOnline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnCmdTakeOffline // // Routine Description: // Processes the ID_FILE_TAKE_OFFLINE menu command. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnCmdTakeOffline(void) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource() != NULL); // Do this in case this object is deleted while we are operating on it. AddRef(); // If this connection was made through the cluster name and this is // either the cluster name resource or one of the resources on which // it is dependent, warn the user. if (!BAllowedToTakeOffline()) { goto Cleanup; } dwStatus = OfflineClusterResource(Hresource()); if ((dwStatus != ERROR_SUCCESS) && (dwStatus != ERROR_IO_PENDING)) { CNTException nte(dwStatus, IDS_TAKE_RESOURCE_OFFLINE_ERROR, StrName(), NULL, FALSE /*bAutoDelete*/); nte.ReportError(); } // if: error taking the resource offline UpdateState(); Cleanup: Release(); } //*** CResource::OnCmdTakeOffline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnCmdInitiateFailure // // Routine Description: // Processes the ID_FILE_INITIATE_FAILURE menu command. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnCmdInitiateFailure(void) { DWORD dwStatus; CWaitCursor wc; ASSERT(Hresource() != NULL); dwStatus = FailClusterResource(Hresource()); if (dwStatus != ERROR_SUCCESS) { CNTException nte(dwStatus, IDS_INIT_RESOURCE_FAILURE_ERROR, StrName(), NULL /*bAutoDelete*/); nte.ReportError(); } // if: error initiating failure UpdateState(); } //*** CResource::OnCmdInitiateFailure() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnCmdMoveResource // // Routine Description: // Processes the ID_FILE_MOVE_RESOURCE_# menu commands. // // Arguments: // nID [IN] Command ID. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnCmdMoveResource(IN UINT nID) { int ipci; ASSERT(Hresource() != NULL); // Do this in case this object is deleted while we are operating on it. AddRef(); ipci = (int) (nID - ID_FILE_MOVE_RESOURCE_1); ASSERT(ipci < Pdoc()->LpciGroups().GetCount()); if (ipci < Pdoc()->LpciGroups().GetCount()) { POSITION pos; CResourceList lpciMove; CString strMsg; CGroup * pciGroup; // Get the group. pos = Pdoc()->LpciGroups().FindIndex(ipci); ASSERT(pos != NULL); pciGroup = (CGroup *) Pdoc()->LpciGroups().GetAt(pos); ASSERT_VALID(pciGroup); try { // Verify that the user really wants to move this resource. strMsg.FormatMessage(IDS_VERIFY_MOVE_RESOURCE, StrName(), StrGroup(), pciGroup->StrName()); if (AfxMessageBox(strMsg, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2) == IDNO) { goto Cleanup; } // Collect the list of resources which will be moved if confirmed. lpciMove.AddTail(this); CollectDependencyTree(&lpciMove); // If this resource is dependent on or is a dependent of any other resource, // display another warning message. if (lpciMove.GetCount() > 0) { CMoveResourcesDlg dlg(this, &lpciMove, AfxGetMainWnd()); if (dlg.DoModal() != IDOK) { goto Cleanup; } } // if: resource is dependent of another resource // Move the resource. { CWaitCursor wc; Move(pciGroup); } // Move the resource } // try catch (CException * pe) { pe->ReportError(); pe->Delete(); } // catch: CException } // if: valid index Cleanup: Release(); } //*** CResource::OnCmdMoveResource() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::OnCmdDelete // // Routine Description: // Processes the ID_FILE_DELETE menu command. // // Arguments: // None. // // Return Value: // None. // //-- ///////////////////////////////////////////////////////////////////////////// void CResource::OnCmdDelete(void) { CResourceList lpci; CString strMsg; ASSERT(Hresource() != NULL); // Do this in case this object is deleted while we are operating on it. AddRef(); try { // If this is a core resource, we can't delete it. if (BCore()) { AfxMessageBox(IDS_CANT_DELETE_CORE_RESOURCE, MB_OK | MB_ICONSTOP); goto Cleanup; } // If this is a core resource // Verify that the user really wants to delete this resource. strMsg.FormatMessage(IDS_VERIFY_DELETE_RESOURCE, StrName()); if (AfxMessageBox(strMsg, MB_YESNO | MB_ICONEXCLAMATION | MB_DEFBUTTON2) == IDNO) { goto Cleanup; } if (Hresource() != NULL) { // Collect the list of resources which will be deleted if confirmed. CollectProvidesFor(&lpci, TRUE /*bFullTree*/); // If any of these resources are core resources, we can't // delete any of the resources. { POSITION pos; CResource * pciRes = NULL; pos = lpci.GetHeadPosition(); while (pos != NULL) { pciRes = (CResource *) lpci.GetNext(pos); ASSERT_VALID(pciRes); if (pciRes->BCore()) { AfxMessageBox(IDS_CANT_DELETE_CORE_RESOURCE, MB_OK | MB_ICONSTOP); goto Cleanup; } // if: found a core resource pciRes = NULL; } // while: more items in the list if (pciRes != NULL) { goto Cleanup; } } // Check for core resources // If this resource is a dependent of any other resource, display // another warning message. if (lpci.GetCount() > 0) { CDeleteResourcesDlg dlg(this, &lpci, AfxGetMainWnd()); if (dlg.DoModal() != IDOK) { goto Cleanup; } } // if: resource is dependent of another resource // Delete the resource. { CWaitCursor wc; DeleteResource(lpci); } // Delete the resource } // if: resource still exists } // try catch (CNTException * pnte) { if (pnte->Sc() != ERROR_RESOURCE_NOT_AVAILABLE) { pnte->ReportError(); } pnte->Delete(); } // catch: CNTException catch (CException * pe) { pe->ReportError(); pe->Delete(); } // catch: CException Cleanup: Release(); } //*** CResource::OnCmdDelete() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnUpdateProperties(CCmdUI * pCmdUI) { pCmdUI->Enable(TRUE); } //*** CResource::OnUpdateProperties() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::BDisplayProperties(IN BOOL bReadOnly) { BOOL bChanged = FALSE; CResourcePropSheet 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; } //*** CResource::BDisplayProperties() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::BAllowedToTakeOffline // // Routine Description: // Determine if this resource is allowed to be taken offline. // // Arguments: // None. // // Return Value: // TRUE Resource is allowed to be taken offline. // FALSE Resource is NOT allowed to be taken offline. // //-- ///////////////////////////////////////////////////////////////////////////// BOOL CResource::BAllowedToTakeOffline(void) { BOOL bAllowed = TRUE; ASSERT_VALID(Pdoc()); // Do this in case this object is deleted while we are operating on it. AddRef(); // Check to see if document is connected via the cluster name. if (Pdoc()->StrName() == Pdoc()->StrNode()) { // If this is the core network name resource, we need to ask // the user first. if ( (StrRealResourceType().CompareNoCase(CLUS_RESTYPE_NAME_NETNAME) == 0) && BCore() ) { bAllowed = FALSE; } else { CResourceList lpci; CResource * pciRes; POSITION pos; // Collect all the resources above this resource in the // dependency tree. If one of them is the cluster name // resource, we need to ask the user first. try { CollectProvidesFor(&lpci, TRUE /*bFullTree*/); pos = lpci.GetHeadPosition(); while (pos != NULL) { pciRes = (CResource *) lpci.GetNext(pos); ASSERT_VALID(pciRes); if ( (pciRes->StrRealResourceType().CompareNoCase(CLUS_RESTYPE_NAME_NETNAME) == 0) && pciRes->BCore() ) { bAllowed = FALSE; } } // while: more resources in the list } // try catch (CException * pe) { pe->Delete(); } // catch: CException } // else: not the cluster name resource } // if: connected via the cluster name // If not allowed to take offline, ask the user to confirm. if (!bAllowed) { ID id; CString strMsg; strMsg.FormatMessage(IDS_TAKE_CLUSTER_NAME_OFFLINE_QUERY, StrName(), Pdoc()->StrName()); id = AfxMessageBox(strMsg, MB_OKCANCEL | MB_ICONEXCLAMATION); bAllowed = (id == IDOK); } // if: not allowed to atake offline Release(); return bAllowed; } //*** CResource::BAllowedToTakeOffline() ///////////////////////////////////////////////////////////////////////////// //++ // // CResource::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 CResource::OnClusterNotify(IN OUT CClusterNotify * pnotify) { ASSERT(pnotify != NULL); ASSERT_VALID(this); try { switch (pnotify->m_dwFilterType) { case CLUSTER_CHANGE_RESOURCE_STATE: Trace(g_tagResNotify, _T("(%s) - Resource '%s' (%x) state changed (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName); UpdateState(); break; case CLUSTER_CHANGE_RESOURCE_DELETED: Trace(g_tagResNotify, _T("(%s) - Resource '%s' (%x) deleted (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName); if (Pdoc()->BClusterAvailable()) { Delete(); } break; case CLUSTER_CHANGE_RESOURCE_PROPERTY: Trace(g_tagResNotify, _T("(%s) - Resource '%s' (%x) properties changed (%s)"), Pdoc()->StrNode(), StrName(), this, pnotify->m_strName); if (!BDeleting() && Pdoc()->BClusterAvailable()) { ReadItem(); } break; case CLUSTER_CHANGE_REGISTRY_NAME: Trace(g_tagResRegNotify, _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_tagResRegNotify, _T("(%s) - Registry attributes for '%s' changed (%s %s (%x))"), Pdoc()->StrNode(), pnotify->m_strName, StrType(), StrName(), this); MarkAsChanged(); break; case CLUSTER_CHANGE_REGISTRY_VALUE: Trace(g_tagResRegNotify, _T("(%s) - Registry value '%s' changed (%s %s (%x))"), Pdoc()->StrNode(), pnotify->m_strName, StrType(), StrName(), this); MarkAsChanged(); break; default: Trace(g_tagResNotify, _T("(%s) - Unknown resource 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; } //*** CResource::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 CResourceList & rlp) { POSITION pos; CResource * pci; // Delete all the items in the Contained list. pos = rlp.GetHeadPosition(); while (pos != NULL) { pci = rlp.GetNext(pos); ASSERT_VALID(pci); // Trace(g_tagClusItemDelete, _T("DeleteAllItemData(rlpcires) - Deleting resource cluster item '%s' (%x)"), pci->StrName(), pci); pci->Delete(); } // while: more items in the list } //*** DeleteAllItemData() #endif