GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r606:7ea0025fca62

Implementation of progression

perrinel -

r606:7ea0025fca62 feature/SynchroIm...

parent child

Context file:

r606:7ea0025fca62

core/include/Data/AcquisitionRequest.h +2 0

                 {
                     m_AcqIdentifier = QUuid::createUuid();
                     m_Size = 0;
+                    m_Progression = 0;
                 }
                 QUuid m_VarRequestId;
                 SqpRange m_RangeRequested;
                 SqpRange m_CacheRangeRequested;
                 int m_Size;
+                int m_Progression;
                 std::shared_ptr<IDataProvider> m_Provider;
             };

core/include/Network/NetworkController.h +2 -1

             signals:
                 void replyFinished(QNetworkReply *reply, QUuid identifier);
-                void replyDownloadProgress(QUuid identifier, double progress);
+                void replyDownloadProgress(QUuid identifier, const QNetworkRequest &networkRequest,
+                                           double progress);
             private:
                 void waitForFinish();

core/src/Network/NetworkController.cpp +4 -4

                 impl->m_NetworkReplyToVariableId[reply] = identifier;
                 impl->unlock();
-                auto onReplyFinished = [reply, this, identifier, callback]() {
+                auto onReplyFinished = [request, reply, this, identifier, callback]() {
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
                                                      << QThread::currentThread() << reply;
                         callback(reply, identifier);
                         reply->deleteLater();
-                        emit this->replyDownloadProgress(identifier, 0);
+                        emit this->replyDownloadProgress(identifier, request, 0);
                     }
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished END")
                                                      << QThread::currentThread() << reply;
                 };
