void Task_MigrateCtTarget::clientDisconnected(IOSender::Handle h)
{
// #439777 to protect call handler for destroying object
WaiterTillHandlerUsingObject::AutoUnlock lock( m_waiter );
if( !lock.isLocked() )
return;
if (h != m_hConnHandle)
return;
WRITE_TRACE(DBG_FATAL, "%s", __FUNCTION__);
SmartPtr<CDspClient> nullClient;
cancelOperation(nullClient, getRequestPackage());
}
/**
* Class constructor
*/
CDspHwMonitorHandler::CDspHwMonitorHandler( QObject * parent )
: QThread (parent),
m_hResetEvent(INVALID_HANDLE_VALUE),
m_FinalizationMutex(QMutex::Recursive)
{
g_pHwMonitorHandler = this;
/* Event to stop HWMonitor */
m_hResetEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (m_hResetEvent == INVALID_HANDLE_VALUE)
WRITE_TRACE(DBG_FATAL, "Failed to create StopEvent");
PRL_ASSERT(m_hResetEvent != INVALID_HANDLE_VALUE);
}
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;
}
int TOntimeSynCmd::DecodeGetPeerList(CBufMgr &bufMgr, int &nHashNum, int &PeerNum)
{
if(bufMgr.GetInt(nHashNum) != 0)
{
WRITE_TRACE("Ping, Decode for nHashNum FAILED!!");
return -1;
}
if(bufMgr.GetInt(PeerNum) != 0)
{
WRITE_TRACE("Ping, Decode for PeerNum FAILED!!");
return -1;
}
lstPeerList.clear();
for (int iA = 0; iA < PeerNum; iA ++)
{
if(m_PingSynCmd.Decode(bufMgr) != 0)
{
WRITE_TRACE("Ping, Decode for Peer FAILED!!");
return -1;
}
else lstPeerList.push_back(m_PingSynCmd.m_PeerInfo);
}
return 0;
}
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);
}
// Open USB Manager and setup USB-changed event
// @return INVALID_HANDLE_VALUE if open failed
static HANDLE openUSBManager(HANDLE hUsbConnectEvent)
{
HANDLE hUsbManager = ::CreateFile( PRL_USBMGR_SRV_LINK,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if (INVALID_HANDLE_VALUE == hUsbManager)
WRITE_TRACE(DBG_FATAL, "Can't open USB manager service (%d)", GetLastError());
else {
DWORD size = 0;
// Pass to driver m_hConnectEvent, m_hDisconnectEvent events only!
if (!::DeviceIoControl( hUsbManager, IOCTL_SET_REPLUG_EVENT,
&hUsbConnectEvent, sizeof(HANDLE),
NULL, 0, &size, NULL)) {
WRITE_TRACE(DBG_FATAL, "IOCTL_SET_REPLUG_EVENT failed (%d)", GetLastError());
}
}
return hUsbManager;
}
QString CAuthHelperTest::getCurrentDomain()
{
QString domain;
#ifdef _WIN_
if ( !CAuth::getCurrentDomain( domain ) )
WRITE_TRACE(DBG_FATAL, "ERROR!!!: CAuth::getCurrentDomain() return false" );
else
#endif
if ( domain.isEmpty() )
domain = getLocalDomain();
else
domain = domain.toLower(); //normalize
return domain;
}
PRL_RESULT CVmMigrateTargetDisk::init(VirtualDisk::Qcow2* disk)
{
WRITE_TRACE(DBG_DEBUG, "[Disk migration] Initializing new virtual disk task");
m_result = PRL_ERR_SUCCESS;
if ( !disk )
return (m_result = PRL_ERR_INVALID_ARG);
m_disk.reset(disk);
QThread::start();
m_sem_init.acquire();
return m_result;
}
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];
}
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_SyncVmsUptime::run_body()
{
quint32 nTimeout =
CDspService::instance()->getDispConfigGuard().getDispWorkSpacePrefs()->getVmUptimeSyncTimeoutInMinutes();
if ( ! nTimeout )
{
WRITE_TRACE(DBG_FATAL, "Synchronization up time task was not started due to timeout is zero !");
return (PRL_ERR_SUCCESS);
}
SmartPtr<QTimer> pTimer(new QTimer);
bool bConnected = connect(pTimer.getImpl(), SIGNAL(timeout()), SLOT(onTimeoutEvent()));
PRL_ASSERT(bConnected);
pTimer->start(nTimeout*60*1000);
exec();
return (PRL_ERR_SUCCESS);
}
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;
}
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;
}
void CVmMigrateTargetDisk::run()
{
m_sem_init.release();
m_result = PRL_ERR_SUCCESS;
while (PRL_SUCCEEDED(m_result) && !(m_queue.empty() && m_wait))
{
DiskQueueElem_t data;
if (m_queue.take(data, m_token))
m_result = write_data(&data);
else
break;
if (PRL_FAILED(m_result))
{
WRITE_TRACE(DBG_FATAL, "[Disk migration] Failed to write block to disk %s,\
address %llu, size %u",
qPrintable(Uuid::fromGuid(data.hdr.disk_id).toString()),
data.hdr.lba, data.hdr.nsect);
m_token.signal();
}
}
}
PRL_RESULT CDspHaClusterHelper::getHaClusterID(QString & sHaClusterID)
{
QStringList args;
QProcess proc;
args += SHAMAN_CMD_INFO;
PRL_RESULT res = runHaman(args, proc);
if (PRL_FAILED(res)) {
WRITE_TRACE(DBG_FATAL, "can not get cluster info");
return res;
}
QList<QByteArray> lstOut = proc.readAllStandardOutput().split('\n');
QByteArray token = "ID :";
foreach(QByteArray entry, lstOut) {
if (entry.startsWith(token)) {
sHaClusterID = QString(entry.right(entry.size() - token.size()).trimmed());
break;
}
}
return PRL_ERR_SUCCESS;
}
int CRecvAndSendTask::SendBufProcess(const char * pBuf, int nLen)
{
if (pBuf == NULL || nLen == 0)
{
return -1;
}
int retValue = 0;
int ret = send(m_pTcpSocket->GetSocket(), pBuf, nLen, MSG_DONTWAIT);
if (ret == nLen) //发送完毕
{
retValue = -1;
}
else if (ret >= 0 && ret < nLen) //将剩下的放入队列
{
PutMsgToSendList(pBuf + ret, nLen - ret);
retValue = 0;
}
else //< ０
{
if (errno != EINTR && errno != EAGAIN)
{
WriteRunInfo::WriteLog("send fail, error(%d) is %s", errno, strerror(errno));
CMyserver::GetInstance()->GetCommonStat().AddNormalStat(SOCKETERRORTYPE);
retValue = -1;
}
else //继续接收消息
{
WRITE_TRACE("EAGAIN, EINTR ");
PutMsgToSendList(pBuf, nLen);
retValue = 0;
}
}
return retValue;
}
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));
}
}
int CSendMailClient::SendMail()
{
WRITE_TRACE("Begin send mail ......");
WriteRunInfo::WriteNowDetailTime();
int ret = m_tcpSocket.Connect(m_sServerAddr, 25); //连接服务器
if (ret != 0)
{
WRITE_TRACE("Connect to mail server fail");
return -1;
}
m_tcpSocket.SetNonBlocking();
char sRecivBuf[MAXMAILRECVBUF];
int nResult = 0;
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 10, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server connect response fail");
return -1;
}
if (strncmp(sRecivBuf, "220", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server connect response parm error, %s", sRecivBuf);
return -1;
}
WRITE_TRACE("recv 220 ok ......");
string sCommand;
sCommand = "HELO register\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 5, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server connect response fail");
return -1;
}
WRITE_TRACE("recv helo register resp ok ......");
if (strncmp(sRecivBuf, "250", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server HELO response parm error, %s", sRecivBuf);
return -1;
}
sCommand = "MAIL FROM:<";
sCommand += m_fromMail;
sCommand += ">\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 5, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server MAIL FROM response fail");
return -1;
}
if (strncmp(sRecivBuf, "250", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server MAIL FROM response parm error, %s", sRecivBuf);
return -1;
}
WRITE_TRACE("recv MAIL FROM resp ok ......");
sCommand = "RCPT TO:<";
sCommand += m_toMail;
sCommand += ">\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 5, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server RCPT TO response fail");
return -1;
}
if (strncmp(sRecivBuf, "250", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server RCPT TO response parm error, %s", sRecivBuf);
return -1;
}
WRITE_TRACE("recv RCPT TO: resp ok ......");
sCommand = "DATA\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 5, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server DATA response fail");
return -1;
}
if (strncmp(sRecivBuf, "354", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server DATA response parm error, %s", sRecivBuf);
return -1;
}
WRITE_TRACE("recv (data) 354 ok ......");
sCommand = "Subject: ";
sCommand += m_sSubject;
sCommand += "\r\n";
sCommand += m_sMailString;
sCommand += "\r\n.\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
ret = m_tcpSocket.Receive(sRecivBuf, MAXMAILRECVBUF, 5, nResult, ENDSTR);
if (nResult != 0) //收到完整的请求
{
WriteRunInfo::WriteRunLog("Recv mail server Subject response fail");
return -1;
}
if (strncmp(sRecivBuf, "250", 3) != 0)
{
WriteRunInfo::WriteRunLog("Mail server Subject response parm error, %s", sRecivBuf);
return -1;
}
sCommand = "QUIT\r\n";
m_tcpSocket.SendRealBuf((char*)sCommand.c_str(), sCommand.length());
WRITE_TRACE("End send mail ......");
WriteRunInfo::WriteNowDetailTime();
return 0;
}
int CListenTask::HandleProcess(int events)
{
// #ifndef __USE_EPOLL
// DelFromEpoll();
// #endif
CListenThread *pThread = (CListenThread*)m_pThread;
pThread->GetListenBlock()->mutex.Lock();
if (events&(MYPOLLIN|MYPOLLRDNORM))
{
struct sockaddr_in tmpAddr;
memset(&tmpAddr, 0, sizeof(sockaddr_in));
int iSocketSize=sizeof(sockaddr_in);
//int ret = 1;
while (1)
{
int iSocket = accept(m_pTcpSocket->GetSocket(), (struct sockaddr *)&tmpAddr, (socklen_t*)&iSocketSize);
if (iSocket > 0)
{
WRITE_TRACE("Recv a client connect request");
CMyserver::GetInstance()->GetCommonStat().AddNormalStat(RECVPKGNUMSTAT);
if (CTcpSocket::GetNum() > CMyserver::GetInstance()->GetBaseConf().GetConfigItem().nMaxFdSize) //如果太忙了， 不再接入
{
WriteRunInfo::WriteInfoRun("The fdsize is %d, greater than %d, close the connect", CTcpSocket::GetNum(),
CMyserver::GetInstance()->GetBaseConf().GetConfigItem().nMaxFdSize);
close(iSocket);
continue;
}
CTimeStat timestat;
timestat.Begin(); //打印开始的时间
if (CMyserver::GetInstance()->GetBaseConf().GetConfigItem().nRecvTaskType == 0) //发到收发线程中去
{
CRecvMsgBody *pBody = new CRecvMsgBody(iSocket, tmpAddr);
pBody->SetTimeStat(timestat);
m_pThread->SendMsg(RECVANDSENDMSGENTITY, RANDOMENTITYID, 0, RECVMSGTYPE, pBody, 0);
}
else //发到本线程
{
CTcpSocket *pSocket = new CTcpSocket(tmpAddr, iSocketSize, iSocket);
//生成一个接收数据的任务
CSocketTask *pRecvTask = NULL;
pRecvTask = CMyserver::GetInstance()->GetClassFactory()->GenSocketTask((CNetProcessThread*)m_pThread,
pSocket, RECVTASK);
if (pRecvTask != NULL)
{
pRecvTask->Init();
pRecvTask->SetTimeStat(timestat);
}
else
{
close(iSocket);
}
}
}
else //句柄accept完毕
{
break;
}
}
}
else
{
WriteRunInfo::WriteRunLog("Receive invalid event %d", events);
}
pThread->GetListenBlock()->mutex.UnLock();
// #ifndef __USE_EPOLL
// AddToEpoll();
// #endif
return 0;
}
void CVmMigrateTargetDisk::stop()
{
m_token.signal();
WRITE_TRACE(DBG_DEBUG, "[Disk migration] Stopping(%u)!!!", m_queue.size() );
QThread::wait();
}
PRL_RESULT CVmMigrateTargetDisk::write_data(DiskQueueElem_t* data)
{
WRITE_TRACE(DBG_DEBUG, "write block %llu", data->hdr.lba);
return m_disk->write(data->buf.getImpl(), data->hdr.nsect * 512, data->hdr.lba);
}
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 );
}
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;
}
void CDspDispConfigGuard::enableCrashSafeMech()
{
if( ! getDispConfig()->enableCrashSafeSaving() )
WRITE_TRACE(DBG_FATAL, "Unable to enableCrashSafeSaving mech for disp config" );
}
int CLongConnectedThread::Process(CMsg *pMsg)
{
TMsg *pTMsg = pMsg->GetTMsg();
if ( !pTMsg )
{
return 0;
}
WRITE_TRACE("The LongConnected thread recv a msg , msgtype %d...", pTMsg->msgType);
if ( pTMsg->srcEntityType == EPOLLREACTORENTITY )
{
if (pTMsg->msgType == CONNECTMSGTYPE)
{
CConnectMsgBody *pBody = (CConnectMsgBody*)pMsg->GetMsgBody();
if ( !pBody )
{
return 0;
}
if ( pBody->GetState() == 0 )
{
std::string tmpStr = pBody->GetRemoteIp();
CTcpSocket *pSocket = new CTcpSocket( tmpStr, pBody->GetRemotePort(), pBody->GetSocket() );
if ( !pSocket )
{
return 0;
}
CSocketTask *tmpSocketTask = NULL;
CCommonTaskArg commonTaskArg( pBody->GetDestMachineType(), pBody->GetDestMachineIndex(), true, m_iListType );
tmpSocketTask = CMyserver::GetInstance()->GetClassFactory()->GenSocketTask(this,
pSocket, COMMONTASK, &commonTaskArg );
tmpSocketTask->Init();
WriteRunInfo::WriteLog( "connect to %d %d %d succ ", ( int )pBody->GetDestMachineType(), ( int )pBody->GetDestMachineIndex(), pBody->GetSocket() );
}
else
{
WriteRunInfo::WriteLog( "EPOLLREACTORENTITY reconnect %d %d", ( int )pBody->GetDestMachineType(), ( int )pBody->GetDestMachineIndex() );
if ( m_pEpollReactor )
{
m_pEpollReactor->AsyncConnect( pBody->GetRemoteIp(), pBody->GetRemotePort(), LONGCONNECTEDENTITY, 0, GetTime( 3 ), pBody->GetDestMachineType(), pBody->GetDestMachineIndex() );
}
}
}
else
{
WriteRunInfo::WriteLog("Send&recv thread recv invalid msgtype %d", pTMsg->msgType);
}
}
else if ( pTMsg->srcEntityType== MAINENTITY )
{
if (pTMsg->msgType == TOCONNECTMSGTYPE)
{
CToConnectMsgBody *pBody = (CToConnectMsgBody*)pMsg->GetMsgBody();
if ( !pBody )
{
return 0;
}
if ( m_pEpollReactor )
{
WriteRunInfo::WriteLog("connect %d %d", pBody->GetDestMachineType(), pBody->GetDestMachineIndex());
m_pEpollReactor->AsyncConnect( pBody->GetRemoteIp(), pBody->GetRemotePort(), LONGCONNECTEDENTITY,
0, GetTime( 3 ), pBody->GetDestMachineType(), pBody->GetDestMachineIndex() );
}
}
else if ( pTMsg->msgType == CLIENTMSGTYPE )
{
CClientMsgBody *pBody = ( CClientMsgBody * )pMsg->GetMsgBody();
if ( !pBody )
{
return 0;
}
if ( m_iListType )
{
std::list<CSocketTask*>::iterator it = m_pSocketList.begin();
while( it != m_pSocketList.end() )
{
CSocketTask * pSocketTask = ( *it );
if ( pSocketTask )
{
pSocketTask->PutMsgToSendList( pBody->GetBuffer(), pBody->GetLen() );
}
it ++;
}
}
else
{
std::map<ULONG64, CSocketTask*>::iterator it = m_pMapSocketList.begin();
while( it != m_pMapSocketList.end() )
{
CSocketTask * pSocketTask = ( *it ).second;
if ( pSocketTask )
{
pSocketTask->PutMsgToSendList( pBody->GetBuffer(), pBody->GetLen() );
}
it ++;
}
}
}
else
{
WriteRunInfo::WriteLog("Send msg thread recv invalid msgtype %d", pTMsg->msgType);
}
}
else if ( pTMsg->srcEntityType== LONGCONNECTEDENTITY )
{
if ( pTMsg->msgType == TOCONNECTMSGTYPE )
{
CToConnectMsgBody *pBody = (CToConnectMsgBody*)pMsg->GetMsgBody();
if ( !pBody )
{
return 0;
}
if ( m_pEpollReactor )
{
WriteRunInfo::WriteLog("LONGCONNECTEDENTITY reconnect %d %d", pBody->GetDestMachineType(), pBody->GetDestMachineIndex());
m_pEpollReactor->AsyncConnect( pBody->GetRemoteIp(), pBody->GetRemotePort(), LONGCONNECTEDENTITY,
0, GetTime( 3 ), pBody->GetDestMachineType(), pBody->GetDestMachineIndex() );
}
}
else
{
WriteRunInfo::WriteLog("Send msg thread recv invalid msgtype %d", pTMsg->msgType);
}
}
else if ( pTMsg->srcEntityType== RECVANDSENDMSGENTITY )
{
if ( pTMsg->msgType == CLIENTMSGTYPE )
{
CClientMsgBody *pBody = ( CClientMsgBody * )pMsg->GetMsgBody();
if ( !pBody )
{
return 0;
}
if ( m_iListType )
{
std::list<CSocketTask*>::iterator it = m_pSocketList.begin();
while( it != m_pSocketList.end() )
{
CSocketTask * pSocketTask = ( *it );
if ( pSocketTask )
{
pSocketTask->PutMsgToSendList( pBody->GetBuffer(), pBody->GetLen() );
}
it ++;
}
}
else
{
map<ULONG64, CSocketTask*>::iterator it = m_pMapSocketList.begin();
while( it != m_pMapSocketList.end() )
{
CSocketTask * pSocketTask = ( *it ).second;
if ( pSocketTask )
{
pSocketTask->PutMsgToSendList( pBody->GetBuffer(), pBody->GetLen() );
}
it ++;
}
}
}
}
else
{
CNetProcessThread::Process( pMsg);
}
return 0;
}
/*
* Overridden method of thread working body
*/
void CDspHwMonitorHandler::run()
{
if (m_hResetEvent == INVALID_HANDLE_VALUE)
return;
HANDLE hUsbConnectEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (hUsbConnectEvent == INVALID_HANDLE_VALUE) {
WRITE_TRACE(DBG_FATAL, "Can't create USB-changed event!");
return;
}
HANDLE hNetConfigEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
if (hNetConfigEvent == INVALID_HANDLE_VALUE) {
::CloseHandle(hUsbConnectEvent);
WRITE_TRACE(DBG_FATAL, "Can't create Net-changed event!");
return;
}
HANDLE hUsbManager = openUSBManager(hUsbConnectEvent);
HANDLE eventsArray[3] = {
m_hResetEvent,
hUsbConnectEvent,
hNetConfigEvent
};
// Setup notification for network changes
OVERLAPPED ovlNet;
ovlNet.hEvent = hNetConfigEvent;
/* Wait for hw-changed events or stop thread event */
DWORD waitResult;
do {
static bool errLogged = false;
HANDLE h; // should not be closed.
if (::NotifyAddrChange(&h, &ovlNet) != ERROR_IO_PENDING && !errLogged) {
WRITE_TRACE(DBG_FATAL, "NotifyAddrChange(..) returned an error");
errLogged = true;
}
waitResult = ::WaitForMultipleObjects( sizeof(eventsArray)/sizeof(HANDLE),
eventsArray,
FALSE,
INFINITE);
switch(waitResult) {
// USB-Event
case (WAIT_OBJECT_0+1):
g_onDeviceChange(PDE_USB_DEVICE, QString(""), 1);
break;
// Network Event
case (WAIT_OBJECT_0+2):
g_onDeviceChange(PDE_GENERIC_NETWORK_ADAPTER, QString(""), 1);
break;
default:
break;
}
} while (waitResult != WAIT_OBJECT_0);
::CloseHandle(hUsbConnectEvent);
::CloseHandle(hNetConfigEvent);
if (hUsbManager != INVALID_HANDLE_VALUE)
::CloseHandle(hUsbManager);
}
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::Deinit()
{
WRITE_TRACE( DBG_DEBUG, "Deinitializing %s manager", getManagerName() );
m_bInitialized = false;
}
