void Task_MigrateCtSource::finalizeTask()
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
SmartPtr<IOPackage> pPackage;
Disconnect();
if (PRL_SUCCEEDED(getLastErrorCode())) {
CProtoCommandPtr pResponse =
CProtoSerializer::CreateDspWsResponseCommand(getRequestPackage(), PRL_ERR_SUCCESS);
getClient()->sendResponse(pResponse, getRequestPackage());
/* We may not report error here since CT already live on destination */
bool bDeleteSource = !(m_nMigrationFlags & PVMT_CLONE_MODE);
PRL_RESULT nRetCode = CVzHelper::src_complete_migrate_env(m_nCtid, &m_pOpaqueLock, bDeleteSource);
if (PRL_FAILED(nRetCode))
WRITE_TRACE(DBG_FATAL, "Can not complete source CT migration for uuid %s", QSTR2UTF8(m_sVmUuid));
} else {
/* send response */
CProtoCommandPtr pResponse =
CProtoSerializer::CreateDspWsResponseCommand(getRequestPackage(), getLastErrorCode());
CProtoCommandDspWsResponse *wsResponse =
CProtoSerializer::CastToProtoCommand<CProtoCommandDspWsResponse>( pResponse );
getLastError()->setEventCode(getLastErrorCode());
wsResponse->SetError(getLastError()->toString());
getClient()->sendResponse( pResponse, getRequestPackage() );
getClient()->sendResponseError( getLastError(), getRequestPackage() );
}
if (m_bExVmOperationRegistered)
CDspService::instance()->getVmDirHelper().unregisterExclusiveVmOperation(
m_sVmUuid, m_sVzDirUuid, PVE::DspCmdDirVmMigrate, getClient());
}
PRL_RESULT Task_GetBackupTreeTarget::run_body()
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
PRL_RESULT nRetCode = PRL_ERR_SUCCESS;
QString msg;
CDispToDispCommandPtr pReply;
SmartPtr<IOPackage> pPackage;
getBackupTree(msg);
pReply = CDispToDispProtoSerializer::CreateGetBackupTreeReply(msg);
pPackage = DispatcherPackage::createInstance(
pReply->GetCommandId(),
pReply->GetCommand()->toString(),
getRequestPackage());
IOSendJob::Handle hJob = m_pDispConnection->sendPackage(pPackage);
if (CDspService::instance()->getIOServer().waitForSend(hJob, m_nTimeout) != IOSendJob::Success) {
WRITE_TRACE(DBG_FATAL, "Package sending failure");
setLastErrorCode(PRL_ERR_BACKUP_INTERNAL_PROTO_ERROR);
return PRL_ERR_BACKUP_INTERNAL_PROTO_ERROR;
}
return nRetCode;
}
PRL_RESULT Task_GetBackupTreeSource::run_body()
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
PRL_RESULT nRetCode = PRL_ERR_SUCCESS;
QFileInfoList excludeList;
QFileInfoList dirList;
QFileInfoList fileList;
if (PRL_FAILED(nRetCode = connect()))
goto exit;
if (PRL_FAILED(nRetCode = GetBackupTreeRequest(m_sUuid, m_sBackupTree)))
goto exit;
exit:
setLastErrorCode(nRetCode);
return nRetCode;
}
/* process VmMigrateCheckPreconditionsCommand */
PRL_RESULT Task_MigrateCtTarget::prepareTask()
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
PRL_RESULT nRetCode = PRL_ERR_SUCCESS;
QString sVmDirPath;
if (CDspService::instance()->isServerStopping()) {
WRITE_TRACE(DBG_FATAL, "Dispatcher shutdown is in progress - CT migrate rejected!");
nRetCode = PRL_ERR_DISP_SHUTDOWN_IN_PROCESS;
goto exit;
}
m_pVmConfig = SmartPtr<CVmConfiguration>(new CVmConfiguration(m_sVmConfig));
if (PRL_FAILED(m_pVmConfig->m_uiRcInit)) {
nRetCode = PRL_ERR_PARSE_VM_CONFIG;
WRITE_TRACE(DBG_FATAL, "Wrong VM condiguration was received: [%s]", QSTR2UTF8(m_sVmConfig));
goto exit;
}
m_sOriginVmUuid = m_pVmConfig->getVmIdentification()->getVmUuid();
m_nCtid = m_nOriginCtid = m_pVmConfig->getVmIdentification()->getEnvId();
m_sVmName = m_pVmConfig->getVmIdentification()->getVmName();
nRetCode = CVzHelper::dst_start_migrate_env(&m_nCtid, &m_pOpaqueLock);
if (PRL_FAILED(nRetCode)) {
WRITE_TRACE(DBG_FATAL, "Can not start destination CT migration for uuid %s", QSTR2UTF8(m_sVmUuid));
goto exit;
}
if (m_nCtid != m_nOriginCtid)
m_pVmConfig->getVmIdentification()->setEnvId(m_nCtid);
{
CDspLockedPointer<CVmDirectory> pDir = CDspService::instance()->getVmDirManager().getVzDirectory();
if (!pDir) {
nRetCode = PRL_ERR_VM_UUID_NOT_FOUND;
WRITE_TRACE(DBG_FATAL, "Couldn't to find VZ directiory UUID");
goto exit;
}
m_sVzDirUuid = pDir->getUuid();
}
m_sVmUuid = (PVMT_CLONE_MODE & getRequestFlags()) ? Uuid::createUuid().toString() : m_sOriginVmUuid;
WRITE_TRACE(DBG_FATAL, "Start migrate origin CTID=%u to CTID=%u for uuid %s",
m_nOriginCtid, m_nCtid, QSTR2UTF8(m_sVmUuid));
/* to get target VM home directory path */
if (!m_sVmDirPath.isEmpty())
m_sTargetVmHomePath = m_sVmDirPath;
else {
m_sTargetVmHomePath = CVzHelper::getCtPrivatePath(m_nCtid);
}
m_sTargetVmHomePath = QFileInfo(m_sTargetVmHomePath).absoluteFilePath();
m_sVmConfigPath = QString("%1/" VMDIR_DEFAULT_VM_CONFIG_FILE).arg(m_sTargetVmHomePath);
/* lock Vm exclusive parameters */
m_pVmInfo = SmartPtr<CVmDirectory::TemporaryCatalogueItem>(new CVmDirectory::TemporaryCatalogueItem(
m_sVmUuid, m_sVmConfigPath, m_sVmName));
nRetCode = CDspService::instance()->getVmDirManager()
.checkAndLockNotExistsExclusiveVmParameters(QStringList(), m_pVmInfo.getImpl());
if (PRL_FAILED(nRetCode))
{
switch (nRetCode)
{
case PRL_ERR_VM_ALREADY_REGISTERED_VM_UUID:
WRITE_TRACE(DBG_FATAL, "UUID '%s' already registered", QSTR2UTF8(m_pVmInfo->vmUuid));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmUuid, EVT_PARAM_RETURN_PARAM_TOKEN));
break;
case PRL_ERR_VM_ALREADY_REGISTERED_VM_PATH:
WRITE_TRACE(DBG_FATAL, "path '%s' already registered", QSTR2UTF8(m_pVmInfo->vmXmlPath));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmName, EVT_PARAM_MESSAGE_PARAM_0));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmXmlPath, EVT_PARAM_MESSAGE_PARAM_1));
break;
case PRL_ERR_VM_ALREADY_REGISTERED_VM_NAME:
WRITE_TRACE(DBG_FATAL, "name '%s' already registered", QSTR2UTF8(m_pVmInfo->vmName));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmName, EVT_PARAM_MESSAGE_PARAM_0));
break;
case PRL_ERR_VM_ALREADY_REGISTERED:
WRITE_TRACE(DBG_FATAL, "container '%s' already registered", QSTR2UTF8(m_pVmInfo->vmName));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmName, EVT_PARAM_MESSAGE_PARAM_0));
break;
case PRL_ERR_VM_ALREADY_REGISTERED_UNIQUE_PARAMS:; // use default
default:
WRITE_TRACE(DBG_FATAL, "can't register container with UUID '%s', name '%s', path '%s",
QSTR2UTF8(m_pVmInfo->vmUuid), QSTR2UTF8(m_pVmInfo->vmName), QSTR2UTF8(m_pVmInfo->vmXmlPath));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmUuid, EVT_PARAM_RETURN_PARAM_TOKEN));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmXmlPath, EVT_PARAM_RETURN_PARAM_TOKEN));
getLastError()->addEventParameter(
new CVmEventParameter( PVE::String, m_pVmInfo->vmName, EVT_PARAM_RETURN_PARAM_TOKEN));
}
goto exit;
}
m_nSteps |= MIGRATE_VM_EXCL_PARAMS_LOCKED;
if (!(PVMT_SWITCH_TEMPLATE & getRequestFlags())) {
/* skip checking for copy to template case (https://jira.sw.ru/browse/PSBM-9597) */
//checkTargetCpusNumber();
//checkTargetCpuCompatibility();
}
exit:
setLastErrorCode(nRetCode);
return nRetCode;
}
PRL_RESULT Task_MigrateCtSource::run_body()
{
SmartPtr<CVmEvent> pEvent;
SmartPtr<IOPackage> pPackage;
IOSendJob::Response pResponse;
CDispToDispCommandPtr pCmd;
CDispToDispResponseCommand *pRespCmd;
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
if (operationIsCancelled())
setLastErrorCode(PRL_ERR_OPERATION_WAS_CANCELED);
PRL_RESULT nRetCode = PRL_ERR_SUCCESS;
if (PRL_FAILED(nRetCode = CheckVmMigrationPreconditions()))
goto exit;
/* set migration mode */
switch (m_nPrevVmState) {
case VMS_RUNNING:
case VMS_PAUSED:
nRetCode = PRL_ERR_VM_MIGRATE_WARM_MODE_NOT_SUPPORTED;
goto exit;
default:
m_nMigrationFlags |= PVMT_COLD_MIGRATION;
}
if (operationIsCancelled())
setLastErrorCode(PRL_ERR_OPERATION_WAS_CANCELED);
pEvent = SmartPtr<CVmEvent>(new CVmEvent(PET_DSP_EVT_VM_MIGRATE_STARTED, m_sVmUuid, PIE_DISPATCHER));
pEvent->addEventParameter(new CVmEventParameter(PVE::Boolean, "true", EVT_PARAM_MIGRATE_IS_SOURCE));
pPackage = DispatcherPackage::createInstance(PVE::DspVmEvent, pEvent->toString());
m_nSteps |= MIGRATE_VM_STATE_CHANGED;
/* and notify clients about VM migration start event */
CDspService::instance()->getClientManager().sendPackageToVmClients(pPackage, m_sVzDirUuid, m_sVmUuid);
/* remove target Vm config from watcher (#448235) */
CDspService::instance()->getVmConfigWatcher().unregisterVmToWatch(m_sVmConfigPath);
m_nSteps |= MIGRATE_UNREGISTER_VM_WATCH;
nRetCode = migrateStoppedCt();
if (PRL_FAILED(nRetCode))
goto exit;
/* wait finish reply from target (https://jira.sw.ru/browse/PSBM-9596) */
quint32 nTimeout = m_nTimeout;
/* wait target task finish */
if (PVMT_CHANGE_SID & getRequestFlags())
/* wait reply during changeSID task timeout (https://jira.sw.ru/browse/PSBM-9733) */
nTimeout = CHANGESID_TIMEOUT;
if (m_pIoClient->waitForResponse(m_hCheckReqJob, nTimeout) != IOSendJob::Success) {
WRITE_TRACE(DBG_FATAL, "Finish acknowledgement receiving failure");
nRetCode = PRL_ERR_CT_MIGRATE_INTERNAL_ERROR;
goto exit;
}
pResponse = m_pIoClient->takeResponse(m_hCheckReqJob);
if (pResponse.responseResult != IOSendJob::Success) {
WRITE_TRACE(DBG_FATAL, "Finish acknowledgement receiving failure");
nRetCode = PRL_ERR_CT_MIGRATE_INTERNAL_ERROR;
goto exit;
}
pPackage = pResponse.responsePackages[0];
if (pPackage->header.type != DispToDispResponseCmd) {
WRITE_TRACE(DBG_FATAL, "Invalid package type : %d", pPackage->header.type);
nRetCode = PRL_ERR_CT_MIGRATE_INTERNAL_ERROR;
goto exit;
}
pCmd = CDispToDispProtoSerializer::ParseCommand(
DispToDispResponseCmd, UTF8_2QSTR(pPackage->buffers[0].getImpl()));
pRespCmd = CDispToDispProtoSerializer::CastToDispToDispCommand<CDispToDispResponseCommand>(pCmd);
nRetCode = pRespCmd->GetRetCode();
if (PRL_FAILED(nRetCode))
getLastError()->fromString(pRespCmd->GetErrorInfo()->toString());
exit:
setLastErrorCode(nRetCode);
return nRetCode;
}
PRL_RESULT Task_MigrateCtSource::prepareTask()
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &getClient()->getAuthHelper() );
PRL_RESULT nRetCode = PRL_ERR_SUCCESS;
if (CDspService::instance()->isServerStopping())
{
WRITE_TRACE(DBG_FATAL, "Dispatcher shutdown is in progress - VM migrate rejected!");
nRetCode = PRL_ERR_DISP_SHUTDOWN_IN_PROCESS;
goto exit;
}
if (CDspService::instance()->getShellServiceHelper().isLocalAddress(m_sServerHostname)) {
WRITE_TRACE(DBG_FATAL,
"Host %s is a local host, migration is impossible", QSTR2UTF8(m_sServerHostname));
nRetCode = PRL_ERR_VM_MIGRATE_TO_THE_SAME_NODE;
goto exit;
}
/* will use Vz dir uuid for Vm */
{
CDspLockedPointer<CVmDirectory> pDir = CDspService::instance()->getVmDirManager().getVzDirectory();
if (!pDir) {
nRetCode = PRL_ERR_VM_UUID_NOT_FOUND;
WRITE_TRACE(DBG_FATAL, "Couldn't to find VZ directiory UUID");
goto exit;
}
m_sVzDirUuid = pDir->getUuid();
nRetCode = CDspService::instance()->getVmDirHelper().registerExclusiveVmOperation(
m_sVmUuid, m_sVzDirUuid, PVE::DspCmdDirVmMigrate, getClient());
if ( PRL_FAILED(nRetCode) ) {
WRITE_TRACE(DBG_FATAL, "[%s] registerExclusiveVmOperation failed. Reason: %#x (%s)",
__FUNCTION__, nRetCode, PRL_RESULT_TO_STRING(nRetCode));
goto exit;
}
m_bExVmOperationRegistered = true;
}
m_pVmConfig = CDspService::instance()->getVzHelper()->getCtConfig(getClient(), m_sVmUuid);
if (!m_pVmConfig.isValid()) {
WRITE_TRACE(DBG_FATAL, "Can not load config for uuid %s", QSTR2UTF8(m_sVmUuid));
goto exit;
}
m_sVmHomePath = m_pVmConfig->getVmIdentification()->getHomePath();
m_nCtid = m_pVmConfig->getVmIdentification()->getEnvId();
nRetCode = CDspService::instance()->getVzHelper()->getVzlibHelper().get_env_status(m_sVmUuid, m_nPrevVmState);
if (PRL_FAILED(nRetCode)) {
WRITE_TRACE(DBG_FATAL, "Can not get status for uuid %s", QSTR2UTF8(m_sVmUuid));
goto exit;
}
if (m_nPrevVmState != VMS_STOPPED) {
WRITE_TRACE(DBG_FATAL, "CT must be stopped for migration");
nRetCode = PRL_ERR_VM_MIGRATE_UNSUITABLE_VM_STATE;
goto exit;
}
nRetCode = CVzHelper::src_start_migrate_env(m_nCtid, &m_pOpaqueLock);
if (PRL_FAILED(nRetCode)) {
WRITE_TRACE(DBG_FATAL, "Can not start source CT migration for uuid %s", QSTR2UTF8(m_sVmUuid));
goto exit;
}
{
/* LOCK inside brackets */
CDspLockedPointer<CDspHostInfo> lockedHostInfo = CDspService::instance()->getHostInfo();
m_cHostInfo.fromString( lockedHostInfo->data()->toString() );
}
nRetCode = Connect(
m_sServerHostname, m_nServerPort, m_sServerSessionUuid, QString(), QString(), m_nMigrationFlags);
if (PRL_FAILED(nRetCode))
goto exit;
exit:
setLastErrorCode(nRetCode);
return nRetCode;
}
PRL_RESULT Mixin_CreateVmSupport::setDefaultVmPermissions(
SmartPtr<CDspClient> pUser,
QString vmPathToConfig,
bool bKeepOthersPermissions
)
{
PRL_ASSERT( pUser );
PRL_ASSERT( ! vmPathToConfig.isEmpty() );
if( ! pUser || vmPathToConfig.isEmpty() )
return PRL_ERR_INVALID_ARG;
// FIXME: isFsSupportPermsAndOwner() should be moved near setFullAccessRightsToVm() and united with it.
{
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &pUser->getAuthHelper() );
// # https://bugzilla.sw.ru/show_bug.cgi?id=112901
// https://jira.sw.ru/browse/PSBM-9040
if( !CFileHelper::isFsSupportPermsAndOwner( vmPathToConfig ) )
{
WRITE_TRACE(DBG_FATAL, "File system does not support permissions. Setting default Vm permission will be ignored. (path=%s)"
, QSTR2UTF8( vmPathToConfig ) );
return PRL_ERR_SUCCESS;
}
}
// get vm directory path
// To prevent stupid errors see https://bugzilla.sw.ru/show_bug.cgi?id=483700 for more details
PRL_ASSERT(QFileInfo( vmPathToConfig ).isFile());
QString strVmDirPath;
if ( QFileInfo( vmPathToConfig ).isFile() )
strVmDirPath = CFileHelper::GetFileRoot( vmPathToConfig );
else
{
strVmDirPath = vmPathToConfig;
vmPathToConfig = QString("%1/%2").arg(strVmDirPath).arg(VMDIR_DEFAULT_VM_CONFIG_FILE);
}
if ( !CDspAccessManager::setOwner( strVmDirPath, &pUser->getAuthHelper(), true ) )
{
WRITE_TRACE(DBG_FATAL, "Can't change owner to vm dir files [%s]. error=[%s]"
, QSTR2UTF8( strVmDirPath )
, QSTR2UTF8( Prl::GetLastErrorAsString() ) );
return PRL_ERR_CANT_CHANGE_OWNER_OF_FILE;
}
//////////////////////////////////////////////////////////////////////////
// set default access rigths
//////////////////////////////////////////////////////////////////////////
CVmDirectoryItem vmDirItem;
vmDirItem.setVmHome( vmPathToConfig );
PRL_SEC_AM ownerAccess = CDspAccessManager::VmAccessRights::makeModeRWX() ;
PRL_SEC_AM otherAccess = CDspAccessManager::VmAccessRights::makeModeNO_ACCESS() ;
PRL_RESULT err = CDspService::instance()->getAccessManager()
.setFullAccessRightsToVm( pUser, &vmDirItem, &ownerAccess,
// Do not change others permissions during registration at desktop mode
// https://bugzilla.sw.ru/show_bug.cgi?id=120191
! bKeepOthersPermissions ? &otherAccess : NULL );
if( PRL_FAILED( err ) )
{
WRITE_TRACE(DBG_FATAL, "Can't change permission to vm dir files [%s]. error=[%s]"
, QSTR2UTF8( strVmDirPath )
, QSTR2UTF8( Prl::GetLastErrorAsString() ) );
return PRL_ERR_CANT_CHANGE_FILE_PERMISSIONS;
}
return PRL_ERR_SUCCESS;
}
PRL_RESULT Task_GetInfoFromParallelsUtils::GetDiskImageInformation(
const QString & strPathToFile,
CVmHardDisk & cHardDisk,
SmartPtr<CDspClient> pUserSession)
{
// VirtualDisk commented out by request from CP team
// PARALLELS_DISK_PARAMETERS DiskParameters;
// PRL_RESULT nRetVal = PRL_ERR_SUCCESS;
LOG_MESSAGE(DBG_DEBUG,
"Task_GetInfoFromParallelsUtils::GetDiskImageInformation(%s)",
strPathToFile.toUtf8().data());
// Pointer to argument is not valid
if (strPathToFile.isEmpty())
return PRL_ERR_VM_GET_HDD_IMG_INVALID_ARG;
//https://bugzilla.sw.ru/show_bug.cgi?id=267152
CAuthHelperImpersonateWrapper _impersonate( &pUserSession->getAuthHelper() );
QString strDirPathToFile = strPathToFile;
if (!QFileInfo(strPathToFile).isDir() && !strPathToFile.endsWith(".vmdk"))
strDirPathToFile = CFileHelper::GetFileRoot(strPathToFile);
SmartPtr<CVmHardDisk> pCachedHardDisk =
CDspService::instance()->getVmConfigManager().getHardDiskConfigCache().
getConfig(strDirPathToFile, pUserSession );
if( pCachedHardDisk )
{
// Fill only Disk specific fields
cHardDisk.setVersion(pCachedHardDisk->getVersion());
cHardDisk.setSystemName(pCachedHardDisk->getSystemName());
cHardDisk.setUserFriendlyName(pCachedHardDisk->getUserFriendlyName());
cHardDisk.setEmulatedType(pCachedHardDisk->getEmulatedType());
cHardDisk.setSplitted(pCachedHardDisk->isSplitted());
cHardDisk.setDiskType(pCachedHardDisk->getDiskType());
cHardDisk.setBlockSize(pCachedHardDisk->getBlockSize());
cHardDisk.setSize(pCachedHardDisk->getSize());
cHardDisk.setCompatLevel(pCachedHardDisk->getCompatLevel());
cHardDisk.setSizeOnDisk(pCachedHardDisk->getSizeOnDisk());
/* FIXME: get size by demand */
// set size on disk in MB
quint64 ui64Size = 0;
CSimpleFileHelper::GetDirSize(strDirPathToFile, &ui64Size);
cHardDisk.setSizeOnDisk(ui64Size/(1024*1024));
return PRL_ERR_SUCCESS;
}
// VirtualDisk commented out by request from CP team
// IDisk* pDisk = IDisk::OpenDisk( strDirPathToFile,
// PRL_DISK_READ | PRL_DISK_FAKE_OPEN,
// &nRetVal);
// if ( !pDisk )
// {
// switch (IDisk::IsDiskValid(strPathToFile))
// {
// case PRL_CHECKED_DISK_VALID:
// // Can not happen
// break;
// case PRL_CHECKED_DISK_OLD_VERSION:
// cHardDisk.setVersion(PVE::HardDiskV1);
// return PRL_ERR_SUCCESS;
// case PRL_CHECKED_DISK_INVALID:
// cHardDisk.setVersion(PVE::HardDiskInvalidVersion);
// return PRL_ERR_SUCCESS;
// default:
// cHardDisk.setVersion(PVE::HardDiskInvalidVersion);
// return PRL_ERR_SUCCESS;
// }
//
// WRITE_TRACE(DBG_FATAL, "Error opening disk %s to get info."
// " Received NULL reference. Error 0x%x",
// QSTR2UTF8(strPathToFile), nRetVal);
// return PRL_ERR_VM_GET_HDD_IMG_NOT_OPEN;
// }
//
// nRetVal = pDisk->GetParameters(DiskParameters);
// if (PRL_FAILED(nRetVal)) {
// pDisk->Close();
// pDisk->Release();
// return PRL_ERR_VM_GET_HDD_IMG_NOT_OPEN;
// }
//
// LOG_MESSAGE(DBG_FATAL, "Cyl %u Head %u SPT %u\n",
// DiskParameters.m_Cylinders,
// DiskParameters.m_Heads,
// DiskParameters.m_Sectors);
//
// cHardDisk.setVersion(PVE::HardDiskV2);
// cHardDisk.setSystemName(strDirPathToFile);
// cHardDisk.setUserFriendlyName(strDirPathToFile);
// cHardDisk.setEmulatedType(PVE::HardDiskImage);
// cHardDisk.setSplitted(DiskParameters.m_Storages.size() > 1);
//
// switch ((*DiskParameters.m_Storages.begin()).Type)
// {
// case PRL_IMAGE_PLAIN:
// case PRL_IMAGE_VMDK_MONOLITHIC_FLAT:
// case PRL_IMAGE_VMDK_EXTENT_2GB_FLAT:
// cHardDisk.setDiskType(PHD_PLAIN_HARD_DISK);
// break;
// case PRL_IMAGE_COMPRESSED:
// case PRL_IMAGE_VMDK_MONOLITHIC_SPARSE:
// case PRL_IMAGE_VMDK_EXTENT_2GB_SPARSE:
// cHardDisk.setDiskType(PHD_EXPANDING_HARD_DISK);
// break;
// default:
// nRetVal = PRL_ERR_INVALID_HDD_GEOMETRY;
// break;
// }
//
// cHardDisk.setBlockSize(DiskParameters.m_BlockSize);
// // virtual size of hdd image
// // size in MB - one sector 512 byte
// cHardDisk.setSize(DiskParameters.m_SizeInSectors/2048);
// // set size on disk in MB
// quint64 ui64Size = 0;
// CSimpleFileHelper::GetDirSize(strDirPathToFile,&ui64Size);
// cHardDisk.setSizeOnDisk(ui64Size/(1024*1024));
//
// // check suspend and change state flags on disk
// if (cHardDisk.getVersion() == PVE::HardDiskV2)
// {
// QString strParam;
//
// PRL_RESULT res = pDisk->GetUserParameter(SUSPEND_STATE_PARAM_NAME, strParam);
// if (PRL_SUCCEEDED(res) && strParam.toUInt())
// cHardDisk.setVersion(PVE::HardDiskV2Suspended);
// }
//
// if (PRL_SUCCEEDED(nRetVal))
// {
// QString qsCompatLevel;
// PRL_RESULT Err = pDisk->GetUserParameter(QString(COMPAT_LEVEL_PARAM_NAME), qsCompatLevel);
// if (PRL_SUCCEEDED(Err))
// cHardDisk.setCompatLevel(qsCompatLevel);
// }
//
// pDisk->Close();
// pDisk->Release();
//
// CDspService::instance()->getVmConfigManager().
// getHardDiskConfigCache().update(strDirPathToFile,
// SmartPtr<CVmHardDisk>(new CVmHardDisk(cHardDisk)),
// pUserSession);
//
// return nRetVal;
return PRL_ERR_FAILURE;
}