-                auto onReplyProgress = [reply, this](qint64 bytesRead, qint64 totalBytes) {
+                auto onReplyProgress = [reply, request, this](qint64 bytesRead, qint64 totalBytes) {
                     double progress = (bytesRead * 100.0) / totalBytes;
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress") << progress
                     auto it = impl->m_NetworkReplyToVariableId.find(reply);
                     impl->unlock();
                     if (it != impl->m_NetworkReplyToVariableId.cend()) {
-                        emit this->replyDownloadProgress(it->second, progress);
+                        emit this->replyDownloadProgress(it->second, request, progress);
                     }
                     qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyProgress END")
                                                      << QThread::currentThread() << reply;

core/src/Variable/VariableAcquisitionWorker.cpp +37 -4

             #include <QReadWriteLock>
             #include <QThread>
+            #include <cmath>
             Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
             struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
             void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                              double progress)
             {
-                // TODO
+                impl->lockRead();
+                auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
+                if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
+                    auto currentPartSize = (aIdToARit->second.m_Size != 0) ? 100 / aIdToARit->second.m_Size : 0;
+                    auto currentPartProgress
+                        = std::isnan(progress) ? 0.0 : (progress * currentPartSize) / 100.0;
+                    auto currentAlreadyProgress = aIdToARit->second.m_Progression * currentPartSize;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: progress :") << progress;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress A:")
+                                                            << aIdToARit->second.m_Progression
+                                                            << aIdToARit->second.m_Size;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress B:")
+                                                            << currentPartSize;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress C:")
+                                                            << currentPartProgress;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress D:")
+                                                            << currentAlreadyProgress;
+                    qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress E:")
+                                                            << currentAlreadyProgress + currentPartProgress
+                                                            << "\n";
+                    auto finalProgression = currentAlreadyProgress + currentPartProgress;
+                    emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
+                    if (finalProgression == 100.0) {
+                        emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
+                    }
+                }
+                impl->unlock();
             }
             void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                                    std::shared_ptr<IDataSeries> dataSeries,
                                                                    SqpRange dataRangeAcquired)
             {
-                qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableDataAcquired on range ")
+                qCInfo(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableDataAcquired on range ")
                                                         << acqIdentifier << dataRangeAcquired;
                 impl->lockWrite();
                 auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                     // Decrement the counter of the request
                     auto &acqRequest = aIdToARit->second;
-                    acqRequest.m_Size = acqRequest.m_Size - 1;
+                    acqRequest.m_Progression = acqRequest.m_Progression + 1;
                     // if the counter is 0, we can return data then run the next request if it exists and
                     // removed the finished request
-                    if (acqRequest.m_Size == 0) {
+                    if (acqRequest.m_Size == acqRequest.m_Progression) {
                         // Return the data
                         aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                         if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                     auto request = it->second;
                     impl->unlock();
+                    emit variableRequestInProgress(request.m_vIdentifier, 0.1);
                     request.m_Provider->requestDataLoading(acqIdentifier, request.m_DataProviderParameters);
                 }
                 else {

core/src/Variable/VariableController.cpp +2 0

             void VariableController::onVariableRetrieveDataInProgress(QUuid identifier, double progress)
             {
+                qCInfo(LOG_VariableController()) << "TORM: ariableController::onVariableRetrieveDataInProgress"
+                                                 << QThread::currentThread()->objectName() << progress;
                 if (auto var = impl->findVariable(identifier)) {
                     impl->m_VariableModel->setDataProgress(var, progress);
                 }

core/tests/Data/TestTwoDimArrayData.cpp +2 -2

                                             << true << Container{{1., 2., 3., 4., 5.},
                                                                  {6., 7., 8., 9., 10.},
                                                                  {11., 12., 13., 14., 15.}};
-                QTest::newRow("invalidInput (invalid data size")
+                QTest::newRow("invalidInput (invalid data size") << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3}
-                    << InputData{{1., 2., 3., 4., 5., 6., 7.}, 3} << false << Container{{}, {}, {}};
+                                                                 << false << Container{{}, {}, {}};
                 QTest::newRow("invalidInput (less than two components")
                     << flatten(Container{{1., 2., 3., 4., 5.}}) << false << Container{{}, {}, {}};
             }

plugins/amda/include/AmdaProvider.h +11 0

             #include <QLoggingCategory>
+            #include <map>
             Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
             class QNetworkReply;
+            class QNetworkRequest;
             /**
              * @brief The AmdaProvider class is an example of how a data provider can generate data
                 void requestDataAborting(QUuid acqIdentifier) override;
+            private slots:
+                void onReplyDownloadProgress(QUuid, const QNetworkRequest &, double progress);
             private:
                 void retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data);
+                void updateRequestProgress(QUuid acqIdentifier, std::shared_ptr<QNetworkRequest> request,
+                                           double progress);
+                std::map<QUuid, std::map<std::shared_ptr<QNetworkRequest>, double> >
+                    m_AcqIdToRequestProgressMap;
             };
             #endif // SCIQLOP_AMDAPROVIDER_H

plugins/amda/src/AmdaProvider.cpp +92 -6

@@ -29,6 +29,11 const auto AMDA_URL_FORMAT = QStringLiteral(
29	/// Dates format passed in the URL (e.g 2013-09-23T09:00)	29	/// Dates format passed in the URL (e.g 2013-09-23T09:00)
30	const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");	30	const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
31		31
		32	// struct AmdaProgression {
		33	// QUuid acqIdentifier;
		34	// std::map<QNetworkRequest, double> m_RequestId;
		35	//};
		36
32	/// Formats a time to a date that can be passed in URL	37	/// Formats a time to a date that can be passed in URL
33	QString dateFormat(double sqpRange) noexcept	38	QString dateFormat(double sqpRange) noexcept
34	{	39	{
@@ -63,8 +68,9 AmdaProvider::AmdaProvider()
63	std::function<void(QNetworkReply *, QUuid)>)));	68	std::function<void(QNetworkReply *, QUuid)>)));
64		69
65		70
66	connect(&sqpApp->networkController(), ~~SIGNAL~~(~~replyDownloadProgress~~(~~QUuid~~, ~~double)),~~ ~~this~~,	71	connect(&sqpApp->networkController(),
67	SIGNAL(~~dataProvide~~dProgress(QUuid, double)));	72	SIGNAL(replyDownloadProgress(QUuid, const QNetworkRequest &, double)), this,
		73	SLOT(onReplyDownloadProgress(QUuid, const QNetworkRequest &, double)));
68	}	74	}
69	}	75	}
70		76
@@ -76,6 +82,7 void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderPar
76	for (const auto &dateTime : qAsConst(times)) {	82	for (const auto &dateTime : qAsConst(times)) {
77	this->retrieveData(acqIdentifier, dateTime, data);	83	this->retrieveData(acqIdentifier, dateTime, data);
78		84
		85
79	// TORM when AMDA will support quick asynchrone request	86	// TORM when AMDA will support quick asynchrone request
80	QThread::msleep(1000);	87	QThread::msleep(1000);
81	}	88	}
@@ -89,6 +96,55 void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
89	}	96	}
90	}	97	}
91		98
		99	void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
		100	const QNetworkRequest &networkRequest, double progress)
		101	{
		102	qCCritical(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << progress;
		103	auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		104	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		105
		106	qCCritical(LOG_AmdaProvider()) << tr("1 onReplyDownloadProgress") << progress;
		107	auto requestPtr = &networkRequest;
		108	auto findRequest
		109	= [requestPtr](const auto &entry) { return requestPtr == entry.first.get(); };
		110
		111	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		112	auto requestProgressMapEnd = requestProgressMap.end();
		113	auto requestProgressMapIt
		114	= std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
		115
		116	if (requestProgressMapIt != requestProgressMapEnd) {
		117	requestProgressMapIt->second = progress;
		118	}
		119	else {
		120	qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress");
		121	}
		122	}
		123
		124	acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		125	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		126	qCCritical(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress") << progress;
		127	double finalProgress = 0.0;
		128
		129	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		130	auto fraq = requestProgressMap.size();
		131
		132	for (auto requestProgress : requestProgressMap) {
		133	finalProgress += requestProgress.second;
		134	}
		135
		136	if (fraq > 0) {
		137	finalProgress = finalProgress / fraq;
		138	}
		139
		140	qCCritical(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress") << finalProgress;
		141	emit dataProvidedProgress(acqIdentifier, finalProgress);
		142	}
		143	else {
		144	emit dataProvidedProgress(acqIdentifier, 0.0);
		145	}
		146	}
		147
92	void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)	148	void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
93	{	149	{
94	// Retrieves product ID from data: if the value is invalid, no request is made	150	// Retrieves product ID from data: if the value is invalid, no request is made
@@ -137,6 +193,7 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
137	/// @todo ALX : debug	193	/// @todo ALX : debug
138	}	194	}
139	}	195	}
		196	m_AcqIdToRequestProgressMap.erase(dataId);
140	}	197	}
141		198
142	};	199	};
@@ -147,7 +204,6 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
147	if (reply->error() != QNetworkReply::OperationCanceledError) {	204	if (reply->error() != QNetworkReply::OperationCanceledError) {
148	auto downloadFileUrl = QUrl{QString{reply->readAll()}};	205	auto downloadFileUrl = QUrl{QString{reply->readAll()}};
149		206
150
151	qCInfo(LOG_AmdaProvider())	207	qCInfo(LOG_AmdaProvider())
152	<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;	208	<< tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
153	// Executes request for downloading file //	209	// Executes request for downloading file //
@@ -155,14 +211,44 void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVa
155	// Creates destination file	211	// Creates destination file
156	if (tempFile->open()) {	212	if (tempFile->open()) {
157	// Executes request	213	// Executes request
158	~~emit~~ request~~Constructed~~(~~QNetworkRequest~~{downloadFileUrl}, ~~dataId~~,	214	auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
159	httpDownloadFinished);	215	updateRequestProgress(dataId, request, 0.0);
		216	emit requestConstructed(*request.get(), dataId, httpDownloadFinished);
160	}	217	}
161	}	218	}
		219	else {
		220	m_AcqIdToRequestProgressMap.erase(dataId);
		221	}
162	};	222	};
163		223
164	// //////////////// //	224	// //////////////// //
165	// Executes request //	225	// Executes request //
166	// //////////////// //	226	// //////////////// //
167	emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);	227
		228	auto request = std::make_shared<QNetworkRequest>(url);
		229	updateRequestProgress(token, request, 0.0);
		230
		231	emit requestConstructed(*request.get(), token, httpFinishedLambda);
		232	}
		233
		234	void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
		235	std::shared_ptr<QNetworkRequest> request, double progress)
		236	{
		237	auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
		238	if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
		239	auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
		240	auto requestProgressMapIt = requestProgressMap.find(request);
		241	if (requestProgressMapIt != requestProgressMap.end()) {
		242	requestProgressMapIt->second = progress;
		243	}
		244	else {
		245	acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
		246	}
		247	}
		248	else {
		249	auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
		250	requestProgressMap.insert(std::make_pair(request, progress));
		251	m_AcqIdToRequestProgressMap.insert(
		252	std::make_pair(acqIdentifier, std::move(requestProgressMap)));
		253	}
168	}	254	}

plugins/mockplugin/src/CosinusProvider.cpp +7 -2

                             progress = currentProgress;
                             emit dataProvidedProgress(acqIdentifier, progress);
+                            qCInfo(LOG_CosinusProvider()) << "TORM: CosinusProvider::retrieveData"
+                                                          << QThread::currentThread()->objectName() << progress;
+                            // NOTE: Try to use multithread if possible
                         }
                     }
                     else {
                         }
                     }
                 }
-                emit dataProvidedProgress(acqIdentifier, 0.0);
+                if (progress != 100) {
+                    // We can close progression beacause all data has been retrieved
+                    emit dataProvidedProgress(acqIdentifier, 100);
+                }
                 return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData),
                                                       Unit{QStringLiteral("t"), true}, Unit{});
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages