GIT_REPOSITORIES/LPP/Users/mperrinel/SCIQLOP-Initialisation Commit - r701:87c4dffdd5b8

Fix progression bug when aborting a request for Amda plugin

perrinel -

r701:87c4dffdd5b8

parent child

Context file:

r701:87c4dffdd5b8

core/src/Variable/VariableAcquisitionWorker.cpp +7 -28

              #include "Variable/VariableAcquisitionWorker.h"
              #include "Variable/Variable.h"
              #include <Data/AcquisitionRequest.h>
              #include <Data/SqpRange.h>
              #include <unordered_map>
              #include <utility>
              #include <QMutex>
              #include <QReadWriteLock>
              #include <QThread>
              #include <cmath>
              Q_LOGGING_CATEGORY(LOG_VariableAcquisitionWorker, "VariableAcquisitionWorker")
              struct VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate {
                  explicit VariableAcquisitionWorkerPrivate(VariableAcquisitionWorker *parent)
                          : m_Lock{QReadWriteLock::Recursive}, q{parent}
                  {
                  }
                  void lockRead() { m_Lock.lockForRead(); }
                  void lockWrite() { m_Lock.lockForWrite(); }
                  void unlock() { m_Lock.unlock(); }
                  void removeVariableRequest(QUuid vIdentifier);
                  /// Remove the current request and execute the next one if exist
                  void updateToNextRequest(QUuid vIdentifier);
                  QMutex m_WorkingMutex;
                  QReadWriteLock m_Lock;
                  std::map<QUuid, QVector<AcquisitionDataPacket> > m_AcqIdentifierToAcqDataPacketVectorMap;
                  std::map<QUuid, AcquisitionRequest> m_AcqIdentifierToAcqRequestMap;
                  std::map<QUuid, std::pair<QUuid, QUuid> > m_VIdentifierToCurrrentAcqIdNextIdPairMap;
                  VariableAcquisitionWorker *q;
              };
              VariableAcquisitionWorker::VariableAcquisitionWorker(QObject *parent)
                      : QObject{parent}, impl{spimpl::make_unique_impl<VariableAcquisitionWorkerPrivate>(this)}
              {
              }
              VariableAcquisitionWorker::~VariableAcquisitionWorker()
              {
                  qCInfo(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker destruction")
                                                          << QThread::currentThread();
                  this->waitForFinish();
              }
              QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
                                                                   SqpRange rangeRequested,
                                                                   SqpRange cacheRangeRequested,
                                                                   DataProviderParameters parameters,
                                                                   std::shared_ptr<IDataProvider> provider)
              {
                  qCDebug(LOG_VariableAcquisitionWorker())
                      << tr("TORM VariableAcquisitionWorker::pushVariableRequest ") << cacheRangeRequested;
                  auto varRequestIdCanceled = QUuid();
                  // Request creation
                  auto acqRequest = AcquisitionRequest{};
                  acqRequest.m_VarRequestId = varRequestId;
                  acqRequest.m_vIdentifier = vIdentifier;
                  acqRequest.m_DataProviderParameters = parameters;
                  acqRequest.m_RangeRequested = rangeRequested;
                  acqRequest.m_CacheRangeRequested = cacheRangeRequested;
                  acqRequest.m_Size = parameters.m_Times.size();
                  acqRequest.m_Provider = provider;
                  // Register request
                  impl->lockWrite();
                  impl->m_AcqIdentifierToAcqRequestMap.insert(
                      std::make_pair(acqRequest.m_AcqIdentifier, acqRequest));
                  auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                  if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                      // A current request already exists, we can replace the next one
                      auto nextAcqId = it->second.second;
                      auto acqIdentifierToAcqRequestMapIt = impl->m_AcqIdentifierToAcqRequestMap.find(nextAcqId);
                      if (acqIdentifierToAcqRequestMapIt != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                          auto request = acqIdentifierToAcqRequestMapIt->second;
                          varRequestIdCanceled = request.m_VarRequestId;
                      }
                      it->second.second = acqRequest.m_AcqIdentifier;
                      impl->unlock();
                  }
                  else {
                      // First request for the variable, it must be stored and executed
                      impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.insert(
                          std::make_pair(vIdentifier, std::make_pair(acqRequest.m_AcqIdentifier, QUuid())));
                      impl->unlock();
                      QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
                                                Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
                  }
                  return varRequestIdCanceled;
              }
              void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
              {
-                 // TODO
                  impl->lockRead();
                  auto it = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                  if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                      auto currentAcqId = it->second.first;
                      auto it = impl->m_AcqIdentifierToAcqRequestMap.find(currentAcqId);
                      if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                          auto request = it->second;
                          impl->unlock();
                          // Remove the current request from the worker
                          impl->lockWrite();
                          impl->updateToNextRequest(vIdentifier);
                          impl->unlock();
                          // notify the request aborting to the provider
                          request.m_Provider->requestDataAborting(currentAcqId);
                      }
                      else {
                          impl->unlock();
                          qCWarning(LOG_VariableAcquisitionWorker())
                              << tr("Impossible to abort an unknown acquisition request") << currentAcqId;
                      }
                  }
                  else {
                      impl->unlock();
                  }
              }
              void VariableAcquisitionWorker::onVariableRetrieveDataInProgress(QUuid acqIdentifier,
                                                                               double progress)
              {
+                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM: onVariableRetrieveDataInProgress ")
+                                                          << acqIdentifier << progress;
                  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;
                      auto finalProgression = currentAlreadyProgress + currentPartProgress;
                      emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
+                     qCDebug(LOG_VariableAcquisitionWorker())
+                         << tr("TORM: onVariableRetrieveDataInProgress ") << aIdToARit->second.m_vIdentifier
+                         << currentPartSize << currentAlreadyProgress << currentPartProgress << 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("TORM: onVariableDataAcquired on range ")
                                                           << acqIdentifier << dataRangeAcquired;
                  impl->lockWrite();
                  auto aIdToARit = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                  if (aIdToARit != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
                      // Store the result
                      auto dataPacket = AcquisitionDataPacket{};
                      dataPacket.m_Range = dataRangeAcquired;
                      dataPacket.m_DateSeries = dataSeries;
                      auto aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                      if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                          // A current request result already exists, we can update it
                          aIdToADPVit->second.push_back(dataPacket);
                      }
                      else {
                          // First request result for the variable, it must be stored
                          impl->m_AcqIdentifierToAcqDataPacketVectorMap.insert(
                              std::make_pair(acqIdentifier, QVector<AcquisitionDataPacket>() << dataPacket));
                      }
                      // Decrement the counter of the request
                      auto &acqRequest = aIdToARit->second;
                      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 == acqRequest.m_Progression) {
                          // Return the data
                          aIdToADPVit = impl->m_AcqIdentifierToAcqDataPacketVectorMap.find(acqIdentifier);
                          if (aIdToADPVit != impl->m_AcqIdentifierToAcqDataPacketVectorMap.cend()) {
                              emit dataProvided(acqRequest.m_vIdentifier, acqRequest.m_RangeRequested,
                                                acqRequest.m_CacheRangeRequested, aIdToADPVit->second);
                          }
-                         // Execute the next one
-                         auto it
-                             = impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(acqRequest.m_vIdentifier);
-                         if (it != impl->m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
-                             if (it->second.second.isNull()) {
-                                 // There is no next request, we can remove the variable request
-                                 impl->removeVariableRequest(acqRequest.m_vIdentifier);
+                             }
-                             else {
-                                 auto acqIdentifierToRemove = it->second.first;
-                                 // Move the next request to the current request
-                                 it->second.first = it->second.second;
-                                 it->second.second = QUuid();
-                                 // Remove AcquisitionRequest and results;
-                                 impl->m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
-                                 impl->m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
-                                 // Execute the current request
-                                 QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
-                                                           Q_ARG(QUuid, it->second.first));
+                             }
+                         }
-                         else {
-                             qCCritical(LOG_VariableAcquisitionWorker())
-                                 << tr("Impossible to execute the acquisition on an unfound variable ");
+                         }
+                         // Update to the next request
+                         impl->updateToNextRequest(acqRequest.m_vIdentifier);
                      }
                  }
                  else {
                      qCWarning(LOG_VariableAcquisitionWorker())
                          << tr("Impossible to retrieve AcquisitionRequest for the incoming data.");
                  }
                  impl->unlock();
              }
              void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
              {
                  qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
                  impl->lockRead();
                  auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
                  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 {
                      impl->unlock();
                      // TODO log no acqIdentifier recognized
                  }
              }
              void VariableAcquisitionWorker::initialize()
              {
                  qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init")
                                                           << QThread::currentThread();
                  impl->m_WorkingMutex.lock();
                  qCDebug(LOG_VariableAcquisitionWorker()) << tr("VariableAcquisitionWorker init END");
              }
              void VariableAcquisitionWorker::finalize()
              {
                  impl->m_WorkingMutex.unlock();
              }
              void VariableAcquisitionWorker::waitForFinish()
              {
                  QMutexLocker locker{&impl->m_WorkingMutex};
              }
              void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::removeVariableRequest(
                  QUuid vIdentifier)
              {
                  lockWrite();
                  auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                  if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                      // A current request already exists, we can replace the next one
                      m_AcqIdentifierToAcqRequestMap.erase(it->second.first);
                      m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.first);
                      m_AcqIdentifierToAcqRequestMap.erase(it->second.second);
                      m_AcqIdentifierToAcqDataPacketVectorMap.erase(it->second.second);
                  }
                  m_VIdentifierToCurrrentAcqIdNextIdPairMap.erase(vIdentifier);
                  unlock();
              }
              void VariableAcquisitionWorker::VariableAcquisitionWorkerPrivate::updateToNextRequest(
                  QUuid vIdentifier)
              {
                  auto it = m_VIdentifierToCurrrentAcqIdNextIdPairMap.find(vIdentifier);
                  if (it != m_VIdentifierToCurrrentAcqIdNextIdPairMap.cend()) {
                      if (it->second.second.isNull()) {
                          // There is no next request, we can remove the variable request
                          removeVariableRequest(vIdentifier);
                      }
                      else {
                          auto acqIdentifierToRemove = it->second.first;
                          // Move the next request to the current request
                          it->second.first = it->second.second;
                          it->second.second = QUuid();
                          // Remove AcquisitionRequest and results;
                          m_AcqIdentifierToAcqRequestMap.erase(acqIdentifierToRemove);
                          m_AcqIdentifierToAcqDataPacketVectorMap.erase(acqIdentifierToRemove);
                          // Execute the current request
                          QMetaObject::invokeMethod(q, "onExecuteRequest", Qt::QueuedConnection,
                                                    Q_ARG(QUuid, it->second.first));
                      }
                  }
                  else {
                      qCCritical(LOG_VariableAcquisitionWorker())
                          << tr("Impossible to execute the acquisition on an unfound variable ");
                  }
              }

