/* * 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 "CQtHttpTransactionManager.h" namespace Konclude { namespace Network { namespace HTTP { CQtHttpTransactionManager::CQtHttpTransactionManager(cint64 timeoutInterval, cint64 downloadSizeLimit, bool downloadLimitCancel) : CIntervalThread("HttpTransactionManagerThread") { mQNAM = nullptr; startThread(); mTimeoutInterval = timeoutInterval; mDownloadSizeLimit = downloadSizeLimit; mDownloadLimitCancel = downloadLimitCancel; } CQtHttpTransactionManager::~CQtHttpTransactionManager() { } CHttpRequest* CQtHttpTransactionManager::createRequest(const QString& url) { CQtHttpRequest* httpRequest = new CQtHttpRequest(url); return httpRequest; } CQtHttpTransactionManager* CQtHttpTransactionManager::setRequestHeader(CHttpRequest* request, const QString& key, const QString& value) { CQtHttpRequest* qtRequest = dynamic_cast(request); if (qtRequest) { qtRequest->getQNetworkRequest()->setRawHeader(key.toUtf8(), value.toUtf8()); } return this; } //CHttpRequest* CQtHttpTransactionManager::createFileDownloadRequest(const QString& url, QIODevice* openWriteFile) { // CQtHttpDownloadFileRequest* httpRequest = new CQtHttpDownloadFileRequest(url); // return httpRequest; //} CHttpRequest* CQtHttpTransactionManager::createRequest(const QString& url, const QByteArray& byteArray) { CQtHttpRequest* httpRequest = new CQtHttpRequest(url,new QByteArray(byteArray)); return httpRequest; } bool CQtHttpTransactionManager::releaseResponse(CHttpResponse* response, bool releaseAlsoRequest) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { CReleaseResponseEvent* responseEvent = new CReleaseResponseEvent(qtResponse,releaseAlsoRequest); postEvent(responseEvent); return true; } return false; } bool CQtHttpTransactionManager::abort(CHttpRequest* request, CHttpResponse* response, ABORT_REASON abortReason) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { CAbortRequestEvent* abortEvent = new CAbortRequestEvent(request, response, (cint64)abortReason); postEvent(abortEvent); return true; } return false; } CHttpResponse* CQtHttpTransactionManager::getResponse(CHttpRequest* request) { if (request) { CQtHttpRequest* qtRequest = dynamic_cast(request); return getResponse(qtRequest); } return nullptr; } CQtHttpResponse* CQtHttpTransactionManager::getResponse(CQtHttpRequest* request) { if (request) { CQtHttpResponse* response = new CQtHttpResponse(request); postEvent(new CHttpRequstEvent(request,response)); return response; } return nullptr; } bool CQtHttpTransactionManager::callbackFinishedRequest(CHttpResponse* response, CCallbackData* callbackData) { return callbackFinished(response,callbackData); } bool CQtHttpTransactionManager::callbackFinished(CHttpResponse* response, CCallbackData* callback) { if (response) { CQtHttpResponse* qtResponse = dynamic_cast(response); return callbackFinished(qtResponse,callback); } return false; } bool CQtHttpTransactionManager::waitFinished(CHttpResponse* response) { if (hasFinished(response)) { return true; } else { CBlockingCallbackData blockingCallbackData; callbackFinished(response, &blockingCallbackData); blockingCallbackData.waitForCallback(); return true; } } bool CQtHttpTransactionManager::callbackFinished(CQtHttpResponse* response, CCallbackData* callback) { postEvent(new CAddResponseFinishedCallbackEvent(response,callback)); return true; } void CQtHttpTransactionManager::finishedNetworkReply(QNetworkReply* reply) { QNetworkReply::NetworkError error = reply->error(); if (error) { QString errorString = reply->errorString(); LOG(WARNING,"::Konclude::Network::HTTP::QtHttpTransactionManager",logTr("HTTP-Error: %1").arg(errorString),this); } postEvent(new CHttpReplyFinishedEvent(reply)); } QIODevice* CQtHttpTransactionManager::getResponseDataReadDevice(CHttpResponse* response) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { return qtResponse->getQNetworkReply(); } return nullptr; } QString* CQtHttpTransactionManager::getExtractedText(CHttpResponse *response) { QString* text = nullptr; CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { QByteArray data; CBlockingCallbackData blockCallback; postEvent(new CExtractResponseDataEvent(qtResponse,&data,&blockCallback)); blockCallback.waitForCallback(); text = new QString(data); } return text; } QByteArray* CQtHttpTransactionManager::getResponseData(CHttpResponse* response) { QByteArray* data = nullptr; CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { data = new QByteArray(); CBlockingCallbackData blockCallback; postEvent(new CExtractResponseDataEvent(qtResponse,data,&blockCallback)); blockCallback.waitForCallback(); } return data; } bool CQtHttpTransactionManager::callbackResponseData(CHttpResponse* response, QByteArray* dataArray, CCallbackData* callback) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { postEvent(new CExtractResponseDataEvent(qtResponse,dataArray,callback)); return true; } return false; } QString* CQtHttpTransactionManager::getErrorString(CHttpResponse* response) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { QNetworkReply* reply = qtResponse->getQNetworkReply(); if (reply) { QString errorString = reply->errorString(); if (!errorString.isEmpty()) { return new QString(errorString); } } } return nullptr; } bool CQtHttpTransactionManager::hasFinishedSucecssfully(CHttpResponse* response) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { QNetworkReply* reply = qtResponse->getQNetworkReply(); if (reply) { //QString errorString = reply->errorString(); if (reply->isFinished() && reply->error() == QNetworkReply::NoError) { return true; } } } return false; } bool CQtHttpTransactionManager::hasFinished(CHttpResponse* response) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { QNetworkReply* reply = qtResponse->getQNetworkReply(); if (reply) { //QString errorString = reply->errorString(); if (reply->isFinished()) { return true; } } } return false; } bool CQtHttpTransactionManager::hasBeenAborted(CHttpResponse* response, ABORT_REASON* abortReason) { CQtHttpResponse* qtResponse = dynamic_cast(response); if (qtResponse) { if (qtResponse->isAborted()) { if (abortReason) { *abortReason = (ABORT_REASON)qtResponse->getAbortReason(); } return true; } } return false; } void CQtHttpTransactionManager::threadStarted() { CThread::threadStarted(); mQNAM = new QNetworkAccessManager(); connect(mQNAM,SIGNAL(finished(QNetworkReply*)),this,SLOT(finishedNetworkReply(QNetworkReply*))); // default is 5 minutes timeout startTimerWithInterval(TIMEOUTCHECKTIMER,mTimeoutInterval); } void CQtHttpTransactionManager::threadStopped() { CThread::threadStopped(); disconnect(mQNAM); delete mQNAM; } bool CQtHttpTransactionManager::processTimer(qint64 timerID) { if (timerID == TIMEOUTCHECKTIMER) { // timeouts foreach (CQtHttpResponse* response, mCriticalTimeoutSet) { response->getFinishedCallbackList()->doCallback(); mTimeoutSet.insert(response); mReplyResponseHash.remove(response->getQNetworkReply()); } mCriticalTimeoutSet.clear(); mCriticalTimeoutSet = mNextTimeoutSet; mNextTimeoutSet.clear(); return true; } return false; } bool CQtHttpTransactionManager::processCustomsEvents(QEvent::Type type, CCustomEvent *event) { if (CThread::processCustomsEvents(type,event)) { return true; } else if (type == CHttpRequstEvent::EVENTTYPE) { CHttpRequstEvent* hre = (CHttpRequstEvent*)event; CQtHttpRequest* request = hre->getRequest(); QByteArray* byteArray = request->getByteArrayData(); CQtHttpResponse* response = hre->getResponse(); QNetworkReply* reply = nullptr; if (!byteArray) { reply = mQNAM->get(*request->getQNetworkRequest()); } else { reply = mQNAM->post(*request->getQNetworkRequest(),*byteArray); } if (mDownloadSizeLimit >= 0) { CQtHttpResponseHandler* handler = new CQtHttpResponseHandler(request, response, mDownloadSizeLimit, mDownloadLimitCancel, this); mHandlerHash.insert(response, handler); connect(reply, &QNetworkReply::downloadProgress, [=](cint64 received, cint64 total) { handler->downloadProgress(received, total); }); } mReplyResponseHash.insert(reply,response); mNextTimeoutSet.insert(response); response->setQNetworkReply(reply); return true; } else if (type == CHttpReplyFinishedEvent::EVENTTYPE) { CHttpReplyFinishedEvent* hrfe = (CHttpReplyFinishedEvent*)event; QNetworkReply* reply = hrfe->getReply(); CQtHttpResponse* response = mReplyResponseHash.value(reply); bool tryAgain = false; if (response) { //if (reply->error() == QNetworkReply::ProtocolUnknownError) { // tryAgain = true; //} if (tryAgain) { CQtHttpRequest* request = response->getHttpRequest(); QByteArray* byteArray = request->getByteArrayData(); QNetworkReply* reply = nullptr; if (!byteArray) { reply = mQNAM->get(*request->getQNetworkRequest()); } else { reply = mQNAM->post(*request->getQNetworkRequest(),*byteArray); } mReplyResponseHash.insert(reply,response); response->setQNetworkReply(reply); } else { response->getFinishedCallbackList()->doCallback(); mCriticalTimeoutSet.remove(response); mNextTimeoutSet.remove(response); mReplyResponseHash.remove(reply); } } return true; } else if (type == CExtractResponseDataEvent::EVENTTYPE) { CExtractResponseDataEvent* erte = (CExtractResponseDataEvent*)event; CQtHttpResponse* response = erte->getResponse(); CExtractResponseDataCallbackEvent* ertce = new CExtractResponseDataCallbackEvent(this,response,erte->getDataPointer(),erte->getCallbacks()); response->getFinishedCallbackList()->addCallbacks(ertce); return true; } else if (type == CAddResponseFinishedCallbackEvent::EVENTTYPE) { CAddResponseFinishedCallbackEvent* erte = (CAddResponseFinishedCallbackEvent*)event; CQtHttpResponse* response = erte->getResponse(); response->getFinishedCallbackList()->addCallbacks(erte->getCallbacks()); return true; } else if (type == CExtractResponseDataCallbackEvent::EVENTTYPE) { CExtractResponseDataCallbackEvent* ertce = (CExtractResponseDataCallbackEvent*)event; CQtHttpResponse* response = ertce->getResponse(); QByteArray* dataArray = ertce->getDataPointer(); if (response && dataArray && hasFinishedSucecssfully(response)) { QNetworkReply* reply = response->getQNetworkReply(); *dataArray = reply->readAll(); } CCallbackData* callbackIt = ertce->getCallbacks(); while (callbackIt) { CCallbackData* callback = callbackIt; callbackIt = callbackIt->getNext(); callback->doCallback(); } return true; } else if (type == CReleaseResponseEvent::EVENTTYPE) { CReleaseResponseEvent* rre = (CReleaseResponseEvent*)event; bool releaseAlsoRequest = rre->getReleaseAccordingRequest(); CQtHttpResponse* response = (CQtHttpResponse*)rre->getResponse(); response->getQNetworkReply()->deleteLater(); CQtHttpResponseHandler* handler = mHandlerHash.value(response); if (handler) { delete handler; mHandlerHash.remove(response); } mReplyResponseHash.remove(response->getQNetworkReply()); mCriticalTimeoutSet.remove(response); mNextTimeoutSet.remove(response); if (releaseAlsoRequest) { delete response->getHttpRequest(); } delete response; return true; } else if (type == CAbortRequestEvent::EVENTTYPE) { CAbortRequestEvent* are = (CAbortRequestEvent*)event; CQtHttpResponse* response = (CQtHttpResponse*)are->getResponse(); response->setAborted(are->getAbortReason()); QString abortReasonString = "none given"; ABORT_REASON abortReason = (ABORT_REASON)are->getAbortReason(); if (abortReason == ABORT_DOWNLOAD_SIZE_LIMIT_REACHED) { abortReasonString = QString("Download size limit of %1 bytes reached").arg(mDownloadSizeLimit); if (mDownloadLimitCancel) { LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("HTTP request aborted with reason: %1").arg(abortReasonString), this); response->getQNetworkReply()->abort(); } else { LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("Deleting download stream due to reason: %1").arg(abortReasonString), this); } } else { LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("HTTP request aborted with reason: %1").arg(abortReasonString), this); response->getQNetworkReply()->abort(); } return true; } return false; } }; // end namespace HTTP }; // end namespace Network }; // end namespace Konclude