HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r389:13937fa7979a

Implement the network controller to permit the execution of a request...

perrinel -

r389:13937fa7979a

parent child

Context file:

r389:13937fa7979a

core/include/Network/NetworkController.h +10 -4

             #include <QLoggingCategory>
             #include <QObject>
+            #include <QUuid>
             #include <Common/spimpl.h>
+            #include <functional>
             Q_DECLARE_LOGGING_CATEGORY(LOG_NetworkController)
             class QNetworkReply;
+            class QNetworkRequest;
             /**
              * @brief The NetworkController class aims to handle all network connection of SciQlop.
             public:
                 explicit NetworkController(QObject *parent = 0);
-                void execute(QNetworkReply *reply);
                 void initialize();
                 void finalize();
+            public slots:
+                void onProcessRequested(const QNetworkRequest &request, QUuid identifier,
+                                        std::function<void(QNetworkReply *, QUuid)> callback);
+                void onReplyCanceled(QUuid identifier);
             signals:
-                replyToRead();
+                void replyFinished(QNetworkReply *reply, QUuid identifier);
+                void replyDownloadProgress(QUuid identifier);
             private:
                 void waitForFinish();

core/src/Network/NetworkController.cpp +46 -11

             #include <QMutex>
             #include <QNetworkAccessManager>
             #include <QNetworkReply>
+            #include <QNetworkRequest>
             #include <QThread>
+            #include <unordered_map>
             Q_LOGGING_CATEGORY(LOG_NetworkController, "NetworkController")
             struct NetworkController::NetworkControllerPrivate {
-                explicit NetworkControllerPrivate(NetworkController *parent)
+                explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
-                        : m_WorkingMutex{}, m_AccessManager{std::make_unique<QNetworkAccessManager>()}
                 QMutex m_WorkingMutex;
+                std::unordered_map<QNetworkReply *, QUuid> m_NetworkReplyToVariableId;
                 std::unique_ptr<QNetworkAccessManager> m_AccessManager{nullptr};
             };
             NetworkController::NetworkController(QObject *parent)
                     : QObject(parent), impl{spimpl::make_unique_impl<NetworkControllerPrivate>(this)}
             {
             }
-            void NetworkController::execute(QNetworkReply *reply)
+            void NetworkController::onProcessRequested(const QNetworkRequest &request, QUuid identifier,
+                                                       std::function<void(QNetworkReply *, QUuid)> callback)
             {
-                auto replyReadyToRead =[reply, this] () {
+                qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
-                       auto content = reply->readAll();
+                                                 << QThread::currentThread();
+                auto reply = impl->m_AccessManager->get(request);
+                // Store the couple reply id
+                impl->m_NetworkReplyToVariableId[reply] = identifier;
-                       emit this->replyToRead();
+                auto onReplyFinished = [reply, this, identifier, callback]() {
+                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyFinished")
+                                                     << QThread::currentThread();
+                    auto it = impl->m_NetworkReplyToVariableId.find(reply);
+                    if (it != impl->m_NetworkReplyToVariableId.cend()) {
+                        callback(reply, identifier);
+                    }
                 };
-                connect(impl->m_Reply, &QNetworkReply::finished, this, replyReadyToRead);
+                auto onReplyDownloadProgress = [reply, this]() {
-                connect(impl->m_Reply, &QNetworkReply::aboutToClose, this, replyReadyToRead);
+                    qCDebug(LOG_NetworkController()) << tr("NetworkController onReplyDownloadProgress")
+                                                     << QThread::currentThread();
+                    auto it = impl->m_NetworkReplyToVariableId.find(reply);
+                    if (it != impl->m_NetworkReplyToVariableId.cend()) {
+                        emit this->replyDownloadProgress(it->second);
+                    }
+                };
+                connect(reply, &QNetworkReply::finished, this, onReplyFinished);
+                connect(reply, &QNetworkReply::downloadProgress, this, onReplyDownloadProgress);
             }
             void NetworkController::initialize()
             {
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init") << QThread::currentThread();
                 impl->m_WorkingMutex.lock();
+                impl->m_AccessManager = std::make_unique<QNetworkAccessManager>();
                 qCDebug(LOG_NetworkController()) << tr("NetworkController init END");
             }
                 impl->m_WorkingMutex.unlock();
             }
+            void NetworkController::onReplyCanceled(QUuid identifier)
+            {
+                auto findReply = [identifier](const auto &entry) { return identifier == entry.second; };
+                auto end = impl->m_NetworkReplyToVariableId.cend();
+                auto it = std::find_if(impl->m_NetworkReplyToVariableId.cbegin(), end, findReply);
+                if (it != end) {
+                    it->first->abort();
+                }
+            }
             void NetworkController::waitForFinish()
             {
                 QMutexLocker locker{&impl->m_WorkingMutex};

core/src/Variable/VariableController.cpp +8 -8

                 std::unordered_map<std::shared_ptr<Variable>, std::shared_ptr<IDataProvider> >
                     m_VariableToProviderMap;
-                std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToToken;
+                std::unordered_map<std::shared_ptr<Variable>, QUuid> m_VariableToIdentifier;
             };
             VariableController::VariableController(QObject *parent)
                 /// in sciqlop
                 auto dateTime = impl->m_TimeController->dateTime();
                 if (auto newVariable = impl->m_VariableModel->createVariable(name, dateTime)) {
-                    auto token = QUuid::createUuid();
+                    auto identifier = QUuid::createUuid();
                     // store the provider
                     impl->m_VariableToProviderMap[newVariable] = provider;
-                    impl->m_VariableToToken[newVariable] = token;
+                    impl->m_VariableToIdentifier[newVariable] = identifier;
                     auto addDateTimeAcquired = [ this, varW = std::weak_ptr<Variable>{newVariable} ](
-                        QUuid token, auto dataSeriesAcquired, auto dateTimeToPutInCache)
+                        QUuid identifier, auto dataSeriesAcquired, auto dateTimeToPutInCache)
                     {
                         if (auto variable = varW.lock()) {
-                            auto varToken = impl->m_VariableToToken.at(variable);
+                            auto varIdentifier = impl->m_VariableToIdentifier.at(variable);
-                            if (varToken == token) {
+                            if (varIdentifier == identifier) {
                                 impl->m_VariableCacheController->addDateTime(variable, dateTimeToPutInCache);
                                 variable->setDataSeries(dataSeriesAcquired);
                             }
                     if (!dateTimeListNotInCache.empty()) {
                         // Ask the provider for each data on the dateTimeListNotInCache
-                        auto token = impl->m_VariableToToken.at(variable);
+                        auto identifier = impl->m_VariableToIdentifier.at(variable);
                         impl->m_VariableToProviderMap.at(variable)->requestDataLoading(
-                            token, std::move(dateTimeListNotInCache));
+                            identifier, std::move(dateTimeListNotInCache));
                     }
                     else {
                         emit variable->updated();

gui/src/SqpApplication.cpp +1 -1

             SqpApplication::SqpApplication(int &argc, char **argv)
                     : QApplication{argc, argv}, impl{spimpl::make_unique_impl<SqpApplicationPrivate>()}
             {
-                qCInfo(LOG_SqpApplication()) << tr("SqpApplication construction");
+                qCDebug(LOG_SqpApplication()) << tr("SqpApplication construction") << QThread::currentThread();
                 connect(&impl->m_DataSourceControllerThread, &QThread::started,
                         impl->m_DataSourceController.get(), &DataSourceController::initialize);

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