plugins/amda/src/AmdaProvider.cpp +14 -5

              #include "AmdaProvider.h"
              #include "AmdaDefs.h"
              #include "AmdaResultParser.h"
              #include <Common/DateUtils.h>
              #include <Data/DataProviderParameters.h>
              #include <Network/NetworkController.h>
              #include <SqpApplication.h>
              #include <Variable/Variable.h>
              #include <QNetworkAccessManager>
              #include <QNetworkReply>
              #include <QTemporaryFile>
              #include <QThread>
              Q_LOGGING_CATEGORY(LOG_AmdaProvider, "AmdaProvider")
              namespace {
              /// URL format for a request on AMDA server. The parameters are as follows:
              /// - %1: start date
              /// - %2: end date
              /// - %3: parameter id
              const auto AMDA_URL_FORMAT = QStringLiteral(
                  "http://amda.irap.omp.eu/php/rest/"
                  "getParameter.php?startTime=%1&stopTime=%2&parameterID=%3&outputFormat=ASCII&"
                  "timeFormat=ISO8601&gzip=0");
              /// Dates format passed in the URL (e.g 2013-09-23T09:00)
              const auto AMDA_TIME_FORMAT = QStringLiteral("yyyy-MM-ddThh:mm:ss");
              /// Formats a time to a date that can be passed in URL
              QString dateFormat(double sqpRange) noexcept
              {
                  auto dateTime = DateUtils::dateTime(sqpRange);
                  return dateTime.toString(AMDA_TIME_FORMAT);
              }
              AmdaResultParser::ValueType valueType(const QString &valueType)
              {
                  if (valueType == QStringLiteral("scalar")) {
                      return AmdaResultParser::ValueType::SCALAR;
                  }
                  else if (valueType == QStringLiteral("vector")) {
                      return AmdaResultParser::ValueType::VECTOR;
                  }
                  else {
                      return AmdaResultParser::ValueType::UNKNOWN;
                  }
              }
              } // namespace
              AmdaProvider::AmdaProvider()
              {
                  qCDebug(LOG_AmdaProvider()) << tr("AmdaProvider::AmdaProvider") << QThread::currentThread();
                  if (auto app = sqpApp) {
                      auto &networkController = app->networkController();
                      connect(this, SIGNAL(requestConstructed(std::shared_ptr<QNetworkRequest>, QUuid,
                                                              std::function<void(QNetworkReply *, QUuid)>)),
                              &networkController,
                              SLOT(onProcessRequested(std::shared_ptr<QNetworkRequest>, QUuid,
                                                      std::function<void(QNetworkReply *, QUuid)>)));
                      connect(&sqpApp->networkController(),
                              SIGNAL(replyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)),
                              this,
                              SLOT(onReplyDownloadProgress(QUuid, std::shared_ptr<QNetworkRequest>, double)));
                  }
              }
              std::shared_ptr<IDataProvider> AmdaProvider::clone() const
              {
                  // No copy is made in the clone
                  return std::make_shared<AmdaProvider>();
              }
              void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderParameters &parameters)
              {
                  // NOTE: Try to use multithread if possible
                  const auto times = parameters.m_Times;
                  const auto data = parameters.m_Data;
                  for (const auto &dateTime : qAsConst(times)) {
                      this->retrieveData(acqIdentifier, dateTime, data);
                      // TORM when AMDA will support quick asynchrone request
                      QThread::msleep(1000);
                  }
              }
              void AmdaProvider::requestDataAborting(QUuid acqIdentifier)
              {
                  if (auto app = sqpApp) {
                      auto &networkController = app->networkController();
                      networkController.onReplyCanceled(acqIdentifier);
                  }
              }
              void AmdaProvider::onReplyDownloadProgress(QUuid acqIdentifier,
                                                         std::shared_ptr<QNetworkRequest> networkRequest,
                                                         double progress)
              {
-                 qCDebug(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
-                                             << networkRequest.get() << progress;
+                 qCInfo(LOG_AmdaProvider()) << tr("onReplyDownloadProgress") << acqIdentifier
+                                            << networkRequest.get() << progress;
                  auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                  if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                      auto requestPtr = networkRequest;
                      auto findRequest = [requestPtr](const auto &entry) { return requestPtr == entry.first; };
                      auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                      auto requestProgressMapEnd = requestProgressMap.end();
                      auto requestProgressMapIt
                          = std::find_if(requestProgressMap.begin(), requestProgressMapEnd, findRequest);
                      if (requestProgressMapIt != requestProgressMapEnd) {
                          requestProgressMapIt->second = progress;
                      }
                      else {
-                         qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
-                                                        << acqIdentifier << networkRequest.get() << progress;
+                         // This case can happened when a progression is send after the request has been
+                         // finished.
+                         // Generaly the case when aborting a request
+                         qCWarning(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress")
+                                                       << acqIdentifier << networkRequest.get() << progress;
                      }
                  }
                  acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                  if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                      double finalProgress = 0.0;
                      auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                      auto fraq = requestProgressMap.size();
                      for (auto requestProgress : requestProgressMap) {
                          finalProgress += requestProgress.second;
                          qCDebug(LOG_AmdaProvider()) << tr("current final progress without freq:")
                                                      << finalProgress << requestProgress.second;
                      }
                      if (fraq > 0) {
                          finalProgress = finalProgress / fraq;
                      }
                      qCDebug(LOG_AmdaProvider()) << tr("2 onReplyDownloadProgress final progress") << fraq
                                                  << finalProgress;
                      emit dataProvidedProgress(acqIdentifier, finalProgress);
                  }
                  else {
-                     emit dataProvidedProgress(acqIdentifier, 0.0);
+                     // This case can happened when a progression is send after the request has been finished.
+                     // Generaly the case when aborting a request
+                     emit dataProvidedProgress(acqIdentifier, 100.0);
                  }
              }
              void AmdaProvider::retrieveData(QUuid token, const SqpRange &dateTime, const QVariantHash &data)
              {
                  // Retrieves product ID from data: if the value is invalid, no request is made
                  auto productId = data.value(AMDA_XML_ID_KEY).toString();
                  if (productId.isNull()) {
                      qCCritical(LOG_AmdaProvider()) << tr("Can't retrieve data: unknown product id");
                      return;
                  }
                  // Retrieves the data type that determines whether the expected format for the result file is
                  // scalar, vector...
                  auto productValueType = valueType(data.value(AMDA_DATA_TYPE_KEY).toString());
                  // /////////// //
                  // Creates URL //
                  // /////////// //
                  auto startDate = dateFormat(dateTime.m_TStart);
                  auto endDate = dateFormat(dateTime.m_TEnd);
                  auto url = QUrl{QString{AMDA_URL_FORMAT}.arg(startDate, endDate, productId)};
                  qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::retrieveData url:") << url;
                  auto tempFile = std::make_shared<QTemporaryFile>();
                  // LAMBDA
                  auto httpDownloadFinished = [this, dateTime, tempFile,
                                               productValueType](QNetworkReply *reply, QUuid dataId) noexcept {
                      // Don't do anything if the reply was abort
                      if (reply->error() != QNetworkReply::OperationCanceledError) {
                          if (tempFile) {
                              auto replyReadAll = reply->readAll();
                              if (!replyReadAll.isEmpty()) {
                                  tempFile->write(replyReadAll);
                              }
                              tempFile->close();
                              // Parse results file
                              if (auto dataSeries
                                  = AmdaResultParser::readTxt(tempFile->fileName(), productValueType)) {
                                  emit dataProvided(dataId, dataSeries, dateTime);
                              }
                              else {
                                  /// @todo ALX : debug
                              }
                          }
+                         qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
+                                                     << dataId;
                          m_AcqIdToRequestProgressMap.erase(dataId);
                      }
                  };
                  auto httpFinishedLambda
                      = [this, httpDownloadFinished, tempFile](QNetworkReply *reply, QUuid dataId) noexcept {
                            // Don't do anything if the reply was abort
                            if (reply->error() != QNetworkReply::OperationCanceledError) {
                                auto downloadFileUrl = QUrl{QString{reply->readAll()}};
                                qCDebug(LOG_AmdaProvider())
                                    << tr("TORM AmdaProvider::retrieveData downloadFileUrl:") << downloadFileUrl;
                                // Executes request for downloading file //
                                // Creates destination file
                                if (tempFile->open()) {
                                    // Executes request and store the request for progression
                                    auto request = std::make_shared<QNetworkRequest>(downloadFileUrl);
                                    updateRequestProgress(dataId, request, 0.0);
                                    emit requestConstructed(request, dataId, httpDownloadFinished);
                                }
                            }
                            else {
+                               qCDebug(LOG_AmdaProvider())
+                                   << tr("acquisition requests erase because of aborting") << dataId;
                                m_AcqIdToRequestProgressMap.erase(dataId);
                            }
                        };
                  // //////////////// //
                  // Executes request //
                  // //////////////// //
                  auto request = std::make_shared<QNetworkRequest>(url);
                  qCDebug(LOG_AmdaProvider()) << tr("First Request creation") << request.get();
                  updateRequestProgress(token, request, 0.0);
                  emit requestConstructed(request, token, httpFinishedLambda);
              }
              void AmdaProvider::updateRequestProgress(QUuid acqIdentifier,
                                                       std::shared_ptr<QNetworkRequest> request, double progress)
              {
                  auto acqIdToRequestProgressMapIt = m_AcqIdToRequestProgressMap.find(acqIdentifier);
                  if (acqIdToRequestProgressMapIt != m_AcqIdToRequestProgressMap.end()) {
                      auto &requestProgressMap = acqIdToRequestProgressMapIt->second;
                      auto requestProgressMapIt = requestProgressMap.find(request);
                      if (requestProgressMapIt != requestProgressMap.end()) {
                          requestProgressMapIt->second = progress;
                          qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new progress for request")
                                                      << acqIdentifier << request.get() << progress;
                      }
                      else {
                          qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new request") << acqIdentifier
                                                      << request.get() << progress;
                          acqIdToRequestProgressMapIt->second.insert(std::make_pair(request, progress));
                      }
                  }
                  else {
                      qCDebug(LOG_AmdaProvider()) << tr("updateRequestProgress new acqIdentifier")
                                                  << acqIdentifier << request.get() << progress;
                      auto requestProgressMap = std::map<std::shared_ptr<QNetworkRequest>, double>{};
                      requestProgressMap.insert(std::make_pair(request, progress));
                      m_AcqIdToRequestProgressMap.insert(
                          std::make_pair(acqIdentifier, std::move(requestProgressMap)));
                  }
              }

General Comments 2

perrinel

|

Pull request updated. Auto status change to "Under Review"

Changed commits:
  * 2 added
  * 0 removed

Changed files:
  * A core/include/Variable/VariableAcquisitionWorker.h
  * M core/include/Data/IDataProvider.h
  * M core/include/Variable/VariableController.h
  * M core/src/Network/NetworkController.cpp
  * M core/src/Variable/VariableAcquisitionWorker.cpp
  * M core/src/Variable/VariableController.cpp
  * M plugins/amda/src/AmdaProvider.cpp

Write
Preview

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

	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