void CDspVmAutoTaskManagerBase::Init() { WRITE_TRACE( DBG_DEBUG, "Initializing %s manager", getManagerName() ); QMultiHash<QString , SmartPtr<CVmConfiguration> > hashAllVms = CDspService::instance()->getVmDirHelper().getAllVmList(); QMultiHash<QString , SmartPtr<CVmConfiguration> >::iterator it; for(it = hashAllVms.begin(); it != hashAllVms.end(); ++it) { SmartPtr<CVmConfiguration> pVmConfig = it.value(); PRL_ASSERT(pVmConfig); if (isEnabled(pVmConfig, true)) { PRL_RESULT res = tryToRegisterVm(pVmConfig, it.key()); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "Can't register VM %s in Auto-task Manager during starting dispetcher." "Error: 0x%x, (%s).", QSTR2UTF8(pVmConfig->getVmIdentification()->getVmUuid()), res, PRL_RESULT_TO_STRING(res) ); } } m_bInitialized = true; }
PRL_RESULT Task_VzManager::delete_env() { PRL_RESULT res, ret; CProtoCommandPtr pCmd = CProtoSerializer::ParseCommand( getRequestPackage() ); if (!pCmd->IsValid()) return PRL_ERR_UNRECOGNIZED_REQUEST; CProtoVmDeleteCommand * pDeleteCmd = CProtoSerializer::CastToProtoCommand<CProtoVmDeleteCommand>(pCmd); QString sUuid = pDeleteCmd->GetVmUuid(); VIRTUAL_MACHINE_STATE nState; res = getVzHelper()->getVzlibHelper().get_env_status(sUuid, nState); if (PRL_FAILED(res)) return res; if (nState == VMS_MOUNTED) { res = get_op_helper()->umount_env(sUuid); if (PRL_FAILED(res)) return res; } res = check_env_state(PVE::DspCmdDirVmDelete, sUuid); if (PRL_FAILED(res)) return res; SmartPtr<CVmConfiguration> pConfig = getVzHelper()->getCtConfig(getClient(), sUuid); if (!pConfig) return PRL_ERR_VM_GET_CONFIG_FAILED; QString vm_uuid = pConfig->getVmIdentification()->getVmUuid(); QString vm_name = pConfig->getVmIdentification()->getVmName(); QString vm_home = pConfig->getVmIdentification()->getHomePath(); CVmDirectory::TemporaryCatalogueItem vmInfo( vm_uuid, vm_home, vm_name); res = CDspService::instance()->getVmDirManager() .lockExclusiveVmParameters(m_sVzDirUuid, &vmInfo); if (PRL_SUCCEEDED(res)) { Backup::Device::Service(pConfig).teardown(); res = get_op_helper()->delete_env(sUuid); if (PRL_SUCCEEDED(res)) { // FIXME: rollback operation ret = CDspService::instance()->getVmDirHelper() .deleteVmDirectoryItem(m_sVzDirUuid, vm_uuid); if (PRL_FAILED(ret) && ret != PRL_ERR_ENTRY_DOES_NOT_EXIST) WRITE_TRACE(DBG_FATAL, "Can't delete Container %s from VmDirectory by error: %s", QSTR2UTF8(vm_uuid), PRL_RESULT_TO_STRING(ret) ); } // delete temporary registration CDspService::instance()->getVmDirManager() .unlockExclusiveVmParameters(m_sVzDirUuid, &vmInfo); } return res; }
void Task_VzStateMonitor::processUnregisterEvt(const QString &sUuid) { PRL_RESULT res; res = CDspService::instance()->getVmDirHelper().deleteVmDirectoryItem(m_sVzDirUuid, sUuid); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, ">>> Can't delete Ct %s from VmDirectory by error %#x, %s", QSTR2UTF8(sUuid), res, PRL_RESULT_TO_STRING( res) ); }
PRL_RESULT Task_VzManager::unregister_env() { PRL_RESULT res, ret; CProtoCommandPtr cmd = CProtoSerializer::ParseCommand( getRequestPackage() ); if ( ! cmd->IsValid() ) return PRL_ERR_UNRECOGNIZED_REQUEST; QString uuid = cmd->GetVmUuid(); // Check state res = check_env_state(PVE::DspCmdDirUnregVm, uuid); if (PRL_FAILED(res)) return res; SmartPtr<CVmConfiguration> pConfig = getVzHelper()->getCtConfig(getClient(), uuid); if (!pConfig) return PRL_ERR_VM_GET_CONFIG_FAILED; QString vm_name = pConfig->getVmIdentification()->getVmName(); QString vm_home = pConfig->getVmIdentification()->getHomePath(); // Lock by vm_uuid/vm_name/vm_home triade CVmDirectory::TemporaryCatalogueItem vmInfo(uuid, vm_home, vm_name); res = CDspService::instance()->getVmDirManager() .lockExclusiveVmParameters(m_sVzDirUuid, &vmInfo); if (PRL_SUCCEEDED(res)) { res = get_op_helper()->unregister_env(uuid, 0); if (PRL_SUCCEEDED(res)) { Backup::Device::Service(pConfig).disable(); ret = CDspService::instance()->getVmDirHelper() .deleteVmDirectoryItem(m_sVzDirUuid, uuid); if (PRL_FAILED(ret) && ret != PRL_ERR_ENTRY_DOES_NOT_EXIST) WRITE_TRACE(DBG_FATAL, "Can't delete Container %s from VmDirectory by error: %s", QSTR2UTF8(uuid), PRL_RESULT_TO_STRING(ret) ); } // delete temporary registration CDspService::instance()->getVmDirManager() .unlockExclusiveVmParameters(m_sVzDirUuid, &vmInfo); } return res; }
PRL_RESULT CDspDispConfigGuard::saveConfig( const QString& path, bool bNoSaveNetwork ) { CDspLockedPointer<CDispatcherConfig> pLockedDispConfig = getDispConfig(); CDispNetworkPreferences* pNetwork = pLockedDispConfig->getDispatcherSettings() ->getCommonPreferences()->getNetworkPreferences(); CDispLockedOperationsList* pLockedOperationsList = pLockedDispConfig->getDispatcherSettings()->getCommonPreferences() ->getLockedOperationsList(); bool oldFlg = pNetwork->getNoSaveFlag(); pNetwork->setNoSaveFlag( bNoSaveNetwork ); // patch to not save operations with confirmation // #436109 ( we store this values in vmdirectory list to prevent deadlock in CDspAccessManager::checkAccess() ) QList<PRL_ALLOWED_VM_COMMAND> confirmList = pLockedOperationsList->getLockedOperations(); pLockedOperationsList->setLockedOperations( ); CDispBackupSourcePreferences *pBackup = pLockedDispConfig->getDispatcherSettings() ->getCommonPreferences()->getBackupSourcePreferences(); pBackup->setSave(false); PRL_RESULT save_rc = pLockedDispConfig->saveToFile( path ); pBackup->setSave(true); pNetwork->setNoSaveFlag( oldFlg ); pLockedOperationsList->setLockedOperations( confirmList ); if( PRL_FAILED(save_rc) ) { WRITE_TRACE(DBG_FATAL, "Error %s on save dispatcher config. Reason: %ld: %s. path = '%s'" , PRL_RESULT_TO_STRING(save_rc) , Prl::GetLastError() , QSTR2UTF8( Prl::GetLastErrorAsString() ) , QSTR2UTF8( path ) ); return PRL_ERR_DISP_CONFIG_WRITE_ERR; } return PRL_ERR_SUCCESS; }
PRL_RESULT Task_MigrateCtSource::migrateStoppedCt() { PRL_RESULT nRetCode = PRL_ERR_SUCCESS; int i; QList<QPair<QFileInfo, QString> > dList; QList<QPair<QFileInfo, QString> > fList; if ( !(m_nReservedFlags & PVM_DONT_COPY_VM) ) /* get full directories and files lists for migration */ if ((nRetCode = GetEntryLists(m_sVmHomePath, dList, fList)) != PRL_ERR_SUCCESS) return nRetCode; if (PRL_FAILED(nRetCode = SendStartRequest())) return nRetCode; /* calculate total transaction size */ for (i = 0; i < fList.size(); ++i) m_nTotalSize += fList.at(i).first.size(); m_pSender = SmartPtr<CVmFileListCopySender>(new CVmFileListCopySenderClient(m_pIoClient)); m_pVmCopySource = SmartPtr<CVmFileListCopySource>( new CVmFileListCopySource( m_pSender.getImpl(), m_pVmConfig->getVmIdentification()->getVmUuid(), m_sVmHomePath, m_nTotalSize, getLastError(), m_nTimeout)); m_pVmCopySource->SetRequest(getRequestPackage()); m_pVmCopySource->SetVmDirectoryUuid(m_sVzDirUuid); m_pVmCopySource->SetProgressNotifySender(NotifyClientsWithProgress); nRetCode = m_pVmCopySource->Copy(dList, fList); if (PRL_FAILED(nRetCode)) WRITE_TRACE(DBG_FATAL, "Error occurred while migration with code [%#x][%s]", nRetCode, PRL_RESULT_TO_STRING(nRetCode)); return nRetCode; }
bool SimpleServerWrapper::Logoff() { m_isLocalAdminInited = false; SdkHandleWrap hJob(PrlSrv_Logoff(m_ServerHandle)); if (PRL_SUCCEEDED(PrlJob_Wait(hJob, PRL_JOB_WAIT_TIMEOUT))) { PRL_RESULT nRetCode = PRL_ERR_UNINITIALIZED; if (PRL_SUCCEEDED(PrlJob_GetRetCode(hJob, &nRetCode))) { if (PRL_SUCCEEDED(nRetCode)) return (true); else WRITE_TRACE(DBG_FATAL, "Logoff operation failed with retcode: 0x%.8X '%s'",\ nRetCode, PRL_RESULT_TO_STRING(nRetCode)); } else WRITE_TRACE(DBG_FATAL, "Failed to extract return code from the job object"); } else WRITE_TRACE(DBG_FATAL, "Failed to wait logoff job"); return (false); }
void Task_VzStateMonitor::processConfigChangedEvt(const QString &sUuid) { // Handle Name change CDspLockedPointer< CVmDirectoryItem > pVmDirItem = CDspService::instance()->getVmDirManager() .getVmDirItemByUuid(CDspVmDirManager::getVzDirectoryUuid(), sUuid ); if (!pVmDirItem) return; SmartPtr<CVmConfiguration> pConfig = CDspService::instance()->getVzHelper()-> getCtConfig(CDspClient::makeServiceUser(), sUuid); if (!pConfig) return; QString sNewName = pConfig->getVmIdentification()->getVmName(); if (pVmDirItem->getVmName() != sNewName && !sNewName.isEmpty()) { pVmDirItem->setVmName(sNewName); PRL_RESULT ret = CDspService::instance()->getVmDirManager(). updateVmDirItem(pVmDirItem); if (PRL_FAILED(ret) ) WRITE_TRACE(DBG_FATAL, "Can't update Container %s VmCatalogue by error: %s", QSTR2UTF8(sUuid), PRL_RESULT_TO_STRING(ret)); } }
PRL_RESULT Task_MigrateCtTarget::run_body() { PRL_RESULT nRetCode = PRL_ERR_SUCCESS; bool bConnected; QTimer *pTimer; CDispToDispCommandPtr pReply; SmartPtr<IOPackage> pPackage; IOSendJob::Handle hJob; if (operationIsCancelled()) { nRetCode = PRL_ERR_OPERATION_WAS_CANCELED; goto exit; } bConnected = QObject::connect(m_pParent, SIGNAL(onPackageReceived( const SmartPtr<CDspDispConnection> &, const QString &, const SmartPtr<IOPackage> &)), SLOT(handleStartPackage( const SmartPtr<CDspDispConnection> &, const QString &, const SmartPtr<IOPackage> &)), Qt::DirectConnection); PRL_ASSERT(bConnected); m_nReservedFlags |= PVM_CT_MIGRATE; pReply = CDispToDispProtoSerializer::CreateVmMigrateCheckPreconditionsReply( m_lstCheckPrecondsErrors, QStringList(), m_nReservedFlags); pPackage = DispatcherPackage::createInstance( pReply->GetCommandId(), pReply->GetCommand()->toString(), m_pCheckPackage); hJob = m_pCheckDispConnection->sendPackage(pPackage); if (!hJob.isValid()) { nRetCode = PRL_ERR_OPERATION_FAILED; goto exit; } /* set timer */ pTimer = new QTimer(); pTimer->setSingleShot(true); bConnected = QObject::connect(pTimer, SIGNAL(timeout()), SLOT(handleStartCommandTimeout()), Qt::DirectConnection); pTimer->start(VM_MIGRATE_START_CMD_WAIT_TIMEOUT); /* will wait StartMigration command */ nRetCode = exec(); pTimer->stop(); if (bConnected) QObject::disconnect(pTimer, SIGNAL(timeout()), this, SLOT(handleStartCommandTimeout())); delete pTimer; QObject::disconnect(m_pParent, SIGNAL(onPackageReceived( const SmartPtr<CDspDispConnection> &, const QString &, const SmartPtr<IOPackage> &)), this, SLOT(handleStartPackage( const SmartPtr<CDspDispConnection> &, const QString &, const SmartPtr<IOPackage> &))); if (PRL_FAILED(nRetCode)) goto exit; if (operationIsCancelled()) { nRetCode = PRL_ERR_OPERATION_WAS_CANCELED; goto exit; } if ( !(m_nReservedFlags & PVM_DONT_COPY_VM) ) { /* to create Vm bundle */ if (!CFileHelper::WriteDirectory(m_sTargetVmHomePath, &getClient()->getAuthHelper())) { nRetCode = PRL_ERR_BACKUP_CANNOT_CREATE_DIRECTORY; CVmEvent *pEvent = getLastError(); pEvent->setEventCode(nRetCode); pEvent->addEventParameter( new CVmEventParameter(PVE::String, m_sTargetVmHomePath, EVT_PARAM_MESSAGE_PARAM_0)); WRITE_TRACE(DBG_FATAL, "[%s] Cannot create \"%s\" directory", __FUNCTION__, QSTR2UTF8(m_sTargetVmHomePath)); goto exit; } /* set original permissions to Vm bundle (https://jira.sw.ru/browse/PSBM-8269) */ if (m_nBundlePermissions) { QFile vmBundle(m_sTargetVmHomePath); if (!vmBundle.setPermissions((QFile::Permissions)m_nBundlePermissions)) { WRITE_TRACE(DBG_FATAL, "[%s] Cannot set permissions for Vm bundle \"%s\", will use default", __FUNCTION__, QSTR2UTF8(m_sTargetVmHomePath)); } } } m_nSteps |= MIGRATE_STARTED; if ((m_nPrevVmState == VMS_RUNNING) || (m_nPrevVmState == VMS_PAUSED)) { nRetCode = PRL_ERR_VM_MIGRATE_UNSUITABLE_VM_STATE; } else { nRetCode = migrateStoppedVm(); /* migration completed and connection state is indifferent for us https://jira.sw.ru/browse/PSBM-8925 */ QObject::disconnect( &CDspService::instance()->getIOServer(), SIGNAL(onClientDisconnected(IOSender::Handle)), this, SLOT(clientDisconnected(IOSender::Handle))); } if (PRL_FAILED(nRetCode)) goto exit; /* rename conf file since source sent it with his origin ctid */ if (m_nOriginCtid != m_nCtid) { QString srcPath = m_sTargetVmHomePath + QString("/%1.conf").arg(m_nOriginCtid); QString dstPath = m_sTargetVmHomePath + QString("/%1.conf").arg(m_nCtid); QFile::rename(srcPath, dstPath); } nRetCode = CVzHelper::dst_complete_migrate_env(m_sVmUuid, m_nCtid, m_nOriginCtid, &m_pOpaqueLock); if (PRL_FAILED(nRetCode)) { WRITE_TRACE(DBG_FATAL, "Can not compelete destination CT migration for ctid %u uuid %s", m_nCtid, QSTR2UTF8(m_sVmUuid)); goto exit; } if (PVMT_CLONE_MODE & getRequestFlags()) m_pVmConfig->getVmIdentification()->setSourceVmUuid(m_sOriginVmUuid); if (PVMT_CLONE_MODE & getRequestFlags()) { if ( PVMT_SWITCH_TEMPLATE & getRequestFlags() ) m_pVmConfig->getVmSettings()->getVmCommonOptions()->setTemplate( !m_pVmConfig->getVmSettings()->getVmCommonOptions()->isTemplate() ); Task_CloneVm::ResetNetSettings(m_pVmConfig); } /* do not fail since here - Ct already migrated */ { QString sServerUuid = CDspService::instance()->getDispConfigGuard().getDispConfig() ->getVmServerIdentification()->getServerUuid(); QString sLastServerUuid = m_pVmConfig->getVmIdentification()->getServerUuid(); m_pVmConfig->getVmIdentification()->setServerUuid(sServerUuid); m_pVmConfig->getVmIdentification()->setLastServerUuid(sLastServerUuid); SmartPtr<CVmConfiguration> pOldConfig = CDspService::instance()->getVzHelper() ->getVzlibHelper().get_env_config(m_nCtid); if (pOldConfig == NULL) { WRITE_TRACE(DBG_FATAL, "Can't get config for CT %s [%d]", QSTR2UTF8(m_sVmUuid), m_nCtid); } else { get_op_helper().apply_env_config(m_pVmConfig, pOldConfig); } } // insert new item in user's VM Directory m_pVmConfig = CDspService::instance()->getVzHelper()->getVzlibHelper().get_env_config(m_nCtid); if (PRL_FAILED(CDspService::instance()->getVzHelper()->insertVmDirectoryItem(m_pVmConfig))) { WRITE_TRACE(DBG_FATAL, "Can't insert CT to VmDirectory by error %#x, %s", nRetCode, PRL_RESULT_TO_STRING(nRetCode) ); } 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 Task_VzManager::editConfig() { PRL_RESULT res; CProtoCommandPtr cmd = CProtoSerializer::ParseCommand( getRequestPackage() ); if ( ! cmd->IsValid() ) return PRL_ERR_UNRECOGNIZED_REQUEST; SmartPtr<CVmConfiguration> pConfig( new CVmConfiguration( cmd->GetFirstStrParam() ) ); if( !IS_OPERATION_SUCCEEDED( pConfig->m_uiRcInit ) ) { PRL_RESULT code = PRL_ERR_PARSE_VM_CONFIG; WRITE_TRACE(DBG_FATAL, "Error occurred while modification CT configuration: %s", PRL_RESULT_TO_STRING( code ) ); return code; } QString sUuid = pConfig->getVmIdentification()->getVmUuid(); SmartPtr<CVmConfiguration> pOldConfig = getVzHelper()->getCtConfig(getClient(), sUuid); if (!pOldConfig) return PRL_ERR_VM_GET_CONFIG_FAILED; QString oldname = pOldConfig->getVmIdentification()->getVmName(); QString name = pConfig->getVmIdentification()->getVmName(); QStringList lstFullItemIds; pConfig->diffDocuments(pOldConfig.getImpl(), lstFullItemIds); // Code below prohibits all other than Hdd and Network devices for Containers if (!lstFullItemIds.filter(QRegExp("Hardware\\.(?!Hdd|Network|Cpu|Memory)")).isEmpty()) return PRL_ERR_ACTION_NOT_SUPPORTED_FOR_CT; // Handle the Firewall settings change on the running CT if (!lstFullItemIds.filter(QRegExp("\\.(?=Firewall\\.|MAC|NetAddress)")).isEmpty()) { VIRTUAL_MACHINE_STATE nState = VMS_UNKNOWN; PRL_RESULT res = getVzHelper()->getVzlibHelper().get_env_status(sUuid, nState); if (nState == VMS_RUNNING) { res = setupFirewall(pConfig); if (PRL_FAILED(res)) return res; } } // Handle Name change if (oldname != name) { QString vm_uuid; // Skip uuid check QString vm_name = name; QString vm_home; // Lock the new name in the VmDirectory CVmDirectory::TemporaryCatalogueItem vmInfo( vm_uuid, vm_home, vm_name); res = checkAndLockRegisterParameters(&vmInfo); if (PRL_FAILED(res)) return res; res = get_op_helper()->set_env_name(sUuid, name); if (PRL_SUCCEEDED(res)) { CDspLockedPointer< CVmDirectoryItem > pVmDirItem = CDspService::instance()->getVmDirManager() .getVmDirItemByUuid(m_sVzDirUuid, sUuid ); if (!pVmDirItem) { WRITE_TRACE(DBG_FATAL, "Can't found VmDirItem by vmUuid = %s", QSTR2UTF8(sUuid)); } else { pVmDirItem->setVmName(name); PRL_RESULT ret = CDspService::instance()->getVmDirManager().updateVmDirItem(pVmDirItem); if (PRL_FAILED(ret) ) WRITE_TRACE(DBG_FATAL, "Can't update Container %s VmCatalogue by error: %s", QSTR2UTF8(sUuid), PRL_RESULT_TO_STRING(ret)); } } // delete temporary registration CDspService::instance()->getVmDirManager() .unlockExclusiveVmParameters(&vmInfo); if (PRL_FAILED(res)) return res; } // reset IP addresses for CT templates Task_EditVm::resetNetworkAddressesFromVmConfig(pConfig, pOldConfig); // update High Availability Cluster resource if (pConfig->getVmSettings()->getHighAvailability()->toString() != pOldConfig->getVmSettings()->getHighAvailability()->toString() && CFileHelper::isSharedFS(pConfig->getVmIdentification()->getHomePath())) { res = CDspService::instance()->getHaClusterHelper()->updateClusterResourceParams( sUuid, pOldConfig->getVmSettings()->getHighAvailability(), pConfig->getVmSettings()->getHighAvailability(), pConfig->getVmIdentification()->getHomePath(), PVT_CT); if (PRL_FAILED(res)) return res; } CVmRemoteDisplay* oldD = pOldConfig->getVmSettings()->getVmRemoteDisplay(); CVmRemoteDisplay* newD = pConfig->getVmSettings()->getVmRemoteDisplay(); if (oldD->getPassword() != newD->getPassword()) { if (newD->getPassword().length() > PRL_VM_REMOTE_DISPLAY_MAX_PASS_LEN) { WRITE_TRACE(DBG_FATAL, "The specified remote display password is too long."); getLastError()->addEventParameter( new CVmEventParameter( PVE::UnsignedInt, QString::number(PRL_VM_REMOTE_DISPLAY_MAX_PASS_LEN), EVT_PARAM_MESSAGE_PARAM_0)); return PRL_ERR_VMCONF_REMOTE_DISPLAY_PASSWORD_TOO_LONG; } } Backup::Device::Service service(pOldConfig); service.setContext(*this).setVmHome(pConfig->getVmIdentification()->getHomePath()); Backup::Device::Details::Transition t = service.getTransition(pConfig); res = t.plant(); if (PRL_FAILED(res)) return res; res = get_op_helper()->apply_env_config(pConfig, pOldConfig, cmd->GetCommandFlags()); if (PRL_FAILED(res)) return res; res = t.remove(); if (PRL_FAILED(res)) return res; // Invalidate cache CDspService::instance()->getVzHelper()->getConfigCache(). remove(pConfig->getVmIdentification()->getHomePath()); res = changeVNCServerState(pOldConfig, pConfig, sUuid); if (PRL_FAILED(res)) return res; // Handle memory limit change unsigned int newRamSize = pConfig->getVmHardwareList()->getMemory()->getRamSize(); unsigned int oldRamSize = pOldConfig->getVmHardwareList()->getMemory()->getRamSize(); if (newRamSize != oldRamSize) { VIRTUAL_MACHINE_STATE nState = VMS_UNKNOWN; PRL_RESULT res = getVzHelper()->getVzlibHelper().get_env_status(sUuid, nState); if (PRL_SUCCEEDED(res) && (nState == VMS_RUNNING)) adjustReservedMemLimit((long long)newRamSize - oldRamSize); } QStringList lstAdd, lstDel; // Handle application templates QStringList newAppTemplates = pConfig->getCtSettings()->getAppTemplate(); QStringList oldAppTemplates = pOldConfig->getCtSettings()->getAppTemplate(); for (int i = 0; i < newAppTemplates.size(); i++) { if (newAppTemplates.at(i).startsWith('.')) newAppTemplates[i].remove(0, 1); } for (int i = 0; i < oldAppTemplates.size(); i++) { if (oldAppTemplates.at(i).startsWith('.')) oldAppTemplates[i].remove(0, 1); } if (newAppTemplates == oldAppTemplates) goto ok; foreach(QString str, newAppTemplates) if (!oldAppTemplates.contains(str)) lstAdd.append(str); foreach(QString str, oldAppTemplates) if (!newAppTemplates.contains(str)) lstDel.append(str); do { CVzTemplateHelper TmplHelper = getVzHelper()->getVzTemplateHelper(); res = TmplHelper.remove_templates_env(sUuid, lstDel); if (PRL_FAILED(res)) return res; res = TmplHelper.install_templates_env(sUuid, lstAdd); } while (0); ok: if ( PRL_SUCCEEDED(res) ) { SmartPtr<CVmConfiguration> pNewConfig = getVzHelper()->getCtConfig(getClient(), sUuid); QStringList lstParams(pNewConfig ? pNewConfig->toString() : pConfig->toString()); getResponseCmd()->SetParamsList( lstParams ); sendEvent(PET_DSP_EVT_VM_CONFIG_CHANGED, sUuid); } return res; }
void Trace::finish(PRL_RESULT code_) const { boost::property_tree::ptree t; t.put("result", PRL_RESULT_TO_STRING(code_)); report(t); }
PRL_RESULT Task_GetBackupTreeSource::prepareTask() { PRL_RESULT ret = PRL_ERR_SUCCESS; try { if ((m_nFlags & (PBT_BACKUP_ID | PBT_CHAIN)) && m_sUuid.isEmpty()) { WRITE_TRACE(DBG_FATAL, "A backup UUID must be specified to get information " "on a single backup or backup chain."); throw PRL_ERR_INVALID_PARAM; } if ((m_nFlags & PBT_BACKUP_ID) && (m_nFlags & PBT_CHAIN)) { WRITE_TRACE(DBG_FATAL, "The PBT_BACKUP_ID and PBT_CHAIN flags are mutually exclusive."); throw PRL_ERR_INVALID_PARAM; } } catch (PRL_RESULT code) { getLastError()->setEventCode(code); ret = code; WRITE_TRACE(DBG_FATAL, "An error occurred while preparing to get the backup tree [%#x][%s]", code, PRL_RESULT_TO_STRING(code)); } return ret; }