HG_REPOSITORIES/LPP/SciQLOP_Repos/SciQLop Commit - r761:ff170594501a

Implementation of automatic cancel for request that failed

perrinel -

r761:ff170594501a

parent child

Context file:

r761:ff170594501a

core/include/Data/IDataProvider.h +6 -2

                                    const SqpRange &dataRangeAcquired);
                  /**
-                     * @brief dataProvided send dataSeries under dateTime and that corresponds of the data
-                     * identified by identifier
+                  * @brief dataProvidedProgress notify the progression of the data identifier by acqIdentifier
-                     */
                  void dataProvidedProgress(QUuid acqIdentifier, double progress);
+                 /**
+                  * @brief dataProvidedFailed notify that data acquisition has failed
+                  */
+                 void dataProvidedFailed(QUuid acqIdentifier);
                  /**
                   * @brief requestConstructed send a request for the data identified by acqIdentifier

core/include/Variable/VariableAcquisitionWorker.h +5 0

                  void variableRequestInProgress(QUuid vIdentifier, double progress);
+                 void variableCanceledRequested(QUuid vIdentifier);
              public slots:
                  void onVariableDataAcquired(QUuid acqIdentifier, std::shared_ptr<IDataSeries> dataSeries,
                                              SqpRange dataRangeAcquired);
                  void onVariableRetrieveDataInProgress(QUuid acqIdentifier, double progress);
+                 void onVariableAcquisitionFailed(QUuid acqIdentifier);
              private:
                  void waitForFinish();

core/include/Variable/VariableController.h +1 0

                  /// Cancel the current request for the variable
                  void onAbortProgressRequested(std::shared_ptr<Variable> variable);
+                 void onAbortAcquisitionRequested(QUuid vIdentifier);
                  // synchronization group methods
                  void onAddSynchronizationGroupId(QUuid synchronizationGroupId);

core/src/Variable/VariableAcquisitionWorker.cpp +23 -1

                  // Request creation
                  auto acqRequest = AcquisitionRequest{};
+                 qCInfo(LOG_VariableAcquisitionWorker()) << tr("TpushVariableRequest ") << vIdentifier;
                  acqRequest.m_VarRequestId = varRequestId;
                  acqRequest.m_vIdentifier = vIdentifier;
                  acqRequest.m_DataProviderParameters = parameters;
                      auto finalProgression = currentAlreadyProgress + currentPartProgress;
                      emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, finalProgression);
                      qCDebug(LOG_VariableAcquisitionWorker())
-                         << tr("TORM: onVariableRetrieveDataInProgress ") << aIdToARit->second.m_vIdentifier
+                         << tr("TORM: onVariableRetrieveDataInProgress ")
+                         << QThread::currentThread()->objectName() << aIdToARit->second.m_vIdentifier
                          << currentPartSize << currentAlreadyProgress << currentPartProgress << finalProgression;
                      if (finalProgression == 100.0) {
                          emit variableRequestInProgress(aIdToARit->second.m_vIdentifier, 0.0);
                  impl->unlock();
              }
+             void VariableAcquisitionWorker::onVariableAcquisitionFailed(QUuid acqIdentifier)
+             {
+                 qCDebug(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
+                                                          << QThread::currentThread();
+                 impl->lockRead();
+                 auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
+                 if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
+                     auto request = it->second;
+                     impl->unlock();
+                     qCInfo(LOG_VariableAcquisitionWorker()) << tr("onVariableAcquisitionFailed")
+                                                             << acqIdentifier << request.m_vIdentifier
+                                                             << QThread::currentThread();
+                     emit variableCanceledRequested(request.m_vIdentifier);
+                 }
+                 else {
+                     impl->unlock();
+                     // TODO log no acqIdentifier recognized
+                 }
+             }
              void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
                                                                     std::shared_ptr<IDataSeries> dataSeries,
                                                                     SqpRange dataRangeAcquired)

core/src/Variable/VariableController.cpp +25 -4

                  connect(impl->m_VariableModel, &VariableModel::abortProgessRequested, this,
                          &VariableController::onAbortProgressRequested);
+                 connect(impl->m_VariableAcquisitionWorker.get(),
+                         &VariableAcquisitionWorker::variableCanceledRequested, this,
+                         &VariableController::onAbortAcquisitionRequested);
                  connect(impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::dataProvided, this,
                          &VariableController::onDataProvided);
                  connect(impl->m_VariableAcquisitionWorker.get(),
                          &VariableAcquisitionWorker::variableRequestInProgress, this,
                          &VariableController::onVariableRetrieveDataInProgress);
                  connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::started,
                          impl->m_VariableAcquisitionWorker.get(), &VariableAcquisitionWorker::initialize);
                  connect(&impl->m_VariableAcquisitionWorkerThread, &QThread::finished,
                      // Associate the provider
                      impl->m_VariableToProviderMap[newVariable] = provider;
+                     qCInfo(LOG_VariableController()) << "createVariable: " << identifier;
                      impl->m_VariableToIdentifierMap[newVariable] = identifier;
                  }
              }
+             void VariableController::onAbortAcquisitionRequested(QUuid vIdentifier)
+             {
+                 qCDebug(LOG_VariableController()) << "TORM: variableController::onAbortAcquisitionRequested"
+                                                   << QThread::currentThread()->objectName() << vIdentifier;
+                 if (auto var = impl->findVariable(vIdentifier)) {
+                     this->onAbortProgressRequested(var);
+                 }
+                 else {
+                     qCCritical(LOG_VariableController())
+                         << tr("Impossible to abort Acquisition Requestof a null variable");
+                 }
+             }
              void VariableController::onAddSynchronizationGroupId(QUuid synchronizationGroupId)
              {
                  qCDebug(LOG_VariableController()) << "TORM: VariableController::onAddSynchronizationGroupId"
                      connect(provider.get(), &IDataProvider::dataProvidedProgress,
                              m_VariableAcquisitionWorker.get(),
                              &VariableAcquisitionWorker::onVariableRetrieveDataInProgress);
+                     connect(provider.get(), &IDataProvider::dataProvidedFailed,
+                             m_VariableAcquisitionWorker.get(),
+                             &VariableAcquisitionWorker::onVariableAcquisitionFailed);
                  }
                  else {
                      qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
                              << varRequestId;
                      }
-                     qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  QUEUE ?")
-                                                       << varRequestIdQueue.size();
                      varRequestIdQueue.pop_front();
-                     qCDebug(LOG_VariableController()) << tr("2: erase REQUEST in  QUEUE ?")
-                                                       << varRequestIdQueue.size();
                      if (varRequestIdQueue.empty()) {
+                         qCDebug(LOG_VariableController())
+                             << tr("TORM Erase REQUEST because it has been accepted") << varId;
                          m_VarIdToVarRequestIdQueueMap.erase(varId);
                      }
                  }

plugins/amda/src/AmdaProvider.cpp +9 -3

                  const auto times = parameters.m_Times;
                  const auto data = parameters.m_Data;
                  for (const auto &dateTime : qAsConst(times)) {
-                     qCInfo(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
+                     qCDebug(LOG_AmdaProvider()) << tr("TORM AmdaProvider::requestDataLoading ") << acqIdentifier
                                                 << dateTime;
                      this->retrieveData(acqIdentifier, dateTime, data);
                          // 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;
+                         qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
+                                                     << networkRequest.get() << progress;
                      }
                      // Compute the current final progress and notify it
                              }
                              else {
                                  /// @todo ALX : debug
+                                 emit dataProvidedFailed(dataId);
                              }
                          }
                          qCDebug(LOG_AmdaProvider()) << tr("acquisition requests erase because of finishing")
                      }
                      else {
                          qCCritical(LOG_AmdaProvider()) << tr("httpDownloadFinished ERROR");
+                         emit dataProvidedFailed(dataId);
                      }
                  };
                                    updateRequestProgress(dataId, request, 0.0);
                                    emit requestConstructed(request, dataId, httpDownloadFinished);
                                }
+                               else {
+                                   emit dataProvidedFailed(dataId);
+                               }
                            }
                            else {
                                qCDebug(LOG_AmdaProvider())
                                    << tr("acquisition requests erase because of aborting") << dataId;
                                qCCritical(LOG_AmdaProvider()) << tr("httpFinishedLambda ERROR");
                                m_AcqIdToRequestProgressMap.erase(dataId);
+                               emit dataProvidedFailed(dataId);
                            }
                        };

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