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)
-                         : m_WorkingMutex{}, m_AccessManager{std::make_unique<QNetworkAccessManager>()}
+                 {
+                 }
+                 explicit NetworkControllerPrivate(NetworkController *parent) : m_WorkingMutex{} {}
                  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] () {
-                        auto content = reply->readAll();
+                 qCDebug(LOG_NetworkController()) << tr("NetworkController registered")
+                                                  << 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);
-                 connect(impl->m_Reply, &QNetworkReply::aboutToClose, this, replyReadyToRead);
+                 auto onReplyDownloadProgress = [reply, this]() {
+                     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);
-                             if (varToken == token) {
+                             auto varIdentifier = impl->m_VariableToIdentifier.at(variable);
+                             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