##// END OF EJS Templates
GIT_REPOSITORIES » LPP » Users » mperrinel » SciQLop-fork
RSS

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge pull request 290 from SCIQLOP-Initialisation develop...
leroux -
r762:b7833b9d2064 merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -21,6 +21,7 struct AcquisitionRequest {
21 21 {
22 22 m_AcqIdentifier = QUuid::createUuid();
23 23 m_Size = 0;
24 m_Progression = 0;
24 25 }
25 26
26 27 QUuid m_VarRequestId;
@@ -30,6 +31,7 struct AcquisitionRequest {
30 31 SqpRange m_RangeRequested;
31 32 SqpRange m_CacheRangeRequested;
32 33 int m_Size;
34 int m_Progression;
33 35 std::shared_ptr<IDataProvider> m_Provider;
34 36 };
35 37
Show file before | Show file after | Hide comments
@@ -55,17 +55,21 signals:
55 55 const SqpRange &dataRangeAcquired);
56 56
57 57 /**
58 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
59 * identified by identifier
58 * @brief dataProvidedProgress notify the progression of the data identifier by acqIdentifier
60 59 */
61 60 void dataProvidedProgress(QUuid acqIdentifier, double progress);
62 61
62 /**
63 * @brief dataProvidedFailed notify that data acquisition has failed
64 */
65 void dataProvidedFailed(QUuid acqIdentifier);
66
63 67
64 68 /**
65 69 * @brief requestConstructed send a request for the data identified by acqIdentifier
66 70 * @callback is the methode call by the reply of the request when it is finished.
67 71 */
68 void requestConstructed(const QNetworkRequest &request, QUuid acqIdentifier,
72 void requestConstructed(std::shared_ptr<QNetworkRequest> request, QUuid acqIdentifier,
69 73 std::function<void(QNetworkReply *, QUuid)> callback);
70 74 };
71 75
Show file before | Show file after | Hide comments
@@ -7,6 +7,7
7 7 #include <QObject>
8 8 #include <QUuid>
9 9
10 #include <Common/MetaTypes.h>
10 11 #include <Common/spimpl.h>
11 12 #include <functional>
12 13
@@ -29,14 +30,15 public:
29 30 public slots:
30 31 /// Execute request and call callback when the reply is finished. Identifier is attached to the
31 32 /// callback
32 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
33 void onProcessRequested(std::shared_ptr<QNetworkRequest> request, QUuid identifier,
33 34 std::function<void(QNetworkReply *, QUuid)> callback);
34 35 /// Cancel the request of identifier
35 36 void onReplyCanceled(QUuid identifier);
36 37
37 38 signals:
38 39 void replyFinished(QNetworkReply *reply, QUuid identifier);
39 void replyDownloadProgress(QUuid identifier, double progress);
40 void replyDownloadProgress(QUuid identifier, std::shared_ptr<QNetworkRequest> networkRequest,
41 double progress);
40 42
41 43 private:
42 44 void waitForFinish();
@@ -45,4 +47,7 private:
45 47 spimpl::unique_impl_ptr<NetworkControllerPrivate> impl;
46 48 };
47 49
50 SCIQLOP_REGISTER_META_TYPE(NETWORKREQUEST_REGISTRY, std::shared_ptr<QNetworkRequest>)
51
52
48 53 #endif // SCIQLOP_NETWORKCONTROLLER_H
Show file before | Show file after | Hide comments
@@ -25,8 +25,7 class SCIQLOP_CORE_EXPORT Variable : public QObject {
25 25 Q_OBJECT
26 26
27 27 public:
28 explicit Variable(const QString &name, const SqpRange &dateTime,
29 const QVariantHash &metadata = {});
28 explicit Variable(const QString &name, const QVariantHash &metadata = {});
30 29
31 30 /// Copy ctor
32 31 explicit Variable(const Variable &other);
Show file before | Show file after | Hide comments
@@ -43,10 +43,15 signals:
43 43
44 44 void variableRequestInProgress(QUuid vIdentifier, double progress);
45 45
46
47 void variableCanceledRequested(QUuid vIdentifier);
48
49
46 50 public slots:
47 51 void onVariableDataAcquired(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dataSeries,
48 52 SqpRange dataRangeAcquired);
49 53 void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
54 void onVariableAcquisitionFailed(QUuid acqIdentifier);
50 55
51 56 private:
52 57 void waitForFinish();
Show file before | Show file after | Hide comments
@@ -68,10 +68,6 public:
68 68 */
69 69 void deleteVariables(const QVector<std::shared_ptr<Variable> > &variables) noexcept;
70 70
71 /**
72 * @brief abort the variable retrieve data progression
73 */
74 void abortProgress(std::shared_ptr<Variable> variable);
75 71
76 72 static AcquisitionZoomType getZoomType(const SqpRange &range, const SqpRange &oldRange);
77 73 signals:
@@ -110,6 +106,7 public slots:
110 106
111 107 /// Cancel the current request for the variable
112 108 void onAbortProgressRequested(std::shared_ptr<Variable> variable);
109 void onAbortAcquisitionRequested(QUuid vIdentifier);
113 110
114 111 // synchronization group methods
115 112 void onAddSynchronizationGroupId(QUuid synchronizationGroupId);
Show file before | Show file after | Hide comments
@@ -45,11 +45,10 public:
45 45 /**
46 46 * Creates a new variable in the model
47 47 * @param name the name of the new variable
48 * @param dateTime the dateTime of the new variable
49 48 * @param metadata the metadata associated to the new variable
50 49 * @return the pointer to the new variable
51 50 */
52 std::shared_ptr<Variable> createVariable(const QString &name, const SqpRange &dateTime,
51 std::shared_ptr<Variable> createVariable(const QString &name,
53 52 const QVariantHash &metadata) noexcept;
54 53
55 54 /**
Show file before | Show file after | Hide comments
@@ -21,7 +21,7 struct NetworkController::NetworkControllerPrivate {
21 21 QMutex m_WorkingMutex;
22 22
23 23 QReadWriteLock m_Lock;
24 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
24 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToId;
25 25 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
26 26 };
27 27
@@ -30,53 +30,66 NetworkController::NetworkController(QObject *parent)
30 30 {
31 31 }
32 32
33 void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
33 void NetworkController::onProcessRequested(std::shared_ptr<QNetworkRequest> request,
34 QUuid identifier,
34 35 std::function<void(QNetworkReply *, QUuid)> callback)
35 36 {
36 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
37 << QThread::currentThread()->objectName();
38 auto reply = impl->m_AccessManager->get(request);
37 qCDebug(LOG_NetworkController()) << tr("NetworkController onProcessRequested")
38 << QThread::currentThread()->objectName() << &request;
39 auto reply = impl->m_AccessManager->get(*request);
39 40
40 41 // Store the couple reply id
41 42 impl->lockWrite();
42 impl->m_NetworkReplyToVariableId[reply] = identifier;
43 impl->m_NetworkReplyToId[reply] = identifier;
44 qCDebug(LOG_NetworkController()) << tr("Store for reply: ") << identifier;
43 45 impl->unlock();
44 46
45 auto onReplyFinished = [reply, this, identifier, callback]() {
47 auto onReplyFinished = [request, reply, this, identifier, callback]() {
46 48
47 49 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
48 << QThread::currentThread() << reply;
50 << QThread::currentThread() << request.get() << reply;
49 51 impl->lockRead();
50 auto it = impl->m_NetworkReplyToVariableId.find(reply);
52 auto it = impl->m_NetworkReplyToId.find(reply);
53 if (it != impl->m_NetworkReplyToId.cend()) {
54 qCDebug(LOG_NetworkController()) << tr("Remove for reply: ") << it->second;
51 55 impl->unlock();
52 if (it != impl->m_NetworkReplyToVariableId.cend()) {
53 56 impl->lockWrite();
54 impl->m_NetworkReplyToVariableId.erase(reply);
57 impl->m_NetworkReplyToId.erase(reply);
55 58 impl->unlock();
56 59 // Deletes reply
57 60 callback(reply, identifier);
58 61 reply->deleteLater();
59
60 emit this->replyDownloadProgress(identifier, 0);
62 }
63 else {
64 impl->unlock();
61 65 }
62 66
63 67 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
64 68 << QThread::currentThread() << reply;
65 69 };
66 70
67 auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
71 auto onReplyProgress = [reply, request, this](qint64 bytesRead, qint64 totalBytes) {
68 72
73 // NOTE: a totalbytes of 0 can happened when a request has been aborted
74 if (totalBytes > 0) {
69 75 double progress = (bytesRead * 100.0) / totalBytes;
70 76 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
71 << QThread::currentThread() << reply;
77 << QThread::currentThread() << request.get() << reply
78 << bytesRead << totalBytes;
72 79 impl->lockRead();
73 auto it = impl->m_NetworkReplyToVariableId.find(reply);
80 auto it = impl->m_NetworkReplyToId.find(reply);
81 if (it != impl->m_NetworkReplyToId.cend()) {
82 auto id = it->second;
74 83 impl->unlock();
75 if (it != impl->m_NetworkReplyToVariableId.cend()) {
76 emit this->replyDownloadProgress(it->second, progress);
84 emit this->replyDownloadProgress(id, request, progress);
77 85 }
86 else {
87 impl->unlock();
88 }
89
78 90 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
79 91 << QThread::currentThread() << reply;
92 }
80 93 };
81 94
82 95
@@ -94,7 +107,6 void NetworkController::initialize()
94 107
95 108
96 109 auto onReplyErrors = [this](QNetworkReply *reply, const QList<QSslError> &errors) {
97
98 110 qCCritical(LOG_NetworkController()) << tr("NetworkAcessManager errors: ") << errors;
99 111
100 112 };
@@ -114,14 +126,16 void NetworkController::onReplyCanceled(QUuid identifier)
114 126 {
115 127 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
116 128 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled")
117 << QThread::currentThread();
129 << QThread::currentThread() << identifier;
118 130
119 131
120 132 impl->lockRead();
121 auto end = impl->m_NetworkReplyToVariableId.cend();
122 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
133 auto end = impl->m_NetworkReplyToId.cend();
134 auto it = std::find_if(impl->m_NetworkReplyToId.cbegin(), end, findReply);
123 135 impl->unlock();
124 136 if (it != end) {
137 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled ABORT DONE")
138 << QThread::currentThread() << identifier;
125 139 it->first->abort();
126 140 }
127 141 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyCanceled END")
Show file before | Show file after | Hide comments
@@ -10,10 +10,10
10 10 Q_LOGGING_CATEGORY(LOG_Variable, "Variable")
11 11
12 12 struct Variable::VariablePrivate {
13 explicit VariablePrivate(const QString &name, const SqpRange &dateTime,
14 const QVariantHash &metadata)
13 explicit VariablePrivate(const QString &name, const QVariantHash &metadata)
15 14 : m_Name{name},
16 m_Range{dateTime},
15 m_Range{INVALID_RANGE},
16 m_CacheRange{INVALID_RANGE},
17 17 m_Metadata{metadata},
18 18 m_DataSeries{nullptr},
19 19 m_RealRange{INVALID_RANGE},
@@ -24,6 +24,7 struct Variable::VariablePrivate {
24 24 VariablePrivate(const VariablePrivate &other)
25 25 : m_Name{other.m_Name},
26 26 m_Range{other.m_Range},
27 m_CacheRange{other.m_CacheRange},
27 28 m_Metadata{other.m_Metadata},
28 29 m_DataSeries{other.m_DataSeries != nullptr ? other.m_DataSeries->clone() : nullptr},
29 30 m_RealRange{other.m_RealRange},
@@ -55,7 +56,8 struct Variable::VariablePrivate {
55 56 auto minXAxisIt = m_DataSeries->minXAxisData(m_Range.m_TStart);
56 57 auto maxXAxisIt = m_DataSeries->maxXAxisData(m_Range.m_TEnd);
57 58
58 m_RealRange = (minXAxisIt != end && maxXAxisIt != end)
59 m_RealRange
60 = (minXAxisIt != end && maxXAxisIt != end && minXAxisIt->x() <= maxXAxisIt->x())
59 61 ? SqpRange{minXAxisIt->x(), maxXAxisIt->x()}
60 62 : INVALID_RANGE;
61 63 m_DataSeries->unlock();
@@ -77,8 +79,8 struct Variable::VariablePrivate {
77 79 QReadWriteLock m_Lock;
78 80 };
79 81
80 Variable::Variable(const QString &name, const SqpRange &dateTime, const QVariantHash &metadata)
81 : impl{spimpl::make_unique_impl<VariablePrivate>(name, dateTime, metadata)}
82 Variable::Variable(const QString &name, const QVariantHash &metadata)
83 : impl{spimpl::make_unique_impl<VariablePrivate>(name, metadata)}
82 84 {
83 85 }
84 86
@@ -242,8 +244,8 bool Variable::cacheIsInside(const SqpRange &range) const noexcept
242 244 QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) const noexcept
243 245 {
244 246 // This code assume that cach in contigue. Can return 0, 1 or 2 SqpRange
245
246 247 auto notInCache = QVector<SqpRange>{};
248 if (impl->m_CacheRange != INVALID_RANGE) {
247 249
248 250 if (!this->cacheContains(range)) {
249 251 if (range.m_TEnd <= impl->m_CacheRange.m_TStart
@@ -267,6 +269,10 QVector<SqpRange> Variable::provideNotInCacheRangeList(const SqpRange &range) co
267 269 << QThread::currentThread();
268 270 }
269 271 }
272 }
273 else {
274 notInCache << range;
275 }
270 276
271 277 return notInCache;
272 278 }
@@ -277,6 +283,7 QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const
277 283
278 284 auto inCache = QVector<SqpRange>{};
279 285
286 if (impl->m_CacheRange != INVALID_RANGE) {
280 287
281 288 if (this->intersect(range)) {
282 289 if (range.m_TStart <= impl->m_CacheRange.m_TStart
@@ -302,6 +309,7 QVector<SqpRange> Variable::provideInCacheRangeList(const SqpRange &range) const
302 309 << QThread::currentThread();
303 310 }
304 311 }
312 }
305 313
306 314 return inCache;
307 315 }
Show file before | Show file after | Hide comments
@@ -12,11 +12,16
12 12 #include <QReadWriteLock>
13 13 #include <QThread>
14 14
15 #include <cmath>
16
15 17 Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
16 18
17 19 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
18 20
19 explicit VariableAcquisitionWorkerPrivate() : m_Lock{QReadWriteLock::Recursive} {}
21 explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
22 : m_Lock{QReadWriteLock::Recursive}, q{parent}
23 {
24 }
20 25
21 26 void lockRead() { m_Lock.lockForRead(); }
22 27 void lockWrite() { m_Lock.lockForWrite(); }
@@ -24,17 +29,21 struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
24 29
25 30 void removeVariableRequest(QUuid vIdentifier);
26 31
32 /// Remove the current request and execute the next one if exist
33 void updateToNextRequest(QUuid vIdentifier);
34
27 35 QMutex m_WorkingMutex;
28 36 QReadWriteLock m_Lock;
29 37
30 38 std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
31 39 std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
32 40 std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
41 VariableAcquisitionWorker *q;
33 42 };
34 43
35 44
36 45 VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
37 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>()}
46 : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
38 47 {
39 48 }
40 49
@@ -58,6 +67,7 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid v
58 67
59 68 // Request creation
60 69 auto acqRequest = AcquisitionRequest{};
70 qCInfo(LOG_VariableAcquisitionWorker()) << tr("TpushVariableRequest ") << vIdentifier;
61 71 acqRequest.m_VarRequestId = varRequestId;
62 72 acqRequest.m_vIdentifier = vIdentifier;
63 73 acqRequest.m_DataProviderParameters = parameters;
@@ -100,20 +110,89 QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid v
100 110
101 111 void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
102 112 {
103 // TODO
113 impl->lockRead();
114
115 auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
116 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
117 auto currentAcqId = it->second.first;
118
119 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
120 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
121 auto request = it->second;
122 impl->unlock();
123
124 // Remove the current request from the worker
125
126 impl->lockWrite();
127 impl->updateToNextRequest(vIdentifier);
128 impl->unlock();
129
130 // notify the request aborting to the provider
131 request.m_Provider->requestDataAborting(currentAcqId);
132 }
133 else {
134 impl->unlock();
135 qCWarning(LOG_VariableAcquisitionWorker())
136 << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
137 }
138 }
139 else {
140 impl->unlock();
141 }
104 142 }
105 143
106 144 void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
107 145 double progress)
108 146 {
109 // TODO
147 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
148 << acqIdentifier << progress;
149 impl->lockRead();
150 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
151 if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
152 auto currentPartSize = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
153
154 auto currentPartProgress
155 = std::isnan(progress) ? 0.0 : (progress * currentPartSize) / 100.0;
156 auto currentAlreadyProgress = aIdToARit->second.m_Progression * currentPartSize;
157
158 auto finalProgression = currentAlreadyProgress + currentPartProgress;
159 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
160 qCDebug(LOG_VariableAcquisitionWorker())
161 << tr("TORM: onVariableRetrieveDataInProgress ")
162 << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
163 << currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
164 if (finalProgression == 100.0) {
165 emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
166 }
167 }
168 impl->unlock();
169 }
170
171 void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
172 {
173 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
174 << QThread::currentThread();
175 impl->lockRead();
176 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
177 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
178 auto request = it->second;
179 impl->unlock();
180 qCInfo(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
181 << acqIdentifier << request.m_vIdentifier
182 << QThread::currentThread();
183 emit variableCanceledRequested(request.m_vIdentifier);
184 }
185 else {
186 impl->unlock();
187 // TODO log no acqIdentifier recognized
188 }
110 189 }
111 190
112 191 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
113 192 std::shared_ptr<IDataSeries> dataSeries,
114 193 SqpRange dataRangeAcquired)
115 194 {
116 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")
195 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
117 196 << acqIdentifier << dataRangeAcquired;
118 197 impl->lockWrite();
119 198 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
@@ -137,11 +216,11 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
137 216
138 217 // Decrement the counter of the request
139 218 auto &acqRequest = aIdToARit->second;
140 acqRequest.m_Size = acqRequest.m_Size - 1;
219 acqRequest.m_Progression = acqRequest.m_Progression + 1;
141 220
142 221 // if the counter is 0, we can return data then run the next request if it exists and
143 222 // removed the finished request
144 if (acqRequest.m_Size == 0) {
223 if (acqRequest.m_Size == acqRequest.m_Progression) {
145 224 // Return the data
146 225 aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
147 226 if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
@@ -149,39 +228,32 void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
149 228 acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
150 229 }
151 230
152 // Execute the next one
153 auto it
154 = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
155
156 if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
157 if (it->second.second.isNull()) {
158 // There is no next request, we can remove the variable request
159 impl->removeVariableRequest(acqRequest.m_vIdentifier);
160 }
161 else {
162 auto acqIdentifierToRemove = it->second.first;
163 // Move the next request to the current request
164 it->second.first = it->second.second;
165 it->second.second = QUuid();
166 // Remove AcquisitionRequest and results;
167 impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
168 impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
169 // Execute the current request
170 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
171 Q_ARG(QUuid, it->second.first));
231 // Update to the next request
232 impl->updateToNextRequest(acqRequest.m_vIdentifier);
172 233 }
173 234 }
174 235 else {
175 qCCritical(LOG_VariableAcquisitionWorker())
176 << tr("Impossible to execute the acquisition on an unfound variable ");
236 qCWarning(LOG_VariableAcquisitionWorker())
237 << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
177 238 }
239 impl->unlock();
178 240 }
241
242 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
243 {
244 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
245 impl->lockRead();
246 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
247 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
248 auto request = it->second;
249 impl->unlock();
250 emit variableRequestInProgress(request.m_vIdentifier, 0.1);
251 request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
179 252 }
180 253 else {
181 qCCritical(LOG_VariableAcquisitionWorker())
182 << tr("Impossible to retrieve AcquisitionRequest for the incoming data");
183 }
184 254 impl->unlock();
255 // TODO log no acqIdentifier recognized
256 }
185 257 }
186 258
187 259 void VariableAcquisitionWorker::initialize()
@@ -221,18 +293,30 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariable
221 293 unlock();
222 294 }
223 295
224 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
296 void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
297 QUuid vIdentifier)
225 298 {
226 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
227 impl->lockRead();
228 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
229 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
230 auto request = it->second;
231 impl->unlock();
232 request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
299 auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
300 if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
301 if (it->second.second.isNull()) {
302 // There is no next request, we can remove the variable request
303 removeVariableRequest(vIdentifier);
233 304 }
234 305 else {
235 impl->unlock();
236 // TODO log no acqIdentifier recognized
306 auto acqIdentifierToRemove = it->second.first;
307 // Move the next request to the current request
308 it->second.first = it->second.second;
309 it->second.second = QUuid();
310 // Remove AcquisitionRequest and results;
311 m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
312 m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
313 // Execute the current request
314 QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
315 Q_ARG(QUuid, it->second.first));
316 }
317 }
318 else {
319 qCCritical(LOG_VariableAcquisitionWorker())
320 << tr("Impossible to execute the acquisition on an unfound variable ");
237 321 }
238 322 }
Show file before | Show file after | Hide comments
@@ -151,12 +151,17 VariableController::VariableController(QObject *parent)
151 151 connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
152 152 &VariableController::onAbortProgressRequested);
153 153
154 connect(impl->m_VariableAcquisitionWorker.get(),
155 &VariableAcquisitionWorker::variableCanceledRequested, this,
156 &VariableController::onAbortAcquisitionRequested);
157
154 158 connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
155 159 &VariableController::onDataProvided);
156 160 connect(impl->m_VariableAcquisitionWorker.get(),
157 161 &VariableAcquisitionWorker::variableRequestInProgress, this,
158 162 &VariableController::onVariableRetrieveDataInProgress);
159 163
164
160 165 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
161 166 impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
162 167 connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
@@ -253,10 +258,6 void VariableController::deleteVariables(
253 258 }
254 259 }
255 260
256 void VariableController::abortProgress(std::shared_ptr<Variable> variable)
257 {
258 }
259
260 261 std::shared_ptr<Variable>
261 262 VariableController::createVariable(const QString &name, const QVariantHash &metadata,
262 263 std::shared_ptr<IDataProvider> provider) noexcept
@@ -269,7 +270,7 VariableController::createVariable(const QString &name, const QVariantHash &meta
269 270
270 271 auto range = impl->m_TimeController->dateTime();
271 272
272 if (auto newVariable = impl->m_VariableModel->createVariable(name, range, metadata)) {
273 if (auto newVariable = impl->m_VariableModel->createVariable(name, metadata)) {
273 274 auto identifier = QUuid::createUuid();
274 275
275 276 // store the provider
@@ -277,11 +278,11 VariableController::createVariable(const QString &name, const QVariantHash &meta
277 278
278 279 // Associate the provider
279 280 impl->m_VariableToProviderMap[newVariable] = provider;
281 qCInfo(LOG_VariableController()) << "createVariable: " << identifier;
280 282 impl->m_VariableToIdentifierMap[newVariable] = identifier;
281 283
282 284
283 285 auto varRequestId = QUuid::createUuid();
284 qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
285 286 impl->processRequest(newVariable, range, varRequestId);
286 287 impl->updateVariableRequest(varRequestId);
287 288
@@ -322,6 +323,9 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &range
322 323
323 324 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
324 325 {
326 qCDebug(LOG_VariableController())
327 << "TORM: variableController::onVariableRetrieveDataInProgress"
328 << QThread::currentThread()->objectName() << progress;
325 329 if (auto var = impl->findVariable(identifier)) {
326 330 impl->m_VariableModel->setDataProgress(var, progress);
327 331 }
@@ -333,12 +337,25 void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, doub
333 337
334 338 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> variable)
335 339 {
336 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAbortProgressRequested"
337 << QThread::currentThread()->objectName();
338
339 340 auto it = impl->m_VariableToIdentifierMap.find(variable);
340 341 if (it != impl->m_VariableToIdentifierMap.cend()) {
341 impl->m_VariableToProviderMap.at(variable)->requestDataAborting(it->second);
342 impl->m_VariableAcquisitionWorker->abortProgressRequested(it->second);
343
344 QUuid varRequestId;
345 auto varIdToVarRequestIdQueueMapIt = impl->m_VarIdToVarRequestIdQueueMap.find(it->second);
346 if (varIdToVarRequestIdQueueMapIt != impl->m_VarIdToVarRequestIdQueueMap.cend()) {
347 auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
348 varRequestId = varRequestIdQueue.front();
349 impl->cancelVariableRequest(varRequestId);
350
351 // Finish the progression for the request
352 impl->m_VariableModel->setDataProgress(variable, 0.0);
353 }
354 else {
355 qCWarning(LOG_VariableController())
356 << tr("Aborting progression of inexistant variable request detected !!!")
357 << QThread::currentThread()->objectName();
358 }
342 359 }
343 360 else {
344 361 qCWarning(LOG_VariableController())
@@ -347,6 +364,20 void VariableController::onAbortProgressRequested(std::shared_ptr<Variable> vari
347 364 }
348 365 }
349 366
367 void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
368 {
369 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
370 << QThread::currentThread()->objectName() << vIdentifier;
371
372 if (auto var = impl->findVariable(vIdentifier)) {
373 this->onAbortProgressRequested(var);
374 }
375 else {
376 qCCritical(LOG_VariableController())
377 << tr("Impossible to abort Acquisition Requestof a null variable");
378 }
379 }
380
350 381 void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
351 382 {
352 383 qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
@@ -431,7 +462,7 void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable>
431 462 // For the other, we ask the provider to give them.
432 463
433 464 auto varRequestId = QUuid::createUuid();
434 qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
465 qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
435 466 << QThread::currentThread()->objectName() << varRequestId;
436 467
437 468 for (const auto &var : variables) {
@@ -549,11 +580,7 void VariableController::VariableControllerPrivate::processRequest(std::shared_p
549 580 if (!notInCacheRangeList.empty()) {
550 581 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
551 582 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
552 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest RR ") << rangeRequested;
553 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest R ")
554 << varStrategyRangesRequested.first;
555 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest CR ")
556 << varStrategyRangesRequested.second;
583
557 584 // store VarRequest
558 585 storeVariableRequest(varId, varRequestId, varRequest);
559 586
@@ -566,7 +593,7 void VariableController::VariableControllerPrivate::processRequest(std::shared_p
566 593 varProvider);
567 594
568 595 if (!varRequestIdCanceled.isNull()) {
569 qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
596 qCDebug(LOG_VariableAcquisitionWorker()) << tr("vsarRequestIdCanceled: ")
570 597 << varRequestIdCanceled;
571 598 cancelVariableRequest(varRequestIdCanceled);
572 599 }
@@ -581,7 +608,6 void VariableController::VariableControllerPrivate::processRequest(std::shared_p
581 608 }
582 609 }
583 610 else {
584
585 611 varRequest.m_RangeRequested = varStrategyRangesRequested.first;
586 612 varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
587 613 // store VarRequest
@@ -639,6 +665,9 void VariableController::VariableControllerPrivate::registerProvider(
639 665 connect(provider.get(), &IDataProvider::dataProvidedProgress,
640 666 m_VariableAcquisitionWorker.get(),
641 667 &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
668 connect(provider.get(), &IDataProvider::dataProvidedFailed,
669 m_VariableAcquisitionWorker.get(),
670 &VariableAcquisitionWorker::onVariableAcquisitionFailed);
642 671 }
643 672 else {
644 673 qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
@@ -709,12 +738,10 QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
709 738 << varRequestId;
710 739 }
711 740
712 qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in QUEUE ?")
713 << varRequestIdQueue.size();
714 741 varRequestIdQueue.pop_front();
715 qCDebug(LOG_VariableController()) << tr("2: erase REQUEST in QUEUE ?")
716 << varRequestIdQueue.size();
717 742 if (varRequestIdQueue.empty()) {
743 qCDebug(LOG_VariableController())
744 << tr("TORM Erase REQUEST because it has been accepted") << varId;
718 745 m_VarIdToVarRequestIdQueueMap.erase(varId);
719 746 }
720 747 }
@@ -759,9 +786,11 void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid
759 786
760 787 /// @todo MPL: confirm
761 788 // Variable update is notified only if there is no pending request for it
762 if (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first) == 0) {
789 // if
790 // (m_VarIdToVarRequestIdQueueMap.count(varIdToVarRequestMapIt->first)
791 // == 0) {
763 792 emit var->updated();
764 }
793 // }
765 794 }
766 795 else {
767 796 qCCritical(LOG_VariableController())
Show file before | Show file after | Hide comments
@@ -97,10 +97,9 bool VariableModel::containsVariable(std::shared_ptr<Variable> variable) const n
97 97 }
98 98
99 99 std::shared_ptr<Variable> VariableModel::createVariable(const QString &name,
100 const SqpRange &dateTime,
101 100 const QVariantHash &metadata) noexcept
102 101 {
103 auto variable = std::make_shared<Variable>(name, dateTime, metadata);
102 auto variable = std::make_shared<Variable>(name, metadata);
104 103 addVariable(variable);
105 104
106 105 return variable;
Show file before | Show file after | Hide comments
@@ -87,8 +87,8 void TestTwoDimArrayData::testCtor_data()
87 87 << true << Container{{1., 2., 3., 4., 5.},
88 88 {6., 7., 8., 9., 10.},
89 89 {11., 12., 13., 14., 15.}};
90 QTest::newRow("invalidInput (invalid data size")
91 << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3} << false << Container{{}, {}, {}};
90 QTest::newRow("invalidInput (invalid data size") << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3}
91 << false << Container{{}, {}, {}};
92 92 QTest::newRow("invalidInput (less than two components")
93 93 << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
94 94 }
Show file before | Show file after | Hide comments
@@ -24,10 +24,12 void TestVariable::testNotInCacheRangeList()
24 24
25 25 auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
26 26 auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
27
27 28 auto sqpCR
28 29 = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
29 30
30 Variable var{"Var test", sqpR};
31 Variable var{"Var test"};
32 var.setRange(sqpR);
31 33 var.setCacheRange(sqpCR);
32 34
33 35 // 1: [ts,te] < varTS
@@ -109,7 +111,8 void TestVariable::testInCacheRangeList()
109 111 auto sqpCR
110 112 = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};
111 113
112 Variable var{"Var test", sqpR};
114 Variable var{"Var test"};
115 var.setRange(sqpR);
113 116 var.setCacheRange(sqpCR);
114 117
115 118 // 1: [ts,te] < varTS
Show file before | Show file after | Hide comments
@@ -32,7 +32,8 void TestVariableCacheController::testProvideNotInCacheDateTimeList()
32 32 auto te2 = QDateTime{QDate{2017, 01, 01}, QTime{2, 20, 0, 0}};
33 33 auto sqp2 = SqpRange{DateUtils::secondsSinceEpoch(ts2), DateUtils::secondsSinceEpoch(te2)};
34 34
35 auto var0 = std::make_shared<Variable>("", sqp0);
35 auto var0 = std::make_shared<Variable>("");
36 var0->setRange(sqp0);
36 37
37 38 variableCacheController.addDateTime(var0, sqp0);
38 39 variableCacheController.addDateTime(var0, sqp1);
@@ -267,7 +268,8 void TestVariableCacheController::testAddDateTime()
267 268 auto sqp03 = SqpRange{DateUtils::secondsSinceEpoch(ts03), DateUtils::secondsSinceEpoch(te03)};
268 269
269 270
270 auto var0 = std::make_shared<Variable>("", sqp0);
271 auto var0 = std::make_shared<Variable>("");
272 var0->setRange(sqp0);
271 273
272 274
273 275 // First case: add the first interval to the variable :sqp0
Show file before | Show file after | Hide comments
@@ -1574,7 +1574,10 void QCPLayerable::applyAntialiasingHint(QCPPainter *painter, bool localAntialia
1574 1574
1575 1575 \see initializeParentPlot
1576 1576 */
1577 void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot){Q_UNUSED(parentPlot)}
1577 void QCPLayerable::parentPlotInitialized(QCustomPlot *parentPlot)
1578 {
1579 Q_UNUSED(parentPlot)
1580 }
1578 1581
1579 1582 /*! \internal
1580 1583
@@ -9391,14 +9394,12 void QCPAxisPainterPrivate::draw(QCPPainter *painter)
9391 9394 painter->setBrush(QBrush(basePen.color()));
9392 9395 QCPVector2D baseLineVector(baseLine.dx(), baseLine.dy());
9393 9396 if (lowerEnding.style() != QCPLineEnding::esNone)
9394 lowerEnding.draw(painter,
9395 QCPVector2D(baseLine.p1())
9397 lowerEnding.draw(painter, QCPVector2D(baseLine.p1())
9396 9398 - baseLineVector.normalized() * lowerEnding.realLength()
9397 9399 * (lowerEnding.inverted() ? -1 : 1),
9398 9400 -baseLineVector);
9399 9401 if (upperEnding.style() != QCPLineEnding::esNone)
9400 upperEnding.draw(painter,
9401 QCPVector2D(baseLine.p2())
9402 upperEnding.draw(painter, QCPVector2D(baseLine.p2())
9402 9403 + baseLineVector.normalized() * upperEnding.realLength()
9403 9404 * (upperEnding.inverted() ? -1 : 1),
9404 9405 baseLineVector);
@@ -16629,8 +16630,7 void QCPColorGradient::updateColorBuffer()
16629 16630 hue -= 1.0;
16630 16631 if (useAlpha) {
16631 16632 const QRgb rgb
16632 = QColor::fromHsvF(hue,
16633 (1 - t) * lowHsv.saturationF()
16633 = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
16634 16634 + t * highHsv.saturationF(),
16635 16635 (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
16636 16636 .rgb();
@@ -16640,8 +16640,7 void QCPColorGradient::updateColorBuffer()
16640 16640 }
16641 16641 else {
16642 16642 mColorBuffer[i]
16643 = QColor::fromHsvF(hue,
16644 (1 - t) * lowHsv.saturationF()
16643 = QColor::fromHsvF(hue, (1 - t) * lowHsv.saturationF()
16645 16644 + t * highHsv.saturationF(),
16646 16645 (1 - t) * lowHsv.valueF() + t * highHsv.valueF())
16647 16646 .rgb();
@@ -19999,12 +19998,10 void QCPColorScale::update(UpdatePhase phase)
19999 19998 switch (phase) {
20000 19999 case upMargins: {
20001 20000 if (mType == QCPAxis::atBottom || mType == QCPAxis::atTop) {
20002 setMaximumSize(QWIDGETSIZE_MAX,
20003 mBarWidth + mAxisRect.data()->margins().top()
20004 + mAxisRect.data()->margins().bottom() + margins().top()
20005 + margins().bottom());
20006 setMinimumSize(0,
20007 mBarWidth + mAxisRect.data()->margins().top()
20001 setMaximumSize(QWIDGETSIZE_MAX, mBarWidth + mAxisRect.data()->margins().top()
20002 + mAxisRect.data()->margins().bottom()
20003 + margins().top() + margins().bottom());
20004 setMinimumSize(0, mBarWidth + mAxisRect.data()->margins().top()
20008 20005 + mAxisRect.data()->margins().bottom() + margins().top()
20009 20006 + margins().bottom());
20010 20007 }
Show file before | Show file after | Hide comments
@@ -7,15 +7,18
7 7
8 8 #include <QLoggingCategory>
9 9
10 #include <map>
10 11
11 12 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
12 13
13 14 class QNetworkReply;
15 class QNetworkRequest;
14 16
15 17 /**
16 18 * @brief The AmdaProvider class is an example of how a data provider can generate data
17 19 */
18 20 class SCIQLOP_AMDA_EXPORT AmdaProvider : public IDataProvider {
21 Q_OBJECT
19 22 public:
20 23 explicit AmdaProvider();
21 24 std::shared_ptr<IDataProvider> clone() const override;
@@ -24,8 +27,18 public:
24 27
25 28 void requestDataAborting(QUuid acqIdentifier) override;
26 29
30 private slots:
31 void onReplyDownloadProgress(QUuid acqIdentifier,
32 std::shared_ptr<QNetworkRequest> networkRequest, double progress);
33
27 34 private:
28 35 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
36
37 void updateRequestProgress(QUuid acqIdentifier, std::shared_ptr<QNetworkRequest> request,
38 double progress);
39
40 std::map<QUuid, std::map<std::shared_ptr<QNetworkRequest>, double> >
41 m_AcqIdToRequestProgressMap;
29 42 };
30 43
31 44 #endif // SCIQLOP_AMDAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -56,15 +56,17 AmdaProvider::AmdaProvider()
56 56 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
57 57 if (auto app = sqpApp) {
58 58 auto &networkController = app->networkController();
59 connect(this, SIGNAL(requestConstructed(QNetworkRequest, QUuid,
59 connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
60 60 std::function<void(QNetworkReply *, QUuid)>)),
61 61 &networkController,
62 SLOT(onProcessRequested(QNetworkRequest, QUuid,
62 SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
63 63 std::function<void(QNetworkReply *, QUuid)>)));
64 64
65 65
66 connect(&sqpApp->networkController(), SIGNAL(replyDownloadProgress(QUuid, double)), this,
67 SIGNAL(dataProvidedProgress(QUuid, double)));
66 connect(&sqpApp->networkController(),
67 SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
68 this,
69 SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
68 70 }
69 71 }
70 72
@@ -80,8 +82,11 void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderPar
80 82 const auto times = parameters.m_Times;
81 83 const auto data = parameters.m_Data;
82 84 for (const auto &dateTime : qAsConst(times)) {
85 qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
86 << dateTime;
83 87 this->retrieveData(acqIdentifier, dateTime, data);
84 88
89
85 90 // TORM when AMDA will support quick asynchrone request
86 91 QThread::msleep(1000);
87 92 }
@@ -95,6 +100,60 void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
95 100 }
96 101 }
97 102
103 void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
104 std::shared_ptr<QNetworkRequest> networkRequest,
105 double progress)
106 {
107 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
108 << networkRequest.get() << progress;
109 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
110 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
111
112 // Update the progression for the current request
113 auto requestPtr = networkRequest;
114 auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
115
116 auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
117 auto requestProgressMapEnd = requestProgressMap.end();
118 auto requestProgressMapIt
119 = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
120
121 if (requestProgressMapIt != requestProgressMapEnd) {
122 requestProgressMapIt->second = progress;
123 }
124 else {
125 // This case can happened when a progression is send after the request has been
126 // finished.
127 // Generaly the case when aborting a request
128 qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
129 << networkRequest.get() << progress;
130 }
131
132 // Compute the current final progress and notify it
133 double finalProgress = 0.0;
134
135 auto fraq = requestProgressMap.size();
136
137 for (auto requestProgress : requestProgressMap) {
138 finalProgress += requestProgress.second;
139 qCDebug(LOG_AmdaProvider()) << tr("Current final progress without fraq:")
140 << finalProgress << requestProgress.second;
141 }
142
143 if (fraq > 0) {
144 finalProgress = finalProgress / fraq;
145 }
146
147 qCDebug(LOG_AmdaProvider()) << tr("Current final progress: ") << fraq << finalProgress;
148 emit dataProvidedProgress(acqIdentifier, finalProgress);
149 }
150 else {
151 // This case can happened when a progression is send after the request has been finished.
152 // Generaly the case when aborting a request
153 emit dataProvidedProgress(acqIdentifier, 100.0);
154 }
155 }
156
98 157 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
99 158 {
100 159 // Retrieves product ID from data: if the value is invalid, no request is made
@@ -103,7 +162,6 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
103 162 qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
104 163 return;
105 164 }
106 qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::retrieveData") << dateTime;
107 165
108 166 // Retrieves the data type that determines whether the expected format for the result file is
109 167 // scalar, vector...
@@ -125,7 +183,7 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
125 183 productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
126 184
127 185 // Don't do anything if the reply was abort
128 if (reply->error() != QNetworkReply::OperationCanceledError) {
186 if (reply->error() == QNetworkReply::NoError) {
129 187
130 188 if (tempFile) {
131 189 auto replyReadAll = reply->readAll();
@@ -141,8 +199,16 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
141 199 }
142 200 else {
143 201 /// @todo ALX : debug
202 emit dataProvidedFailed(dataId);
203 }
144 204 }
205 qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
206 << dataId;
207 m_AcqIdToRequestProgressMap.erase(dataId);
145 208 }
209 else {
210 qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
211 emit dataProvidedFailed(dataId);
146 212 }
147 213
148 214 };
@@ -150,25 +216,68 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
150 216 = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
151 217
152 218 // Don't do anything if the reply was abort
153 if (reply->error() != QNetworkReply::OperationCanceledError) {
219 if (reply->error() == QNetworkReply::NoError) {
154 220 auto downloadFileUrl = QUrl{QString{reply->readAll()}};
155 221
156
157 222 qCInfo(LOG_AmdaProvider())
158 223 << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
159 224 // Executes request for downloading file //
160 225
161 226 // Creates destination file
162 227 if (tempFile->open()) {
163 // Executes request
164 emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId,
165 httpDownloadFinished);
228 // Executes request and store the request for progression
229 auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
230 updateRequestProgress(dataId, request, 0.0);
231 emit requestConstructed(request, dataId, httpDownloadFinished);
232 }
233 else {
234 emit dataProvidedFailed(dataId);
235 }
166 236 }
237 else {
238 qCDebug(LOG_AmdaProvider())
239 << tr("acquisition requests erase because of aborting") << dataId;
240 qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
241 m_AcqIdToRequestProgressMap.erase(dataId);
242 emit dataProvidedFailed(dataId);
167 243 }
168 244 };
169 245
170 246 // //////////////// //
171 247 // Executes request //
172 248 // //////////////// //
173 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
249
250 auto request = std::make_shared<QNetworkRequest>(url);
251 qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
252 updateRequestProgress(token, request, 0.0);
253
254 emit requestConstructed(request, token, httpFinishedLambda);
255 }
256
257 void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
258 std::shared_ptr<QNetworkRequest> request, double progress)
259 {
260 auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
261 if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
262 auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
263 auto requestProgressMapIt = requestProgressMap.find(request);
264 if (requestProgressMapIt != requestProgressMap.end()) {
265 requestProgressMapIt->second = progress;
266 qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
267 << acqIdentifier << request.get() << progress;
268 }
269 else {
270 qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
271 << request.get() << progress;
272 acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
273 }
274 }
275 else {
276 qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
277 << acqIdentifier << request.get() << progress;
278 auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
279 requestProgressMap.insert(std::make_pair(request, progress));
280 m_AcqIdToRequestProgressMap.insert(
281 std::make_pair(acqIdentifier, std::move(requestProgressMap)));
282 }
174 283 }
Show file before | Show file after | Hide comments
@@ -100,8 +100,6 void TestAmdaAcquisition::testAcquisition()
100 100 auto var = vc.createVariable("bx_gse", metaData, provider);
101 101
102 102 // 1 : Variable creation
103 QCOMPARE(var->range().m_TStart, sqpR.m_TStart);
104 QCOMPARE(var->range().m_TEnd, sqpR.m_TEnd);
105 103
106 104 qDebug() << " 1: TIMECONTROLLER" << timeController->dateTime();
107 105 qDebug() << " 1: RANGE " << var->range();
Show file before | Show file after | Hide comments
@@ -59,6 +59,9 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
59 59 progress = currentProgress;
60 60
61 61 emit dataProvidedProgress(acqIdentifier, progress);
62 qCInfo(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
63 << QThread::currentThread()->objectName() << progress;
64 // NOTE: Try to use multithread if possible
62 65 }
63 66 }
64 67 else {
@@ -69,8 +72,10 std::shared_ptr<IDataSeries> CosinusProvider::retrieveData(QUuid acqIdentifier,
69 72 }
70 73 }
71 74 }
72 emit dataProvidedProgress(acqIdentifier, 0.0);
73
75 if (progress != 100) {
76 // We can close progression beacause all data has been retrieved
77 emit dataProvidedProgress(acqIdentifier, 100);
78 }
74 79 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
75 80 Unit{QStringLiteral("t"), true}, Unit{});
76 81 }
General Comments 0
You need to be logged in to leave comments. Login now