Debian Codegraph @

Source/Network/HTTP/CQtHttpTransactionManager.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CQtHttpTransactionManager.h"
22
23
24 namespace Konclude {
25
26 namespace Network {
27
28 namespace HTTP {
29
30 CQtHttpTransactionManager::CQtHttpTransactionManager(cint64 timeoutInterval, cint64 downloadSizeLimit, bool downloadLimitCancel) : CIntervalThread("HttpTransactionManagerThread") {
31 mQNAM = nullptr;
32 startThread();
33 mTimeoutInterval = timeoutInterval;
34 mDownloadSizeLimit = downloadSizeLimit;
35 mDownloadLimitCancel = downloadLimitCancel;
36 }
37
38 CQtHttpTransactionManager::~CQtHttpTransactionManager() {
39 }
40
41
42 CHttpRequest* CQtHttpTransactionManager::createRequest(const QString& url) {
43 CQtHttpRequest* httpRequest = new CQtHttpRequest(url);
44 return httpRequest;
45 }
46
47
48 CQtHttpTransactionManager* CQtHttpTransactionManager::setRequestHeader(CHttpRequest* request, const QString& key, const QString& value) {
49 CQtHttpRequest* qtRequest = dynamic_cast<CQtHttpRequest*>(request);
50 if (qtRequest) {
51 qtRequest->getQNetworkRequest()->setRawHeader(key.toUtf8(), value.toUtf8());
52 }
53 return this;
54 }
55
56
57 //CHttpRequest* CQtHttpTransactionManager::createFileDownloadRequest(const QString& url, QIODevice* openWriteFile) {
58 // CQtHttpDownloadFileRequest* httpRequest = new CQtHttpDownloadFileRequest(url);
59 // return httpRequest;
60 //}
61
62
63 CHttpRequest* CQtHttpTransactionManager::createRequest(const QString& url, const QByteArray& byteArray) {
64 CQtHttpRequest* httpRequest = new CQtHttpRequest(url,new QByteArray(byteArray));
65 return httpRequest;
66 }
67
68
69 bool CQtHttpTransactionManager::releaseResponse(CHttpResponse* response, bool releaseAlsoRequest) {
70 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
71 if (qtResponse) {
72 CReleaseResponseEvent* responseEvent = new CReleaseResponseEvent(qtResponse,releaseAlsoRequest);
73 postEvent(responseEvent);
74 return true;
75 }
76 return false;
77 }
78
79
80 bool CQtHttpTransactionManager::abort(CHttpRequest* request, CHttpResponse* response, ABORT_REASON abortReason) {
81 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
82 if (qtResponse) {
83 CAbortRequestEvent* abortEvent = new CAbortRequestEvent(request, response, (cint64)abortReason);
84 postEvent(abortEvent);
85 return true;
86 }
87 return false;
88 }
89
90
91 CHttpResponse* CQtHttpTransactionManager::getResponse(CHttpRequest* request) {
92 if (request) {
93 CQtHttpRequest* qtRequest = dynamic_cast<CQtHttpRequest*>(request);
94 return getResponse(qtRequest);
95 }
96 return nullptr;
97 }
98
99 CQtHttpResponse* CQtHttpTransactionManager::getResponse(CQtHttpRequest* request) {
100 if (request) {
101 CQtHttpResponse* response = new CQtHttpResponse(request);
102 postEvent(new CHttpRequstEvent(request,response));
103 return response;
104 }
105 return nullptr;
106 }
107
108
109 bool CQtHttpTransactionManager::callbackFinishedRequest(CHttpResponse* response, CCallbackData* callbackData) {
110 return callbackFinished(response,callbackData);
111 }
112
113
114 bool CQtHttpTransactionManager::callbackFinished(CHttpResponse* response, CCallbackData* callback) {
115 if (response) {
116 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
117 return callbackFinished(qtResponse,callback);
118 }
119 return false;
120 }
121
122
123
124 bool CQtHttpTransactionManager::waitFinished(CHttpResponse* response) {
125 if (hasFinished(response)) {
126 return true;
127 } else {
128 CBlockingCallbackData blockingCallbackData;
129 callbackFinished(response, &blockingCallbackData);
130 blockingCallbackData.waitForCallback();
131 return true;
132 }
133 }
134
135
136
137 bool CQtHttpTransactionManager::callbackFinished(CQtHttpResponse* response, CCallbackData* callback) {
138 postEvent(new CAddResponseFinishedCallbackEvent(response,callback));
139 return true;
140 }
141
142
143 void CQtHttpTransactionManager::finishedNetworkReply(QNetworkReply* reply) {
144 QNetworkReply::NetworkError error = reply->error();
145 if (error) {
146 QString errorString = reply->errorString();
147 LOG(WARNING,"::Konclude::Network::HTTP::QtHttpTransactionManager",logTr("HTTP-Error: %1").arg(errorString),this);
148 }
149 postEvent(new CHttpReplyFinishedEvent(reply));
150 }
151
152
153
154 QIODevice* CQtHttpTransactionManager::getResponseDataReadDevice(CHttpResponse* response) {
155 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
156 if (qtResponse) {
157 return qtResponse->getQNetworkReply();
158 }
159 return nullptr;
160 }
161
162 QString* CQtHttpTransactionManager::getExtractedText(CHttpResponse *response) {
163 QString* text = nullptr;
164 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
165 if (qtResponse) {
166 QByteArray data;
167 CBlockingCallbackData blockCallback;
168 postEvent(new CExtractResponseDataEvent(qtResponse,&data,&blockCallback));
169 blockCallback.waitForCallback();
170 text = new QString(data);
171 }
172 return text;
173 }
174
175
176 QByteArray* CQtHttpTransactionManager::getResponseData(CHttpResponse* response) {
177 QByteArray* data = nullptr;
178 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
179 if (qtResponse) {
180 data = new QByteArray();
181 CBlockingCallbackData blockCallback;
182 postEvent(new CExtractResponseDataEvent(qtResponse,data,&blockCallback));
183 blockCallback.waitForCallback();
184 }
185 return data;
186
187 }
188
189
190 bool CQtHttpTransactionManager::callbackResponseData(CHttpResponse* response, QByteArray* dataArray, CCallbackData* callback) {
191 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
192 if (qtResponse) {
193 postEvent(new CExtractResponseDataEvent(qtResponse,dataArray,callback));
194 return true;
195 }
196 return false;
197 }
198
199
200 QString* CQtHttpTransactionManager::getErrorString(CHttpResponse* response) {
201 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
202 if (qtResponse) {
203 QNetworkReply* reply = qtResponse->getQNetworkReply();
204 if (reply) {
205 QString errorString = reply->errorString();
206 if (!errorString.isEmpty()) {
207 return new QString(errorString);
208 }
209 }
210 }
211 return nullptr;
212 }
213
214
215 bool CQtHttpTransactionManager::hasFinishedSucecssfully(CHttpResponse* response) {
216 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
217 if (qtResponse) {
218 QNetworkReply* reply = qtResponse->getQNetworkReply();
219 if (reply) {
220 //QString errorString = reply->errorString();
221 if (reply->isFinished() && reply->error() == QNetworkReply::NoError) {
222 return true;
223 }
224 }
225 }
226 return false;
227 }
228
229
230
231 bool CQtHttpTransactionManager::hasFinished(CHttpResponse* response) {
232 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
233 if (qtResponse) {
234 QNetworkReply* reply = qtResponse->getQNetworkReply();
235 if (reply) {
236 //QString errorString = reply->errorString();
237 if (reply->isFinished()) {
238 return true;
239 }
240 }
241 }
242 return false;
243 }
244
245 bool CQtHttpTransactionManager::hasBeenAborted(CHttpResponse* response, ABORT_REASON* abortReason) {
246 CQtHttpResponse* qtResponse = dynamic_cast<CQtHttpResponse*>(response);
247 if (qtResponse) {
248 if (qtResponse->isAborted()) {
249 if (abortReason) {
250 *abortReason = (ABORT_REASON)qtResponse->getAbortReason();
251 }
252 return true;
253 }
254 }
255 return false;
256 }
257
258
259
260 void CQtHttpTransactionManager::threadStarted() {
261 CThread::threadStarted();
262 mQNAM = new QNetworkAccessManager();
263 connect(mQNAM,SIGNAL(finished(QNetworkReply*)),this,SLOT(finishedNetworkReply(QNetworkReply*)));
264 // default is 5 minutes timeout
265 startTimerWithInterval(TIMEOUTCHECKTIMER,mTimeoutInterval);
266 }
267
268 void CQtHttpTransactionManager::threadStopped() {
269 CThread::threadStopped();
270 disconnect(mQNAM);
271 delete mQNAM;
272 }
273
274
275 bool CQtHttpTransactionManager::processTimer(qint64 timerID) {
276 if (timerID == TIMEOUTCHECKTIMER) {
277 // timeouts
278 foreach (CQtHttpResponse* response, mCriticalTimeoutSet) {
279 response->getFinishedCallbackList()->doCallback();
280 mTimeoutSet.insert(response);
281 mReplyResponseHash.remove(response->getQNetworkReply());
282 }
283 mCriticalTimeoutSet.clear();
284 mCriticalTimeoutSet = mNextTimeoutSet;
285 mNextTimeoutSet.clear();
286 return true;
287 }
288 return false;
289 }
290
291
292
293 bool CQtHttpTransactionManager::processCustomsEvents(QEvent::Type type, CCustomEvent *event) {
294 if (CThread::processCustomsEvents(type,event)) {
295 return true;
296 } else if (type == CHttpRequstEvent::EVENTTYPE) {
297 CHttpRequstEvent* hre = (CHttpRequstEvent*)event;
298 CQtHttpRequest* request = hre->getRequest();
299 QByteArray* byteArray = request->getByteArrayData();
300 CQtHttpResponse* response = hre->getResponse();
301
302 QNetworkReply* reply = nullptr;
303 if (!byteArray) {
304 reply = mQNAM->get(*request->getQNetworkRequest());
305 } else {
306 reply = mQNAM->post(*request->getQNetworkRequest(),*byteArray);
307 }
308 if (mDownloadSizeLimit >= 0) {
309 CQtHttpResponseHandler* handler = new CQtHttpResponseHandler(request, response, mDownloadSizeLimit, mDownloadLimitCancel, this);
310 mHandlerHash.insert(response, handler);
311 connect(reply, &QNetworkReply::downloadProgress, [=](cint64 received, cint64 total) {
312 handler->downloadProgress(received, total);
313 });
314 }
315 mReplyResponseHash.insert(reply,response);
316 mNextTimeoutSet.insert(response);
317
318 response->setQNetworkReply(reply);
319 return true;
320 } else if (type == CHttpReplyFinishedEvent::EVENTTYPE) {
321 CHttpReplyFinishedEvent* hrfe = (CHttpReplyFinishedEvent*)event;
322 QNetworkReply* reply = hrfe->getReply();
323 CQtHttpResponse* response = mReplyResponseHash.value(reply);
324 bool tryAgain = false;
325 if (response) {
326 //if (reply->error() == QNetworkReply::ProtocolUnknownError) {
327 // tryAgain = true;
328 //}
329 if (tryAgain) {
330 CQtHttpRequest* request = response->getHttpRequest();
331 QByteArray* byteArray = request->getByteArrayData();
332
333 QNetworkReply* reply = nullptr;
334 if (!byteArray) {
335 reply = mQNAM->get(*request->getQNetworkRequest());
336 } else {
337 reply = mQNAM->post(*request->getQNetworkRequest(),*byteArray);
338 }
339 mReplyResponseHash.insert(reply,response);
340 response->setQNetworkReply(reply);
341 } else {
342 response->getFinishedCallbackList()->doCallback();
343 mCriticalTimeoutSet.remove(response);
344 mNextTimeoutSet.remove(response);
345 mReplyResponseHash.remove(reply);
346 }
347 }
348 return true;
349 } else if (type == CExtractResponseDataEvent::EVENTTYPE) {
350 CExtractResponseDataEvent* erte = (CExtractResponseDataEvent*)event;
351 CQtHttpResponse* response = erte->getResponse();
352 CExtractResponseDataCallbackEvent* ertce = new CExtractResponseDataCallbackEvent(this,response,erte->getDataPointer(),erte->getCallbacks());
353 response->getFinishedCallbackList()->addCallbacks(ertce);
354 return true;
355 } else if (type == CAddResponseFinishedCallbackEvent::EVENTTYPE) {
356 CAddResponseFinishedCallbackEvent* erte = (CAddResponseFinishedCallbackEvent*)event;
357 CQtHttpResponse* response = erte->getResponse();
358 response->getFinishedCallbackList()->addCallbacks(erte->getCallbacks());
359 return true;
360 } else if (type == CExtractResponseDataCallbackEvent::EVENTTYPE) {
361 CExtractResponseDataCallbackEvent* ertce = (CExtractResponseDataCallbackEvent*)event;
362 CQtHttpResponse* response = ertce->getResponse();
363 QByteArray* dataArray = ertce->getDataPointer();
364 if (response && dataArray && hasFinishedSucecssfully(response)) {
365 QNetworkReply* reply = response->getQNetworkReply();
366 *dataArray = reply->readAll();
367 }
368 CCallbackData* callbackIt = ertce->getCallbacks();
369 while (callbackIt) {
370 CCallbackData* callback = callbackIt;
371 callbackIt = callbackIt->getNext();
372 callback->doCallback();
373 }
374 return true;
375 } else if (type == CReleaseResponseEvent::EVENTTYPE) {
376 CReleaseResponseEvent* rre = (CReleaseResponseEvent*)event;
377 bool releaseAlsoRequest = rre->getReleaseAccordingRequest();
378 CQtHttpResponse* response = (CQtHttpResponse*)rre->getResponse();
379
380 response->getQNetworkReply()->deleteLater();
381
382 CQtHttpResponseHandler* handler = mHandlerHash.value(response);
383 if (handler) {
384 delete handler;
385 mHandlerHash.remove(response);
386 }
387
388 mReplyResponseHash.remove(response->getQNetworkReply());
389 mCriticalTimeoutSet.remove(response);
390 mNextTimeoutSet.remove(response);
391 if (releaseAlsoRequest) {
392 delete response->getHttpRequest();
393 }
394
395 delete response;
396 return true;
397 } else if (type == CAbortRequestEvent::EVENTTYPE) {
398 CAbortRequestEvent* are = (CAbortRequestEvent*)event;
399 CQtHttpResponse* response = (CQtHttpResponse*)are->getResponse();
400 response->setAborted(are->getAbortReason());
401 QString abortReasonString = "none given";
402 ABORT_REASON abortReason = (ABORT_REASON)are->getAbortReason();
403 if (abortReason == ABORT_DOWNLOAD_SIZE_LIMIT_REACHED) {
404 abortReasonString = QString("Download size limit of %1 bytes reached").arg(mDownloadSizeLimit);
405 if (mDownloadLimitCancel) {
406 LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("HTTP request aborted with reason: %1").arg(abortReasonString), this);
407 response->getQNetworkReply()->abort();
408 } else {
409 LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("Deleting download stream due to reason: %1").arg(abortReasonString), this);
410 }
411 } else {
412 LOG(WARNING, "::Konclude::Network::HTTP::QtHttpTransactionManager", logTr("HTTP request aborted with reason: %1").arg(abortReasonString), this);
413 response->getQNetworkReply()->abort();
414 }
415 return true;
416 }
417 return false;
418 }
419
420
421
422 }; // end namespace HTTP
423
424 }; // end namespace Network
425
426 }; // end namespace Konclude
427