windows-server-2003/base/cluster/admin/cluadmin/res.cpp

/////////////////////////////////////////////////////////////////////////////
//
//  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