GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork 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
+                 * @brief dataProvidedProgress notify the progression of the data identifier by acqIdentifier
-                    * identified by identifier
                  */
                 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")
+                        qCDebug(LOG_AmdaProvider()) << tr("Can't retrieve Request in progress") << acqIdentifier
-                                                      << acqIdentifier << networkRequest.get() << progress;
+                                                    << 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