/* * 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 "CSPARQLRecordResultStreamingInterpreter.h" namespace Konclude { namespace Control { namespace Interface { namespace SPARQL { CSPARQLRecordResultStreamingInterpreter::CSPARQLRecordResultStreamingInterpreter(CSPARQLStreamingWriter* resultStreamingWriter, CCommandDelegater *commandDelegater, CConfiguration* config) : CCommandRecorder() { mResultStreamingWriter = resultStreamingWriter; mConfBufferSize = 104857600; mDelegater = commandDelegater; mCurrentProcessingSeqNumber = 0; mConfig = config; mConfBufferSize = CConfigDataReader::readConfigInteger(mConfig, "Konclude.SPARQL.Serialization.ChunkEncodingSize", 104857600); mNextSeqNumber = 0; } CSPARQLRecordResultStreamingInterpreter::~CSPARQLRecordResultStreamingInterpreter() { } CCommandDelegater *CSPARQLRecordResultStreamingInterpreter::delegateCommand(CCommand *command) { CCalculateQueryCommand* calcQueryCommand = dynamic_cast(command); if (calcQueryCommand) { mSeqSyncMutex.lock(); cint64 sequenceNumber = mNextSeqNumber++; CQueryCommandProvider* queryProvider = calcQueryCommand->getQueryCommandProvider(); CSPARQLResultStreamingData* data = nullptr; if (queryProvider) { data = new CSPARQLResultStreamingData(queryProvider, sequenceNumber, mConfBufferSize, this); } else { data = new CSPARQLResultStreamingData(calcQueryCommand->getQuery(), sequenceNumber, mConfBufferSize, this); } calcQueryCommand->setQueryCommandProvider(data); mCommandSequenceDataHash.insert(command, data); mSequenceDataHash.insert(sequenceNumber, data); mSeqSyncMutex.unlock(); } if (mDelegater) { mDelegater->delegateCommand(command); } return this; } bool CSPARQLRecordResultStreamingInterpreter::notifyWriteRequest(cint64 sequenceNumber) { bool continueWriting = true; if (mCurrentProcessingSeqNumber == sequenceNumber) { CSPARQLResultStreamingData* seqData = mSequenceDataHash.value(sequenceNumber); continueWriting = writeStreamingData(seqData, false); } return continueWriting; } bool CSPARQLRecordResultStreamingInterpreter::writeStreamingData(CSPARQLResultStreamingData* seqData, bool lastData) { QList bufferList = seqData->takeWriteableBuffers(); bool continueWriting = true; if (mResultStreamingWriter) { continueWriting &= mResultStreamingWriter->writeStreamData(bufferList, lastData); } else { continueWriting = false; } return continueWriting; } bool CSPARQLRecordResultStreamingInterpreter::canWrite() { return mResultStreamingWriter != nullptr; } CCommandRecorder* CSPARQLRecordResultStreamingInterpreter::recordData(CCommandRecordData *recData) { CCommandRecorder::recordData(recData); if (dynamic_cast(recData)) { if (recData) { CCommand *command = recData->getCommand(); if (command) { if (mCommandSequenceDataHash.contains(command)) { CCalculateQueryCommand *calcQueryCommand = dynamic_cast(command); if (calcQueryCommand) { CQuery *query = calcQueryCommand->getQuery(); CSPARQLResultStreamingData* seqData = mCommandSequenceDataHash.value(command); if (command->getMaxErrorLevel() <= 0) { if (query) { if (query->hasError()) { QString errorString = query->getErrorStringList().join(" "); seqData->handleQueryError(query, errorString); } else { CQueryResult* queryResult = query->getQueryResult(); seqData->handleQueryResult(query, queryResult); } } } else { QString errorString = getErrorString(recData, "Error"); seqData->handleQueryError(query, errorString); } seqData->finalize(); writeStreamingData(seqData, true); mSeqSyncMutex.lock(); mSequenceDataHash.remove(seqData->getSequenceNumber()); mCommandSequenceDataHash.remove(command); mCurrentProcessingSeqNumber = seqData->getSequenceNumber() + 1; delete seqData; mSeqSyncMutex.unlock(); } else { if (command->getMaxErrorLevel() > 0) { QString errorString = getErrorString(recData, "Error"); //TODO: report error to stream writer } } } } } } return this; } QString CSPARQLRecordResultStreamingInterpreter::getErrorString(CCommandRecordData *recData, const QString &nodeString) { QString errorText; if (recData) { errorText = QString("An error has occurred while processing '%1',\n%2 process protocol:\n").arg(recData->getCommand()->getBriefCommandDescription()).arg(nodeString); CCommandRecordData *nextRecData = recData; while (nextRecData) { errorText += QString("{%3}, [%1]:%2\n").arg(nextRecData->getRecordDomain()).arg(nextRecData->getRecordMessage()).arg(getErrorLevelString(nextRecData->getRecordErrorLevel())); nextRecData = nextRecData->getNextCommandRecordData(); } CCommand *command = recData->getCommand(); CLinker *subCommIt = command->getSubCommandLinker(); QString subNodeString = QString("Sub-%1").arg(nodeString); while (subCommIt) { CCommand *subCommand = subCommIt->getData(); if (subCommand->getMaxErrorLevel() > 0) { CCommandRecordData *subCommandRecData = subCommand->getRecordData(); if (subCommandRecData) { QString subErrorString = QString("{%1}, %2").arg(getErrorLevelString(subCommand->getMaxErrorLevel())).arg(getErrorString(subCommandRecData, subNodeString)); errorText += subErrorString; } } subCommIt = subCommIt->getNext(); } } else { errorText = QString("An error has occurred while processing, process interface not available"); } return errorText; } QString CSPARQLRecordResultStreamingInterpreter::getErrorLevelString(double level) { QString logLevelString; if (level >= 90) { logLevelString = "catastrophic error"; } else if (level >= 80) { logLevelString = "exception error"; } else if (level >= 70) { logLevelString = "error"; } else if (level >= 60) { logLevelString = "warning"; } else if (level >= 30) { logLevelString = "info"; } else { logLevelString = "notice"; } return logLevelString; } }; // end namespace SPARQL }; // end namespace Interface }; // end namespace Control }; // end namespace Konclude