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

Fork of HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop

Merge pull request 181 from SCIQLOP-Initialisation develop...
leroux -
r391:4e032e665b92 merge
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,3 +1,5
1 1 # Ignore false positive relative to App macro
2 2 \.h:\d+:.IPSIS_S04.*found: Ui
3 3
4 # Ignore false positive relative to macros
5 Main\.cpp:\d+:.*IPSIS_S04_VARIABLE.*found: (__ppc64__) No newline at end of file
Show file before | Show file after | Hide comments
@@ -24,7 +24,7 INCLUDE_DIRECTORIES(${SCIQLOP-PLUGIN_INCLUDE_DIR})
24 24 #
25 25 # Find Qt modules
26 26 #
27 SCIQLOP_FIND_QT(Core)
27 SCIQLOP_FIND_QT(Core Network)
28 28
29 29 #
30 30 # Compile the library library
@@ -39,7 +39,7 ADD_LIBRARY(${SQPCORE_LIBRARY_NAME} ${MODULE_SOURCES})
39 39 set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD 14)
40 40 set_property(TARGET ${SQPCORE_LIBRARY_NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
41 41 TARGET_LINK_LIBRARIES(${SQPCORE_LIBRARY_NAME})
42 qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core)
42 qt5_use_modules(${SQPCORE_LIBRARY_NAME} Core Network)
43 43
44 44 INSTALL(TARGETS ${SQPCORE_LIBRARY_NAME}
45 45 RUNTIME DESTINATION ${INSTALL_BINARY_DIR}
Show file before | Show file after | Hide comments
@@ -12,6 +12,8
12 12
13 13 class DataProviderParameters;
14 14 class IDataSeries;
15 class QNetworkReply;
16 class QNetworkRequest;
15 17
16 18 /**
17 19 * @brief The IDataProvider interface aims to declare a data provider.
@@ -27,14 +29,32 class IDataProvider : public QObject {
27 29 public:
28 30 virtual ~IDataProvider() noexcept = default;
29 31
30 virtual void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) = 0;
32 /**
33 * @brief requestDataLoading provide datas for the data identified by identifier for all
34 * SqpDateTime of dateTimeList
35 */
36 virtual void requestDataLoading(QUuid identifier, const QVector<SqpDateTime> &dateTimeList) = 0;
31 37
32 38 signals:
33 void dataProvided(QUuid token, std::shared_ptr<IDataSeries> dateSerie,
39 /**
40 * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
41 * identified by identifier
42 */
43 void dataProvided(QUuid identifier, std::shared_ptr<IDataSeries> dateSerie,
34 44 const SqpDateTime &dateTime);
45
46
47 /**
48 * @brief requestConstructed send a request for the data identified by identifier
49 * @callback is the methode call by the reply of the request when it is finished.
50 */
51 void requestConstructed(const QNetworkRequest &request, QUuid identifier,
52 std::function<void(QNetworkReply *, QUuid)> callback);
35 53 };
36 54
37 55 // Required for using shared_ptr in signals/slots
38 56 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_PTR_REGISTRY, std::shared_ptr<IDataProvider>)
57 SCIQLOP_REGISTER_META_TYPE(IDATAPROVIDER_FUNCTION_REGISTRY,
58 std::function<void(QNetworkReply *, QUuid)>)
39 59
40 60 #endif // SCIQLOP_IDATAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -3,11 +3,16
3 3
4 4 #include <QLoggingCategory>
5 5 #include <QObject>
6 #include <QUuid>
6 7
7 8 #include <Common/spimpl.h>
9 #include <functional>
8 10
9 11 Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
10 12
13 class QNetworkReply;
14 class QNetworkRequest;
15
11 16 /**
12 17 * @brief The NetworkController class aims to handle all network connection of SciQlop.
13 18 */
@@ -16,10 +21,18 class NetworkController : public QObject {
16 21 public:
17 22 explicit NetworkController(QObject *parent = 0);
18 23
19
20 24 void initialize();
21 25 void finalize();
22 26
27 public slots:
28 void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
29 std::function<void(QNetworkReply *, QUuid)> callback);
30 void onReplyCanceled(QUuid identifier);
31
32 signals:
33 void replyFinished(QNetworkReply *reply, QUuid identifier);
34 void replyDownloadProgress(QUuid identifier);
35
23 36 private:
24 37 void waitForFinish();
25 38
Show file before | Show file after | Hide comments
@@ -1,13 +1,21
1 1 #include "Network/NetworkController.h"
2 2
3 3 #include <QMutex>
4 #include <QNetworkAccessManager>
5 #include <QNetworkReply>
6 #include <QNetworkRequest>
4 7 #include <QThread>
5 8
9 #include <unordered_map>
10
6 11 Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
7 12
8 13 struct NetworkController::NetworkControllerPrivate {
9 14 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
10 15 QMutex m_WorkingMutex;
16
17 std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
18 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
11 19 };
12 20
13 21 NetworkController::NetworkController(QObject *parent)
@@ -15,10 +23,46 NetworkController::NetworkController(QObject *parent)
15 23 {
16 24 }
17 25
26 void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
27 std::function<void(QNetworkReply *, QUuid)> callback)
28 {
29 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
30 << QThread::currentThread();
31 auto reply = impl->m_AccessManager->get(request);
32
33 // Store the couple reply id
34 impl->m_NetworkReplyToVariableId[reply] = identifier;
35
36 auto onReplyFinished = [reply, this, identifier, callback]() {
37
38 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
39 << QThread::currentThread();
40 auto it = impl->m_NetworkReplyToVariableId.find(reply);
41 if (it != impl->m_NetworkReplyToVariableId.cend()) {
42 callback(reply, identifier);
43 }
44 };
45
46 auto onReplyDownloadProgress = [reply, this]() {
47
48 qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyDownloadProgress")
49 << QThread::currentThread();
50 auto it = impl->m_NetworkReplyToVariableId.find(reply);
51 if (it != impl->m_NetworkReplyToVariableId.cend()) {
52 emit this->replyDownloadProgress(it->second);
53 }
54 };
55
56
57 connect(reply, &QNetworkReply::finished, this, onReplyFinished);
58 connect(reply, &QNetworkReply::downloadProgress, this, onReplyDownloadProgress);
59 }
60
18 61 void NetworkController::initialize()
19 62 {
20 63 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
21 64 impl->m_WorkingMutex.lock();
65 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
22 66 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
23 67 }
24 68
@@ -27,6 +71,17 void NetworkController::finalize()
27 71 impl->m_WorkingMutex.unlock();
28 72 }
29 73
74 void NetworkController::onReplyCanceled(QUuid identifier)
75 {
76 auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
77
78 auto end = impl->m_NetworkReplyToVariableId.cend();
79 auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
80 if (it != end) {
81 it->first->abort();
82 }
83 }
84
30 85 void NetworkController::waitForFinish()
31 86 {
32 87 QMutexLocker locker{&impl->m_WorkingMutex};
Show file before | Show file after | Hide comments
@@ -38,7 +38,7 struct VariableController::VariableControllerPrivate {
38 38
39 39 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
40 40 m_VariableToProviderMap;
41 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToToken;
41 std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifier;
42 42 };
43 43
44 44 VariableController::VariableController(QObject *parent)
@@ -120,18 +120,18 void VariableController::createVariable(const QString &name,
120 120 /// in sciqlop
121 121 auto dateTime = impl->m_TimeController->dateTime();
122 122 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
123 auto token = QUuid::createUuid();
123 auto identifier = QUuid::createUuid();
124 124
125 125 // store the provider
126 126 impl->m_VariableToProviderMap[newVariable] = provider;
127 impl->m_VariableToToken[newVariable] = token;
127 impl->m_VariableToIdentifier[newVariable] = identifier;
128 128
129 129 auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
130 QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
130 QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
131 131 {
132 132 if (auto variable = varW.lock()) {
133 auto varToken = impl->m_VariableToToken.at(variable);
134 if (varToken == token) {
133 auto varIdentifier = impl->m_VariableToIdentifier.at(variable);
134 if (varIdentifier == identifier) {
135 135 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
136 136 variable->setDataSeries(dataSeriesAcquired);
137 137 }
@@ -173,9 +173,9 void VariableController::onRequestDataLoading(std::shared_ptr<Variable> variable
173 173
174 174 if (!dateTimeListNotInCache.empty()) {
175 175 // Ask the provider for each data on the dateTimeListNotInCache
176 auto token = impl->m_VariableToToken.at(variable);
176 auto identifier = impl->m_VariableToIdentifier.at(variable);
177 177 impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
178 token, std::move(dateTimeListNotInCache));
178 identifier, std::move(dateTimeListNotInCache));
179 179 }
180 180 else {
181 181 emit variable->updated();
Show file before | Show file after | Hide comments
@@ -8,6 +8,7 DataSourceItem\.h:\d+:.*IPSIS_S01.*
8 8 ArrayData\.h:\d+:.*IPSIS_S04_VARIABLE.*found: (D)
9 9 ArrayData\.h:\d+:.*IPSIS_S06.*found: (D)
10 10 ArrayData\.h:\d+:.*IPSIS_S06.*found: (Dim)
11 DataSeries\.h:\d+:.*IPSIS_S04_VARIABLE.*
11 12
12 13 # Ignore false positive relative to an alias
13 14 DataSourceItemAction\.h:\d+:.*IPSIS_S06.*found: (ExecuteFunction)
Show file before | Show file after | Hide comments
@@ -78,7 +78,7 public:
78 78 SqpApplication::SqpApplication(int &argc, char **argv)
79 79 : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
80 80 {
81 qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
81 qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
82 82
83 83 connect(&impl->m_DataSourceControllerThread, &QThread::started,
84 84 impl->m_DataSourceController.get(), &DataSourceController::initialize);
Show file before | Show file after | Hide comments
@@ -12,6 +12,8
12 12
13 13 Q_DECLARE_LOGGING_CATEGORY(LOG_AmdaProvider)
14 14
15 class QNetworkReply;
16
15 17 /**
16 18 * @brief The AmdaProvider class is an example of how a data provider can generate data
17 19 */
@@ -22,15 +24,15 public:
22 24 void requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList) override;
23 25
24 26 private:
25 void retrieveData(QUuid token, const DataProviderParameters &parameters) const;
27 void retrieveData(QUuid token, const DataProviderParameters &parameters);
26 28
27 29 class AmdaProviderPrivate;
28 30 spimpl::unique_impl_ptr<AmdaProviderPrivate> impl;
29 31
30 private slots:
31 void httpFinished() noexcept;
32 void httpDownloadFinished() noexcept;
33 void httpDownloadReadyRead() noexcept;
32 // private slots:
33 // void httpFinished(QNetworkReply *reply, QUuid dataId) noexcept;
34 // void httpDownloadFinished(QNetworkReply *reply, QUuid dataId) noexcept;
35 // void httpDownloadReadyRead(QNetworkReply *reply, QUuid dataId) noexcept;
34 36 };
35 37
36 38 #endif // SCIQLOP_AMDAPROVIDER_H
Show file before | Show file after | Hide comments
@@ -2,10 +2,14
2 2 #include "AmdaResultParser.h"
3 3
4 4 #include <Data/DataProviderParameters.h>
5 #include <Network/NetworkController.h>
6 #include <SqpApplication.h>
7 #include <Variable/Variable.h>
5 8
6 9 #include <QNetworkAccessManager>
7 10 #include <QNetworkReply>
8 11 #include <QTemporaryFile>
12 #include <QThread>
9 13
10 14 Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
11 15
@@ -30,18 +34,26 QString dateFormat(double sqpDateTime) noexcept
30 34 return dateTime.toString(AMDA_TIME_FORMAT);
31 35 }
32 36
37
33 38 } // namespace
34 39
35 40 struct AmdaProvider::AmdaProviderPrivate {
36 41 DataProviderParameters m_Params{};
37 42 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
38 43 QNetworkReply *m_Reply{nullptr};
39 std::unique_ptr<QTemporaryFile> m_File{nullptr};
44 // std::unique_ptr<QTemporaryFile> m_File{nullptr};
40 45 QUuid m_Token;
41 46 };
42 47
43 48 AmdaProvider::AmdaProvider() : impl{spimpl::make_unique_impl<AmdaProviderPrivate>()}
44 49 {
50 qCDebug(LOG_NetworkController()) << tr("AmdaProvider::AmdaProvider")
51 << QThread::currentThread();
52 if (auto app = sqpApp) {
53 auto &networkController = app->networkController();
54 connect(this, &AmdaProvider::requestConstructed, &networkController,
55 &NetworkController::onProcessRequested);
56 }
45 57 }
46 58
47 59 void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &dateTimeList)
@@ -52,7 +64,7 void AmdaProvider::requestDataLoading(QUuid token, const QVector<SqpDateTime> &d
52 64 }
53 65 }
54 66
55 void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters) const
67 void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &parameters)
56 68 {
57 69 // /////////// //
58 70 // Creates URL //
@@ -64,71 +76,53 void AmdaProvider::retrieveData(QUuid token, const DataProviderParameters &param
64 76
65 77 auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
66 78
67 // //////////////// //
68 // Executes request //
69 // //////////////// //
79 auto tempFile = std::make_shared<QTemporaryFile>();
70 80
71 impl->m_Token = token;
72 impl->m_Params = parameters;
73 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
74 impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{url});
75 connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpFinished);
76 }
77 81
78 void AmdaProvider::httpFinished() noexcept
79 {
80 // ////////////////////// //
81 // Gets download file url //
82 // ////////////////////// //
83
84 auto downloadFileUrl = QUrl{QString{impl->m_Reply->readAll()}};
85
86 // ///////////////////////////////////// //
87 // Executes request for downloading file //
88 // ///////////////////////////////////// //
89
90 // Deletes old reply
91 impl->m_Reply->deleteLater();
92 impl->m_Reply = nullptr;
93
94 // Creates destination file
95 impl->m_File = std::make_unique<QTemporaryFile>();
96 if (impl->m_File->open()) {
97 qCDebug(LOG_AmdaProvider()) << "Temp file: " << impl->m_File->fileName();
98
99 // Executes request
100 impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
101 impl->m_Reply = impl->m_AccessManager->get(QNetworkRequest{downloadFileUrl});
102 connect(impl->m_Reply, &QNetworkReply::finished, this,
103 &AmdaProvider::httpDownloadReadyRead);
104 connect(impl->m_Reply, &QNetworkReply::finished, this, &AmdaProvider::httpDownloadFinished);
105 }
106 }
82 // LAMBDA
83 auto httpDownloadFinished = [this, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
107 84
108 void AmdaProvider::httpDownloadFinished() noexcept
109 {
110 if (impl->m_File) {
111 impl->m_File->close();
85 if (tempFile) {
86 auto replyReadAll = reply->readAll();
87 if (!replyReadAll.isEmpty()) {
88 tempFile->write(replyReadAll);
89 }
90 tempFile->close();
112 91
113 // Parse results file
114 if (auto dataSeries = AmdaResultParser::readTxt(impl->m_File->fileName())) {
115 emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
116 }
117 else {
118 /// @todo ALX : debug
92 // Parse results file
93 if (auto dataSeries = AmdaResultParser::readTxt(tempFile->fileName())) {
94 emit dataProvided(impl->m_Token, dataSeries, impl->m_Params.m_Time);
95 }
96 else {
97 /// @todo ALX : debug
98 }
119 99 }
120 100
121 impl->m_File = nullptr;
122 }
101 // Deletes reply
102 reply->deleteLater();
103 reply = nullptr;
104 };
105 auto httpFinishedLambda = [this, httpDownloadFinished, tempFile](QNetworkReply *reply,
106 QUuid dataId) noexcept {
123 107
124 // Deletes reply
125 impl->m_Reply->deleteLater();
126 impl->m_Reply = nullptr;
127 }
108 auto downloadFileUrl = QUrl{QString{reply->readAll()}};
109 // Deletes old reply
110 reply->deleteLater();
128 111
129 void AmdaProvider::httpDownloadReadyRead() noexcept
130 {
131 if (impl->m_File) {
132 impl->m_File->write(impl->m_Reply->readAll());
133 }
112 // Executes request for downloading file //
113
114 // Creates destination file
115 if (tempFile->open()) {
116 // Executes request
117 emit requestConstructed(QNetworkRequest{downloadFileUrl}, dataId, httpDownloadFinished);
118 }
119 };
120
121 // //////////////// //
122 // Executes request //
123 // //////////////// //
124
125 impl->m_Token = token;
126 impl->m_Params = parameters;
127 emit requestConstructed(QNetworkRequest{url}, token, httpFinishedLambda);
134 128 }
General Comments 0
You need to be logged in to leave comments. Login now