void Task_VzStateMonitor::processRegisterEvt(const QString &ctid) { PRL_RESULT res; SmartPtr<CVmConfiguration> pConfig = CDspService::instance()->getVzHelper()-> getVzlibHelper().get_env_config_by_ctid(ctid); if (!pConfig) return; QString vm_uuid = pConfig->getVmIdentification()->getVmUuid(); QString vm_name = pConfig->getVmIdentification()->getVmName(); QString vm_home = pConfig->getVmIdentification()->getHomePath(); WRITE_TRACE(DBG_INFO, "Register Ct uuid=%s name=%s home=%s", QSTR2UTF8(vm_uuid), QSTR2UTF8(vm_name), QSTR2UTF8(vm_home)); CVmDirectory::TemporaryCatalogueItem vmInfo( vm_uuid, vm_home, vm_name); res = CDspService::instance()->getVmDirManager() .checkAndLockNotExistsExclusiveVmParameters(QStringList(), &vmInfo); if (PRL_FAILED(res)) return; CDspService::instance()->getVzHelper()->insertVmDirectoryItem(pConfig); // delete temporary registration CDspService::instance()->getVmDirManager() .unlockExclusiveVmParameters(&vmInfo); }
void PrlNetworkShapingTest::testCreateNetworkClassOnWrongParams() { // Null pointer CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_Create(1, NULL), PRL_ERR_INVALID_ARG); CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_SetNetworkList(NULL, NULL), PRL_ERR_INVALID_ARG); SdkHandleWrap hClass; CreateNetworkClass(hClass, 0); // network/mask validation { SdkHandleWrap hList; QString sNet = "192.164.0.0"; CHECK_RET_CODE_EXP(PrlApi_CreateStringsList(hList.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlStrList_AddItem(hList, QSTR2UTF8(sNet))); CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_SetNetworkList(hClass, hList), PRL_ERR_INVALID_ARG); } { SdkHandleWrap hList; QString sNet = "x/24"; CHECK_RET_CODE_EXP(PrlApi_CreateStringsList(hList.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlStrList_AddItem(hList, QSTR2UTF8(sNet))); CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_SetNetworkList(hClass, hList), PRL_ERR_INVALID_ARG); } SdkHandleWrap hClass0; CreateNetworkClass(hClass0, 0); CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_SetNetworkList(hClass0, NULL), PRL_ERR_INVALID_ARG); CHECK_CONCRETE_EXPRESSION_RET_CODE(PrlNetworkClass_SetNetworkList(hClass0, m_hServer), PRL_ERR_INVALID_ARG); }
PRL_RESULT CDspHaClusterHelper::runProgram(const QString & sPath, const QStringList & lstArgs, QProcess & proc) { WRITE_TRACE(DBG_INFO, "run %s %s", qPrintable(sPath), qPrintable(lstArgs.join(" "))); proc.start(sPath, lstArgs); if (!proc.waitForStarted(HAMAN_START_TMO)) { WRITE_TRACE(DBG_FATAL, "Failed to run %s : %s", QSTR2UTF8(sPath), QSTR2UTF8(proc.errorString())); return PRL_ERR_CLUSTER_RESOURCE_ERROR; } if (!proc.waitForFinished(HAMAN_EXEC_TMO)) { WRITE_TRACE(DBG_FATAL, "Failed to wait for finished %s : %s", QSTR2UTF8(sPath), QSTR2UTF8(proc.errorString())); proc.terminate(); return PRL_ERR_CLUSTER_RESOURCE_ERROR; } if (proc.exitCode()) { WRITE_TRACE(DBG_FATAL, "%s failed : retcode : %d, stdout: [%s] stderr: [%s]", QSTR2UTF8(sPath), proc.exitCode(), proc.readAllStandardOutput().constData(), proc.readAllStandardError().constData() ); return PRL_ERR_CLUSTER_RESOURCE_ERROR; } return PRL_ERR_SUCCESS; }
void CDspIOCtClientHandler::handleClientDisconnected ( const IOSender::Handle& h ) { WRITE_TRACE( DBG_WARNING, "CDspIOCtClientHandler::handleClientDisconnected %s", QSTR2UTF8(h)); QMutexLocker locker( &m_mutex ); m_ioClients.remove( h ); }
PRL_RESULT CDspHaClusterHelper::addClusterResource(const QString & sName, const CVmHighAvailability *ha, const QString & sPath) { PRL_ASSERT(ha); if (!ha->isEnabled()) return PRL_ERR_SUCCESS; // handle only VM on shared FS - nfs, gfs, gfs2, pcs if (!CFileHelper::isSharedFS(sPath)) return PRL_ERR_SUCCESS; QProcess proc; QStringList args; args += SHAMAN_CMD_ADD; args += getResourcePrefix() + sName; args += QString("--prio"); args += QString("%1").arg(ha->getPriority()); args += QString("--path"); args += sPath; args += QString("--force"); PRL_RESULT res = runHaman(args, proc); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "cluster resource '%s' registration error", QSTR2UTF8(sName)); return res; }
PRL_RESULT CDspVmAutoTaskManagerBase::unregisterVm(const CVmIdent& vmIdent, bool bEditVmConfig, const SmartPtr<CDspClient>& pClient) { WRITE_TRACE( DBG_DEBUG, "Unregistering VM '%s' from %s manager", QSTR2UTF8( vmIdent.first ), getManagerName() ); // Clear settings { CDspLockedPointer<QSettings> pQSettings = CDspService::instance()->getQSettings(); QString qsGroup = getSettingsGroupKey(vmIdent); pQSettings->remove(qsGroup); } { QMutexLocker locker(&m_lockVmIdents); if ( ! m_mapVmIdents.contains(vmIdent) ) return PRL_ERR_SUCCESS; // Stop timer emit killVmTimerSignal(m_mapVmIdents.value(vmIdent).iTimerId); // TODO: Check running task for this VM. Cancel it ? // Unregister VM m_mapVmIdents.remove(vmIdent); } return finalizeUnregistration( vmIdent, pClient, bEditVmConfig ); }
QFileInfoList CDspHaClusterHelper::getReport() { QFileInfoList output; QFileInfo p("/usr/bin/vstorage-make-report"); if (!p.exists()) return output; QDir d("/etc/vstorage/clusters"); if (!d.exists()) return output; QStringList a = d.entryList(QDir::NoDotAndDotDot | QDir::Dirs); foreach (QString x, a) { QTemporaryFile t; t.setFileTemplate(QString("%1/pstorage.%2.XXXXXX.tgz") .arg(QDir::tempPath()).arg(x)); if (!t.open()) { WRITE_TRACE(DBG_FATAL, "QTemporaryFile::open() error: %s", QSTR2UTF8(t.errorString())); continue; } QString b, c = QString("%1 -f %2 \"%3\"").arg(p.filePath()).arg(t.fileName()).arg(x); if (!HostUtils::RunCmdLineUtility(c, b, -1) || t.size() == 0) { t.close(); continue; } t.setAutoRemove(false); output.append(QFileInfo(t.fileName())); t.close(); }
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; }
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_VzManager::create_env_disk() { CProtoCommandPtr cmd = CProtoSerializer::ParseCommand( getRequestPackage() ); if (!cmd->IsValid()) return PRL_ERR_UNRECOGNIZED_REQUEST; CProtoCreateImageCommand *pCmd = CProtoSerializer::CastToProtoCommand<CProtoCreateImageCommand>(cmd); /* TODO: handle bRecreateIsAllowed bool bRecreateIsAllowed = pCmd->IsRecreateAllowed(); */ CVmHardDisk disk; if (!StringToElement(&disk, pCmd->GetImageConfig())) { WRITE_TRACE(DBG_FATAL, "%s", QSTR2UTF8(pCmd->GetImageConfig())); return PRL_ERR_BAD_PARAMETERS; } SmartPtr<CVmConfiguration> pConfig = getVzHelper()->getCtConfig(getClient(), pCmd->GetVmUuid()); if (!pConfig) { WRITE_TRACE(DBG_FATAL, "Unable to find CT by uuid %s", QSTR2UTF8(pCmd->GetVmUuid())); return PRL_ERR_VM_GET_CONFIG_FAILED; } if (disk.getUserFriendlyName().isEmpty()) { WRITE_TRACE(DBG_FATAL, "Unable to create disk: empty path"); return PRL_ERR_BAD_PARAMETERS; } QString sPath = getFullPath(pConfig->getVmIdentification()->getHomePath(), disk.getUserFriendlyName()); if (QFileInfo(sPath).exists()) { WRITE_TRACE(DBG_FATAL, "Disk image [%s] is already exist.", QSTR2UTF8(sPath)); getLastError()->addEventParameter( new CVmEventParameter(PVE::String, sPath, EVT_PARAM_MESSAGE_PARAM_0)); return PRL_ERR_HDD_IMAGE_IS_ALREADY_EXIST; } /* Mbytes -> Bytes */ quint64 size = (quint64) disk.getSize() << 20; return get_op_helper()->create_disk_image(sPath, size); }
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; }
bool CAuthHelperTest::isLocalUserName( const QString& userName) { #ifndef _WIN_ return true; #endif QString cmdline = QString (" net user %1 > NUL" ).arg( userName ); int ret = system( QSTR2UTF8( cmdline ) ); return ret == 0; }
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 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; }
void PrlNetworkShapingTest::testCreateNetworkBandwidthEntry() { SdkHandleWrap hEntry; QString sDev = "eth0"; PRL_UINT32 nBandwidth = 10000; CHECK_RET_CODE_EXP(PrlNetworkShapingBandwidthEntry_Create(QSTR2UTF8(sDev), nBandwidth, hEntry.GetHandlePtr())); CHECK_HANDLE_TYPE(hEntry, PHT_NETWORK_SHAPING_BANDWIDTH); CHECK_RET_CODE_EXP(PrlNetworkShapingBandwidthEntry_SetDevice(hEntry, QSTR2UTF8(sDev))); CHECK_RET_CODE_EXP(PrlNetworkShapingBandwidthEntry_SetBandwidth(hEntry, nBandwidth)); QString _sDev; PRL_UINT32 _nBandwidth = 0; PRL_EXTRACT_STRING_VALUE(_sDev, hEntry, PrlNetworkShapingBandwidthEntry_GetDevice); QCOMPARE(_sDev, sDev); CHECK_RET_CODE_EXP(PrlNetworkShapingBandwidthEntry_GetBandwidth(hEntry, &_nBandwidth)); QVERIFY(_nBandwidth == nBandwidth); }
PRL_RESULT CDspHaClusterHelper::moveToClusterResource(const QString & sName, const QString & sRemoteNode) { QProcess proc; QStringList args; args += SHAMAN_CMD_TO; args += getResourcePrefix() + sName; args += sRemoteNode; PRL_RESULT res = runHaman(args, proc); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "cluster resource '%s' removing error", QSTR2UTF8(sName)); return res; }
PRL_RESULT CDspHaClusterHelper::removeClusterResource(const QString & sName, bool removeFromAllNodes) { QProcess proc; QStringList args; args += removeFromAllNodes ? SHAMAN_CMD_DEL_EVERYWHERE : SHAMAN_CMD_DEL; args += getResourcePrefix() + sName; WRITE_TRACE(DBG_FATAL, "%s removing resource %s", removeFromAllNodes ? "recursively" : "", QSTR2UTF8(sName)); PRL_RESULT res = runHaman(args, proc); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "cluster resource '%s' removing error", QSTR2UTF8(sName)); return res; }
PRL_RESULT CDspHaClusterHelper::updateClusterResourceParams(const QString & sName, CVmHighAvailability *oldHa, CVmHighAvailability *newHa, const QString & newPath, PRL_VM_TYPE vmType) { QProcess proc; QStringList args; QString cmd; PRL_ASSERT(oldHa); PRL_ASSERT(newHa); if (newHa->isEnabled() != oldHa->isEnabled()) cmd = newHa->isEnabled() ? SHAMAN_CMD_ADD : SHAMAN_CMD_DEL; else if (newHa->getPriority() != oldHa->getPriority()) { cmd = SHAMAN_CMD_SET; } else { /* HA options are not changed */ return PRL_ERR_SUCCESS; } /* * Don't run shaman if HA is disabled in VM config and the command line * doesn't contain '--ha-enable yes'. */ if ((newHa->isEnabled() == oldHa->isEnabled()) && !newHa->isEnabled()) return PRL_ERR_SUCCESS; args += cmd; args += getResourcePrefix(vmType) + sName; if (cmd != SHAMAN_CMD_DEL) { /* * Specify all parameters from the config when doing 'shaman add'. * This is needed e.g. when registering an already existing VM - newly * created cluster resource for this VM should contain all actual * HA parameter values. */ if ((newHa->getPriority() != oldHa->getPriority()) || (cmd == SHAMAN_CMD_ADD)) { args += QString("--path"); args += newPath; args += QString("--prio"); args += QString("%1").arg(newHa->getPriority()); } } PRL_RESULT res = runHaman(args, proc); if (PRL_FAILED(res)) WRITE_TRACE(DBG_FATAL, "cluster resource '%s' registration error", QSTR2UTF8(sName)); return res; }
SmartPtr<CDspCtResponseHandler> CDspIOCtClientHandler::registerResponseHandler( const IOSender::Handle& h, const QString &sGuestSessionUuid) { QMutexLocker locker( &m_mutex ); if (!m_ioClients.contains(h)) return SmartPtr<CDspCtResponseHandler>(); struct ClientInfo &ci = m_ioClients[h]; if (ci.sessions.contains(sGuestSessionUuid)) { WRITE_TRACE(DBG_FATAL, "Guest session %s handler already registersd", QSTR2UTF8(sGuestSessionUuid)); return SmartPtr<CDspCtResponseHandler>(); } WRITE_TRACE(DBG_WARNING, "Register client %s guest session %s response handler", QSTR2UTF8(h), QSTR2UTF8(sGuestSessionUuid)); ci.sessions[sGuestSessionUuid] = SmartPtr<CDspCtResponseHandler> (new CDspCtResponseHandler()); return ci.sessions[sGuestSessionUuid]; }
int run_prg(const char *name, const QStringList &lstArgs, QByteArray *out, QByteArray *err, unsigned timeout, const Abort::token_type &token) { IndependentProcess proc; proc.start(name, lstArgs); unsigned step; for (step = 0; step < timeout; ++step) { if (proc.waitForFinished(CMD_WORK_STEP_TIME)) break; if (token && token->isCancellationRequested()) { fprintf(stderr, "Execution of '%s' has been cancelled. Terminate it now.\n", name); proc.kill(); proc.waitForFinished(); return -1; } } if (step >= timeout) { fprintf(stderr, "%s tool not responding. Terminate it now.", name); proc.kill(); proc.waitForFinished(); return -1; } if (out) *out = proc.readAllStandardOutput(); if (err) *err = proc.readAllStandardError(); if (0 != proc.exitCode()) { fprintf(stderr, "%s utility failed: %s %s [%d]\nout=%s\nerr=%s", name, name, QSTR2UTF8(lstArgs.join(" ")), proc.exitCode(), out ? out->data() : proc.readAllStandardOutput().data(), err ? err->data() : proc.readAllStandardError().data()); return -1; } return 0; }
PRL_RESULT CDspHaClusterHelper::revokeLeases(const QString & sPath) { QProcess proc; QStringList args; QFileInfo fi(PSTORAGE_BIN); if (!fi.exists()) { WRITE_TRACE(DBG_FATAL, "Failed to run %s : file not found", QSTR2UTF8(fi.filePath())); return PRL_ERR_CLUSTER_RESOURCE_ERROR; } args += "revoke"; args += "-R"; args += sPath; return runProgram(fi.filePath(), args, proc); }
PRL_RESULT Task_VzManager::create_env() { CProtoCommandPtr cmd = CProtoSerializer::ParseCommand( getRequestPackage()); if ( ! cmd->IsValid() ) return PRL_ERR_UNRECOGNIZED_REQUEST; CProtoVmCreateCommand *pCmd = CProtoSerializer::CastToProtoCommand<CProtoVmCreateCommand>(cmd); if (!pCmd->IsValid()) return PRL_ERR_UNRECOGNIZED_REQUEST; SmartPtr<CVmConfiguration> pConfig(new CVmConfiguration); pConfig->fromString(pCmd->GetVmConfig()); QString sPath = pCmd->GetVmHomePath(); if (!sPath.isEmpty() && !QDir::isAbsolutePath( sPath) ) { WRITE_TRACE(DBG_FATAL, "Invalid path '%s'", QSTR2UTF8(sPath)); return PRL_ERR_VMDIR_PATH_IS_NOT_ABSOLUTE; } QString vm_uuid = pConfig->getVmIdentification()->getVmUuid(); QString vm_name = pConfig->getVmIdentification()->getVmName(); QString vm_home; CVmDirectory::TemporaryCatalogueItem vmInfo( vm_uuid, vm_home, vm_name); // Lock PRL_RESULT res = checkAndLockRegisterParameters(&vmInfo); if (PRL_FAILED(res)) return res; res = get_op_helper()->create_env(sPath, pConfig, pCmd->GetCommandFlags()); if (PRL_SUCCEEDED(res)) { res = getVzHelper()->insertVmDirectoryItem(pConfig); if (PRL_FAILED(res)) get_op_helper()->delete_env( pConfig->getVmIdentification()->getVmUuid()); } // Unlock temporary registration CDspService::instance()->getVmDirManager() .unlockExclusiveVmParameters(&vmInfo); if (PRL_SUCCEEDED(res)) { getResponseCmd()->SetVmConfig(pConfig->toString()); sendEvent(PET_DSP_EVT_VM_ADDED, vm_uuid); } return 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; }
void PrlNetworkShapingTest::CreateNetworkClass(SdkHandleWrap &hClass, PRL_UINT32 nClassId) { CHECK_RET_CODE_EXP(PrlNetworkClass_Create(nClassId, hClass.GetHandlePtr())); CHECK_HANDLE_TYPE(hClass, PHT_NETWORK_CLASS); CHECK_RET_CODE_EXP(PrlNetworkClass_SetClassId(hClass, nClassId)); QString sNetOrig = "192.164.0.0/24"; SdkHandleWrap hList; CHECK_RET_CODE_EXP(PrlApi_CreateStringsList(hList.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlStrList_AddItem(hList, QSTR2UTF8(sNetOrig))); CHECK_RET_CODE_EXP(PrlNetworkClass_SetNetworkList(hClass, hList)); NETWORK_CLASS_TO_XML_OBJECT NETWORK_CLASS_FROM_XML_OBJECT PRL_UINT32 _nClassId = 0; CHECK_RET_CODE_EXP(PrlNetworkClass_GetClassId(hClass, &_nClassId)); QVERIFY(_nClassId == nClassId); }
void PrlNetworkShapingTest::CreateNetworkShapingEntry(SdkHandleWrap &hEntry, PRL_UINT32 nClassId, const QString &sDevOrig) { PRL_UINT32 nTotalRate = 4; PRL_UINT32 nRate = 4; PRL_INT32 nRateMPU; CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_Create(nClassId, nTotalRate, hEntry.GetHandlePtr())); CHECK_HANDLE_TYPE(hEntry, PHT_NETWORK_SHAPING); // If not defined, this should be turned on with default mpu. CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_getRateMPU(hEntry, &nRateMPU)); QVERIFY(nRateMPU == NRM_ENABLED); nRateMPU = NRM_DISABLED; CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_SetDevice(hEntry, QSTR2UTF8(sDevOrig))); CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_SetRate(hEntry, nRate)); CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_SetPacketLimited(hEntry, nRateMPU)); NETWORK_SHAPING_ENTRY_TO_XML_OBJECT NETWORK_SHAPING_ENTRY_FROM_XML_OBJECT PRL_UINT32 _nClassId = 0; PRL_UINT32 _nTotalRate = 0; PRL_UINT32 _nRate = 0; QString sDev = "xxx"; PRL_INT32 _nRateMPU = NRM_ENABLED; CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_GetClassId(hEntry, &_nClassId)); QVERIFY(_nClassId == nClassId); CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_GetTotalRate(hEntry, &_nTotalRate)); QVERIFY(_nTotalRate == nTotalRate); CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_GetRate(hEntry, &_nRate)); QVERIFY(_nRate == nRate); PRL_EXTRACT_STRING_VALUE(sDev, hEntry, PrlNetworkShapingEntry_GetDevice); QCOMPARE(sDev, sDevOrig); CHECK_RET_CODE_EXP(PrlNetworkShapingEntry_GetRateMPU(hEntry, &_nRateMPU)); QVERIFY(_nRateMPU == nRateMPU); }
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)); } }
void CDspIOCtClientHandler::handleToDispatcherPackage ( const IOSender::Handle& h, const SmartPtr<IOPackage>& p ) { if ( p->header.type == PET_IO_CLI_AUTHENTICATE_EXEC_SESSION ) { const PRL_IO_AUTH_EXEC_REQUEST *authRequest = reinterpret_cast<const PRL_IO_AUTH_EXEC_REQUEST*>( p->buffers[0].getImpl() ); if ( p->data[0].bufferSize < sizeof(*authRequest) ) { WRITE_TRACE(DBG_FATAL, "Wrong auth session package!"); CDspService::instance()->getIOServer().disconnectClient( h ); return; } Uuid sessionId = Uuid::toUuid( authRequest->sessionUuid ); if ( sessionId.isNull() ) { WRITE_TRACE(DBG_FATAL, "Wrong auth session package!"); CDspService::instance()->getIOServer().disconnectClient( h ); return; } // Try to find client by auth session SmartPtr<CDspClient> client = CDspService::instance()-> getClientManager().getUserSession( sessionId.toString() ); bool auth = client.isValid(); PRL_IO_AUTH_RESPONSE authResp = { auth }; SmartPtr<IOPackage> pkg = IOPackage::createInstance( PET_IO_AUTH_RESPONSE, IOPackage::RawEncoding, &authResp, sizeof(authResp) ); // Save result QMutexLocker locker( &m_mutex ); ClientInfo cliInfo; m_ioClients[h] = cliInfo; locker.unlock(); // Send package IOSendJob::Handle job = CDspService::instance()->getIOServer().sendPackage( h, pkg ); IOSendJob::Result res = CDspService::instance()->getIOServer().waitForSend( job ); // Close connection if fail if ( ! auth || res != IOSendJob::Success ) { WRITE_TRACE(DBG_FATAL, "Error: %s", (! auth ? "authentication failed!" : "send of authentication pkg failed!")); CDspService::instance()->getIOServer().disconnectClient( h ); } return; } else if (p->header.type == PET_IO_STDIN_PORTION || p->header.type == PET_IO_STDIN_WAS_CLOSED || p->header.type == PET_IO_CLIENT_PROCESSED_ALL_DESCS_DATA) { if (!getIOUserSession(h)) { WRITE_TRACE(DBG_FATAL, "Client '%s' is not authed! Close connection!", QSTR2UTF8(h)); CDspService::instance()->getIOServer().disconnectClient( h ); return; } SmartPtr<CDspCtResponseHandler> hResponse = getResponseHandler(h, Uuid::toString(p->header.parentUuid)); if (!hResponse) { WRITE_TRACE(DBG_FATAL, "Client %s guest session %s is not created pkt.type=%d", QSTR2UTF8(h), QSTR2UTF8((Uuid::toString(p->header.parentUuid))), p->header.type); CDspService::instance()->getIOServer().disconnectClient( h ); return; } hResponse->process(p); } }
void CDspVmAutoTaskManagerBase::timerEvent(QTimerEvent* te) { if (!IsInitialized()) { WRITE_TRACE( DBG_WARNING, "Timer event on unitialized %s manager", getManagerName() ); return; } // Looking for proper VM ident. bool bRestartTimer = false; TimerInfo timerInfo; CVmIdent vmIdent; { QMutexLocker locker(&m_lockVmIdents); QMap<CVmIdent, TimerInfo >::iterator it; for(it = m_mapVmIdents.begin(); it != m_mapVmIdents.end(); ++it) { timerInfo = it.value(); if (timerInfo.iTimerId == te->timerId()) break; } if ( it == m_mapVmIdents.end() || timerInfo.bTaskInUse) return; vmIdent = it.key(); bRestartTimer = (timerInfo.iPeriod != timerInfo.iOriginalPeriod); if (bRestartTimer) { emit killVmTimerSignal(timerInfo.iTimerId); m_mapVmIdents.remove(vmIdent); } } if (bRestartTimer) { emit startVmTimerSignal(vmIdent, timerInfo.iOriginalPeriod, timerInfo.iOriginalPeriod); } // Store timestamp { CDspLockedPointer<QSettings> pQSettings = CDspService::instance()->getQSettings(); QString qsGroup = getSettingsGroupKey(vmIdent); pQSettings->beginGroup(qsGroup); pQSettings->setValue(getSettingsKeyTimestamp(), QVariant(QDateTime::currentDateTime())); pQSettings->endGroup(); } // Get client QHash< IOSender::Handle, SmartPtr<CDspClient> > hashClients = CDspService::instance()->getClientManager().getSessionListByVm( vmIdent.second, vmIdent.first, CDspAccessManager::VmAccessRights::makeModeRWX() ); if ( hashClients.empty() ) { WRITE_TRACE(DBG_FATAL, "No clients connect to VM %s with required permissions", QSTR2UTF8(vmIdent.first) ); return; } // Start auto task if ( ! updateTaskState(vmIdent, true) ) return; // Fake client SmartPtr<CDspClient> pClient( new CDspClient(IOSender::Handle()) ); pClient->getAuthHelper().AuthUserBySelfProcessOwner(); pClient->setVmDirectoryUuid(vmIdent.second); startTask( pClient, vmIdent ); }
void PrlNetworkShapingTest::testUpdateNetworkShapingConfig() { SdkHandleWrap hJob, hResult, hShaping, hShapingOrig ; SdkHandleWrap hShapingList, hShapingListOrig, hBandList; SdkHandleWrap hEntry0; SdkHandleWrap hEntry1; QString sDev = "eth0"; testLoginLocal(); AddNetworkClassesConfig(); hJob.reset(PrlSrv_GetNetworkShapingConfig(m_hServer, 0)); CHECK_JOB_RET_CODE(hJob); CHECK_RET_CODE_EXP(PrlJob_GetResult(hJob, hResult.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlResult_GetParam(hResult, hShaping.GetHandlePtr())); hJob.reset(PrlSrv_GetNetworkShapingConfig(m_hServer, 0)); CHECK_JOB_RET_CODE(hJob); CHECK_RET_CODE_EXP(PrlJob_GetResult(hJob, hResult.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlResult_GetParam(hResult, hShapingOrig.GetHandlePtr())); PRL_BOOL bEnabled = PRL_FALSE; CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_IsEnabled(hShaping, &bEnabled)); // BANDWIDTH CHECK_RET_CODE_EXP(PrlApi_CreateHandlesList(hBandList.GetHandlePtr())); PrlNet::EthAdaptersList ethList; PrlNet::makeBindableAdapterList( ethList, true ); for (PrlNet::EthAdaptersList::Iterator it = ethList.begin(); it != ethList.end(); ++it ) { SdkHandleWrap hEntry; if (!it->_systemName.startsWith("eth")) continue; sDev = it->_systemName; CHECK_RET_CODE_EXP(PrlNetworkShapingBandwidthEntry_Create( QSTR2UTF8(it->_systemName), 100000, hEntry.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlHndlList_AddItem(hBandList, hEntry)); } CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_SetNetworkDeviceBandwidthList(hShaping, hBandList)) // TOTALRATE CreateNetworkShapingEntry(hEntry0, 1, sDev); CreateNetworkShapingEntry(hEntry1, 2, sDev); CHECK_RET_CODE_EXP(PrlApi_CreateHandlesList(hShapingList.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlHndlList_AddItem(hShapingList, hEntry0)); CHECK_RET_CODE_EXP(PrlHndlList_AddItem(hShapingList, hEntry1)); // check setter CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_SetNetworkShapingList(hShaping, hShapingList)); bEnabled = !bEnabled; CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_SetEnabled(hShaping, bEnabled)); CHECK_ASYNC_OP_FAILED(PrlSrv_UpdateNetworkShapingConfig(m_hServer, hShaping, 0), 0); // verify result with getter hJob.reset(PrlSrv_GetNetworkShapingConfig(m_hServer, 0)); CHECK_JOB_RET_CODE(hJob); CHECK_RET_CODE_EXP(PrlJob_GetResult(hJob, hResult.GetHandlePtr())); CHECK_RET_CODE_EXP(PrlResult_GetParam(hResult, hShaping.GetHandlePtr())); PRL_BOOL bNewEnabled = PRL_FALSE; CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_IsEnabled(hShaping, &bNewEnabled)); QVERIFY(bNewEnabled == bEnabled); CHECK_RET_CODE_EXP(PrlNetworkShapingConfig_GetNetworkShapingList(hShaping, hShapingList.GetHandlePtr())); CHECK_HANDLE_TYPE(hShapingList, PHT_HANDLES_LIST); PRL_UINT32 nItemsCount = 0; CHECK_RET_CODE_EXP(PrlHndlList_GetItemsCount(hShapingList, &nItemsCount)) QVERIFY(nItemsCount == 2); SdkHandleWrap hEntry; CHECK_RET_CODE_EXP(PrlHndlList_GetItem(hShapingList, 0, hEntry.GetHandlePtr())); CHECK_HANDLE_TYPE(hEntry, PHT_NETWORK_SHAPING); COMPARE_SHAPING_ENTRIES(hEntry, hEntry0); CHECK_RET_CODE_EXP(PrlHndlList_GetItem(hShapingList, 1, hEntry.GetHandlePtr())); CHECK_HANDLE_TYPE(hEntry, PHT_NETWORK_SHAPING); COMPARE_SHAPING_ENTRIES(hEntry, hEntry1); // restore original values CHECK_ASYNC_OP_FAILED(PrlSrv_UpdateNetworkShapingConfig(m_hServer, hShapingOrig, 0), 0); }
PRL_RESULT CDspVmAutoTaskManagerBase::tryToRegisterVm(const SmartPtr<CVmConfiguration>& pVmConfig, const QString& qsVmDirUuid, int iRecommendedNextTime) { if ( ! pVmConfig ) return PRL_ERR_FAILURE; CVmIdent vmIdent = MakeVmIdent(pVmConfig->getVmIdentification()->getVmUuid(), qsVmDirUuid); // Fake client (calling at starting dispatcher from Init()) SmartPtr<CDspClient> pClient( new CDspClient(IOSender::Handle()) ); pClient->getAuthHelper().AuthUserBySelfProcessOwner(); pClient->setVmDirectoryUuid(vmIdent.second); PRL_RESULT res = prepareRegistration( vmIdent, pClient ); if ( PRL_FAILED( res ) ) return res; if ( !isEnabled( pVmConfig, false ) ) return unregisterVm(vmIdent); // Check period int iPeriod; res = getPeriod( pVmConfig, iPeriod ); if ( PRL_FAILED( res ) ) return res; // Register VM and start timer { QMutexLocker locker(&m_lockVmIdents); if (m_mapVmIdents.contains(vmIdent)) { TimerInfo timerInfo = m_mapVmIdents.value(vmIdent); if ( timerInfo.bAutoTask ) { int iOldPeriod = timerInfo.iPeriod; if (iOldPeriod && iOldPeriod != iPeriod) { emit killVmTimerSignal(timerInfo.iTimerId); m_mapVmIdents.remove(vmIdent); } else { return PRL_ERR_SUCCESS; } } } } // Check timestamp QDateTime dtNow = QDateTime::currentDateTime(); QDateTime dtTimestamp; { CDspLockedPointer<QSettings> pQSettings = CDspService::instance()->getQSettings(); QString qsGroup = getSettingsGroupKey(vmIdent); pQSettings->beginGroup(qsGroup); QString qsKeyTimeStamp = getSettingsKeyTimestamp(); dtTimestamp = pQSettings->value(qsKeyTimeStamp, QVariant(dtNow)).toDateTime(); if ( ! pQSettings->contains(qsKeyTimeStamp) ) pQSettings->setValue(qsKeyTimeStamp, QVariant(dtNow)); pQSettings->endGroup(); } int iOriginalPeriod = iPeriod; int iSkippedInterval = dtTimestamp.secsTo( dtNow ); if ( iSkippedInterval > 0 ) { iPeriod = (iSkippedInterval > iPeriod ? 0 : iPeriod - iSkippedInterval); } if ( iRecommendedNextTime ) iPeriod = qMin(iPeriod, iRecommendedNextTime); WRITE_TRACE( DBG_FATAL, "%s manager: register VM %s with period %d (%d)", getManagerName(), QSTR2UTF8( pVmConfig->getVmIdentification()->getVmName() ), iPeriod, iOriginalPeriod ); emit startVmTimerSignal(vmIdent, iPeriod, iOriginalPeriod); return PRL_ERR_SUCCESS; }