|
|
/*++
Module Name:
MmcRep.cpp
Abstract:
This module contains the implementation for CMmcDfsReplica. This is an class for MMC display related calls for the third level node(the Replica nodes)
--*/
#include "stdafx.h"
#include "DfsGUI.h"
#include "Utils.h" // For the LoadStringFromResource method
#include "MenuEnum.h" // Contains the menu and toolbar command ids
#include "resource.h" // For the Resource ID for strings, etc.
#include "MmcRep.h"
#include "DfsEnums.h"
#include "DfsNodes.h" // For Node GUIDs
#include "MmcRoot.h"
#include "netutils.h"
#include "staging.h"
HRESULT GetReplicationText( IN BOOL i_bFRSMember, IN CAlternateReplicaInfo* i_pRepInfo, OUT BSTR* o_pbstrColumnText, OUT BSTR* o_pbstrStatusBarText );
const int CMmcDfsReplica::m_iIMAGE_OFFSET = 20;
//////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor For _DFS_REPLICA_LIST
REP_LIST_NODE :: REP_LIST_NODE (CMmcDfsReplica* i_pMmcReplica) { pReplica = i_pMmcReplica;}
//////////////////////////////////////////////////////////////////////////////////////////////////
// destructor
REP_LIST_NODE :: ~REP_LIST_NODE (){ SAFE_RELEASE(pReplica);}
CMmcDfsReplica::CMmcDfsReplica( IN IDfsReplica* i_pReplicaObject, IN CMmcDfsJunctionPoint* i_pJPObject ){ dfsDebugOut((_T("CMmcDfsReplica::CMmcDfsReplica this=%p\n"), this));
MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pReplicaObject); MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pJPObject);
m_pDfsReplicaObject = i_pReplicaObject; m_pDfsParentJP = i_pJPObject; m_pDfsParentRoot = NULL;
m_pRepInfo = NULL; m_bFRSMember = FALSE;
// Get the display name from the IDfsReplica
HRESULT hr = m_pDfsReplicaObject->get_StorageServerName(&m_bstrServerName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr); hr = m_pDfsReplicaObject->get_StorageShareName(&m_bstrShareName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr); hr = GetDfsReplicaDisplayName(m_bstrServerName, m_bstrShareName, &m_bstrDisplayName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
hr = m_pDfsReplicaObject->get_State(&m_lReferralState); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
if (DFS_REFERRAL_STATE_ONLINE == m_lReferralState) LoadStringFromResource(IDS_ENABLED, &m_bstrDfsReferralColumnText); else LoadStringFromResource(IDS_DISABLED, &m_bstrDfsReferralColumnText);
m_lTargetState = DFS_TARGET_STATE_UNASSIGNED; LoadStringFromResource(IDS_TARGET_STATUS_UNKNOWN, &m_bstrTargetStatusColumnText);
m_CLSIDNodeType = s_guidDfsReplicaNodeType; m_bstrDNodeType = s_tchDfsReplicaNodeType;}
CMmcDfsReplica::CMmcDfsReplica( IN IDfsReplica* i_pReplicaObject, IN CMmcDfsRoot* i_pRootObject ){ dfsDebugOut((_T("CMmcDfsReplica::CMmcDfsReplica this=%p\n"), this));
MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pReplicaObject); MMC_DISP_CTOR_RETURN_INVALIDARG_IF_NULL(i_pRootObject);
m_pDfsReplicaObject = i_pReplicaObject; m_pDfsParentRoot = i_pRootObject; m_pDfsParentJP = NULL;
m_pRepInfo = NULL; m_bFRSMember = FALSE;
// Get the display name from the IDfsReplica
HRESULT hr = m_pDfsReplicaObject->get_StorageServerName(&m_bstrServerName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr); hr = m_pDfsReplicaObject->get_StorageShareName(&m_bstrShareName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr); hr = GetDfsReplicaDisplayName(m_bstrServerName, m_bstrShareName, &m_bstrDisplayName); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
hr = m_pDfsReplicaObject->get_State(&m_lReferralState); MMC_DISP_CTOR_RETURN_HR_IF_FAILED(hr);
if (DFS_REFERRAL_STATE_ONLINE == m_lReferralState) LoadStringFromResource(IDS_ENABLED, &m_bstrDfsReferralColumnText); else LoadStringFromResource(IDS_DISABLED, &m_bstrDfsReferralColumnText);
m_lTargetState = DFS_TARGET_STATE_UNASSIGNED; LoadStringFromResource(IDS_TARGET_STATUS_UNKNOWN, &m_bstrTargetStatusColumnText);
m_CLSIDNodeType = s_guidDfsReplicaNodeType; m_bstrDNodeType = s_tchDfsReplicaNodeType;}
CMmcDfsReplica::~CMmcDfsReplica(){ if (m_pRepInfo) delete m_pRepInfo;
dfsDebugOut((_T("CMmcDfsReplica::~CMmcDfsReplica this=%p\n"), this));}
STDMETHODIMP CMmcDfsReplica :: AddMenuItems( IN LPCONTEXTMENUCALLBACK i_lpContextMenuCallback, IN LPLONG i_lpInsertionAllowed)/*++
Routine Description:
This routine adds the context menu for Replica nodes using the ContextMenuCallback provided.
Arguments:
lpContextMenuCallback - A callback(function pointer) that is used to add the menu items
lpInsertionAllowed - Specifies what menus can be added and where they can be added.
--*/{ RETURN_INVALIDARG_IF_NULL(i_lpContextMenuCallback);
enum { IDM_CONTEXTMENU_COMMAND_MAX = IDM_REPLICA_MAX, IDM_CONTEXTMENU_COMMAND_MIN = IDM_REPLICA_MIN };
LONG lInsertionPoints [IDM_CONTEXTMENU_COMMAND_MAX - IDM_CONTEXTMENU_COMMAND_MIN + 1] = { CCM_INSERTIONPOINTID_PRIMARY_TOP, CCM_INSERTIONPOINTID_PRIMARY_TOP, CCM_INSERTIONPOINTID_PRIMARY_TOP, CCM_INSERTIONPOINTID_PRIMARY_TOP, CCM_INSERTIONPOINTID_PRIMARY_TOP, CCM_INSERTIONPOINTID_PRIMARY_TOP };
LPTSTR aszLanguageIndependentName[IDM_CONTEXTMENU_COMMAND_MAX - IDM_CONTEXTMENU_COMMAND_MIN + 1] = { _T("ReplicaTopOpen"), _T("ReplicaTopCheckStatus"), _T("ReplicaTopTakeReplicaOfflineOnline"), _T("ReplicaTopRemoveFromDfs"), _T("ReplicaTopReplicate"), _T("ReplicaTopStopReplication") };
CComPtr<IContextMenuCallback2> spiCallback2; HRESULT hr = i_lpContextMenuCallback->QueryInterface(IID_IContextMenuCallback2, (void **)&spiCallback2); RETURN_IF_FAILED(hr);
BOOL bShowFRS = FALSE; if (m_pDfsParentRoot) bShowFRS = m_pDfsParentRoot->get_ShowFRS(); else bShowFRS = m_pDfsParentJP->get_ShowFRS();
for (int iCommandID = IDM_CONTEXTMENU_COMMAND_MIN, iMenuResource = IDS_MENUS_REPLICA_TOP_OPEN; iCommandID <= IDM_CONTEXTMENU_COMMAND_MAX; iCommandID++,iMenuResource++) { // No TakeOnlineOffline on root replicas
if (m_pDfsParentRoot && IDM_REPLICA_TOP_TAKE_REPLICA_OFFLINE_ONLINE == iCommandID) continue;
if (!bShowFRS && (IDM_REPLICA_TOP_REPLICATE == iCommandID || IDM_REPLICA_TOP_STOP_REPLICATION == iCommandID)) { continue; }
// bShowFRS is FALSE if it's a standalone DFS or user is not interested in seeing FRS info.
// Hence, there is no need to retrieve replication info here. This will greatly improve PERF
// especially when dealing with DFS hosted on standalone server, save us the call to DsGetDCName.
if (bShowFRS && !m_pRepInfo) GetReplicationInfo();
if (bShowFRS && m_pRepInfo && FRSSHARE_TYPE_OK != m_pRepInfo->m_nFRSShareType && (IDM_REPLICA_TOP_REPLICATE == iCommandID || IDM_REPLICA_TOP_STOP_REPLICATION == iCommandID)) { continue; }
if (m_bFRSMember && IDM_REPLICA_TOP_REPLICATE == iCommandID) { continue; }
if (!m_bFRSMember && IDM_REPLICA_TOP_STOP_REPLICATION == iCommandID) { continue; }
CComBSTR bstrMenuText; CComBSTR bstrStatusBarText; hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, NULL, &bstrStatusBarText); RETURN_IF_FAILED(hr);
CONTEXTMENUITEM2 ContextMenuItem; // The structure which contains menu information
ZeroMemory(&ContextMenuItem, sizeof(ContextMenuItem)); ContextMenuItem.strName = bstrMenuText; ContextMenuItem.strStatusBarText = bstrStatusBarText; ContextMenuItem.lInsertionPointID = lInsertionPoints[iCommandID - IDM_CONTEXTMENU_COMMAND_MIN]; ContextMenuItem.lCommandID = iCommandID; ContextMenuItem.strLanguageIndependentName = aszLanguageIndependentName[iCommandID - IDM_CONTEXTMENU_COMMAND_MIN];
LONG lInsertionFlag = 0; switch(ContextMenuItem.lInsertionPointID) { case CCM_INSERTIONPOINTID_PRIMARY_TOP: lInsertionFlag = CCM_INSERTIONALLOWED_TOP; break; case CCM_INSERTIONPOINTID_PRIMARY_NEW: lInsertionFlag = CCM_INSERTIONALLOWED_NEW; break; case CCM_INSERTIONPOINTID_PRIMARY_TASK: lInsertionFlag = CCM_INSERTIONALLOWED_TASK; break; case CCM_INSERTIONPOINTID_PRIMARY_VIEW: lInsertionFlag = CCM_INSERTIONALLOWED_VIEW; break; default: break; }
if (*i_lpInsertionAllowed & lInsertionFlag) { hr = spiCallback2->AddItem(&ContextMenuItem); RETURN_IF_FAILED(hr); } } // for
return hr;}
STDMETHODIMP CMmcDfsReplica::Command( IN LONG i_lCommandID )/*++
Routine Description:
Action to be taken on a context menu selection or click is takes place.
Arguments:
lCommandID - The Command ID of the menu for which action has to be taken
--*/{ HRESULT hr = S_OK;
switch (i_lCommandID) { case IDM_REPLICA_TOP_OPEN: hr = OnOpen(); break; case IDM_REPLICA_TOP_REMOVE_FROM_DFS: hr = DoDelete(); break; case IDM_REPLICA_TOP_CHECK_STATUS: hr = OnCheckStatus (); if (FAILED(hr)) DisplayMessageBoxForHR(hr); break; case IDM_REPLICA_TOP_TAKE_REPLICA_OFFLINE_ONLINE: hr = TakeReplicaOffline(); break; case IDM_REPLICA_TOP_REPLICATE: { hr = m_pDfsReplicaObject->FindTarget(); if (S_OK != hr) { //
// the target has been deleted by others, refresh the root/link
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_TARGET); if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } else { hr = OnReplicate (); } break; } case IDM_REPLICA_TOP_STOP_REPLICATION: { hr = m_pDfsReplicaObject->FindTarget(); if (S_OK != hr) { //
// the target has been deleted by others, refresh the root/link
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_TARGET); if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } else { BOOL bRepSetExist = FALSE; hr = AllowFRSMemberDeletion(&bRepSetExist); if (bRepSetExist && SUCCEEDED(hr)) { if (S_OK == hr) { hr = OnStopReplication(TRUE); if (FAILED(hr)) DisplayMessageBoxForHR(hr); } } else { if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } } break; } default: hr = E_INVALIDARG; break; }
return hr;}
STDMETHODIMP CMmcDfsReplica::SetColumnHeader( IN LPHEADERCTRL2 i_piHeaderControl ){ return S_OK;}
STDMETHODIMP CMmcDfsReplica::GetResultDisplayInfo( IN OUT LPRESULTDATAITEM io_pResultDataItem )/*++
Routine Description:
Returns the information required for MMC display for this item.
Arguments:
io_pResultDataItem - The ResultItem which specifies what display information is required
--*/{ RETURN_INVALIDARG_IF_NULL(io_pResultDataItem);
if (RDI_IMAGE & io_pResultDataItem->mask) io_pResultDataItem->nImage = CMmcDfsReplica::m_iIMAGE_OFFSET + m_lTargetState;
if (RDI_STR & io_pResultDataItem->mask) { switch (io_pResultDataItem->nCol) { case 0: io_pResultDataItem->str = m_bstrDisplayName; break; case 1: // DFS Referral
io_pResultDataItem->str = m_bstrDfsReferralColumnText; break; case 2: // Status
io_pResultDataItem->str = m_bstrTargetStatusColumnText; break; case 3: io_pResultDataItem->str = m_bstrFRSColumnText; break; default: break; } }
return S_OK;}
STDMETHODIMP CMmcDfsReplica::SetConsoleVerbs( IN LPCONSOLEVERB i_lpConsoleVerb ) /*++
Routine Description:
Routine used to set the console verb settings. Sets all of them except Open off. For all scope pane items, default verb is "open'. For result items, it is "properties"
Arguments:
i_lpConsoleVerb - The callback used to handle console verbs--*/{ RETURN_INVALIDARG_IF_NULL(i_lpConsoleVerb);
i_lpConsoleVerb->SetVerbState(MMC_VERB_COPY, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_PASTE, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_RENAME, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_PRINT, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_REFRESH, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_DELETE, HIDDEN, TRUE); i_lpConsoleVerb->SetVerbState(MMC_VERB_OPEN, HIDDEN, TRUE);
i_lpConsoleVerb->SetVerbState(MMC_VERB_PROPERTIES, ENABLED, FALSE);
return S_OK; }
STDMETHODIMP CMmcDfsReplica::AddItemToResultPane ( IResultData* i_lpResultData ) /*++
Routine Description:
Adds an item (a replica result pane item) to the result pane.
Arguments:
i_lpResultData - The pointer to the IResultData interface on which InsertItem will be called.
--*/{ RESULTDATAITEM ReplicaResultDataItem; ZeroMemory(&ReplicaResultDataItem, sizeof(ReplicaResultDataItem));
ReplicaResultDataItem.mask = RDI_PARAM | RDI_STR | RDI_IMAGE; ReplicaResultDataItem.lParam = reinterpret_cast<LPARAM> (this); ReplicaResultDataItem.str = MMC_TEXTCALLBACK; ReplicaResultDataItem.nImage = CMmcDfsReplica::m_iIMAGE_OFFSET + m_lTargetState; // set the icon to the default status
// i.e. no known status
HRESULT hr = i_lpResultData -> InsertItem (&ReplicaResultDataItem); RETURN_IF_FAILED(hr); m_pResultData = i_lpResultData; m_hResultItem = ReplicaResultDataItem.itemID;
return hr;}
STDMETHODIMP CMmcDfsReplica :: RemoveReplica( ) /*++
Routine Description:
Handles the removal of a replica from the replica set of a junction point.
--*/{ //
// delete it from replica set
//
HRESULT hr = RemoveReplicaFromSet(); RETURN_IF_FAILED(hr);
CWaitCursor Wait;
if (m_pDfsParentRoot) { // This means that this is a root level replica.
// The removal of Root level Replica is by tearing
// down Dfs.
CComBSTR bstrFTDfsName; if (DFS_TYPE_FTDFS == m_pDfsParentRoot->m_lDfsRootType) { hr = m_pDfsParentRoot->m_DfsRoot->get_DfsName(&bstrFTDfsName); RETURN_IF_FAILED(hr); }
hr = m_pDfsParentRoot->_DeleteDfsRoot(m_bstrServerName, m_bstrShareName, bstrFTDfsName); RETURN_IF_FAILED(hr); } else { hr = m_pDfsParentJP->m_pDfsJPObject->RemoveReplica(m_bstrServerName, m_bstrShareName); RETURN_IF_FAILED(hr); }
m_pResultData->DeleteItem(m_hResultItem, 0);
// Remove item from list and Re-display List.
if (m_pDfsParentRoot) hr = m_pDfsParentRoot->RemoveResultPaneItem(this); else hr = m_pDfsParentJP->RemoveResultPaneItem(this);
return hr;}
//
// Call the corresponding root/link's RemoveReplica() method to:
// 1. refresh the root/link node to pick up possible namespace updates by others,
// 2. then locate the appropriate target to actually perform the removal operation.
//
STDMETHODIMP CMmcDfsReplica::OnRemoveReplica( ) { HRESULT hr = S_OK;
if (m_pDfsParentRoot) hr = m_pDfsParentRoot->RemoveReplica(m_bstrDisplayName); else hr = m_pDfsParentJP->RemoveReplica(m_bstrDisplayName);
return hr;}
STDMETHODIMP CMmcDfsReplica :: ConfirmOperationOnDfsTarget(int idString)/*++
Routine Description:
Asks the user for confirmation of whether he really wants to remove the particular replica from the replica set.
--*/{ CComBSTR bstrAppName; HRESULT hr = LoadStringFromResource (IDS_APPLICATION_NAME, &bstrAppName); RETURN_IF_FAILED(hr);
CComBSTR bstrFormattedMessage; hr = FormatResourceString (idString, m_bstrDisplayName, &bstrFormattedMessage); RETURN_IF_FAILED(hr);
CThemeContextActivator activator; if (IDNO == ::MessageBox(::GetActiveWindow(), bstrFormattedMessage, bstrAppName, MB_YESNO | MB_ICONEXCLAMATION | MB_APPLMODAL)) return S_FALSE;
return S_OK;}
STDMETHODIMP CMmcDfsReplica::DoDelete( ) /*++
Routine Description:
This method allows the item to delete itself. Called when DEL key is pressed or when the "Delete" context menu item is selected.
--*/{ HRESULT hr = S_OK; if (NULL != m_pDfsParentRoot) hr = m_pDfsParentRoot->ClosePropertySheet(FALSE); else hr = m_pDfsParentJP->ClosePropertySheet(FALSE); if (S_OK != hr) return hr; // if property page found, discontinue
hr = ConfirmOperationOnDfsTarget(NULL != m_pDfsParentRoot ? IDS_MSG_REMOVE_ROOT_REPLICA : IDS_MSG_REMOVE_REPLICA); if(S_OK != hr) // User decided to abort the operation
return S_OK;
CWaitCursor wait;
BOOL bRepSetExist = FALSE; hr = AllowFRSMemberDeletion(&bRepSetExist); if (bRepSetExist && S_OK != hr) // not allowed on a hub or user cancelled the operation
return S_OK;
hr = OnRemoveReplica(); if(FAILED(hr) && !m_pDfsParentRoot) // For Root level replica
// Error message is already displayed.
{ DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_WIZ_DELETE_REPLICA_FAILURE); }
return hr;}
HRESULT CMmcDfsReplica::OnReplicate(){ CWaitCursor wait;
HRESULT hr = S_OK; CComPtr<IReplicaSet> piReplicaSet; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->GetIReplicaSetPtr(&piReplicaSet); else hr = m_pDfsParentJP->GetIReplicaSetPtr(&piReplicaSet); if (FAILED(hr)) { DisplayMessageBoxForHR(hr); return hr; } else if (S_OK != hr) // no replica set on the corresponding link/root
return hr;
// refresh m_pRepInfo
GetReplicationInfo();
m_bFRSMember = FALSE;
if (FRSSHARE_TYPE_OK != m_pRepInfo->m_nFRSShareType) { GetReplicationText(m_bFRSMember, m_pRepInfo, &m_bstrFRSColumnText, &m_bstrStatusText); DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_MSG_ADDFRSMEMBER_FAILED_EX, m_pRepInfo->m_bstrDisplayName, m_bstrStatusText); } else { // confirm the staging path
CStagingDlg dlg; hr = dlg.Init(m_pRepInfo); if (FAILED(hr)) { DisplayMessageBoxForHR(hr); return hr; }
dlg.DoModal();
CWaitCursor wait;
(void) CreateAndHideStagingPath(m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrStagingPath);
hr = ConfigAndStartNtfrs(m_pRepInfo->m_bstrDnsHostName); if (SUCCEEDED(hr) || IDYES == DisplayMessageBox( ::GetActiveWindow(), MB_YESNO, hr, IDS_MSG_FRS_BADSERVICE, m_pRepInfo->m_bstrDisplayName, m_pRepInfo->m_bstrDnsHostName)) { hr = AddFRSMember(piReplicaSet, m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath, m_pRepInfo->m_bstrStagingPath);
if (S_OK == hr) m_bFRSMember = TRUE; else if (S_FALSE == hr) { DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_MSG_TARGETS_ONSAMECOMPUTER_1, m_pRepInfo->m_bstrDnsHostName); }
GetReplicationText(m_bFRSMember, m_pRepInfo, &m_bstrFRSColumnText, &m_bstrStatusText); } }
_UpdateThisItem();
return hr;}
HRESULT CMmcDfsReplica::OnStopReplication(BOOL bConfirm /* = FALSE */){ HRESULT hr = S_OK;
if (bConfirm) { hr = ConfirmOperationOnDfsTarget(IDS_MSG_STOP_REPLICATION_TARGET); if (S_OK != hr) return hr; }
CWaitCursor wait;
CComPtr<IReplicaSet> piReplicaSet; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->GetIReplicaSetPtr(&piReplicaSet); else hr = m_pDfsParentJP->GetIReplicaSetPtr(&piReplicaSet); if (S_OK != hr) // no replica set on the corresponding link/root
hr = S_OK; else { if (!m_pRepInfo) GetReplicationInfoEx(&m_pRepInfo);
if (!m_pRepInfo->m_bstrDnsHostName || !m_pRepInfo->m_bstrRootPath) { hr = DeleteBadFRSMember(piReplicaSet, m_pRepInfo->m_bstrDisplayName, m_pRepInfo->m_hrFRS);
if (S_FALSE == hr) // operation cancelled
return hr; } else { hr = DeleteFRSMember(piReplicaSet, m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath); } }
if (SUCCEEDED(hr)) { m_bFRSMember = FALSE;
m_bstrFRSColumnText.Empty(); m_bstrStatusText.Empty(); LoadStringFromResource(IDS_DISABLED, &m_bstrFRSColumnText); LoadStringFromResource(IDS_REPLICATION_STATUSBAR_NONMEMBER, &m_bstrStatusText);
_UpdateThisItem(); }
return hr;}
STDMETHODIMP CMmcDfsReplica::OnCheckStatus( ) /*++
Routine Description:
This method checks the state of the replica.
--*/{ CWaitCursor WaitCursor;
// check network connectivity from this client computer to this target
m_bstrTargetStatusColumnText.Empty(); if (0xffffffff == GetFileAttributes(m_bstrDisplayName)) { m_lTargetState = DFS_TARGET_STATE_UNREACHABLE; LoadStringFromResource(IDS_TARGET_STATUS_UNREACHABLE, &m_bstrTargetStatusColumnText); } else { m_lTargetState = DFS_TARGET_STATE_OK; LoadStringFromResource(IDS_TARGET_STATUS_OK, &m_bstrTargetStatusColumnText); }
_UpdateThisItem();
return S_OK;}
void CMmcDfsReplica::_UpdateThisItem(){ if (m_pDfsParentRoot) { m_pDfsParentRoot->m_lpConsole->UpdateAllViews( (IDataObject*)m_pDfsParentRoot, // Parent object
(LPARAM)((CMmcDisplay *)this), 1); } else { m_pDfsParentJP->m_pDfsParentRoot->m_lpConsole->UpdateAllViews( (IDataObject*)m_pDfsParentJP, // Parent object
(LPARAM)((CMmcDisplay *)this), 1); }}
HRESULT CMmcDfsReplica::ToolbarSelect( IN const LONG i_lArg, IN IToolbar* i_pToolBar )/*++
Routine Description:
Handle a select event for a toolbar Create a toolbar, it it doesn't exist. Attach the toolbar and enable the buttons, if the event for a selection. Disable the buttons, if the event was for a deselection
Arguments: i_lArg - The argument passed to the actual method. o_pToolBar - The Toolbar pointer. the class exposed to MMC.--*/{ RETURN_INVALIDARG_IF_NULL(i_pToolBar);
BOOL bSelect = (BOOL) HIWORD(i_lArg);
EnableToolbarButtons(i_pToolBar, IDT_REPLICA_MIN, IDT_REPLICA_MAX, bSelect);
if (bSelect) { // No TakeOnlineOffline on root replicas
if (m_pDfsParentRoot) { i_pToolBar->SetButtonState(IDT_REPLICA_TAKE_REPLICA_OFFLINE_ONLINE, ENABLED, FALSE); i_pToolBar->SetButtonState(IDT_REPLICA_TAKE_REPLICA_OFFLINE_ONLINE, HIDDEN, TRUE); }
BOOL bShowFRS = FALSE; if (m_pDfsParentRoot) bShowFRS = m_pDfsParentRoot->get_ShowFRS(); else bShowFRS = m_pDfsParentJP->get_ShowFRS();
// bShowFRS is FALSE if it's a standalone DFS or user is not interested in seeing FRS info.
// Hence, there is no need to retrieve replication info here. This will greatly improve PERF
// especially when dealing with DFS hosted on standalone server, save us the call to DsGetDCName.
if (bShowFRS && !m_pRepInfo) GetReplicationInfo();
if (!bShowFRS || (m_pRepInfo && FRSSHARE_TYPE_OK != m_pRepInfo->m_nFRSShareType)) { i_pToolBar->SetButtonState(IDT_REPLICA_REPLICATE, ENABLED, FALSE); i_pToolBar->SetButtonState(IDT_REPLICA_REPLICATE, HIDDEN, TRUE); i_pToolBar->SetButtonState(IDT_REPLICA_STOP_REPLICATION, ENABLED, FALSE); i_pToolBar->SetButtonState(IDT_REPLICA_STOP_REPLICATION, HIDDEN, TRUE); } else if (m_bFRSMember) { i_pToolBar->SetButtonState(IDT_REPLICA_REPLICATE, ENABLED, FALSE); i_pToolBar->SetButtonState(IDT_REPLICA_REPLICATE, HIDDEN, TRUE); } else { i_pToolBar->SetButtonState(IDT_REPLICA_STOP_REPLICATION, ENABLED, FALSE); i_pToolBar->SetButtonState(IDT_REPLICA_STOP_REPLICATION, HIDDEN, TRUE); }
}
return S_OK; }
HRESULTCMmcDfsReplica::CreateToolbar( IN const LPCONTROLBAR i_pControlbar, IN const LPEXTENDCONTROLBAR i_lExtendControlbar, OUT IToolbar** o_pToolBar )/*++
Routine Description:
Create the toolbar. Involves the actual toolbar creation call, creating the bitmap and adding it and finally adding the buttons to the toolbar
Arguments: i_pControlbar - The controlbar used to create toolbar. i_lExtendControlbar - The object implementing IExtendControlbar. This is the class exposed to MMC.--*/{ RETURN_INVALIDARG_IF_NULL(i_pControlbar); RETURN_INVALIDARG_IF_NULL(i_lExtendControlbar); RETURN_INVALIDARG_IF_NULL(o_pToolBar);
// Create the toolbar
HRESULT hr = i_pControlbar->Create(TOOLBAR, i_lExtendControlbar, reinterpret_cast<LPUNKNOWN*>(o_pToolBar)); RETURN_IF_FAILED(hr);
// Add the bitmap to the toolbar
hr = AddBitmapToToolbar(*o_pToolBar, IDB_REPLICA_TOOLBAR); RETURN_IF_FAILED(hr);
int iButtonPosition = 0; // The first button position
for (int iCommandID = IDT_REPLICA_MIN, iMenuResource = IDS_MENUS_REPLICA_TOP_OPEN; iCommandID <= IDT_REPLICA_MAX; iCommandID++,iMenuResource++,iButtonPosition++) { CComBSTR bstrMenuText; CComBSTR bstrToolTipText; hr = GetMenuResourceStrings(iMenuResource, &bstrMenuText, &bstrToolTipText, NULL); RETURN_IF_FAILED(hr);
MMCBUTTON ToolbarButton; ZeroMemory(&ToolbarButton, sizeof ToolbarButton); ToolbarButton.nBitmap = iButtonPosition; ToolbarButton.idCommand = iCommandID; ToolbarButton.fsState = TBSTATE_ENABLED; ToolbarButton.fsType = TBSTYLE_BUTTON; ToolbarButton.lpButtonText = bstrMenuText; ToolbarButton.lpTooltipText = bstrToolTipText;
// Add the button to the toolbar
hr = (*o_pToolBar)->InsertButton(iButtonPosition, &ToolbarButton); RETURN_IF_FAILED(hr); }
return hr;}
STDMETHODIMP CMmcDfsReplica::ToolbarClick( IN const LPCONTROLBAR i_pControlbar, IN const LPARAM i_lParam ) /*++
Routine Description:
Action to take on a click on a toolbar
Arguments: i_pControlbar - The controlbar used to create toolbar. i_lParam - The lparam to the actual notify. This is the command id of the button on which a click occurred.--*/{ RETURN_INVALIDARG_IF_NULL(i_pControlbar);
HRESULT hr = S_OK;
switch(i_lParam) // What button did the user click on.
{ case IDT_REPLICA_REMOVE_FROM_DFS: hr = DoDelete(); break; case IDT_REPLICA_TAKE_REPLICA_OFFLINE_ONLINE: hr = TakeReplicaOffline(); break; case IDT_REPLICA_CHECK_STATUS: hr = OnCheckStatus (); if (FAILED(hr)) DisplayMessageBoxForHR(hr); break; case IDT_REPLICA_REPLICATE: { hr = m_pDfsReplicaObject->FindTarget(); if (S_OK != hr) { //
// the target has been deleted by others, refresh the root/link
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_TARGET); if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } else { hr = OnReplicate(); }
break; } case IDT_REPLICA_STOP_REPLICATION: { hr = m_pDfsReplicaObject->FindTarget(); if (S_OK != hr) { //
// the target has been deleted by others, refresh the root/link
//
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_TARGET); if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } else { BOOL bRepSetExist = FALSE; hr = AllowFRSMemberDeletion(&bRepSetExist); if (bRepSetExist && SUCCEEDED(hr)) { if (S_OK == hr) { hr = OnStopReplication(TRUE); if (FAILED(hr)) DisplayMessageBoxForHR(hr); } } else { if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } }
break; } case IDT_REPLICA_OPEN: hr = OnOpen(); break; default: break; };
return hr; }
HRESULTCMmcDfsReplica::OnOpen( )/*++
Routine Description:
Open the display path for this replica
--*/{ CWaitCursor WaitCursor; // Display the wait cursor
if (-1 == GetFileAttributes(m_bstrDisplayName) || // bug#96670
32 >= (INT_PTR) ShellExecute( NULL, // Handle to window
_T("explore"), // Action to take
m_bstrDisplayName, // Folder to explore
NULL, // Parameters
NULL, // Default directory
SW_SHOWNORMAL // Show command
)) { DisplayMessageBoxWithOK(IDS_MSG_EXPLORE_FAILURE, m_bstrDisplayName); return(S_FALSE); }
return S_OK;}
STDMETHODIMP CMmcDfsReplica::TakeReplicaOffline( ) {/*++
Routine Description:
Take replica offline by calling put_State method of replica.
--*/
CWaitCursor WaitCursor;
// Always toggle the mapping status.
long lReplicaState = DFS_REFERRAL_STATE_OFFLINE; HRESULT hr = m_pDfsReplicaObject->get_State(&lReplicaState);
if (S_OK == hr) { long newVal = 0;
switch (lReplicaState) { case DFS_REFERRAL_STATE_ONLINE: newVal = DFS_REFERRAL_STATE_OFFLINE; hr = m_pDfsReplicaObject->put_State(newVal); if (SUCCEEDED(hr)) m_lReferralState = newVal; break; case DFS_REFERRAL_STATE_OFFLINE: newVal = DFS_REFERRAL_STATE_ONLINE; hr = m_pDfsReplicaObject->put_State(newVal); if (SUCCEEDED(hr)) m_lReferralState = newVal; break; default: break; } }
if (S_OK == hr) { m_bstrDfsReferralColumnText.Empty(); if (DFS_REFERRAL_STATE_ONLINE == m_lReferralState) { LoadStringFromResource(IDS_ENABLED, &m_bstrDfsReferralColumnText); } else { LoadStringFromResource(IDS_DISABLED, &m_bstrDfsReferralColumnText); }
_UpdateThisItem(); } else if (S_FALSE == hr) { //
// this target has been deleted by other means, refresh the root/link,
//
m_lReferralState = DFS_REFERRAL_STATE_OFFLINE; m_bstrDfsReferralColumnText.Empty(); LoadStringFromResource(IDS_DISABLED, &m_bstrDfsReferralColumnText);
m_lTargetState = DFS_TARGET_STATE_UNASSIGNED; m_bstrTargetStatusColumnText.Empty(); LoadStringFromResource(IDS_TARGET_STATUS_UNKNOWN, &m_bstrTargetStatusColumnText);
DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_INVALID_TARGET); if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnRefresh(); else hr = m_pDfsParentJP->OnRefresh(); } else { DisplayMessageBoxForHR(hr); }
return hr;}
STDMETHODIMP CMmcDfsReplica::ViewChange( IResultData* i_pResultData, LONG_PTR i_lHint )/*++
Routine Description:
This method handles the MMCN_VIEW_CHANGE notification. This updates the icon for the replica item as this is called when the state changes. i_lHint is ignored here.
--*/{ RETURN_INVALIDARG_IF_NULL(i_pResultData);
HRESULT hr = S_OK;
if (i_pResultData != NULL) { RESULTDATAITEM ResultDataItem; ZeroMemory(&ResultDataItem, sizeof(ResultDataItem)); hr = i_pResultData->FindItemByLParam((LPARAM)(this), &(ResultDataItem.itemID)); RETURN_IF_FAILED(hr);
ResultDataItem.mask = RDI_IMAGE; ResultDataItem.nCol = 0; ResultDataItem.nImage = CMmcDfsReplica::m_iIMAGE_OFFSET + m_lTargetState; i_pResultData->SetItem(&ResultDataItem);
ResultDataItem.mask = RDI_STR; ResultDataItem.nCol = 1; ResultDataItem.str= MMC_TEXTCALLBACK; i_pResultData->SetItem(&ResultDataItem);
ResultDataItem.mask = RDI_STR; ResultDataItem.nCol = 2; ResultDataItem.str= MMC_TEXTCALLBACK; i_pResultData->SetItem(&ResultDataItem);
BOOL bShowFRS = FALSE; if (m_pDfsParentRoot) bShowFRS = m_pDfsParentRoot->get_ShowFRS(); else bShowFRS = m_pDfsParentJP->get_ShowFRS();
if (bShowFRS) { ResultDataItem.mask = RDI_STR; ResultDataItem.nCol = 3; ResultDataItem.str= MMC_TEXTCALLBACK; i_pResultData->SetItem(&ResultDataItem); } }
return hr;}
//
// Set m_ReplicationState and m_hrFRS appropriately
//
// Return:
// "No" if this alternate is not a Frs member
// "N/A: <reason>" if this alternate is not eligible to join frs
// hr: if we cannot get info on this alternate
void CAlternateReplicaInfo::Reset(){ m_bstrDisplayName.Empty(); m_bstrDnsHostName.Empty(); m_bstrRootPath.Empty(); m_bstrStagingPath.Empty(); m_nFRSShareType = FRSSHARE_TYPE_OK; m_hrFRS = S_OK; m_dwServiceStartType = SERVICE_AUTO_START; m_dwServiceState = SERVICE_RUNNING;}
HRESULT PathOverlapped(LPCTSTR pszPath1, LPCTSTR pszPath2){ if (!pszPath1 || !*pszPath1 || !pszPath2 || !*pszPath2) return E_INVALIDARG;
BOOL bOverlapped = FALSE;
int len1 = lstrlen(pszPath1); int len2 = lstrlen(pszPath2); int minLen = min(len1, len2);
if (len1 == len2) { if (!lstrcmpi(pszPath1, pszPath2)) bOverlapped = TRUE; } else { LPCTSTR pszLongerOne = ((len1 < len2) ? pszPath2 : pszPath1); CComBSTR bstrShorterOne = ((len1 < len2) ? pszPath1 : pszPath2); RETURN_OUTOFMEMORY_IF_NULL((BSTR)bstrShorterOne);
BOOL bEndingSlash = (_T('\\') == *(bstrShorterOne + minLen - 1)); if (!bEndingSlash) { bstrShorterOne += _T("\\"); RETURN_OUTOFMEMORY_IF_NULL((BSTR)bstrShorterOne); minLen++; }
if (!mylstrncmpi(pszLongerOne, (BSTR)bstrShorterOne, minLen)) bOverlapped = TRUE; } return bOverlapped ? S_OK : S_FALSE;}
HRESULT CMmcDfsReplica::GetReplicationInfoEx(CAlternateReplicaInfo** o_ppInfo){ RETURN_INVALIDARG_IF_NULL(o_ppInfo);
CAlternateReplicaInfo* pInfo = new CAlternateReplicaInfo; RETURN_OUTOFMEMORY_IF_NULL(pInfo);
pInfo->m_bstrDisplayName = m_bstrDisplayName; if (!pInfo->m_bstrDisplayName) { delete pInfo; return E_OUTOFMEMORY; }
HRESULT hr = S_OK; do { //
// validate connectivity
//
if (-1 == GetFileAttributes(pInfo->m_bstrDisplayName)) { hr = HRESULT_FROM_WIN32(GetLastError()); break; }
//
// exclude non-Lanman share resources, e.g., webdav
//
hr = CheckResourceProvider(pInfo->m_bstrDisplayName); if (S_OK != hr) { pInfo->m_nFRSShareType = FRSSHARE_TYPE_NOTSMBDISK; hr = S_OK; break; }
//
// retrieve DnsHostName
//
CComBSTR bstrComputerGuid; SUBSCRIBERLIST FRSRootList; hr= GetServerInfo( m_bstrServerName, NULL, // Domain,
NULL, // NetbiosServerName,
NULL, // bValidComputerObject,
&(pInfo->m_bstrDnsHostName), &bstrComputerGuid, NULL, // FQDN
&FRSRootList); BREAK_IF_FAILED(hr); if (S_FALSE == hr) { pInfo->m_nFRSShareType = FRSSHARE_TYPE_NODOMAIN; break; }
//
// retrieve RootPath
//
hr = GetFolderInfo( m_bstrServerName, m_bstrShareName, &(pInfo->m_bstrRootPath)); BREAK_IF_FAILED(hr);
//
// calculate memberDN for this target
//
CComBSTR bstrReplicaSetDN; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->m_DfsRoot->get_ReplicaSetDN(&bstrReplicaSetDN); else hr = m_pDfsParentJP->m_pDfsJPObject->get_ReplicaSetDN(&bstrReplicaSetDN); BREAK_IF_FAILED(hr);
CComBSTR bstrDomainDN; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->m_DfsRoot->get_DomainDN(&bstrDomainDN); else hr = m_pDfsParentJP->m_pDfsParentRoot->m_DfsRoot->get_DomainDN(&bstrDomainDN); BREAK_IF_FAILED(hr);
CComBSTR bstrMemberDN = _T("CN="); BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr); bstrMemberDN += bstrComputerGuid; BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr); bstrMemberDN += _T(","); BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr); bstrMemberDN += bstrReplicaSetDN; BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr); bstrMemberDN += _T(","); BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr); bstrMemberDN += bstrDomainDN; BREAK_OUTOFMEMORY_IF_NULL((BSTR)bstrMemberDN, &hr);
//
// Detect if the current folder overlaps with an existing replicated folder that
// is not in the same replica set
//
for (SUBSCRIBERLIST::iterator i = FRSRootList.begin(); i != FRSRootList.end(); i++) { if (!lstrcmpi((*i)->bstrMemberDN, bstrMemberDN)) continue;
if (S_OK == PathOverlapped(pInfo->m_bstrRootPath, (*i)->bstrRootPath)) { // overlapping detected
pInfo->m_nFRSShareType = FRSSHARE_TYPE_OVERLAPPING; break; } }
FreeSubscriberList(&FRSRootList);
if (FRSSHARE_TYPE_OK != pInfo->m_nFRSShareType) break;
//
// check if share is on non NTFS5.0 volume
//
hr = FRSShareCheck( m_bstrServerName, m_bstrShareName, &(pInfo->m_nFRSShareType)); BREAK_IF_FAILED(hr);
if (FRSSHARE_TYPE_OK != pInfo->m_nFRSShareType) break;
//
// retrieve StagingPath
//
TCHAR lpszDrive[2]; lpszDrive[0] = GetDiskForStagingPath(m_bstrServerName, *(pInfo->m_bstrRootPath)); lpszDrive[1] = NULL;
pInfo->m_bstrStagingPath = lpszDrive; BREAK_OUTOFMEMORY_IF_NULL((BSTR)pInfo->m_bstrStagingPath, &hr); pInfo->m_bstrStagingPath += _T(":\\"); BREAK_OUTOFMEMORY_IF_NULL((BSTR)pInfo->m_bstrStagingPath, &hr); pInfo->m_bstrStagingPath += FRS_STAGE_PATH; BREAK_OUTOFMEMORY_IF_NULL((BSTR)pInfo->m_bstrStagingPath, &hr);
//
// ntfrs won't work if bstrSharePath points at the root directory of a volume
// and no other volumes on this computer are suitable to store temporary file
//
if (_tcslen(pInfo->m_bstrRootPath) == 3 && _totupper(*(pInfo->m_bstrRootPath)) == _totupper(*lpszDrive)) { pInfo->m_nFRSShareType = FRSSHARE_TYPE_CONFLICTSTAGING; } } while (0);
if (FAILED(hr)) pInfo->m_nFRSShareType = FRSSHARE_TYPE_UNKNOWN;
pInfo->m_hrFRS = hr;
*o_ppInfo = pInfo;
return S_OK;}
HRESULT CMmcDfsReplica::GetReplicationInfo(){ if (m_pRepInfo) delete m_pRepInfo;
return GetReplicationInfoEx(&m_pRepInfo);}
HRESULT CMmcDfsReplica::ShowReplicationInfo(IReplicaSet* i_piReplicaSet){ HRESULT hr = S_OK;
m_bFRSMember = FALSE; m_bstrStatusText.Empty(); m_bstrFRSColumnText.Empty();
if (i_piReplicaSet) // show FRS
{ hr = GetReplicationInfo(); // refresh m_pRepInfo
RETURN_IF_FAILED(hr);
if (FRSSHARE_TYPE_OK == m_pRepInfo->m_nFRSShareType) { hr = i_piReplicaSet->IsFRSMember(m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath); m_bFRSMember = (S_OK == hr); // it is set to TRUE only when "Show Replication Info" and is a FRS member
}
GetReplicationText(m_bFRSMember, m_pRepInfo, &m_bstrFRSColumnText, &m_bstrStatusText); }
return S_OK;}
HRESULT CMmcDfsReplica::GetBadMemberInfo( IN IReplicaSet* i_piReplicaSet, IN BSTR i_bstrServerName, OUT BSTR* o_pbstrDnsHostName, OUT BSTR* o_pbstrRootPath ){ RETURN_INVALIDARG_IF_NULL(i_bstrServerName); RETURN_INVALIDARG_IF_NULL(o_pbstrDnsHostName); RETURN_INVALIDARG_IF_NULL(o_pbstrRootPath);
VARIANT var; VariantInit(&var); HRESULT hr = i_piReplicaSet->GetBadMemberInfo(i_bstrServerName, &var); if (S_OK != hr) return hr;
if (V_VT(&var) != (VT_ARRAY | VT_VARIANT)) return E_INVALIDARG;
SAFEARRAY *psa = V_ARRAY(&var); if (!psa) // no such member at all
return S_FALSE;
long lLowerBound = 0; long lUpperBound = 0; long lCount = 0; SafeArrayGetLBound(psa, 1, &lLowerBound); SafeArrayGetUBound(psa, 1, &lUpperBound); lCount = lUpperBound - lLowerBound + 1;
VARIANT HUGEP *pArray; SafeArrayAccessData(psa, (void HUGEP **) &pArray);
*o_pbstrDnsHostName = SysAllocString(pArray[4].bstrVal); *o_pbstrRootPath = SysAllocString(pArray[3].bstrVal);
SafeArrayUnaccessData(psa);
VariantClear(&var); // it will in turn call SafeArrayDestroy(psa);
RETURN_OUTOFMEMORY_IF_NULL(*o_pbstrDnsHostName); RETURN_OUTOFMEMORY_IF_NULL(*o_pbstrRootPath);
return hr;}
HRESULT CMmcDfsReplica::DeleteBadFRSMember(IReplicaSet* i_piReplicaSet, IN BSTR i_bstrDisplayName, IN HRESULT i_hres){ RETURN_INVALIDARG_IF_NULL((IReplicaSet *)i_piReplicaSet);
CComBSTR bstrServerName; HRESULT hr = GetUNCPathComponent(i_bstrDisplayName, &bstrServerName, 2, 3);
long lNumOfMembers = 0; hr = i_piReplicaSet->get_NumOfMembers(&lNumOfMembers); RETURN_IF_FAILED(hr);
CComBSTR bstrDnsHostName; CComBSTR bstrRootPath; hr = GetBadMemberInfo(i_piReplicaSet, bstrServerName, &bstrDnsHostName, &bstrRootPath); if (S_OK != hr) return S_OK; // no such bad member, continue with other operations
int nRet = DisplayMessageBox(::GetActiveWindow(), MB_YESNOCANCEL, i_hres, IDS_MSG_ERROR_BADFRSMEMBERDELETION, i_bstrDisplayName, bstrRootPath, bstrDnsHostName);
if (IDNO == nRet) return S_OK; // return immediately, continue with other operations
else if (IDCANCEL == nRet) return S_FALSE; // do not proceed
CWaitCursor wait;
if (lNumOfMembers <= 2) { if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnStopReplication(FALSE, FALSE); else hr = m_pDfsParentJP->OnStopReplication(FALSE, FALSE); } else hr = i_piReplicaSet->RemoveMemberEx(bstrDnsHostName, bstrRootPath);
return hr;}
HRESULT CMmcDfsReplica::AddFRSMember( IN IReplicaSet* i_piReplicaSet, IN BSTR i_bstrDnsHostName, IN BSTR i_bstrRootPath, IN BSTR i_bstrStagingPath){ RETURN_INVALIDARG_IF_NULL((IReplicaSet *)i_piReplicaSet);
HRESULT hr = i_piReplicaSet->AddMember(i_bstrDnsHostName, i_bstrRootPath, i_bstrStagingPath, TRUE, NULL);
if (FAILED(hr)) { DisplayMessageBox(::GetActiveWindow(), MB_OK, hr, IDS_MSG_ADDFRSMEMBER_FAILED, i_bstrDnsHostName); } else if (S_OK == hr) // let S_FALSE drop through: computer is already a member
{ CComBSTR bstrTopologyPref; hr = i_piReplicaSet->get_TopologyPref(&bstrTopologyPref); if (SUCCEEDED(hr) && !lstrcmpi(bstrTopologyPref, FRS_RSTOPOLOGYPREF_CUSTOM)) { DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_MSG_ADDMEMBER_TO_CUSTOM); } }
return hr;}
HRESULT CMmcDfsReplica::DeleteFRSMember( IN IReplicaSet* i_piReplicaSet, IN BSTR i_bstrDnsHostName, IN BSTR i_bstrRootPath){ RETURN_INVALIDARG_IF_NULL((IReplicaSet *)i_piReplicaSet); RETURN_INVALIDARG_IF_NULL(i_bstrDnsHostName); RETURN_INVALIDARG_IF_NULL(i_bstrRootPath);
long lNumOfMembers = 0; HRESULT hr = i_piReplicaSet->get_NumOfMembers(&lNumOfMembers); RETURN_IF_FAILED(hr);
hr = i_piReplicaSet->IsFRSMember(i_bstrDnsHostName, i_bstrRootPath); if (S_OK != hr) return hr;
if (lNumOfMembers <= 2) { if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnStopReplication(FALSE, FALSE); else hr = m_pDfsParentJP->OnStopReplication(FALSE, FALSE); } else hr = i_piReplicaSet->RemoveMemberEx(i_bstrDnsHostName, i_bstrRootPath);
return hr;}
HRESULT CMmcDfsReplica::RemoveReplicaFromSet(){ CWaitCursor wait;
HRESULT hr = S_OK;
CComPtr<IReplicaSet> piReplicaSet; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->GetIReplicaSetPtr(&piReplicaSet); else hr = m_pDfsParentJP->GetIReplicaSetPtr(&piReplicaSet); if (S_OK != hr) // no replica set on the corresponding link/root
return hr;
hr = GetReplicationInfo(); // fill in m_pRepInfo
RETURN_IF_FAILED(hr);
if (!m_pRepInfo->m_bstrDnsHostName) return DeleteBadFRSMember(piReplicaSet, m_pRepInfo->m_bstrDisplayName, m_pRepInfo->m_hrFRS);
long lNumOfMembers = 0; hr = piReplicaSet->get_NumOfMembers(&lNumOfMembers); RETURN_IF_FAILED(hr);
hr = piReplicaSet->IsFRSMember(m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath);
if (S_OK != hr) // not a member
return hr;
if (lNumOfMembers <= 2) { if (m_pDfsParentRoot) hr = m_pDfsParentRoot->OnStopReplication(FALSE, FALSE); else hr = m_pDfsParentJP->OnStopReplication(FALSE, FALSE); } else { hr = piReplicaSet->RemoveMemberEx(m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath); }
return hr;}
//
// S_OK: either not the hub server or #Members is not more than 2,
// okay to proceed(e.g., remove the member from the set)
// S_FALSE: it is the hub server and #Members is more than 2,
// not safe to proceed
// others: error occurred
//
HRESULT CMmcDfsReplica::AllowFRSMemberDeletion(BOOL *pbRepSetExist){ RETURN_INVALIDARG_IF_NULL(pbRepSetExist);
*pbRepSetExist = FALSE;
HRESULT hr = S_OK;
CComPtr<IReplicaSet> piReplicaSet; if (m_pDfsParentRoot) hr = m_pDfsParentRoot->GetIReplicaSetPtr(&piReplicaSet); else hr = m_pDfsParentJP->GetIReplicaSetPtr(&piReplicaSet); if (S_OK != hr) // no replica set on the corresponding link/root
return S_OK;
*pbRepSetExist = TRUE;
long lNumOfMembers = 0; hr = piReplicaSet->get_NumOfMembers(&lNumOfMembers); RETURN_IF_FAILED(hr);
if (lNumOfMembers <= 2) // removing this member will tear down the whole set
return S_OK; // no need to check if it's the hub or not
if (!m_pRepInfo) { hr = GetReplicationInfo(); RETURN_IF_FAILED(hr); }
hr = piReplicaSet->IsHubMember(m_pRepInfo->m_bstrDnsHostName, m_pRepInfo->m_bstrRootPath);
if (S_OK == hr) // do not proceed, for it's the hub
{ DisplayMessageBox(::GetActiveWindow(), MB_OK, 0, IDS_MSG_CANNOT_DELETE_HUBMEMBER); hr = S_FALSE; // do not proceed
} else if (S_FALSE == hr) { hr = S_OK; // not a hub, okay to proceed
} else if (FAILED(hr)) { if (IDOK == DisplayMessageBox(::GetActiveWindow(), MB_OKCANCEL, hr, IDS_MSG_ERROR_ALLOWFRSMEMBERDELETION)) hr = S_OK; // okay to proceed
else hr = S_FALSE; // do not proceed
}
return hr;}
HRESULT GetReplicationText( IN BOOL i_bFRSMember, IN CAlternateReplicaInfo* i_pRepInfo, OUT BSTR* o_pbstrColumnText, OUT BSTR* o_pbstrStatusBarText ){ RETURN_INVALIDARG_IF_NULL(o_pbstrColumnText); RETURN_INVALIDARG_IF_NULL(o_pbstrStatusBarText);
*o_pbstrColumnText = NULL; *o_pbstrStatusBarText = NULL;
int nShortID = 0, nStatusID = 0; switch (i_pRepInfo->m_nFRSShareType) { case FRSSHARE_TYPE_OK: nShortID = (i_bFRSMember ? IDS_ENABLED : IDS_DISABLED); nStatusID = (i_bFRSMember ? IDS_REPLICATION_STATUSBAR_MEMBER : IDS_REPLICATION_STATUSBAR_NONMEMBER); break; case FRSSHARE_TYPE_NONTFRS: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_NONTFRS; break; case FRSSHARE_TYPE_NOTDISKTREE: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_NOTDISKTREE; break; case FRSSHARE_TYPE_NOTNTFS: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_NOTNTFS; break; case FRSSHARE_TYPE_CONFLICTSTAGING: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_CONFLICTSTAGING; break; case FRSSHARE_TYPE_NODOMAIN: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_NODOMAIN; break; case FRSSHARE_TYPE_NOTSMBDISK: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_NOTSMBDISK; break; case FRSSHARE_TYPE_OVERLAPPING: nShortID = IDS_REPLICATION_STATUS_NOTELIGIBLE; nStatusID = IDS_REPLICATION_STATUSBAR_OVERLAPPING; break; default: nShortID = IDS_REPLICATION_STATUS_UNKNOWN; break; }
if (nStatusID) LoadStringFromResource(nStatusID, o_pbstrStatusBarText); if (FRSSHARE_TYPE_UNKNOWN == i_pRepInfo->m_nFRSShareType) GetErrorMessage(i_pRepInfo->m_hrFRS, o_pbstrStatusBarText);
LoadStringFromResource(nShortID, o_pbstrColumnText);
return S_OK;}
|
