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;
}
