/* * 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 "CSPARQLHttpConnectionHandlerProcessor.h" namespace Konclude { namespace Control { namespace Interface { namespace SPARQL { CSPARQLHttpConnectionHandlerProcessor::CSPARQLHttpConnectionHandlerProcessor(CConfiguration* loaderConfig, CQtHttpConnectionHandlerReleaser* releaser) : COWLlinkProcessor(false) { mReleaser = releaser; mLoaderConfig = loaderConfig; reasonerCommander = CConfigManagerReader::readCommanderManagerConfig(mLoaderConfig); mSocket = nullptr; mQueued = false; mForceDisconnect = CConfigDataReader::readConfigBoolean(mLoaderConfig,"Konclude.SPARQL.Server.ForceDisconnectAfterProcessing",false); mProcessingCommand = nullptr; startThread(); mThreadStartedSemaphore.acquire(1); mOriginPreSynchronizer = preSynchronizer; mDataWritten = false; mThreadedWriting = CConfigDataReader::readConfigBoolean(mLoaderConfig, "Konclude.SPARQL.Server.ThreadedSocketWriting", true); cint64 writeBufferBlockingLimit = CConfigDataReader::readConfigInteger(mLoaderConfig, "Konclude.SPARQL.Server.WriteBufferBlockingLimit", 20); if (writeBufferBlockingLimit > 0) { mWriteLimitSemaphore = new QSemaphore(writeBufferBlockingLimit); } else { mWriteLimitSemaphore = nullptr; } mBlockingWarned = false; mStreamSPARQLHeader = QString("\r\n").toLocal8Bit(); mStreamSPARQLFooter = QString("\r\n").toLocal8Bit(); mWrittenContinueSemaphore = nullptr; if (!mThreadedWriting) { mWrittenContinueSemaphore = new QSemaphore(); } } CSPARQLHttpConnectionHandlerProcessor::~CSPARQLHttpConnectionHandlerProcessor() { } void CSPARQLHttpConnectionHandlerProcessor::threadStarted() { COWLlinkProcessor::threadStarted(); mParser = new CQtHttpRequestBodyOnlyParser(); mSocket = new QTcpSocket(); mSocket->moveToThread(this); mProcessingRequest = false; mProcessMoreRead = false; connect(mSocket,SIGNAL(readyRead()),this,SLOT(connectionRead())); connect(mSocket,SIGNAL(disconnected()),this,SLOT(connectionDisconnect())); mThreadStartedSemaphore.release(1); } void CSPARQLHttpConnectionHandlerProcessor::threadStopped() { COWLlinkProcessor::threadStopped(); mSocket->close(); delete mSocket; delete mParser; if (mWriteLimitSemaphore) { delete mWriteLimitSemaphore; } if (mWrittenContinueSemaphore) { delete mWrittenContinueSemaphore; } } bool CSPARQLHttpConnectionHandlerProcessor::handleIncomingConnection(int socketDescriptor) { postEvent(new CHandleIncomingHttpConnectionEvent(socketDescriptor)); return true; } bool CSPARQLHttpConnectionHandlerProcessor::isHandlerQueued() { return mQueued; } CSPARQLHttpConnectionHandlerProcessor* CSPARQLHttpConnectionHandlerProcessor::setHandlerQueued(bool queued) { mQueued = queued; return this; } bool CSPARQLHttpConnectionHandlerProcessor::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { if (COWLlinkProcessor::processCustomsEvents(type,event)) { return true; } else { if (type == CConnectionReadyReadEvent::EVENTTYPE) { CConnectionReadyReadEvent* crre = (CConnectionReadyReadEvent*)event; if (!mProcessingRequest) { if (!mParser->readFromDevice(mSocket)) { // error QString errorString = QString("HTTP/1.1 400 error parsing request\r\nConnection: close\r\n\r\n400 Parsing error: %1\r\n").arg(mParser->getHttpRequestParsingErrorString()); LOG(INFO,"::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor",logTr("Error parsing HTTP request, '%1'.").arg(mParser->getHttpRequestParsingErrorString()),this); mSocket->write(errorString.toLocal8Bit()); mSocket->disconnectFromHost(); } if (mParser->hasHttpRequestParsingCompleted()) { mProcessingRequest = true; mProcessingByteArray = mParser->takeBodyData(); if (mProcessingByteArray != 0) { LOG(INFO,"::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor",logTr("HTTP request successfully parsed, %1 Bytes received.").arg(mProcessingByteArray->count()),this); mSPARQLInterpreter = new CSPARQLRecordResultStreamingInterpreter(this, mOriginPreSynchronizer, mLoaderConfig); mWritingStarted = false; mWritingFailed = false; mDataWritten = false; mChunkPart = 0; defaultCommandDelegater = mSPARQLInterpreter; preSynchronizer = new CPreconditionSynchronizer(mSPARQLInterpreter); QString dataString = QString::fromUtf8(mProcessingByteArray->data()); CParseProcessSPARQLTextCommand* parseProcSPARQLCommand = new CParseProcessSPARQLTextCommand(dataString); CCommandProcessedCallbackEvent *proComm = new CCommandProcessedCallbackEvent(this, parseProcSPARQLCommand); parseProcSPARQLCommand->setRecorder(mSPARQLInterpreter); mProcessingCommand = parseProcSPARQLCommand; defaultCommandDelegater->delegateCommand(parseProcSPARQLCommand); parseProcSPARQLCommand->addProcessedCallback(proComm); delete mProcessingByteArray; } else { // invalid request QString koncludeString = QString("%1 %2").arg(CKoncludeInfo::getKoncludeName()).arg(CKoncludeInfo::getKoncludeVersionString()); sendData(QString("

%1 SPARQL Sever

This response is generated from Konclude's SPARQL server for invalid SPARQL requests. Please make sure that the SPARQL request is appended as content (with correct Content-Length) of your HTTP request. See konclude.com for help and further information.

").arg(koncludeString).toLocal8Bit()); mProcessingRequest = false; if (mForceDisconnect || mParser->hasRequestedCloseConnection()) { mSocket->disconnectFromHost(); } else if (mProcessMoreRead) { mProcessMoreRead = false; connectionRead(); } mParser->reset(); } } } return true; } else if (type == CConnectionDisconnectedEvent::EVENTTYPE) { CConnectionDisconnectedEvent* cde = (CConnectionDisconnectedEvent*)event; mParser->reset(); mProcessMoreRead = false; if (!mProcessingRequest) { mHandlerBusy = false; } mReleaser->releaseConnectionHandler(this); return true; } else if (type == CHandleIncomingHttpConnectionEvent::EVENTTYPE) { CHandleIncomingHttpConnectionEvent* hihc = (CHandleIncomingHttpConnectionEvent*)event; cint64 socketDescriptor = hihc->getSocketDescriptor(); LOG(INFO,"::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor",logTr("Start processing new incoming connection."),this); mSocket->setSocketDescriptor(socketDescriptor); mHandlerBusy = true; return true; } else if (type == CResultStreamingWriteEvent::EVENTTYPE) { CResultStreamingWriteEvent* rswe = (CResultStreamingWriteEvent*)event; QList* bufferList = rswe->getBufferList(); bool last = rswe->isLast(); writeStreamDataToSocket(bufferList, last); mWriteLimitSemaphore->release(1); if (mWrittenContinueSemaphore) { mWrittenContinueSemaphore->release(1); } mDataWritten = true; return true; } } return false; } COWLlinkProcessor* CSPARQLHttpConnectionHandlerProcessor::initializeOWLlinkContent() { return this; } CSPARQLStreamingWriter* CSPARQLHttpConnectionHandlerProcessor::writeChunk(const QByteArray& byteArray) { QString chunckHeader = QString::number(byteArray.length(), 16) + "\r\n"; mSocket->write(chunckHeader.toLocal8Bit()); mSocket->write(byteArray); mSocket->write(QString("\r\n").toLocal8Bit()); return this; } bool CSPARQLHttpConnectionHandlerProcessor::writeStreamData(const QList& bufferList, bool last) { if (mWriteLimitSemaphore) { if (!mBlockingWarned && mWriteLimitSemaphore->available() <= 2) { mBlockingWarned = true; LOG(WARN, "::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor", logTr("Result sending buffer limit almost reached, result generation may be blocked due to slow network connection."), this); } mWriteLimitSemaphore->acquire(1); } postEvent(new CResultStreamingWriteEvent(bufferList, last)); if (!mThreadedWriting && mWrittenContinueSemaphore) { mWrittenContinueSemaphore->acquire(); } //writeStreamDataToSocket(buffer, last); //mDataWritten = true; return !mWritingFailed; } CSPARQLStreamingWriter* CSPARQLHttpConnectionHandlerProcessor::writeStreamDataToSocket(QList* bufferList, bool last) { if (mSocket->state() == QTcpSocket::ConnectedState) { if (!mWritingStarted && last && bufferList->size() == 1) { CSPARQLResultBufferWriteData bufferData = bufferList->first(); for (cint64 i = bufferData.getWriteCount(); i > 0; --i) { sendData(*bufferData.getBuffer()); } delete bufferData.getBuffer(); } else { ++mChunkPart; // write with chunked encoding bool firstChunk = false; if (!mWritingStarted) { mWritingStarted = true; QString connectionString = QString("Connection: "); if (mParser->hasRequestedCloseConnection()) { connectionString += QString("close"); } else { connectionString += QString("keep-alive"); } QString serverString = QString("Server: %1 %2").arg(CKoncludeInfo::getKoncludeName()).arg(CKoncludeInfo::getKoncludeVersionString()); QString responseHeadString = QString("HTTP/1.1 200 OK\r\n%1\r\n%2\r\nTransfer-Encoding: chunked\r\n\r\n").arg(serverString).arg(connectionString); mSocket->write(responseHeadString.toLocal8Bit()); writeChunk(mStreamSPARQLHeader); mSocket->flush(); firstChunk = true; } cint64 bufferSize = 0; for (CSPARQLResultBufferWriteData bufferData : *bufferList) { for (cint64 i = bufferData.getWriteCount(); i > 0; --i) { writeChunk(*bufferData.getBuffer()); bufferSize += bufferData.getBuffer()->size(); } delete bufferData.getBuffer(); } mSocket->flush(); if (last) { writeChunk(mStreamSPARQLFooter); writeChunk(QByteArray()); mSocket->flush(); LOG(INFO, "::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor", logTr("HTTP request successfully processed, last part of %1 with %2 bytes sent.").arg(mChunkPart).arg(bufferSize), this); } else { LOG(INFO, "::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor", logTr("Sending part %1 with %2 bytes of HTTP response via chunked encoding.").arg(mChunkPart).arg(bufferSize), this); } } } else { mWritingFailed = true; LOG(INFO, "::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor", logTr("Cannot write HTTP response data since connection already closed."), this); } return this; } COWLlinkProcessor* CSPARQLHttpConnectionHandlerProcessor::sendData(const QByteArray& dataArray) { if (mSocket->state() == QTcpSocket::ConnectedState) { QString connectionString = QString("Connection: "); if (mParser->hasRequestedCloseConnection()) { connectionString += QString("close"); } else { connectionString += QString("keep-alive"); } cint64 contentLength = dataArray.length(); if (contentLength > 0) { contentLength += mStreamSPARQLHeader.length(); contentLength += mStreamSPARQLFooter.length(); } QString serverString = QString("Server: %1 %2").arg(CKoncludeInfo::getKoncludeName()).arg(CKoncludeInfo::getKoncludeVersionString()); QString responseHeadString = QString("HTTP/1.1 200 OK\r\n%1\r\n%2\r\nContent-Length: %3\r\n\r\n").arg(serverString).arg(connectionString).arg(contentLength); mSocket->write(responseHeadString.toLocal8Bit()); if (contentLength > 0) { mSocket->write(mStreamSPARQLHeader); mSocket->write(dataArray); mSocket->write(mStreamSPARQLFooter); } mSocket->flush(); LOG(INFO,"::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor",logTr("HTTP request successfully processed, %1 bytes sent.").arg(contentLength),this); } else { LOG(INFO,"::Konclude::Control::Interface::SPARQL::SPARQLHTTPConnectionProcessor",logTr("HTTP request successfully processed, but connection already closed."),this); } return this; } COWLlinkProcessor* CSPARQLHttpConnectionHandlerProcessor::concludeOWLlinkContent() { if (!mDataWritten) { mDataWritten = true; sendData(QByteArray()); } delete mSPARQLInterpreter; delete mProcessingCommand; mProcessingCommand = nullptr; mSPARQLInterpreter = nullptr; mProcessingRequest = false; if (mForceDisconnect || mParser->hasRequestedCloseConnection()) { mSocket->disconnectFromHost(); } else if (mProcessMoreRead) { mProcessMoreRead = false; connectionRead(); } mParser->reset(); return this; } void CSPARQLHttpConnectionHandlerProcessor::connectionRead() { postEvent(new CConnectionReadyReadEvent()); } void CSPARQLHttpConnectionHandlerProcessor::connectionDisconnect() { postEvent(new CConnectionDisconnectedEvent()); } CConfiguration* CSPARQLHttpConnectionHandlerProcessor::getConfiguration() { if (!reasonerCommander) { return mLoaderConfig; } else { CGetDescriptionCommand *getDesComm = new CGetDescriptionCommand(); reasonerCommander->delegateCommand(getDesComm); CCommandExecutedBlocker commExeBlocker; commExeBlocker.waitExecutedCommand(getDesComm); CConfiguration *config = getDesComm->getConfiguration(); return config; } } }; // end namespace SPARQL }; // end namespace Interface }; // end namespace Control }; // end namespace Konclude