/*
* 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 "COREBatchProcessingLoader.h"
namespace Konclude {
namespace Control {
namespace Loader {
COREBatchProcessingLoader::COREBatchProcessingLoader() : mORELogIdentifier("::Konclude::OREBatchProcessor",this) {
mOWLLinkInterpreter = nullptr;
mLoaderConfig = nullptr;
mConfLogProcessingTimes = false;
mProcessingCommandData = nullptr;
mCloseAfterOutput = true;
mBlockUntilProcessed = true;
mSatOperationString = QString("sat").toLower();
mSatisfiabilityOperationString = QString("satisfiability").toLower();
mQueryOperationString = QString("query").toLower();
mClassificationOperationString = QString("classification").toLower();
mConsistencyOperationString = QString("consistency").toLower();
mRealisationOperationString = QString("realisation").toLower();
mRealizationOperationString = QString("realization").toLower();
mOperationTimeOutputString = QString("Operation time: ");
mInfoConsoleObserver = nullptr;
mErrorFileObserver = nullptr;
mConsistencyKBCommand = nullptr;
mTriviallyConsistencyKBCommand = nullptr;
mAdditionalCheckingTime = 0;
mReportAllTime = false;
}
COREBatchProcessingLoader::~COREBatchProcessingLoader() {
}
CCommandRecorder* COREBatchProcessingLoader::recordData(CCommandRecordData *recData) {
LOGC(recData->getRecordErrorLevel(),recData->getRecordDomain(),recData->getRecordMessage(),recData->getCommand());
return this;
}
CLoader *COREBatchProcessingLoader::init(CLoaderFactory *loaderFactory, CConfiguration *config) {
mLoaderConfig = config;
reasonerCommander = CConfigManagerReader::readCommanderManagerConfig(config);
mOperationTaskString = CConfigDataReader::readConfigString(config,"Konclude.ORE.OperationTask");
mOntologyFileString = CConfigDataReader::readConfigString(config,"Konclude.ORE.OntologyFile");
mResponseFileString = CConfigDataReader::readConfigString(config,"Konclude.ORE.ResponseFile");
mIRINameString = CConfigDataReader::readConfigString(config,"Konclude.ORE.IRIName");
mCloseAfterOutput = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.CloseAfterProcessed");
mOutputMeasuredTimeInSeconds = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.OutputTimeMeasurementInSeconds");
mReportParsingTimeForConsistency = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.ReportParsingTimeForConsistency");
mReportParsingTimeForSatisfiability = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.ReportParsingTimeForSatisfiability");
mReportParsingTimeForRealisation = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.ReportParsingTimeForRealization");
mReportParsingTimeForClassification = CConfigDataReader::readConfigBoolean(config,"Konclude.ORE.ReportParsingTimeForClassification");
mInfoConsoleObserver = new COREConsolePrintLogObserver(QStringList()<addLogObserver(mInfoConsoleObserver);
CLogger::getInstance()->addLogObserver(mErrorFileObserver);
return this;
}
CLoader *COREBatchProcessingLoader::load() {
startProcessing();
if (mBlockUntilProcessed) {
mBlockingSemaphore.acquire();
}
return this;
}
CConfiguration *COREBatchProcessingLoader::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 COREBatchProcessingLoader::createClassificationTestingCommands() {
logOutputMessage(QString("Started %1 on %2").arg(mProcessingOperationString).arg(mOntologyFileString));
QString oreTestKB = QString("http://konclude.com/ore/test/kb");
CCreateKnowledgeBaseCommand* createKBCommand = new CCreateKnowledgeBaseCommand(oreTestKB);
QStringList ontoIRIList;
ontoIRIList.append(mOntologyFileString);
CLoadKnowledgeBaseOWLAutoOntologyCommand* loadKBCommand = new CLoadKnowledgeBaseOWLAutoOntologyCommand(oreTestKB,ontoIRIList);
CKnowledgeBaseClassifyCommand* classifyKBCommand = new CKnowledgeBaseClassifyCommand(oreTestKB);
CWriteFunctionalSubClassHierarchyQueryCommand* writeHierarchyCommand = new CWriteFunctionalSubClassHierarchyQueryCommand(oreTestKB,mResponseFileString);
if (mReportParsingTimeForClassification) {
mReportAllTime = true;
}
addProcessingCommand(createKBCommand);
addProcessingCommand(loadKBCommand);
addProcessingCommand(classifyKBCommand,true,mOperationTimeOutputString);
addProcessingCommand(writeHierarchyCommand);
processNextCommand();
}
void COREBatchProcessingLoader::createRealisationTestingCommands() {
logOutputMessage(QString("Started %1 on %2").arg(mProcessingOperationString).arg(mOntologyFileString));
QString oreTestKB = QString("http://konclude.com/ore/test/kb");
CCreateKnowledgeBaseCommand* createKBCommand = new CCreateKnowledgeBaseCommand(oreTestKB);
QStringList ontoIRIList;
ontoIRIList.append(mOntologyFileString);
CLoadKnowledgeBaseOWLAutoOntologyCommand* loadKBCommand = new CLoadKnowledgeBaseOWLAutoOntologyCommand(oreTestKB,ontoIRIList);
CKnowledgeBaseRealizeCommand* realizeKBCommand = new CKnowledgeBaseRealizeCommand(oreTestKB);
CWriteCustomQueryCommand* writeIndividualTypesCommand = new CWriteCustomQueryCommand(oreTestKB,CWriteQuery::WRITEINDIVIDUALFLATTENEDTYPES,new CWriteQueryFileOWL2FunctionalSerializer(mResponseFileString));
//CWriteFunctionalIndividualTypesQueryCommand* writeIndividualTypesCommand = new CWriteFunctionalIndividualTypesQueryCommand(oreTestKB,mResponseFileString);
if (mReportParsingTimeForRealisation) {
mReportAllTime = true;
}
addProcessingCommand(createKBCommand);
addProcessingCommand(loadKBCommand);
addProcessingCommand(realizeKBCommand,true,mOperationTimeOutputString);
addProcessingCommand(writeIndividualTypesCommand);
processNextCommand();
}
void COREBatchProcessingLoader::createConsistencyTestingCommands() {
logOutputMessage(QString("Started %1 on %2").arg(mProcessingOperationString).arg(mOntologyFileString));
QString oreTestKB = QString("http://konclude.com/ore/test/kb");
CCreateKnowledgeBaseCommand* createKBCommand = new CCreateKnowledgeBaseCommand(oreTestKB);
QStringList ontoIRIList;
ontoIRIList.append(mOntologyFileString);
CLoadKnowledgeBaseOWLAutoOntologyCommand* loadKBCommand = new CLoadKnowledgeBaseOWLAutoOntologyCommand(oreTestKB,ontoIRIList);
mConsistencyKBCommand = new CIsConsistentQueryCommand(oreTestKB);
mTriviallyConsistencyKBCommand = new CIsTriviallyConsistentQueryCommand(oreTestKB);
if (mReportParsingTimeForConsistency) {
mReportAllTime = true;
}
addProcessingCommand(createKBCommand);
addProcessingCommand(loadKBCommand);
addProcessingCommand(mTriviallyConsistencyKBCommand,true,mOperationTimeOutputString,true,mResponseFileString);
processNextCommand();
}
void COREBatchProcessingLoader::createSatisfiabilityTesingCommands() {
logOutputMessage(QString("Started %1 on %2").arg(mProcessingOperationString).arg(mOntologyFileString));
QString oreTestKB = QString("http://konclude.com/ore/test/kb");
CCreateKnowledgeBaseCommand* createKBCommand = new CCreateKnowledgeBaseCommand(oreTestKB);
QStringList ontoIRIList;
ontoIRIList.append(mOntologyFileString);
mWriteSatisfiabilityPrefixString = mIRINameString+QString(",");
CLoadKnowledgeBaseOWLAutoOntologyCommand* loadKBCommand = new CLoadKnowledgeBaseOWLAutoOntologyCommand(oreTestKB,ontoIRIList);
CProcessClassNameSatisfiableQueryCommand* consistencyKBCommand = new CProcessClassNameSatisfiableQueryCommand(oreTestKB,mIRINameString);
if (mReportParsingTimeForSatisfiability) {
mReportAllTime = true;
}
addProcessingCommand(createKBCommand);
addProcessingCommand(loadKBCommand);
addProcessingCommand(consistencyKBCommand,true,mOperationTimeOutputString,true,mResponseFileString);
processNextCommand();
}
void COREBatchProcessingLoader::addProcessingCommand(CCommand* command) {
mProcessCommandList.append(new CCommandProcessData(command));
}
void COREBatchProcessingLoader::addProcessingCommand(CCommand* command, bool measureTime, const QString& measuredOutputString) {
mProcessCommandList.append(new CCommandProcessData(command,measureTime,measuredOutputString));
}
void COREBatchProcessingLoader::addProcessingCommand(CCommand* command, bool measureTime, const QString& measuredOutputString, bool writeSatisfiabilityOutput, const QString& outputFileName) {
mProcessCommandList.append(new CCommandProcessData(command,measureTime,measuredOutputString,writeSatisfiabilityOutput,outputFileName));
}
COWLlinkProcessor *COREBatchProcessingLoader::initializeOWLlinkContent() {
QString operationTaskString = mOperationTaskString;
operationTaskString = operationTaskString.toLower();
if (operationTaskString == mSatOperationString) {
mProcessingOperationString = mSatOperationString;
createSatisfiabilityTesingCommands();
} else if (operationTaskString == mSatisfiabilityOperationString) {
mProcessingOperationString = mSatisfiabilityOperationString;
createSatisfiabilityTesingCommands();
} else if (operationTaskString == mClassificationOperationString) {
mProcessingOperationString = mClassificationOperationString;
createClassificationTestingCommands();
} else if (operationTaskString == mConsistencyOperationString) {
mProcessingOperationString = mConsistencyOperationString;
createConsistencyTestingCommands();
} else if (operationTaskString == mRealisationOperationString) {
mProcessingOperationString = mRealisationOperationString;
createRealisationTestingCommands();
} else if (operationTaskString == mRealizationOperationString) {
mProcessingOperationString = mRealizationOperationString;
createRealisationTestingCommands();
} else {
logOutputError(QString("Operation %1 not supported").arg(mOperationTaskString));
terminateProcessing();
}
return this;
}
COWLlinkProcessor *COREBatchProcessingLoader::concludeOWLlinkContent() {
finishCommandProcessing();
if (hasMoreProcessingCommands()) {
processNextCommand();
} else {
logOutputMessage(QString("Completed %1 on %2").arg(mProcessingOperationString).arg(mOntologyFileString));
terminateProcessing();
}
return this;
}
void COREBatchProcessingLoader::logOutputError(const QString& errorString) {
LOG(ERROR,mORELogIdentifier.getLogDomain(),logTr("Error: %1").arg(errorString),this);
}
void COREBatchProcessingLoader::logOutputNotice(const QString& outputString) {
LOG(NOTICE,mORELogIdentifier.getLogDomain(),logTr("%1").arg(outputString),this);
}
void COREBatchProcessingLoader::logOutputMessage(const QString& outputString) {
LOG(INFO,mORELogIdentifier.getLogDomain(),logTr("%1").arg(outputString),this);
}
void COREBatchProcessingLoader::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 COREBatchProcessingLoader::writeSatisfiabilityResult(const QString& outputFileName, CCommand* processedCommand) {
bool outputWritten = false;
bool calculationCompleted = false;
CKnowledgeBaseQueryCommand* kbQueryCommand = dynamic_cast(processedCommand);
if (kbQueryCommand) {
CQuery* query = kbQueryCommand->getCalculateQueryCommand()->getQuery();
if (query) {
CQueryResult* queryResult = query->getQueryResult();
if (queryResult) {
CBooleanQueryResult* boolQueryResult = dynamic_cast(queryResult);
if (boolQueryResult) {
calculationCompleted = true;
forcedPathCreated(outputFileName);
QFile outputFile(outputFileName);
if (outputFile.open(QIODevice::Append)) {
QString outputData;
if (boolQueryResult->getResult() == true) {
outputData = mWriteSatisfiabilityPrefixString+QString("true\n");
} else {
outputData = mWriteSatisfiabilityPrefixString+QString("false\n");
}
outputFile.write(outputData.toUtf8());
outputFile.close();
outputWritten = true;
} else {
logOutputError(QString("Failed writing output to file '%1'").arg(outputFileName));
}
}
}
}
}
if (!calculationCompleted) {
logOutputError("Calculation failed");
}
}
void COREBatchProcessingLoader::finishCommandProcessing() {
if (mProcessingCommandData) {
bool writeResults = true;
if (mProcessingCommandData->mCommand == mTriviallyConsistencyKBCommand) {
CKnowledgeBaseQueryCommand* kbQueryCommand = dynamic_cast(mProcessingCommandData->mCommand);
if (kbQueryCommand) {
CQuery* query = kbQueryCommand->getCalculateQueryCommand()->getQuery();
if (query) {
CQueryResult* queryResult = query->getQueryResult();
if (queryResult) {
CBooleanQueryResult* boolQueryResult = dynamic_cast(queryResult);
if (boolQueryResult) {
if (!boolQueryResult->getResult()) {
writeResults = false;
mAdditionalCheckingTime += mMeasurementTime.elapsed();
addProcessingCommand(mConsistencyKBCommand,true,mOperationTimeOutputString,true,mResponseFileString);
}
}
}
}
}
}
if (writeResults) {
if (mProcessingCommandData->mMeasureTime) {
QString outputString = mProcessingCommandData->mMeasuredOutputString;
cint64 timeElapsed = mMeasurementTime.elapsed();
timeElapsed += mAdditionalCheckingTime;
if (mOutputMeasuredTimeInSeconds) {
logOutputMessage(outputString+QString("%1").arg(timeElapsed/1000.));
} else {
logOutputMessage(outputString+QString("%1").arg(timeElapsed));
}
} else {
if (mReportAllTime) {
mAdditionalCheckingTime += mMeasurementTime.elapsed();
}
}
if (mProcessingCommandData->mWriteSatisfiableOutput) {
QString outputFile = mProcessingCommandData->mWriteOutputFile;
writeSatisfiabilityResult(outputFile,mProcessingCommandData->mCommand);
}
}
mProcessingCommandData = nullptr;
}
}
void COREBatchProcessingLoader::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 COREBatchProcessingLoader::hasMoreProcessingCommands() {
return !mProcessCommandList.isEmpty();
}
void COREBatchProcessingLoader::terminateProcessing() {
mInfoConsoleObserver->flushLogging();
mErrorFileObserver->flushLogging();
if (mBlockUntilProcessed) {
mBlockingSemaphore.release();
}
if (mCloseAfterOutput) {
CLogger::getInstance()->waitSynchronization();
QCoreApplication::exit();
}
}
CLoader *COREBatchProcessingLoader::exit() {
stopThread();
return this;
}
}; // end namespace Loader
}; // end namespace Control
}; // end namespace Konclude