BOOL
HasSameBoundDiskList(CUnitDiskObjectPtr first, CUnitDiskObjectPtr second)
{
CDiskLocationVector vtFirst, vtSecond;
CUnitDiskInfoHandlerPtr handlerFirst, handlerSecond;
handlerFirst = first->GetInfoHandler();
handlerSecond = second->GetInfoHandler();
if ( !handlerFirst->IsBound() || !handlerSecond->IsBound() )
{
return FALSE;
}
vtFirst = handlerFirst->GetBoundDiskLocations( first->GetLocation() );
vtSecond = handlerSecond->GetBoundDiskLocations( second->GetLocation() );
if ( vtFirst.size() != vtSecond.size() )
return FALSE;
for ( UINT i=0; i < vtFirst.size(); i++ )
{
if ( !vtFirst[i]->Equal(vtSecond[i]) )
return FALSE;
}
return TRUE;
}
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;
}
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;
}
WTL::CString CObjectUIHandler::GetFaultTolerance(CDiskObjectPtr obj) const
{
WTL::CString strTitle;
strTitle = _T("");
if(obj->IsUnitDisk())
{
if((dynamic_cast<CEmptyDiskObject*>(obj.get()) == NULL))
{
CDiskObjectPtr parent;
CUnitDiskObjectPtr pUnitDiskObject =
boost::dynamic_pointer_cast<CUnitDiskObject>(obj);
if(!(parent = pUnitDiskObject->GetParent())->IsRoot())
{
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(parent);
if (NMT_RAID4 == pDiskObjectComposite->GetNDASMediaType())
{
UINT8 child_status =
pDiskObjectComposite->RMDUnitStatus(pUnitDiskObject->GetLocation()->GetUnitDiskLocation());
if(NDAS_UNIT_META_BIND_STATUS_FAULT & child_status)
{
strTitle.LoadString(IDS_FT_FAULT_CHILD);
}
else if(NDAS_UNIT_META_BIND_STATUS_SPARE & child_status)
{
strTitle.LoadString(IDS_FT_FAULT_SPARE);
}
}
}
else
{
strTitle.LoadString(IDS_FT_UNIT);
}
}
}
else
{
CDiskObjectCompositePtr pDiskObjectComposite =
boost::dynamic_pointer_cast<CDiskObjectComposite>(obj);
// check missing member
if(pDiskObjectComposite->IsBroken())
{
strTitle.LoadString(IDS_FT_MISSING);
}
else
{
switch(pDiskObjectComposite->GetNDASMediaType())
{
case NMT_AGGREGATE:
case NMT_RAID0:
case NMT_MIRROR:
if(pDiskObjectComposite->IsBroken())
strTitle.LoadString(IDS_FT_MISSING);
else
strTitle.LoadString(IDS_FT_NOT_FAULT_TOLERANT);
break;
case NMT_RAID1:
{
CMirDiskObjectPtr pMirDiskObject =
boost::dynamic_pointer_cast<CMirDiskObject>(pDiskObjectComposite);
if(pMirDiskObject->IsBroken())
strTitle.LoadString(IDS_FT_NEED_REPAIR);
else if(pMirDiskObject->IsDirty())
strTitle.LoadString(IDS_FT_DIRTY);
else
strTitle.LoadString(IDS_FT_FAULT_TOLERANT);
}
break;
case NMT_RAID4:
{
CRAID4DiskObjectPtr pRAID4DiskObject =
boost::dynamic_pointer_cast<CRAID4DiskObject>(pDiskObjectComposite);
if(pRAID4DiskObject->IsBroken())
{
strTitle.LoadString(IDS_FT_NEED_REPAIR);
}
else
{
switch(pDiskObjectComposite->RMDStatus())
{
case 0:
strTitle.LoadString(IDS_FT_FAULT_TOLERANT);
break;
case 1:
strTitle.LoadString(IDS_FT_DIRTY);
break;
case 2:
strTitle.LoadString(IDS_FT_FAULT);
break;
case 3:
strTitle.LoadString(IDS_FT_IN_SYNC);
break;
default:
break;
}
}
}
break;
default:
break;
}
}
}
return strTitle;
}
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;
}
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 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);
}
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);
}
}
}
CDiskObjectPtr
CDiskObjectBuilder::Build(const CDeviceInfoList listDevice, LPREFRESH_STATUS pFuncRefreshStatus, void *context)
{
CUnitDiskObjectList listDiskObj;
CDiskObjectCompositePtr root;
CUnitDiskObjectList::const_iterator found;
//
// Build list of unit disks from the device list
//
listDiskObj = BuildDiskObjectList(listDevice, pFuncRefreshStatus, context);
//
// Construct structure of disks including aggregation and mirroring
//
root = CDiskObjectCompositePtr(new CRootDiskObject());
while ( !listDiskObj.empty() )
{
CUnitDiskObjectPtr disk;
disk = listDiskObj.front();
CUnitDiskInfoHandlerPtr pInfoHandler = disk->GetInfoHandler();
if ( !pInfoHandler->IsHDD() )
{
listDiskObj.pop_front();
continue; // Only HDD type disk is supported.(This may be changed later)
}
if ( pInfoHandler->IsBound() )
{
CDiskLocationVector vtLocation =
pInfoHandler->GetBoundDiskLocations(disk->GetLocation());
if(NMT_RAID4 == pInfoHandler->GetNDASMediaType())
{
CDiskObjectCompositePtr raid4Disks =
CDiskObjectCompositePtr(new CRAID4DiskObject());
for(UINT i = 0; i < vtLocation.size(); i++)
{
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i]));
if(found != listDiskObj.end() &&
::HasSameBoundDiskList(*found, disk))
{
raid4Disks->AddChild(raid4Disks, *found);
listDiskObj.erase(found);
}
else
{
raid4Disks->AddChild(raid4Disks,
::CreateEmptyDiskObject());
}
}
root->AddChild(root, raid4Disks);
}
else if ( pInfoHandler->IsBoundAndNotSingleMirrored() )
{
CDiskObjectCompositePtr aggrDisks =
CDiskObjectCompositePtr(new CAggrDiskObject());
if ( pInfoHandler->IsMirrored() ) // double tree
{
for ( UINT i=0; i < vtLocation.size(); i+= 2 )
{
CMirDiskObjectPtr mirDisks =
CMirDiskObjectPtr( new CMirDiskObject() );
int emptydisk = 0;
// find first of the pair
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i])
);
if ( found != listDiskObj.end()
&& ::HasSameBoundDiskList(*found, disk) )
{
mirDisks->AddChild( mirDisks, *found );
listDiskObj.erase(found);
}
else
{
// create empty unit disk
emptydisk++;
}
// find second of the pair
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i+1])
);
if ( found != listDiskObj.end()
&& ::HasSameBoundDiskList(*found, disk) )
{
mirDisks->AddChild( mirDisks, *found );
listDiskObj.erase(found);
}
else
{
// create empty unit disk
emptydisk++;
}
if(0 == emptydisk)
{
}
else if(1 == emptydisk)
{
mirDisks->AddChild( mirDisks, ::CreateEmptyDiskObject());
}
else
{
listDiskObj.pop_front();
root->AddChild( root, disk );
break;
}
if ( mirDisks->size() != 0 ) // always 2 including empty disks
aggrDisks->AddChild( aggrDisks, mirDisks );
}
}
else
{
BOOL bFound = FALSE, bFoundSelf = FALSE;
for ( UINT i=0; i < vtLocation.size(); i++ )
{
CDiskLocationPtr p = vtLocation[i];
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i])
);
if ( found != listDiskObj.end()
&& ::HasSameBoundDiskList(*found, disk) )
{
bFound = TRUE;
if(*found == disk)
bFoundSelf = TRUE;
aggrDisks->AddChild( aggrDisks, *found );
listDiskObj.erase(found);
}
else
{
// create empty unit disk
aggrDisks->AddChild( aggrDisks, ::CreateEmptyDiskObject());
}
}
if(!bFound)
{
listDiskObj.pop_front();
root->AddChild( root, disk );
break;
}
if(!bFoundSelf)
{
listDiskObj.pop_front();
root->AddChild( root, disk );
}
}
root->AddChild( root, aggrDisks );
}
else if ( pInfoHandler->IsMirrored() )
{
CMirDiskObjectPtr mirDisks =
CMirDiskObjectPtr( new CMirDiskObject() );
UINT i = 0;
int emptydisk = 0;
// find first of the pair
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i])
);
if ( found != listDiskObj.end()
&& ::HasSameBoundDiskList(*found, disk) )
{
mirDisks->AddChild( mirDisks, *found );
listDiskObj.erase(found);
}
else
{
// create empty unit disk
emptydisk++;
}
// find second of the pair
found = std::find_if(
listDiskObj.begin(),
listDiskObj.end(),
std::bind1st(CDiskLocationEqual(), vtLocation[i+1])
);
if ( found != listDiskObj.end()
&& ::HasSameBoundDiskList(*found, disk) )
{
mirDisks->AddChild( mirDisks, *found );
listDiskObj.erase(found);
}
else
{
// create empty unit disk
emptydisk++;
}
if(0 == emptydisk)
{
}
else if(1 == emptydisk)
{
mirDisks->AddChild( mirDisks, ::CreateEmptyDiskObject());
}
else
{
listDiskObj.pop_front();
root->AddChild( root, disk );
break;
}
root->AddChild(root, mirDisks);
}
else
{
listDiskObj.pop_front();
root->AddChild( root, disk );
}
}
else // pDiskInfoHander->IsBound()
{
listDiskObj.pop_front();
root->AddChild( root, disk );
}
} // while ( !listDiskObj.empty() )
return root;
}