/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CReasonerExecutableEvaluationProvider.h" namespace Konclude { namespace Test { namespace Evaluation { CReasonerExecutableEvaluationProvider::CReasonerExecutableEvaluationProvider() : CIntervalThread("ReasonerExecutionThread"), CLogIdentifier("::Konclude::Test::Evaluation::ReasonerExecutionThread", this) { mProcess = nullptr; mKillTimeout = 1000; mReasonerPort = 8080; mMemoryCheckingThread = nullptr; mReasonerForcedTermination = false; startThread(); } CReasonerExecutableEvaluationProvider::~CReasonerExecutableEvaluationProvider() { stopThread(); } bool CReasonerExecutableEvaluationProvider::createReasoner(CConfiguration *config) { mConfig = config; mReasonerName = CConfigDataReader::readConfigString(config, "Konclude.Evaluation.Reasoner.Name"); mReasonerBinaryFile = CConfigDataReader::readConfigString(config,"Konclude.Evaluation.Reasoner.Execution.Binary.File"); mReasonerBinaryArguments = CConfigDataReader::readConfigString(config,"Konclude.Evaluation.Reasoner.Execution.Binary.Arguments"); mReasonerPort = CConfigDataReader::readConfigInteger(config,"Konclude.Evaluation.Reasoner.Address.Port"); mKillScriptString = CConfigDataReader::readConfigString(config, "Konclude.Evaluation.TerminateAssistProgram"); mKillScriptArgumentsString = CConfigDataReader::readConfigString(config, "Konclude.Evaluation.TerminateAssistAdditionalArgument"); mCheckingMemoryUsage = CConfigDataReader::readConfigBoolean(config, "Konclude.Evaluation.CheckingMemoryUsage"); mRestartSleepTime = CConfigDataReader::readConfigInteger(config, "Konclude.Evaluation.ReasonerRestartPausingTime"); mTerminationSleepTime = CConfigDataReader::readConfigInteger(config, "Konclude.Evaluation.ReasonerTerminationPausingTime"); mProcessFinished = false; mProcessError = false; startReasoner(); return true; } QString CReasonerExecutableEvaluationProvider::getReasonerAddressString() { return QString("127.0.0.1:%1").arg(mReasonerPort); } void CReasonerExecutableEvaluationProvider::startReasoner() { CBlockingCallbackData blockCallBack; postEvent(new CReasonerEvaluationReasonerStartEvent(&blockCallBack)); blockCallBack.waitForCallback(); } void CReasonerExecutableEvaluationProvider::startReasonerThreaded() { mMemoryCheckingThread = nullptr; QString argString = QString("%1").arg(mReasonerBinaryArguments); QString appString = QString("%1 %2").arg(mReasonerBinaryFile).arg(argString); mProcess = new QProcess(); connect(mProcess, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError)), Qt::DirectConnection); connect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(processFinished(int, QProcess::ExitStatus)), Qt::DirectConnection); mProcess->start(appString); if (mCheckingMemoryUsage) { mMemoryCheckingThread = new CReasonerMemoryUsageCheckingThread(mConfig, QString::number((cint64)mProcess->pid())); } } bool CReasonerExecutableEvaluationProvider::restartReasoner() { CBlockingCallbackData blockCallBack; postEvent(new CReasonerEvaluationReasonerRestartEvent(&blockCallBack)); blockCallBack.waitForCallback(); return true; } bool CReasonerExecutableEvaluationProvider::restartReasonerThreaded() { terminateReasonerThreaded(); if (mRestartSleepTime > 0) { QThread::msleep(mRestartSleepTime); } startReasonerThreaded(); return true; } void CReasonerExecutableEvaluationProvider::terminateReasoner() { CBlockingCallbackData blockCallBack; postEvent(new CReasonerEvaluationReasonerStopEvent(&blockCallBack)); blockCallBack.waitForCallback(); } void CReasonerExecutableEvaluationProvider::terminateReasonerThreaded() { if (mMemoryCheckingThread) { mMaxMemoryUsage = qMax(mMaxMemoryUsage, mMemoryCheckingThread->getMemoryUsage()); delete mMemoryCheckingThread; mMemoryCheckingThread = nullptr; } try { QByteArray standOutput = mProcess->readAllStandardOutput(); QByteArray standError = mProcess->readAllStandardError(); mReasonerStdOutText += QString(standOutput); mReasonerStdErrText += QString(standError); mReasonerErrorString += mProcess->errorString(); } catch (std::bad_alloc& ba) { mReasonerStdErrText = "Reasoners outputs exceed size limitations\r\n"; LOG(INFO, "::Konclude::Test::ReasonerEvaluationProvider", logTr("Failed to read reasoner output due to size limitations."), this); } disconnect(mProcess, SIGNAL(error(QProcess::ProcessError)), this, SLOT(processError(QProcess::ProcessError))); disconnect(mProcess, SIGNAL(finished(int, QProcess::ExitStatus)), this, SLOT(processFinished(int, QProcess::ExitStatus))); disconnect(mProcess); disconnect(this); if (!mProcessFinished) { assistTermination(mProcess->pid()); mProcessFinished = true; mReasonerFinishedInTime = false; mReasonerForcedTermination = true; mProcess->terminate(); mProcess->waitForFinished(mKillTimeout); mProcess->kill(); mProcess->waitForFinished(mKillTimeout); mProcess->kill(); mProcess->waitForFinished(mKillTimeout); } mProcess->close(); delete mProcess; mProcess = nullptr; } CReasonerEvaluationTerminationResult* CReasonerExecutableEvaluationProvider::destroyReasoner() { terminateReasoner(); CReasonerEvaluationTerminationResult* result = new CReasonerEvaluationTerminationResult(); result->initResult(mProcessError, mReasonerFinishedInTime, mReasonerForcedTermination, mReasonerErrorString, mReasonerStdOutText, mReasonerStdErrText, mMaxMemoryUsage); mReasonerForcedTermination = false; mMaxMemoryUsage = 0; mReasonerFinishedInTime = true; mReasonerStdOutText.clear(); mReasonerStdErrText.clear(); mReasonerErrorString.clear(); mProcessFinished = false; mProcessError = false; if (mTerminationSleepTime > 0) { QThread::msleep(mTerminationSleepTime); } return result; } bool CReasonerExecutableEvaluationProvider::assistTermination(Q_PID processID) { if (!mKillScriptString.isEmpty()) { QProcess killProcess; QStringList argumentList; argumentList += QString::number((cint64)processID); if (!mKillScriptArgumentsString.isEmpty()) { argumentList += mKillScriptArgumentsString; } LOG(INFO,"::Konclude::Test::ReasonerEvaluationProvider",logTr("Executing '%1' to assist termination of process with id '%2'.").arg(mKillScriptString).arg((cint64)processID),this); killProcess.start(mKillScriptString,argumentList); if (!killProcess.waitForStarted()) { return false; } if (!killProcess.waitForFinished()) { return false; } if (killProcess.exitCode() != 0) { return true; } } return false; } void CReasonerExecutableEvaluationProvider::processError(QProcess::ProcessError error) { if (!mProcessFinished) { mProcessError = true; } } void CReasonerExecutableEvaluationProvider::processFinished(int exitCode, QProcess::ExitStatus exitStatus) { if (!mProcessFinished) { mProcessFinished = true; if (exitStatus != QProcess::NormalExit) { mProcessError = true; } } } bool CReasonerExecutableEvaluationProvider::processTimer(qint64 timerID) { return false; } bool CReasonerExecutableEvaluationProvider::processCustomsEvents(QEvent::Type type, CCustomEvent* event) { if (CThread::processCustomsEvents(type, event)) { return true; } else { if (type == CReasonerEvaluationReasonerStartEvent::EVENTTYPE) { CReasonerEvaluationReasonerStartEvent* rerse = (CReasonerEvaluationReasonerStartEvent*)event; startReasonerThreaded(); CCallbackData* callback = rerse->getCallback(); if (callback) { callback->doCallback(); } return true; } else if (type == CReasonerEvaluationReasonerRestartEvent::EVENTTYPE) { CReasonerEvaluationReasonerRestartEvent* rerse = (CReasonerEvaluationReasonerRestartEvent*)event; restartReasonerThreaded(); CCallbackData* callback = rerse->getCallback(); if (callback) { callback->doCallback(); } return true; } else if (type == CReasonerEvaluationReasonerStopEvent::EVENTTYPE) { CReasonerEvaluationReasonerStopEvent* rerse = (CReasonerEvaluationReasonerStopEvent*)event; terminateReasonerThreaded(); CCallbackData* callback = rerse->getCallback(); if (callback) { callback->doCallback(); } return true; } } return false; } }; // end namespace Evaluation }; // end namespace Test }; // end namespace Konclude