void CMainFrame::OnSpareAdd(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice || !pLogicalDevice->IsOperatableAll())
return;
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_SPARE_ADD_DLG_CAPTION,
IDS_SPARE_ADD_DLG_MESSAGE,
GetOperatableSingleDevices(),
1,
CheckCapacityForSpare,
pLogicalDevice);
if(dlgSelectDevice.DoModal() != IDOK)
return;
CNBUnitDevice *pUnitDevice = dlgSelectDevice.GetSelectedDevice();
// Bind & Synchronize
NDASCOMM_CONNECTION_INFO ci, ci_spare;
(*pLogicalDevice)[0]->InitConnectionInfo(&ci, TRUE);
pUnitDevice->InitConnectionInfo(&ci_spare, TRUE);
AutoCursor l_auto_cursor(IDC_WAIT);
BOOL bResults = NdasOpSpareAdd(
&ci, &ci_spare);
l_auto_cursor.Release();
pLogicalDevice->HixChangeNotify(pGetNdasHostGuid());
pUnitDevice->HixChangeNotify(pGetNdasHostGuid());
if(!bResults)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
strMsg.LoadString(IDS_OPERATION_FAIL);
ShowErrorMessageBox(strMsg);
return;
}
OnRefreshStatus(NULL, NULL, NULL);
}
BOOL CRAID4DiskUIHandler::OnRecover(CDiskObjectPtr obj) const
{
ATLASSERT( dynamic_cast<CRAID4DiskObject*>(obj.get()) != NULL );
CRAID4DiskObjectPtr raid4Disk =
boost::dynamic_pointer_cast<CRAID4DiskObject>(obj);
if(!raid4Disk->IsDirty())
{
WTL::CString strMsg;
strMsg.LoadString(IDS_WARNING_NOT_NEED_RECOVER );
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK | MB_ICONERROR
);
return TRUE;
}
std::list<CDiskObjectPtr>::iterator it;
CUnitDiskObjectPtr pUnitDisk;
it = raid4Disk->begin();
INT32 iDirty;
for(iDirty = raid4Disk->GetDirtyDisk(); iDirty > 0; iDirty--)
it++;
pUnitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*it);
CRecoverDlg dlgRecover(FALSE, IDS_LOGDEV_TYPE_DISK_RAID4, IDS_RECOVERDLG_TASK_RECOVER);
dlgRecover.SetMemberDevice(pUnitDisk);
dlgRecover.DoModal();
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
NDAS_UNITDEVICE_ID unitDeviceId;
for(it = raid4Disk->begin(); it != raid4Disk->end(); ++it)
{
pUnitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*it);
CopyMemory(unitDeviceId.DeviceId.Node,
pUnitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
pUnitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
}
return TRUE;
}
void CMainFrame::OnSpareRemove(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBUnitDevice *pUnitDevice = dynamic_cast<CNBUnitDevice *>(pDevice);
if(!pUnitDevice || !pUnitDevice->GetLogicalDevice()->IsOperatableAll())
return;
NBUnitDevicePtrList listUnitDevices;
listUnitDevices.push_back(pUnitDevice);
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_SPARE_REMOVE_DLG_CAPTION,
IDS_SPARE_REMOVE_DLG_MESSAGE,
listUnitDevices,
0,
NULL,
NULL);
if(dlgSelectDevice.DoModal() != IDOK)
return;
NDASCOMM_CONNECTION_INFO ci;
pUnitDevice->InitConnectionInfo(&ci, TRUE);
AutoCursor l_auto_cursor(IDC_WAIT);
BOOL bResults = NdasOpSpareRemove(&ci);
l_auto_cursor.Release();
pUnitDevice->GetLogicalDevice()->HixChangeNotify(pGetNdasHostGuid());
if(!bResults)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
strMsg.LoadString(IDS_OPERATION_FAIL);
ShowErrorMessageBox(strMsg);
return;
}
OnRefreshStatus(NULL, NULL, NULL);
}
CNdasService::Impl::Impl(CNdasService& service) :
m_service(service),
m_nWorkItems(0),
m_cHeartbeatListener(service),
m_cAutoRegProcessor(service),
m_cHIXServer(service,pGetNdasHostGuid()),
m_cDeviceEventHandler(service),
m_cPowerEventHandler(service),
m_cCmdServer(service),
m_cDeviceRegistrar(service),
m_cLogDeviceManager(service)
{
}
void CMainFrame::OnMigrate(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice)
return;
if (NMT_MIRROR != pLogicalDevice->GetType() &&
NMT_RAID1 != pLogicalDevice->GetType() &&
NMT_RAID4 != pLogicalDevice->GetType())
return;
// warning message
CString strMsg;
NBUnitDevicePtrList listUnitDevices = pLogicalDevice->GetOperatableDevices();
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_MIGRATE_DLG_CAPTION,
IDS_MIGRATE_DLG_MESSAGE,
listUnitDevices,
0,
NULL,
NULL);
if(dlgSelectDevice.DoModal() != IDOK)
return;
NDASCOMM_CONNECTION_INFO *ci = new NDASCOMM_CONNECTION_INFO[listUnitDevices.size()];
UINT32 i = 0;
for(NBUnitDevicePtrList::iterator itUnitDevice = listUnitDevices.begin();
itUnitDevice != listUnitDevices.end(); i++, itUnitDevice++)
{
(*itUnitDevice)->InitConnectionInfo(&ci[i], TRUE);
}
AutoCursor l_auto_cursor(IDC_WAIT);
BOOL bResult = NdasOpMigrate(&ci[0]);
l_auto_cursor.Release();
DWORD dwLastError = ::GetLastError();
if(!bResult)
{
ShowErrorMessageBox(IDS_MAINFRAME_SINGLE_ACCESS_FAIL);
}
for(NBUnitDevicePtrList::iterator itUnitDevice = listUnitDevices.begin();
itUnitDevice != listUnitDevices.end(); i++, itUnitDevice++)
{
(*itUnitDevice)->HixChangeNotify(pGetNdasHostGuid());
}
delete [] ci;
OnRefreshStatus(NULL, NULL, NULL);
return;
}
void CMainFrame::OnAddMirror(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice || pLogicalDevice->IsGroup())
return;
NBUnitDevicePtrList listUnitDevices = GetOperatableSingleDevices();
// remove self
listUnitDevices.remove((*pLogicalDevice)[0]);
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_MIRROR_ADD_DLG_CAPTION,
IDS_MIRROR_ADD_DLG_MESSAGE,
listUnitDevices,
1,
CheckCapacityForMirror,
pLogicalDevice);
if(dlgSelectDevice.DoModal() != IDOK)
return;
CNBUnitDevice *pUnitDeviceAdd = dlgSelectDevice.GetSelectedDevice();
CNBUnitDevice *pUnitDevice = pUnitDevice = (*pLogicalDevice)[0];
// Bind & Synchronize
NDASCOMM_CONNECTION_INFO ConnectionInfo[2];
pUnitDevice->InitConnectionInfo(&ConnectionInfo[0], TRUE);
pUnitDeviceAdd->InitConnectionInfo(&ConnectionInfo[1], TRUE);
AutoCursor l_auto_cursor(IDC_WAIT);
UINT32 BindResult = NdasOpBind(
2,
ConnectionInfo,
NMT_SAFE_RAID1,
0);
l_auto_cursor.Release();
if(2 != BindResult)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT,
(BindResult == 0) ? pUnitDevice->GetName() : pUnitDeviceAdd->GetName());
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
return;
}
pUnitDevice->HixChangeNotify(pGetNdasHostGuid());
pUnitDeviceAdd->HixChangeNotify(pGetNdasHostGuid());
/*
CRecoverDlg dlgRecover(FALSE, IDS_LOGDEV_TYPE_DISK_RAID1, IDS_RECOVERDLG_TASK_ADD_MIRROR);
ATLASSERT(FALSE);
// dlgRecover.SetMemberDevice(pUnitDeviceAdd);
dlgRecover.DoModal();
*/
OnRefreshStatus(NULL, NULL, NULL);
}
void CMainFrame::OnReplaceUnitDevice(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice)
return;
// find the missing device
CNBLogicalDevice *pLogicalDeviceReplace = NULL;
CNBUnitDevice *pUnitDeviceReplace = NULL;
NBUnitDevicePtrList listUnitDevicesReplace;
NBLogicalDevicePtrList::iterator itLogicalDevice;
for(UINT32 i = 0; i < pLogicalDevice->DevicesTotal(); i++)
{
if(!(*pLogicalDevice)[i])
{
for(itLogicalDevice = m_listLogicalDevices.begin();
itLogicalDevice != m_listLogicalDevices.end();
++itLogicalDevice)
{
pLogicalDeviceReplace = *itLogicalDevice;
if(pLogicalDeviceReplace)
{
if (pLogicalDeviceReplace->IsHDD() &&
!pLogicalDeviceReplace->IsGroup() &&
pLogicalDeviceReplace->IsOperatable())
{
pUnitDeviceReplace = (*pLogicalDeviceReplace)[0];
if (pUnitDeviceReplace->IsThis(
pLogicalDevice->DIB()->UnitDisks[i].MACAddr,
pLogicalDevice->DIB()->UnitDisks[i].UnitNumber))
{
// ok we found replacable HDD
listUnitDevicesReplace.push_back(pUnitDeviceReplace);
}
}
}
}
}
}
if(!listUnitDevicesReplace.size())
return;
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_REPLACE_UNIT_DEVICE_DLG_CAPTION,
IDS_REPLACE_UNIT_DEVICE_DLG_MESSAGE,
listUnitDevicesReplace,
0,
CheckCapacityForSpare,
pLogicalDevice);
if(dlgSelectDevice.DoModal() != IDOK)
return;
// dlgSelectDevice is not selective dialog. get unit device from listUnitDevicesReplace
CNBUnitDevice *pUnitDevice = *(listUnitDevicesReplace.begin());
// Bind & Synchronize
NDASCOMM_CONNECTION_INFO ci, ci_replace;
pLogicalDevice->InitConnectionInfo(&ci, TRUE); // use write access. this function does not support run time replace yet.
pUnitDevice->InitConnectionInfo(&ci_replace, TRUE);
for(UINT32 i = 0; i < pLogicalDevice->DevicesTotal(); i++)
{
if (!(*pLogicalDevice)[i])
{
break;
}
}
if(pLogicalDevice->DevicesTotal() == i)
{
// failed to find missing device
return;
}
AutoCursor l_auto_cursor(IDC_WAIT);
BOOL bResults = NdasOpReplaceUnitDevice(
&ci, &ci_replace, i);
l_auto_cursor.Release();
pLogicalDevice->HixChangeNotify(pGetNdasHostGuid());
pUnitDevice->HixChangeNotify(pGetNdasHostGuid());
if(!bResults)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
strMsg.LoadString(IDS_OPERATION_FAIL);
ShowErrorMessageBox(strMsg);
return;
}
OnRefreshStatus(NULL, NULL, NULL);
}
void CUnBindDlg::OnOK(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
UINT32 nDiskCount = 0;
unsigned int i;
NDASCOMM_CONNECTION_INFO *pConnectionInfo;
CFindIfVisitor<TRUE> unitDiskFinder;
CDiskObjectList listUnbind; // List of disks to unbind
CDiskObjectList::iterator itr;
CUnitDiskObjectPtr unitDisk;
WTL::CString strMsg;
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
BOOL bUnbindMirror;
BOOL bReadyToUnbind;
UINT32 BindResult;
bUnbindMirror = (dynamic_cast<const CMirDiskObject*>(m_pDiskUnbind.get()) != NULL);
// warning message
strMsg.LoadString((bUnbindMirror) ? IDS_WARNING_UNBIND_MIR : IDS_WARNING_UNBIND);
int id = MessageBox(
strMsg,
strTitle,
MB_YESNO|MB_ICONEXCLAMATION
);
if(IDYES != id)
return;
listUnbind = unitDiskFinder.FindIf( m_pDiskUnbind, IsUnitDisk);
nDiskCount = listUnbind.size();
pConnectionInfo = new NDASCOMM_CONNECTION_INFO[nDiskCount];
ZeroMemory(pConnectionInfo, sizeof(NDASCOMM_CONNECTION_INFO) * nDiskCount);
bReadyToUnbind = TRUE;
for ( itr = listUnbind.begin(), i = 0; itr != listUnbind.end(); ++itr )
{
if(!(*itr)->IsUnitDisk())
continue;
unitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
ZeroMemory(&pConnectionInfo[i], sizeof(NDASCOMM_CONNECTION_INFO));
pConnectionInfo[i].address_type = NDASCOMM_CONNECTION_INFO_TYPE_ADDR_LPX;
pConnectionInfo[i].login_type = NDASCOMM_LOGIN_TYPE_NORMAL;
pConnectionInfo[i].UnitNo = unitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
pConnectionInfo[i].bWriteAccess = TRUE;
pConnectionInfo[i].ui64OEMCode = NULL;
pConnectionInfo[i].bSupervisor = FALSE;
pConnectionInfo[i].protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(pConnectionInfo[i].AddressLPX,
unitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
if(!(unitDisk->GetAccessMask() & GENERIC_WRITE))
{
// "%1!s! does not have a write access privilege. You need to set write key to this NDAS device before this action."
strMsg.FormatMessage(IDS_ERROR_NOT_REGISTERD_WRITE_FMT,
unitDisk->GetTitle()
);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONERROR
);
bReadyToUnbind = FALSE;
}
i++;
}
if(!bReadyToUnbind)
{
delete [] pConnectionInfo;
EndDialog(IDCANCEL);
}
BindResult = NdasOpBind(i, pConnectionInfo,NMT_SINGLE);
DWORD dwLastError = ::GetLastError();
m_unboundDisks = listUnbind;
if(i == BindResult)
{
strMsg.LoadString(
(bUnbindMirror) ? IDS_WARNING_UNBIND_AFTER_MIR :
IDS_WARNING_UNBIND_AFTER);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONINFORMATION
);
}
else
{
for ( itr = listUnbind.begin(); itr != listUnbind.end(); ++itr )
{
unitDisk = boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
if(!BindResult)
break;
BindResult--;
}
::SetLastError(dwLastError);
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT, unitDisk->GetTitle());
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(IDS_MAINFRAME_SINGLE_ACCESS_FAIL);
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
for(i = 0; i < BindResult; i++)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node, pConnectionInfo[i].AddressLPX,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo = pConnectionInfo[i].UnitNo;
HixChangeNotify.Notify(unitDeviceId);
}
}
delete [] pConnectionInfo;
EndDialog(IDOK);
}
BOOL CMirDiskUIHandler::OnSynchronize(CDiskObjectPtr obj) const
{
ATLASSERT( dynamic_cast<CMirDiskObject*>(obj.get()) != NULL );
CMirDiskObjectPtr mirDisk =
boost::dynamic_pointer_cast<CMirDiskObject>(obj);
CUnitDiskObjectPtr sourceDisk, destDisk;
BOOL bFirstDefected, bSecondDefected;
BOOL bResults;
bResults = mirDisk->GetDirtyDiskStatus(&bFirstDefected, &bSecondDefected);
if(!bResults)
return FALSE;
// check dirty status here
// ATLASSERT( mirDisk->GetDirtyDiskCount() > 0 );
if ( !bFirstDefected && !bSecondDefected)
{
WTL::CString strMsg;
strMsg.LoadString(IDS_WARNING_NOT_NEED_RECOVER );
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK | MB_ICONERROR
);
return TRUE;
}
//
// Select the source disk and the dest disk
//
if ( bFirstDefected && bSecondDefected)
{
CSelectDiskDlg dlgSelect(IDD_SELSOURCE);
CDiskObjectList listDisks;
listDisks.push_back( mirDisk->front() );
listDisks.push_back( mirDisk->back() );
dlgSelect.SetSingleDisks( listDisks );
if ( dlgSelect.DoModal() != IDOK )
return TRUE;
sourceDisk = dlgSelect.GetSelectedDisk();
if ( sourceDisk == mirDisk->front() )
destDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(mirDisk->back());
else
destDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(mirDisk->front());
}
else
{
if (bFirstDefected)
{
sourceDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->SecondDisk());
destDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->FirstDisk());
}
else if (bSecondDefected )
{
sourceDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->FirstDisk());
destDisk =
/*boost::dynamic_pointer_cast<CUnitDiskObject>*/ (mirDisk->SecondDisk());
}
else
{
return FALSE;
}
}
//
// Synchronize
//
CRecoverDlg dlgRecover(FALSE, IDS_LOGDEV_TYPE_DISK_RAID1, IDS_RECOVERDLG_TASK_RECOVER);
dlgRecover.SetMemberDevice(destDisk);
dlgRecover.DoModal();
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
bResults = HixChangeNotify.Initialize();
if(bResults)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
CopyMemory(unitDeviceId.DeviceId.Node,
destDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
destDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
return TRUE;
}
void CMainFrame::OnRepair(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
#ifdef __NEVER_DEFINED__
BOOL bResults;
BOOL bReturn = FALSE;
int iItemSelected = m_viewTreeList.GetSelectedItemData();
if (-1 == iItemSelected)
{
return;
}
CDiskObjectPtr obj = m_mapObject[iItemSelected];
if( dynamic_cast<CDiskObjectComposite *>(obj.get()) == NULL )
{
return;
}
CDiskObjectCompositePtr DiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(obj);
if(!((NMT_RAID1 == DiskObjectComposite->GetNDASMediaType() ||
NMT_RAID4 == DiskObjectComposite->GetNDASMediaType()) &&
1 == DiskObjectComposite->GetMissingMemberCount()))
{
// TODO : No disk is available
CString strMsg;
strMsg.LoadString( IDS_MAINFRAME_NOT_READY_REPAIR );
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONERROR
);
return;
}
CSelectDiskDlg dlgSelect(IDD_REPAIR);
CDiskObjectList singleDisks;
CFindIfVisitor<FALSE> singleDiskFinder;
singleDisks = singleDiskFinder.FindIf(m_pRoot, IsWritableUnitDisk);
if ( singleDisks.size() == 0 )
{
// TODO : No disk is available
CString strMsg;
strMsg.LoadString( IDS_MAINFRAME_NO_DISK_REPAIR );
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
dlgSelect.SetSingleDisks(singleDisks);
if ( dlgSelect.DoModal() != IDOK )
return;
CUnitDiskObjectPtr replaceDisk, sourceDisk;
sourceDisk = DiskObjectComposite->GetAvailableUnitDisk();
replaceDisk = dlgSelect.GetSelectedDisk();
if(NULL == sourceDisk.get())
return;
NDASCOMM_CONNECTION_INFO ci, ciReplace;
ZeroMemory(&ci, sizeof(NDASCOMM_CONNECTION_INFO));
ci.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ci.AddressType = NDASCOMM_CIT_DEVICE_ID;
ci.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL;
ci.UnitNo = sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ci.WriteAccess = TRUE;
ci.Protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(
ci.DeviceId.Node,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(ci.DeviceId.Node));
ZeroMemory(&ciReplace, sizeof(NDASCOMM_CONNECTION_INFO));
ciReplace.Size = sizeof(NDASCOMM_CONNECTION_INFO);
ciReplace.AddressType = NDASCOMM_CIT_DEVICE_ID;
ciReplace.LoginType = NDASCOMM_LOGIN_TYPE_NORMAL;
ciReplace.UnitNo = replaceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ciReplace.WriteAccess = TRUE;
ciReplace.Protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(
ciReplace.DeviceId.Node,
replaceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(ciReplace.DeviceId.Node));
AutoCursor l_auto_cursor(IDC_WAIT);
bResults = NdasOpRepair(&ci, &ciReplace);
l_auto_cursor.Release();
if(!bResults)
{
CString strMsg;
DWORD dwLastError = ::GetLastError();
strMsg.LoadString(IDS_REPAIR_FAIL);
ShowErrorMessageBox(strMsg);
return;
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
bResults = HixChangeNotify.Initialize();
if(bResults)
{
CUnitDiskObjectPtr UnitDiskObjectPtr;
NDAS_UNITDEVICE_ID unitDeviceId;
CDiskObjectComposite::const_iterator itr;
for ( itr = DiskObjectComposite->begin(); itr != DiskObjectComposite->end(); ++itr )
{
if((dynamic_cast<CEmptyDiskObject*>((*itr).get()) != NULL))
continue;
UnitDiskObjectPtr =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
CopyMemory(unitDeviceId.DeviceId.Node,
UnitDiskObjectPtr->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
UnitDiskObjectPtr->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
CopyMemory(unitDeviceId.DeviceId.Node,
replaceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
replaceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
CRecoverDlg dlgRecover(
TRUE,
(NMT_RAID1 == DiskObjectComposite->GetNDASMediaType()) ?
IDS_LOGDEV_TYPE_DISK_RAID1 : IDS_LOGDEV_TYPE_DISK_RAID4,
IDS_RECOVERDLG_TASK_REPAIR);
dlgRecover.SetMemberDevice(sourceDisk);
dlgRecover.DoModal();
OnRefreshStatus(NULL, NULL, NULL);
#endif
return;
}
BOOL
CNdasUnitDevice::GetActualHostUsageCount(
LPDWORD lpnROHosts,
LPDWORD lpnRWHosts,
BOOL bUpdate)
{
ximeta::CAutoLock autolock(this);
DWORD nROHosts, nRWHosts;
BOOL fSuccess = GetHostUsageCount(&nROHosts, &nRWHosts, bUpdate);
if (!fSuccess) {
return FALSE;
}
//
// Following cases does not need further consideration
// - RW = 0, RO = any
// - RW = 1, RO = 0
// Otherwise, we need HIX to discover the actual count
//
if (nRWHosts == 0 || nROHosts == 0) {
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
DWORD nHosts = nROHosts + nRWHosts;
NDAS_UNITDEVICE_ID unitDeviceId = GetUnitDeviceId();
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
fSuccess = hixdisc.Initialize();
if (!fSuccess) {
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
fSuccess = hixdisc.Discover(
unitDeviceId,
NHIX_UDA_READ_ACCESS, // read bit is set - all hosts
nHosts,
2000);
if (!fSuccess) {
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId);
for (DWORD i = 0; i < nRepliedHosts; ++i) {
NHIX_UDA uda = 0;
fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda);
_ASSERTE(fSuccess); // index must be valid!
if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS)
{
--nROHosts;
++nRWHosts;
}
}
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
BOOL
CNdasUnitDevice::CheckNDFSCompatibility()
{
InstanceAutoLock autolock(this);
//
// Unit devices other than disks are not allowed for NDFS
//
if (m_type != NDAS_UNITDEVICE_TYPE_DISK)
{
return FALSE;
}
//
// LfsFilter compatibility check.
// NDFS Major version should be same
//
WORD wHostNDFSVerMajor;
BOOL fSuccess = ::LfsFiltCtlGetVersion(
NULL, NULL, NULL, NULL,
&wHostNDFSVerMajor, NULL);
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Getting LFS Filter Version failed, error=0x%X\n", GetLastError());
return FALSE;
}
//
// Primary Host Info is valid for 30 seconds
//
#if 0
DWORD dwMaxTickAllowance = 30 * 1000;
if (0 != m_PrimaryHostInfo.NDFSCompatVersion &&
::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance)
{
// primary host info is valid
return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion);
}
#endif
//
// No Primary Host Info is available (IX)
// Use HIX to discover
//
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
fSuccess = hixdisc.Initialize();
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"HIXDiscover init failed, error=0x%X\n", GetLastError());
return FALSE;
}
NDAS_UNITDEVICE_ID udid = GetUnitDeviceId();
DWORD timeout = NdasServiceConfig::Get(nscWriteShareCheckTimeout);
fSuccess = hixdisc.Discover(udid,NHIX_UDA_SHRW_PRIM,1,timeout);
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"hixdisc.Discover failed, error=0x%X\n", GetLastError());
return FALSE;
}
DWORD nHosts = hixdisc.GetHostCount(udid);
if (0 == nHosts)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostCount failed, error=0x%X\n", GetLastError());
return FALSE;
}
GUID hostGuid;
fSuccess = hixdisc.GetHostData(udid,0,NULL,&hostGuid,NULL,NULL);
if (!fSuccess)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostData failed, error=0x%X\n", GetLastError());
return FALSE;
}
CNdasHostInfoCache* phic = pGetNdasHostInfoCache();
XTLASSERT(phic); // phic is not null (by pGetNdasHostInfoCache)
const NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid);
if (NULL == pHostInfo)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostInfo failed, error=0x%X\n", GetLastError());
return FALSE;
}
//
// ReservedVerInfo contains NDFS Version Information
//
if (pHostInfo->ReservedVerInfo.VersionMajor != wHostNDFSVerMajor)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"Host NDFS %d, Primary NDFS %d failed.\n",
wHostNDFSVerMajor, pHostInfo->ReservedVerInfo.VersionMajor);
return FALSE;
}
//
// Primary and this host's NDFS compatible version is same
//
return TRUE;
}
BOOL
CNdasUnitDevice::GetActualHostUsageCount(
LPDWORD lpnROHosts,
LPDWORD lpnRWHosts,
BOOL bUpdate)
{
InstanceAutoLock autolock(this);
DWORD nROHosts = 0;
DWORD nRWHosts = 0;
if (!GetHostUsageCount(&nROHosts, &nRWHosts, bUpdate))
{
return FALSE;
}
//
// Following cases does not need further consideration
// - RW = 0, RO any
// - RW = 1, RO = 0
// Neither RO or RW is not NDAS_HOST_COUNT_UNKNOWN
// Otherwise, we need HIX to discover the actual count
//
if ((nRWHosts == 0 || nROHosts == 0) &&
(NDAS_HOST_COUNT_UNKNOWN != nRWHosts) &&
(NDAS_HOST_COUNT_UNKNOWN != nROHosts))
{
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
DWORD nHosts =
(NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts) ?
NDAS_MAX_CONNECTION_V11 : nROHosts + nRWHosts;
NDAS_UNITDEVICE_ID unitDeviceId = GetUnitDeviceId();
//
// BUG: Workaround for weird lock
// We should unlock the global lock (yes, it's global lock at the moment)
// for local HIX server to work!
//
autolock.Release();
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
BOOL fSuccess = hixdisc.Initialize();
if (!fSuccess)
{
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
fSuccess = hixdisc.Discover(
unitDeviceId,
NHIX_UDA_READ_ACCESS, // read bit is set - all hosts
nHosts,
2000);
if (!fSuccess)
{
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return TRUE;
}
if (NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts)
{
DWORD rawROHosts = nROHosts;
DWORD rawRWHosts = nRWHosts;
// If any host count is unknown, use HIX counter only
nROHosts = 0;
nRWHosts = 0;
DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId);
for (DWORD i = 0; i < nRepliedHosts; ++i)
{
NHIX_UDA uda = 0;
fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda);
XTLASSERT(fSuccess); // index must be valid!
if (NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS == uda ||
NHIX_UDA_SHARED_READ_WRITE_PRIMARY_ACCESS == uda ||
NHIX_UDA_READ_WRITE_ACCESS == uda)
{
++nRWHosts;
}
else if (uda == NHIX_UDA_READ_ACCESS)
{
++nROHosts;
}
else
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING,
"Invalid uda=0x%08X\n", uda);
}
}
//
// If HIX counter is not available either, we should at least show
// the original counter.
//
if (NDAS_HOST_COUNT_UNKNOWN != rawRWHosts && rawRWHosts > nRWHosts)
{
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING,
"RWHost adjusted to Raw=%d from HIX=%d\n", rawRWHosts, nRWHosts);
nRWHosts = rawRWHosts;
}
}
else
{
// Otherwise, use SharedRW counter
DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId);
for (DWORD i = 0; i < nRepliedHosts; ++i)
{
NHIX_UDA uda = 0;
fSuccess = hixdisc.GetHostData(unitDeviceId,i,&uda);
XTLASSERT(fSuccess); // index must be valid!
if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS)
{
--nROHosts;
++nRWHosts;
}
}
}
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_INFORMATION,
"Actual Host Usage Count: RO=%d, RW=%d.\n",
*lpnROHosts, *lpnRWHosts);
return TRUE;
}
void CMainFrame::OnAddMirror(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus);
CTreeItem itemSelected = m_view.GetSelectedItem();
if ( itemSelected.IsNull() )
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
CDiskObjectList singleDisks;
CUnitDiskObjectPtr sourceDisk;
sourceDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(
m_mapObject[m_view.GetItemData(itemSelected)]
);
ATLASSERT( sourceDisk.get() != NULL );
CFindIfVisitor<FALSE> singleDiskFinder;
singleDisks = singleDiskFinder.FindIf(m_pRoot, IsWritableUnitDisk);
singleDisks.remove( sourceDisk );
if ( singleDisks.size() == 0 )
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
// TODO : No disk is available
WTL::CString strMsg;
strMsg.LoadString( IDS_MAINFRAME_NO_DISK_TO_MIRROR );
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
DWORD UnitNo = 0;
CSelectMirDlg dlgSelDisk(IDD_ADDMIR);
dlgSelDisk.SetSingleDisks( singleDisks );
dlgSelDisk.SetSourceDisk( sourceDisk );
if ( dlgSelDisk.DoModal() == IDOK )
{
CUnitDiskObjectPtr mirDisk = dlgSelDisk.GetSelectedDisk();
// Bind & Synchronize
NDAS_CONNECTION_INFO ConnectionInfo[2];
ZeroMemory(&ConnectionInfo[0], sizeof(NDAS_CONNECTION_INFO));
ConnectionInfo[0].type = NDAS_CONNECTION_INFO_TYPE_MAC_ADDRESS;
ConnectionInfo[0].UnitNo = sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ConnectionInfo[0].bWriteAccess = TRUE;
ConnectionInfo[0].ui64OEMCode = NULL;
ConnectionInfo[0].protocol = IPPROTO_LPXTCP;
CopyMemory(ConnectionInfo[0].MacAddress,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
ZeroMemory(&ConnectionInfo[1], sizeof(NDAS_CONNECTION_INFO));
ConnectionInfo[1].type = NDAS_CONNECTION_INFO_TYPE_MAC_ADDRESS;
ConnectionInfo[1].UnitNo = mirDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ConnectionInfo[1].bWriteAccess = TRUE;
ConnectionInfo[1].ui64OEMCode = NULL;
ConnectionInfo[1].protocol = IPPROTO_LPXTCP;
CopyMemory(ConnectionInfo[1].MacAddress,
mirDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
UINT32 BindResult = NdasOpBind(
2,
ConnectionInfo,
NMT_SAFE_RAID1);
if(2 != BindResult)
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
WTL :: CString strMsg;
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT,
(BindResult == 0) ? sourceDisk->GetTitle() : mirDisk->GetTitle());
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
return;
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node,
sourceDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
sourceDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
CopyMemory(unitDeviceId.DeviceId.Node,
mirDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo =
mirDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
HixChangeNotify.Notify(unitDeviceId);
}
CRecoverDlg dlgRecover(TRUE, IDS_LOGDEV_TYPE_DISK_RAID1, IDS_RECOVERDLG_TASK_ADD_MIRROR);
dlgRecover.SetMemberDevice(mirDisk);
dlgRecover.DoModal();
OnRefreshStatus(NULL, NULL, NULL);
}
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
}
void CMainFrame::OnSingle(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
ENTER_CRITICAL_SECTION(&m_csThreadRefreshStatus);
WTL::CString strMsg;
CTreeItem itemSelected = m_view.GetSelectedItem();
if ( itemSelected.IsNull() )
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
CDiskObjectPtr obj, parent;
obj = m_mapObject[m_view.GetItemData(itemSelected)];
if(!obj->IsUnitDisk())
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
// AING_TO_DO
{
strMsg.LoadString(IDS_WARNING_SINGLE);
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
int ret = MessageBox(
strMsg,
strTitle,
MB_YESNO | MB_ICONWARNING
);
if(IDYES != ret)
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
return;
}
}
//
// Check whether any disk is being accessed by other program/computer
//
if ( !obj->CanAccessExclusive() )
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
strMsg.LoadString(IDS_FAIL_TO_ACCESS_EXCLUSIVELY);
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
if(!(obj->GetAccessMask() & GENERIC_WRITE))
{
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
// "%1!s! does not have a write access privilege. You need to set write key to this NDAS device before this action."
strMsg.FormatMessage(IDS_ERROR_NOT_REGISTERD_WRITE_FMT,
obj->GetTitle()
);
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONERROR
);
return;
}
NDAS_CONNECTION_INFO ConnectionInfo;
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(obj);
ZeroMemory(&ConnectionInfo, sizeof(NDAS_CONNECTION_INFO));
ConnectionInfo.type = NDAS_CONNECTION_INFO_TYPE_MAC_ADDRESS;
ConnectionInfo.UnitNo = unitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
ConnectionInfo.bWriteAccess = TRUE;
ConnectionInfo.ui64OEMCode = NULL;
ConnectionInfo.protocol = IPPROTO_LPXTCP;
CopyMemory(ConnectionInfo.MacAddress,
unitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
UINT32 BindResult = NdasOpBind(
1,
&ConnectionInfo,
NMT_SINGLE);
LEAVE_CRITICAL_SECTION(&m_csThreadRefreshStatus);
if(1 != BindResult)
{
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT, unitDisk->GetTitle());
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node, ConnectionInfo.MacAddress,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo = ConnectionInfo.UnitNo;
HixChangeNotify.Notify(unitDeviceId);
}
OnRefreshStatus(NULL, NULL, NULL);
}
void CMainFrame::OnSingle(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CString strMsg;
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBUnitDevice *pUnitDevice;
if(dynamic_cast<CNBLogicalDevice *>(pDevice))
{
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice || !pLogicalDevice->IsOperatableAll())
return;
pUnitDevice = (*pLogicalDevice)[0];
}
else
{
pUnitDevice = dynamic_cast<CNBUnitDevice *>(pDevice);
if(!pUnitDevice || !pUnitDevice->IsOperatable())
return;
}
if(!pUnitDevice)
return;
NBUnitDevicePtrList listUnitDevices;
listUnitDevices.push_back(pUnitDevice);
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_SINGLE_DLG_CAPTION,
IDS_SINGLE_DLG_MESSAGE,
listUnitDevices,
0,
NULL,
NULL);
if(dlgSelectDevice.DoModal() != IDOK)
return;
NDASCOMM_CONNECTION_INFO ConnectionInfo;
if(!pUnitDevice->InitConnectionInfo(&ConnectionInfo, TRUE))
{
// "%1!s! does not have a write access privilege. You need to set write key to this NDAS device before this action."
strMsg.FormatMessage(IDS_ERROR_NOT_REGISTERD_WRITE_FMT,
pUnitDevice->GetName()
);
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONERROR
);
return;
}
AutoCursor l_auto_cursor(IDC_WAIT);
UINT32 BindResult = NdasOpBind(
1,
&ConnectionInfo,
NMT_SINGLE,
0);
l_auto_cursor.Release();
if(1 != BindResult)
{
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT, pUnitDevice->GetName());
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
}
pUnitDevice->HixChangeNotify(pGetNdasHostGuid());
OnRefreshStatus(NULL, NULL, NULL);
}
BOOL
CNdasUnitDevice::CheckNDFSCompatibility()
{
ximeta::CAutoLock autolock(this);
//
// Unit devices other than disks are not allowed for NDFS
//
if (m_type != NDAS_UNITDEVICE_TYPE_DISK) {
return FALSE;
}
//
// LfsFilter compatibility check.
// NDFS Major version should be same
//
WORD wHostNDFSVerMajor;
BOOL fSuccess = ::LfsFiltCtlGetVersion(
NULL,
NULL,
NULL,
NULL,
&wHostNDFSVerMajor,
NULL);
if (!fSuccess) {
DBGPRT_ERR_EX(_FT("Getting LFS Filter Version failed:"));
return FALSE;
}
//
// Primary Host Info is valid for 30 seconds
//
DWORD dwMaxTickAllowance = 30 * 1000;
if (0 != m_PrimaryHostInfo.NDFSCompatVersion &&
::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance)
{
// primary host info is valid
return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion);
}
//
// No Primary Host Info is available (IX)
// Use HIX to discover
//
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
fSuccess = hixdisc.Initialize();
if (!fSuccess) {
DBGPRT_ERR_EX(_FT("HIXDiscover init failed: "));
return FALSE;
}
NDAS_UNITDEVICE_ID udid = GetUnitDeviceId();
hixdisc.Discover(udid,NHIX_UDA_SHRW_PRIM,1,1000);
DWORD nHosts = hixdisc.GetHostCount(udid);
if (0 == nHosts) {
DBGPRT_ERR_EX(_FT("GetHostCount failed: "));
return FALSE;
}
GUID hostGuid;
fSuccess = hixdisc.GetHostData(udid,0,NULL,&hostGuid,NULL,NULL);
if (!fSuccess) {
DBGPRT_ERR_EX(_FT("GetHostData failed: "));
return FALSE;
}
CNdasHostInfoCache* phic = pGetNdasHostInfoCache();
_ASSERTE(phic); // phic is not null (by pGetNdasHostInfoCache)
CONST NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid);
if (NULL == pHostInfo) {
DBGPRT_ERR_EX(_FT("GetHostInfo failed: "));
return FALSE;
}
if (pHostInfo->NDASSWVerInfo.VersionMajor != wHostNDFSVerMajor) {
DBGPRT_ERR(_FT("Host NDFS %d, Primary NDFS %d failed: "),
wHostNDFSVerMajor, pHostInfo->NDASSWVerInfo.VersionMajor);
return FALSE;
}
//
// Primary and this host's NDFS compat version is same
//
return TRUE;
}
void CMainFrame::OnUnBind(UINT wNotifyCode, int wID, HWND hwndCtl)
{
CNBDevice *pDevice = m_viewTreeList.GetSelectedDevice();
if(!pDevice)
return;
if(!pDevice->GetCommandAbility(wID))
return;
CNBLogicalDevice *pLogicalDevice = dynamic_cast<CNBLogicalDevice *>(pDevice);
if(!pLogicalDevice)
return;
BOOL bUnbindMirror =
(NMT_RAID1 == pLogicalDevice->GetType() ||
NMT_RAID1R == pLogicalDevice->GetType() ||
NMT_MIRROR == pLogicalDevice->GetType());
// warning message
CString strMsg;
NBUnitDevicePtrList listUnitDevices = pLogicalDevice->GetOperatableDevices();
CNBSelectDeviceDlg dlgSelectDevice(
IDD_DEVICE_LIST,
IDS_UNBIND_DLG_CAPTION,
(bUnbindMirror) ? IDS_WARNING_UNBIND_MIR : IDS_WARNING_UNBIND,
listUnitDevices,
0,
NULL,
NULL);
if(dlgSelectDevice.DoModal() != IDOK)
return;
NDASCOMM_CONNECTION_INFO *ci = new NDASCOMM_CONNECTION_INFO[listUnitDevices.size()];
UINT32 i = 0;
for(NBUnitDevicePtrList::iterator itUnitDevice = listUnitDevices.begin();
itUnitDevice != listUnitDevices.end(); i++, itUnitDevice++)
{
(*itUnitDevice)->InitConnectionInfo(&ci[i], TRUE);
}
AutoCursor l_auto_cursor(IDC_WAIT);
UINT32 BindResult = NdasOpBind(listUnitDevices.size(), ci, NMT_SINGLE, 0);
l_auto_cursor.Release();
DWORD dwLastError = ::GetLastError();
if(i == BindResult)
{
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
strMsg.LoadString(
(bUnbindMirror) ? IDS_WARNING_UNBIND_AFTER_MIR :
IDS_WARNING_UNBIND_AFTER);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONINFORMATION
);
}
else
{
::SetLastError(dwLastError);
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
if(BindResult < listUnitDevices.size())
{
i = 0;
for(NBUnitDevicePtrList::iterator itUnitDevice = listUnitDevices.begin();
itUnitDevice != listUnitDevices.end(); i++, itUnitDevice++)
{
if(i == BindResult)
strMsg.FormatMessage(IDS_BIND_FAIL_AT_SINGLE_NDAS_FMT, (*itUnitDevice)->GetName());
}
}
else
strMsg.LoadString(IDS_BIND_FAIL);
break;
default:
strMsg.LoadString(IDS_BIND_FAIL);
break;
}
ShowErrorMessageBox(IDS_MAINFRAME_SINGLE_ACCESS_FAIL);
}
for(NBUnitDevicePtrList::iterator itUnitDevice = listUnitDevices.begin();
itUnitDevice != listUnitDevices.end(); i++, itUnitDevice++)
{
(*itUnitDevice)->HixChangeNotify(pGetNdasHostGuid());
}
delete [] ci;
OnRefreshStatus(NULL, NULL, NULL);
return;
}
STDMETHODIMP
CNdasUnitImpl::GetActualHostUsageCount (
LPDWORD lpnROHosts,
LPDWORD lpnRWHosts,
BOOL bUpdate
)
{
DWORD nROHosts = 0;
DWORD nRWHosts = 0;
HRESULT hr = GetHostUsageCount( &nROHosts, &nRWHosts, bUpdate );
if (FAILED(hr)) {
return hr;
}
// Following cases does not need further consideration
// - RW = 0, RO any
// - RW = 1, RO = 0
// Neither RO or RW is not NDAS_HOST_COUNT_UNKNOWN
// Otherwise, we need HIX to discover the actual count
if (nRWHosts != NDAS_HOST_COUNT_UNKNOWN && nROHosts == 0) {
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return S_OK;
}
DWORD nHosts = (NDAS_HOST_COUNT_UNKNOWN == nRWHosts || NDAS_HOST_COUNT_UNKNOWN == nROHosts) ?
NDAS_MAX_CONNECTION_V11 : nROHosts + nRWHosts;
NDAS_UNITDEVICE_ID unitDeviceId;
hr = get_NdasUnitId(&unitDeviceId);
if (FAILED(hr)) {
return hr;
}
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
BOOL success = hixdisc.Initialize();
if (!success) {
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return S_OK;
}
success = hixdisc.HixDiscover( unitDeviceId,
NHIX_UDA_READ_ACCESS, // read bit is set - all hosts
nHosts,
2000 );
if (!success) {
ATLASSERT(FALSE);
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
return S_OK;
}
if (nRWHosts == NDAS_HOST_COUNT_UNKNOWN || nROHosts == NDAS_HOST_COUNT_UNKNOWN) {
DWORD rawROHosts = nROHosts;
DWORD rawRWHosts = nRWHosts;
// If any host count is unknown, use HIX counter only
nROHosts = 0;
nRWHosts = 0;
DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId);
for (DWORD i = 0; i < nRepliedHosts; ++i) {
NHIX_UDA uda = 0;
success = hixdisc.GetHostData(unitDeviceId,i,&uda);
XTLASSERT(success); // index must be valid!
if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS ||
uda == NHIX_UDA_SHARED_READ_WRITE_PRIMARY_ACCESS ||
uda == NHIX_UDA_READ_WRITE_ACCESS) {
++nRWHosts;
} else if (uda == NHIX_UDA_READ_ACCESS) {
++nROHosts;
} else {
ATLASSERT(FALSE);
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING,
"Invalid uda=0x%08X\n", uda);
}
}
// If HIX counter is not available either, we should at least show
// the original counter.
if (rawRWHosts != NDAS_HOST_COUNT_UNKNOWN && rawRWHosts > nRWHosts) {
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_WARNING,
"RWHost adjusted to Raw=%d from HIX=%d\n", rawRWHosts, nRWHosts);
nRWHosts = rawRWHosts;
}
} else {
// Otherwise, use SharedRW counter
DWORD nRepliedHosts = hixdisc.GetHostCount(unitDeviceId);
for (DWORD i = 0; i < nRepliedHosts; ++i) {
NHIX_UDA uda = 0;
success = hixdisc.GetHostData(unitDeviceId,i,&uda);
XTLASSERT(success); // index must be valid!
if (uda == NHIX_UDA_SHARED_READ_WRITE_SECONDARY_ACCESS) {
--nROHosts;
++nRWHosts;
}
}
}
*lpnROHosts = nROHosts;
*lpnRWHosts = nRWHosts;
ATLASSERT( *lpnRWHosts != NDAS_HOST_COUNT_UNKNOWN && *lpnROHosts != NDAS_HOST_COUNT_UNKNOWN );
NdasUiDbgCall( 2, "Actual Host Usage Count: RO=%d, RW=%d.\n", *lpnROHosts, *lpnRWHosts );
return S_OK;
}
BOOL CMirDiskUIHandler::OnMigrate(CDiskObjectPtr obj ) const
{
CMirDiskObjectPtr mirDisk =
boost::dynamic_pointer_cast<CMirDiskObject>(obj);
if(NMT_MIRROR != mirDisk->GetNDASMediaType())
return FALSE;
UINT32 BindResult;
CDiskObjectPtr disk = obj;
NDASCOMM_CONNECTION_INFO pConnectionInfo[NUMBER_MIGRATE_DISK];
UINT32 i;
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
// Find aggregation root
if (NUMBER_MIGRATE_DISK != disk->GetDiskCount())
{
WTL::CString strMsg;
strMsg.LoadString( IDS_DISKPROPERTYPAGE_MIGRATE_DISK_NOT_EXIST );
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return FALSE;
}
WTL::CString strConfirmMsg;
strConfirmMsg.LoadString( IDS_DISKPROPERTYPAGE_MIGRATE_CONFIRM );
if ( IDYES != MessageBox(
::GetFocus(),
strConfirmMsg,
strTitle,
MB_YESNO | MB_ICONWARNING
)
)
{
return FALSE;
}
if ( !disk->CanAccessExclusive() )
{
WTL::CString strMsg;
strMsg.LoadString( IDS_FAIL_TO_ACCESS_EXCLUSIVELY );
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return FALSE;
}
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(disk);
CDiskObjectComposite::const_iterator itr;
for (itr = pDiskObjectComposite->begin(), i = 0; itr != pDiskObjectComposite->end(); ++itr, ++i)
{
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
ZeroMemory(&pConnectionInfo[i], sizeof(NDASCOMM_CONNECTION_INFO));
pConnectionInfo[i].address_type = NDASCOMM_CONNECTION_INFO_TYPE_ADDR_LPX;
pConnectionInfo[i].login_type = NDASCOMM_LOGIN_TYPE_NORMAL;
pConnectionInfo[i].UnitNo = unitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
pConnectionInfo[i].bWriteAccess = TRUE;
pConnectionInfo[i].ui64OEMCode = NULL;
pConnectionInfo[i].bSupervisor = FALSE;
pConnectionInfo[i].protocol = NDASCOMM_TRANSPORT_LPX;
CopyMemory(pConnectionInfo[i].AddressLPX,
unitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
}
BindResult = NdasOpBind(NUMBER_MIGRATE_DISK, pConnectionInfo, NMT_RAID1);
WTL :: CString strMsg;
if(NUMBER_MIGRATE_DISK == BindResult)
{
strMsg.LoadString(IDS_DISKPROPERTYPAGE_MIGRATE_SUCCESS);
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
::GetFocus(),
strMsg,
strTitle,
MB_OK|MB_ICONINFORMATION
);
}
else
{
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
for (itr = pDiskObjectComposite->begin(), i = 0; itr != pDiskObjectComposite->end(); ++itr, ++i)
{
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
if(BindResult == i)
strMsg.FormatMessage(IDS_DISKPROPERTYPAGE_MIGRATE_FAIL_AT_FMT, unitDisk->GetTitle());
}
break;
default:
strMsg.LoadString(IDS_DISKPROPERTYPAGE_MIGRATE_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
for(i = 0; i < NUMBER_MIGRATE_DISK; i++)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node, pConnectionInfo[i].AddressLPX,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo = pConnectionInfo[i].UnitNo;
HixChangeNotify.Notify(unitDeviceId);
}
}
return TRUE;
}
DWORD
CNdasService::OnTaskStart()
{
//
// Call Instance Manager to initialize the objects
// functions Initialize() of objects are called automatically
//
BOOL fSuccess = CNdasInstanceManager::Initialize();
if (!fSuccess) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
return ::GetLastError();
}
//
// Get the initialized instance
//
PCNdasInstanceManager pInstMan = CNdasInstanceManager::Instance();
fSuccess = pInstMan->GetCommandServer()->Run();
if (!fSuccess) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
fSuccess = pInstMan->GetHBListener()->Run();
if (!fSuccess) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
fSuccess = pInstMan->GetEventMonitor()->Run();
if (!fSuccess) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
fSuccess = pInstMan->GetEventPublisher()->Run();
if (!fSuccess) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
//
// Register Plug'n'Play Device Notification
//
CNdasServiceDeviceEventHandler* pDeviceEventHandler;
if (m_bDebugMode) {
pDeviceEventHandler = pInstMan->CreateDeviceEventHandler(
m_hWndDebug,
DEVICE_NOTIFY_WINDOW_HANDLE);
} else {
pDeviceEventHandler = pInstMan->CreateDeviceEventHandler(
m_sshStatusHandle,
DEVICE_NOTIFY_SERVICE_HANDLE);
}
if (NULL == pDeviceEventHandler) {
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
fSuccess = pDeviceEventHandler->Initialize();
if (!fSuccess) {
DPErrorEx(_FT("PnpHandler Initialization failed: "));
ReportStatusToSCMgr(SERVICE_STOPPED, 0, ::GetLastError());
CNdasInstanceManager::Cleanup();
return ::GetLastError();
}
CNdasServicePowerEventHandler *pPowerEventHandler =
pInstMan->CreatePowerEventHandler();
CNdasIXBcast cixb;
fSuccess = cixb.Initialize();
_ASSERTE(fSuccess);
fSuccess = cixb.Run();
_ASSERTE(fSuccess);
CNdasIXServer cixserver;
fSuccess = cixserver.Initialize();
_ASSERTE(fSuccess);
fSuccess = cixserver.Run();
_ASSERTE(fSuccess);
LPCGUID lpHostGuid = pGetNdasHostGuid();
CNdasHIXServer hixsrv(lpHostGuid);
fSuccess = hixsrv.Initialize();
_ASSERTE(fSuccess);
fSuccess = hixsrv.Run();
_ASSERTE(fSuccess);
CNdasAutoRegister autoRegister;
fSuccess = autoRegister.Initialize();
_ASSERTE(fSuccess);
fSuccess = autoRegister.Run();
_ASSERTE(fSuccess);
//
// Now time to bootstrap registrar from the registry
//
fSuccess = pInstMan->GetRegistrar()->Bootstrap();
_ASSERTE(fSuccess && "Bootstrap should not failed!");
//
// Termination Handle
//
BOOL bTerminate = FALSE;
DWORD dwWin32ExitCode = 0;
HANDLE hEvents[1];
hEvents[0] = m_hTaskTerminateEvent;
while (!bTerminate) {
DWORD dwWaitResult = ::WaitForMultipleObjects(
1,
hEvents,
FALSE,
INFINITE);
switch (dwWaitResult) {
case WAIT_OBJECT_0:
bTerminate = TRUE;
break;
default:
;
}
}
pInstMan->GetEventPublisher()->ServiceTerminating();
autoRegister.Stop();
hixsrv.Stop();
cixserver.Stop();
cixb.Stop();
pInstMan->GetCommandServer()->Stop();
pInstMan->GetHBListener()->Stop();
pInstMan->GetEventMonitor()->Stop();
pInstMan->GetEventPublisher()->Stop();
CNdasInstanceManager::Cleanup();
return dwWin32ExitCode;
}
// 0 to automatically advance to the next page
// -1 to prevent the page from changing
INT
CSelectDiskPage::OnWizardNext()
{
ATLASSERT( m_wndListBind.GetItemCount() == (int)m_pWizData->m_nDiskCount);
ATLASSERT(
NMT_AGGREGATE == m_pWizData->m_nBindType ||
NMT_RAID0 == m_pWizData->m_nBindType ||
NMT_RAID1 == m_pWizData->m_nBindType ||
NMT_RAID4 == m_pWizData->m_nBindType);
NBUnitDevicePtrList listBind;
unsigned int i;
UINT32 BindResult;
WTL::CString strMsg;
// warning message
{
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
strMsg.LoadString(IDS_WARNING_BIND);
int id = MessageBox(
strMsg,
strTitle,
MB_YESNO|MB_ICONEXCLAMATION
);
if(IDYES != id)
return -1;
}
m_pWizData->listUnitDevicesBind = m_wndListBind.GetDiskObjectList();
NDASCOMM_CONNECTION_INFO *pConnectionInfo;
pConnectionInfo = new NDASCOMM_CONNECTION_INFO[m_pWizData->m_nDiskCount];
ZeroMemory(pConnectionInfo, sizeof(NDASCOMM_CONNECTION_INFO) * m_pWizData->m_nDiskCount);
listBind = m_wndListBind.GetDiskObjectList();
WTL::CString strTitle;
CNBUnitDevice *UnitDiskObject;
NBUnitDevicePtrList::const_iterator itr;
for (i = 0, itr = listBind.begin(); itr != listBind.end(); ++itr, i++ )
{
UnitDiskObject = *itr;
if(!UnitDiskObject->InitConnectionInfo(&pConnectionInfo[i], TRUE))
// if(!((*itr)->GetAccessMask() & GENERIC_WRITE))
{
// "%1!s! does not have a write access privilege. You need to set write key to this NDAS device before this action."
strMsg.FormatMessage(IDS_ERROR_NOT_REGISTERD_WRITE_FMT,
(*itr)->GetName()
);
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONERROR
);
delete [] pConnectionInfo;
return -1;
}
}
m_pWizData->m_BindResult = NdasOpBind(
m_pWizData->m_nDiskCount, pConnectionInfo, m_pWizData->m_nBindType);
if(m_pWizData->m_BindResult != m_pWizData->m_nDiskCount) // error
m_pWizData->dwBindLastError = ::GetLastError();
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
for (i = 0; i < m_pWizData->m_nDiskCount; i++ )
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node, pConnectionInfo[i].AddressLPX,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo = pConnectionInfo[i].UnitNo;
HixChangeNotify.Notify(unitDeviceId);
}
}
delete [] pConnectionInfo;
return 0;
}
// 0 to automatically advance to the next page
// -1 to prevent the page from changing
INT
CSelectDiskPage::OnWizardNext()
{
ATLASSERT( m_wndListBind.GetItemCount() == (int)m_pWizData->m_nDiskCount);
ATLASSERT(
NMT_AGGREGATE == m_pWizData->m_nBindType ||
NMT_RAID0 == m_pWizData->m_nBindType ||
NMT_RAID1R3 == m_pWizData->m_nBindType ||
NMT_RAID4R3 == m_pWizData->m_nBindType ||
NMT_RAID5 == m_pWizData->m_nBindType
);
NBUnitDevicePtrList listBind;
unsigned int i;
CString strMsg;
// Warning message if disk is over 2T.
{
UINT64 nSize = pGetBoundDiskSize(
m_pWizData->m_nBindType,
m_pWizData->m_nDiskCount,
m_wndListBind.GetDiskObjectList());
if (nSize >= 2LL * 1024 * 1024 * 1024 * 1024) { // 2 Tera.
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
strMsg.LoadString(IDS_WARNING_BIND_SIZE);
int id = MessageBox(
strMsg,
strTitle,
MB_YESNO|MB_ICONEXCLAMATION
);
if(IDYES != id)
return -1;
}
}
// warning message
{
CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
strMsg.LoadString(IDS_WARNING_BIND);
int id = MessageBox(
strMsg,
strTitle,
MB_YESNO|MB_ICONEXCLAMATION
);
if(IDYES != id)
return -1;
}
m_pWizData->listUnitDevicesBind = m_wndListBind.GetDiskObjectList();
NDASCOMM_CONNECTION_INFO *pConnectionInfo;
pConnectionInfo = new NDASCOMM_CONNECTION_INFO[m_pWizData->m_nDiskCount];
ZeroMemory(pConnectionInfo, sizeof(NDASCOMM_CONNECTION_INFO) * m_pWizData->m_nDiskCount);
listBind = m_wndListBind.GetDiskObjectList();
CString strTitle;
CNBUnitDevice *UnitDiskObject;
NBUnitDevicePtrList::const_iterator itr;
for (i = 0, itr = listBind.begin(); itr != listBind.end(); ++itr, i++ )
{
UnitDiskObject = *itr;
if(!UnitDiskObject->InitConnectionInfo(&pConnectionInfo[i], TRUE))
// if(!((*itr)->GetAccessMask() & GENERIC_WRITE))
{
// "%1!s! does not have a write access privilege. You need to set write key to this NDAS device before this action."
strMsg.FormatMessage(IDS_ERROR_NOT_REGISTERD_WRITE_FMT,
(*itr)->GetName()
);
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONERROR);
delete [] pConnectionInfo;
return -1;
}
}
DWORD dwUserSpace = 0;
if(!pGetAppConfigValue(_T("UserSpace"), &dwUserSpace))
{
dwUserSpace = 0;
}
AutoCursor l_auto_cursor(IDC_WAIT);
m_pWizData->m_BindResult = NdasOpBind(
m_pWizData->m_nDiskCount, pConnectionInfo, m_pWizData->m_nBindType, dwUserSpace);
l_auto_cursor.Release();
if(m_pWizData->m_BindResult != m_pWizData->m_nDiskCount) // error
m_pWizData->dwBindLastError = ::GetLastError();
LPCGUID hostGuid = pGetNdasHostGuid();
for (i = 0; i < m_pWizData->m_nDiskCount; i++ )
{
BOOL success = NdasCommNotifyUnitDeviceChange(
NDAS_DIC_NDAS_ID,
pConnectionInfo[i].Address.NdasId.Id,
pConnectionInfo[i].UnitNo,
hostGuid);
if (!success)
{
ATLTRACE("NdasCommNotifyUnitDeviceChange failed, error=0x%X\n",
GetLastError());
}
}
delete [] pConnectionInfo;
return 0;
}
STDMETHODIMP
CNdasUnitImpl::CheckNdasfsCompatibility()
{
CAutoInstanceLock autolock(this);
HRESULT hr;
// Unit devices other than disks are not allowed for NDFS
if (m_type != NDAS_UNITDEVICE_TYPE_DISK) {
return E_FAIL;
}
// LfsFilter compatibility check.
// NDFS Major version should be same
WORD wHostNDFSVerMajor;
BOOL success = ::LfsFiltCtlGetVersion( NULL, NULL, NULL, NULL, &wHostNDFSVerMajor, NULL );
if (!success) {
ATLASSERT(FALSE);
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
return hr;
}
ATLASSERT( wHostNDFSVerMajor == 0x0006 );
// Primary Host Info is valid for 30 seconds
#if 0
DWORD dwMaxTickAllowance = 30 * 1000;
if (0 != m_PrimaryHostInfo.NDFSCompatVersion &&
::GetTickCount() < m_PrimaryHostInfo.LastUpdate + dwMaxTickAllowance)
{
// primary host info is valid
return (wHostNDFSVerMajor == m_PrimaryHostInfo.NDFSCompatVersion);
}
#endif
// No Primary Host Info is available (IX)
// Use HIX to discover
CNdasHIXDiscover hixdisc(pGetNdasHostGuid());
success = hixdisc.Initialize();
if (!success) {
ATLASSERT(FALSE);
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
return hr;
}
NDAS_UNITDEVICE_ID ndasUnitId;
get_NdasUnitId( &ndasUnitId );
ATLASSERT( ndasUnitId.DeviceId.Reserved == 0 );
DWORD timeout = NdasServiceConfig::Get(nscWriteShareCheckTimeout);
success = hixdisc.HixDiscover( ndasUnitId, NHIX_UDA_SHRW_PRIM, 1, timeout );
if (!success) {
ATLASSERT(FALSE);
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"hixdisc.Discover failed, hr=0x%X\n", hr);
return hr;
}
DWORD nHosts = hixdisc.GetHostCount(ndasUnitId);
if (nHosts == 0) {
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostCount failed, hr=0x%X\n", hr);
return hr;
}
GUID hostGuid;
success = hixdisc.GetHostData( ndasUnitId, 0, NULL, &hostGuid, NULL, NULL );
if (!success) {
ATLASSERT(FALSE);
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostData failed, hr=0x%X\n", hr);
return hr;
}
CNdasHostInfoCache* phic = pGetNdasHostInfoCache();
XTLASSERT(phic); // phic is not null (by pGetNdasHostInfoCache)
const NDAS_HOST_INFO* pHostInfo = phic->GetHostInfo(&hostGuid);
if (pHostInfo == NULL) {
ATLASSERT(FALSE);
hr = HRESULT_FROM_WIN32(GetLastError());
hr = SUCCEEDED(hr) ? E_FAIL : hr;
XTLTRACE2(NDASSVC_NDASUNITDEVICE, TRACE_LEVEL_ERROR,
"GetHostInfo failed, hr=0x%X\n", hr);
return hr;
}
// ReservedVerInfo contains NDFS Version Information
if (pHostInfo->ReservedVerInfo.VersionMajor != wHostNDFSVerMajor) {
NdasUiDbgCall( 1, "Host NDFS %d, Primary NDFS %d failed\n", wHostNDFSVerMajor, pHostInfo->ReservedVerInfo.VersionMajor );
return E_FAIL;
}
// Primary and this host's NDFS compatible version is same
return S_OK;
}
void CDiskPropertyPage1::OnMigrate(UINT /*wNotifyCode*/, int /*wID*/, HWND /*hwndCtl*/)
{
UINT32 BindResult;
CDiskObjectPtr disk = GetParentSheet()->GetDiskObject();
NDAS_CONNECTION_INFO pConnectionInfo[NUMBER_MIGRATE_DISK];
UINT32 i;
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
// Find aggregation root
if (NUMBER_MIGRATE_DISK != disk->GetDiskCount())
{
WTL::CString strMsg;
strMsg.LoadString( IDS_DISKPROPERTYPAGE_MIGRATE_DISK_NOT_EXIST );
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
WTL::CString strConfirmMsg;
strConfirmMsg.LoadString( IDS_DISKPROPERTYPAGE_MIGRATE_CONFIRM );
if ( IDYES != MessageBox(
strConfirmMsg,
strTitle,
MB_YESNO | MB_ICONWARNING
)
)
{
return;
}
if ( !disk->CanAccessExclusive() )
{
WTL::CString strMsg;
strMsg.LoadString( IDS_DISKPROPERTYPAGE_MIGRATE_ACCESS_FAIL );
MessageBox(
strMsg,
strTitle,
MB_OK | MB_ICONWARNING
);
return;
}
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(disk);
CDiskObjectComposite::const_iterator itr;
for (itr = pDiskObjectComposite->begin(), i = 0; itr != pDiskObjectComposite->end(); ++itr, ++i)
{
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
pConnectionInfo[i].type = NDAS_CONNECTION_INFO_TYPE_MAC_ADDRESS;
pConnectionInfo[i].UnitNo = unitDisk->GetLocation()->GetUnitDiskLocation()->UnitNumber;
pConnectionInfo[i].bWriteAccess = TRUE;
pConnectionInfo[i].ui64OEMCode = NULL;
pConnectionInfo[i].protocol = IPPROTO_LPXTCP;
CopyMemory(pConnectionInfo[i].MacAddress,
unitDisk->GetLocation()->GetUnitDiskLocation()->MACAddr,
LPXADDR_NODE_LENGTH);
}
BindResult = NdasOpBind(NUMBER_MIGRATE_DISK, pConnectionInfo, NMT_RAID1);
WTL :: CString strMsg;
if(NUMBER_MIGRATE_DISK == BindResult)
{
strMsg.LoadString(IDS_DISKPROPERTYPAGE_MIGRATE_SUCCESS);
WTL::CString strTitle;
strTitle.LoadString(IDS_APPLICATION);
MessageBox(
strMsg,
strTitle,
MB_OK|MB_ICONINFORMATION
);
GetDlgItem(IDC_TEXT_MIGRATE).ShowWindow( SW_HIDE );
GetDlgItem(IDC_BTN_MIGRATE).ShowWindow( SW_HIDE );
GetDlgItem(IDC_ST_MIGRATE).ShowWindow( SW_HIDE );
}
else
{
DWORD dwLastError = ::GetLastError();
switch(dwLastError)
{
case NDASCOMM_ERROR_RW_USER_EXIST:
case NDASOP_ERROR_ALREADY_USED:
case NDASOP_ERROR_DEVICE_FAIL:
case NDASOP_ERROR_NOT_SINGLE_DISK:
case NDASOP_ERROR_DEVICE_UNSUPPORTED:
case NDASOP_ERROR_NOT_BOUND_DISK: // does not return this error
for (itr = pDiskObjectComposite->begin(), i = 0; itr != pDiskObjectComposite->end(); ++itr, ++i)
{
CUnitDiskObjectPtr unitDisk =
boost::dynamic_pointer_cast<CUnitDiskObject>(*itr);
if(BindResult == i)
strMsg.FormatMessage(IDS_DISKPROPERTYPAGE_MIGRATE_FAIL_AT_FMT, unitDisk->GetTitle());
}
break;
default:
strMsg.LoadString(IDS_DISKPROPERTYPAGE_MIGRATE_FAIL);
break;
}
ShowErrorMessageBox(strMsg);
}
CNdasHIXChangeNotify HixChangeNotify(pGetNdasHostGuid());
BOOL bResults = HixChangeNotify.Initialize();
if(bResults)
{
for(i = 0; i < NUMBER_MIGRATE_DISK; i++)
{
NDAS_UNITDEVICE_ID unitDeviceId;
CopyMemory(unitDeviceId.DeviceId.Node, pConnectionInfo[i].MacAddress,
sizeof(unitDeviceId.DeviceId.Node));
unitDeviceId.UnitNo = pConnectionInfo[i].UnitNo;
HixChangeNotify.Notify(unitDeviceId);
}
}
}
