/* * 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 "CCLIBatchProcessingLoader.h" namespace Konclude { namespace Control { namespace Loader { CCLIBatchProcessingLoader::CCLIBatchProcessingLoader() : mLogIdentifier("::Konclude::CLIBatchProcessor",this) { mOWLLinkInterpreter = nullptr; mLoaderConfig = nullptr; mConfLogProcessingTimes = false; mProcessingCommandData = nullptr; mLogTotalProcessingTime = false; } CCLIBatchProcessingLoader::~CCLIBatchProcessingLoader() { } CCommandRecorder* CCLIBatchProcessingLoader::recordData(CCommandRecordData *recData) { LOGC(recData->getRecordErrorLevel(),recData->getRecordDomain(),recData->getRecordMessage(),recData->getCommand()); return this; } CLoader *CCLIBatchProcessingLoader::init(CLoaderFactory *loaderFactory, CConfiguration *config) { mLoaderConfig = config; reasonerCommander = CConfigManagerReader::readCommanderManagerConfig(config); mCloseAfterOutput = CConfigDataReader::readConfigBoolean(mLoaderConfig, "Konclude.CLI.CloseAfterProcessedRequest", true); mBlockUntilProcessed = CConfigDataReader::readConfigBoolean(mLoaderConfig, "Konclude.CLI.BlockUntilProcessedRequest", true); mRequestFileString = CConfigDataReader::readConfigString(config,"Konclude.CLI.RequestFile"); mResponseFileString = CConfigDataReader::readConfigString(config,"Konclude.CLI.ResponseFile"); mIRINameString = CConfigDataReader::readConfigString(config,"Konclude.CLI.IRIName"); mConfLogProcessingTimes = mLogTotalProcessingTime = CConfigDataReader::readConfigBoolean(config,"Konclude.OWLlink.LoggingExtendedProcessingTimes"); return this; } CLoader *CCLIBatchProcessingLoader::load() { startProcessing(); if (mBlockUntilProcessed) { mBlockingSemaphore.acquire(); } return this; } CConfiguration *CCLIBatchProcessingLoader::getConfiguration() { if (!reasonerCommander) { return mLoaderConfig; } else { CGetDescriptionCommand* getDesComm = new CGetDescriptionCommand(); reasonerCommander->delegateCommand(getDesComm); CCommandExecutedBlocker commExeBlocker; commExeBlocker.waitExecutedCommand(getDesComm); CConfiguration* config = getDesComm->getConfiguration(); return config; } } void CCLIBatchProcessingLoader::createTestingCommands() { } void CCLIBatchProcessingLoader::addProcessingCommand(CCommand* command) { mProcessCommandList.append(new CCommandProcessData(command)); } void CCLIBatchProcessingLoader::addProcessingCommand(CCommand* command, bool measureTime, const QString& measuredOutputString) { mProcessCommandList.append(new CCommandProcessData(command,measureTime,measuredOutputString)); } void CCLIBatchProcessingLoader::addProcessingCommand(CCommand* command, bool measureTime, const QString& measuredOutputString, bool writeSatisfiabilityOutput, const QString& outputFileName) { mProcessCommandList.append(new CCommandProcessData(command,measureTime,measuredOutputString,writeSatisfiabilityOutput,outputFileName)); } COWLlinkProcessor *CCLIBatchProcessingLoader::initializeOWLlinkContent() { if (mLogTotalProcessingTime) { mTotalTime.start(); } createTestingCommands(); return this; } COWLlinkProcessor *CCLIBatchProcessingLoader::concludeOWLlinkContent() { finishCommandProcessing(); if (hasMoreProcessingCommands()) { processNextCommand(); } else { finishProcessing(); terminateProcessing(); } return this; } void CCLIBatchProcessingLoader::logOutputError(const QString& errorString) { LOG(ERROR,mLogIdentifier.getLogDomain(),errorString,this); } void CCLIBatchProcessingLoader::logOutputNotice(const QString& outputString) { LOG(NOTICE,mLogIdentifier.getLogDomain(),outputString,this); } void CCLIBatchProcessingLoader::logOutputMessage(const QString& outputString) { LOG(INFO,mLogIdentifier.getLogDomain(),outputString,this); } void CCLIBatchProcessingLoader::forcedPathCreated(const QString& filePath) { QString path = filePath; if (path.contains("/") || path.contains("\\")) { int lastSlash = path.lastIndexOf("/"); int lastBackSlash = path.lastIndexOf("\\"); int lastSeparator = qMax(lastBackSlash,lastSlash); path = path.mid(0,lastSeparator); if (!path.isEmpty()) { QDir dir; dir.mkpath(path); } } } void CCLIBatchProcessingLoader::writeCommandOutput(const QString& outputFileName, CCommand* processedCommand) { } void CCLIBatchProcessingLoader::finishCommandProcessing() { if (mProcessingCommandData) { if (mProcessingCommandData->mMeasureTime) { QString outputString = mProcessingCommandData->mMeasuredOutputString; cint64 timeElapsed = mMeasurementTime.elapsed(); if (mOutputMeasuredTimeInSeconds) { logOutputMessage(outputString.arg(timeElapsed/1000.)); } else { logOutputMessage(outputString.arg(timeElapsed)); } } if (mProcessingCommandData->mWriteOutput) { QString outputFile = mProcessingCommandData->mWriteOutputFile; writeCommandOutput(outputFile,mProcessingCommandData->mCommand); } mProcessingCommandData = nullptr; } } void CCLIBatchProcessingLoader::processNextCommand() { mProcessingCommandData = mProcessCommandList.takeFirst(); CCommand* command = mProcessingCommandData->mCommand; logOutputNotice(QString("Starting '%1' command").arg(command->getBriefCommandDescription())); command->setRecorder(this); command->setReportErrorFromSubCommands(false); CCommandProcessedCallbackEvent *proComm = new CCommandProcessedCallbackEvent(this,command); command->addProcessedCallback(proComm); mMeasurementTime.start(); preSynchronizer->delegateCommand(command); } bool CCLIBatchProcessingLoader::hasMoreProcessingCommands() { return !mProcessCommandList.isEmpty(); } void CCLIBatchProcessingLoader::finishProcessing() { } void CCLIBatchProcessingLoader::terminateProcessing() { if (mLogTotalProcessingTime) { cint64 timeElapsed = mTotalTime.elapsed(); logOutputMessage(QString("Total processing time: %1 ms.").arg(timeElapsed)); } if (mBlockUntilProcessed) { mBlockingSemaphore.release(); } if (mCloseAfterOutput) { CLogger::getInstance()->waitSynchronization(); QCoreApplication::exit(); } } CLoader *CCLIBatchProcessingLoader::exit() { stopThread(); return this; } }; // end namespace Loader }; // end namespace Control }; // end namespace Konclude