From 3e1ed974ea5f370a29e5e93404b10188f817771e 2017-08-24 07:58:46
From: mperrinel <mperrinel@itlink.fr>
Date: 2017-08-24 07:58:46
Subject: [PATCH] Merge branch 'feature/SynchroImpl' into develop
---

diff --git a/core/include/Data/AcquisitionRequest.h b/core/include/Data/AcquisitionRequest.h
index f1cc89d..d9d338a 100644
--- a/core/include/Data/AcquisitionRequest.h
+++ b/core/include/Data/AcquisitionRequest.h
@@ -14,16 +14,16 @@
 #include <memory>
 
 /**
- * @brief The AcquisitionRequest struct holds the information of an acquisition request
+ * @brief The AcquisitionRequest struct holds the information of an variable request
  */
 struct AcquisitionRequest {
     AcquisitionRequest()
     {
-
         m_AcqIdentifier = QUuid::createUuid();
         m_Size = 0;
     }
 
+    QUuid m_VarRequestId;
     QUuid m_AcqIdentifier;
     QUuid m_vIdentifier;
     DataProviderParameters m_DataProviderParameters;
diff --git a/core/include/Data/VariableRequest.h b/core/include/Data/VariableRequest.h
new file mode 100644
index 0000000..4356735
--- /dev/null
+++ b/core/include/Data/VariableRequest.h
@@ -0,0 +1,28 @@
+#ifndef SCIQLOP_VARIABLEREQUEST_H
+#define SCIQLOP_VARIABLEREQUEST_H
+
+#include <QObject>
+
+#include <QUuid>
+
+#include <Common/MetaTypes.h>
+#include <Data/IDataSeries.h>
+#include <Data/SqpRange.h>
+
+#include <memory>
+
+/**
+ * @brief The VariableRequest struct holds the information of an acquisition request
+ */
+struct VariableRequest {
+    VariableRequest() { m_CanUpdate = false; }
+
+    SqpRange m_RangeRequested;
+    SqpRange m_CacheRangeRequested;
+    std::shared_ptr<IDataSeries> m_DataSeries;
+    bool m_CanUpdate;
+};
+
+SCIQLOP_REGISTER_META_TYPE(VARIABLEREQUEST_REGISTRY, VariableRequest)
+
+#endif // SCIQLOP_VARIABLEREQUEST_H
diff --git a/core/include/Variable/VariableAcquisitionWorker.h b/core/include/Variable/VariableAcquisitionWorker.h
index d2adf83..4c76379 100644
--- a/core/include/Variable/VariableAcquisitionWorker.h
+++ b/core/include/Variable/VariableAcquisitionWorker.h
@@ -28,9 +28,9 @@ public:
     explicit VariableAcquisitionWorker(QObject *parent = 0);
     virtual ~VariableAcquisitionWorker();
 
-    void pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
-                             SqpRange cacheRangeRequested, DataProviderParameters parameters,
-                             std::shared_ptr<IDataProvider> provider);
+    QUuid pushVariableRequest(QUuid varRequestId, QUuid vIdentifier, SqpRange rangeRequested,
+                              SqpRange cacheRangeRequested, DataProviderParameters parameters,
+                              std::shared_ptr<IDataProvider> provider);
 
     void abortProgressRequested(QUuid vIdentifier);
 
diff --git a/core/include/Variable/VariableCacheStrategy.h b/core/include/Variable/VariableCacheStrategy.h
index 50f417e..da94ff4 100644
--- a/core/include/Variable/VariableCacheStrategy.h
+++ b/core/include/Variable/VariableCacheStrategy.h
@@ -29,8 +29,8 @@ class SCIQLOP_CORE_EXPORT VariableCacheStrategy : public QObject {
 public:
     explicit VariableCacheStrategy(QObject *parent = 0);
 
-    std::pair<SqpRange, SqpRange> computeCacheRange(const SqpRange &vRange,
-                                                    const SqpRange &rangeRequested);
+    std::pair<SqpRange, SqpRange> computeStrategyRanges(const SqpRange &vRange,
+                                                        const SqpRange &rangeRequested);
 
 private:
     class VariableCacheStrategyPrivate;
diff --git a/core/src/Variable/VariableAcquisitionWorker.cpp b/core/src/Variable/VariableAcquisitionWorker.cpp
index 3d10846..93aa9bb 100644
--- a/core/src/Variable/VariableAcquisitionWorker.cpp
+++ b/core/src/Variable/VariableAcquisitionWorker.cpp
@@ -46,16 +46,19 @@ VariableAcquisitionWorker::~VariableAcquisitionWorker()
 }
 
 
-void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange rangeRequested,
-                                                    SqpRange cacheRangeRequested,
-                                                    DataProviderParameters parameters,
-                                                    std::shared_ptr<IDataProvider> provider)
+QUuid VariableAcquisitionWorker::pushVariableRequest(QUuid varRequestId, QUuid vIdentifier,
+                                                     SqpRange rangeRequested,
+                                                     SqpRange cacheRangeRequested,
+                                                     DataProviderParameters parameters,
+                                                     std::shared_ptr<IDataProvider> provider)
 {
-    qCInfo(LOG_VariableAcquisitionWorker())
+    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;
@@ -63,6 +66,7 @@ void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange 
     acqRequest.m_Size = parameters.m_Times.size();
     acqRequest.m_Provider = provider;
 
+
     // Register request
     impl->lockWrite();
     impl->m_AcqIdentifierToAcqRequestMap.insert(
@@ -71,6 +75,13 @@ void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange 
     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();
     }
@@ -83,6 +94,8 @@ void VariableAcquisitionWorker::pushVariableRequest(QUuid vIdentifier, SqpRange 
         QMetaObject::invokeMethod(this, "onExecuteRequest", Qt::QueuedConnection,
                                   Q_ARG(QUuid, acqRequest.m_AcqIdentifier));
     }
+
+    return varRequestIdCanceled;
 }
 
 void VariableAcquisitionWorker::abortProgressRequested(QUuid vIdentifier)
@@ -173,7 +186,7 @@ void VariableAcquisitionWorker::onVariableDataAcquired(QUuid acqIdentifier,
 
 void VariableAcquisitionWorker::onExecuteRequest(QUuid acqIdentifier)
 {
-    qCInfo(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
+    qCDebug(LOG_VariableAcquisitionWorker()) << tr("onExecuteRequest") << QThread::currentThread();
     impl->lockRead();
     auto it = impl->m_AcqIdentifierToAcqRequestMap.find(acqIdentifier);
     if (it != impl->m_AcqIdentifierToAcqRequestMap.cend()) {
diff --git a/core/src/Variable/VariableCacheStrategy.cpp b/core/src/Variable/VariableCacheStrategy.cpp
index 8ab1a85..962c5b6 100644
--- a/core/src/Variable/VariableCacheStrategy.cpp
+++ b/core/src/Variable/VariableCacheStrategy.cpp
@@ -20,7 +20,7 @@ VariableCacheStrategy::VariableCacheStrategy(QObject *parent)
 }
 
 std::pair<SqpRange, SqpRange>
-VariableCacheStrategy::computeCacheRange(const SqpRange &vRange, const SqpRange &rangeRequested)
+VariableCacheStrategy::computeStrategyRanges(const SqpRange &vRange, const SqpRange &rangeRequested)
 {
 
     auto varRanges = std::pair<SqpRange, SqpRange>{};
diff --git a/core/src/Variable/VariableController.cpp b/core/src/Variable/VariableController.cpp
index 1df9fed..fa8e248 100644
--- a/core/src/Variable/VariableController.cpp
+++ b/core/src/Variable/VariableController.cpp
@@ -1,6 +1,5 @@
 #include <Variable/Variable.h>
 #include <Variable/VariableAcquisitionWorker.h>
-#include <Variable/VariableCacheController.h>
 #include <Variable/VariableCacheStrategy.h>
 #include <Variable/VariableController.h>
 #include <Variable/VariableModel.h>
@@ -9,6 +8,7 @@
 #include <Data/DataProviderParameters.h>
 #include <Data/IDataProvider.h>
 #include <Data/IDataSeries.h>
+#include <Data/VariableRequest.h>
 #include <Time/TimeController.h>
 
 #include <QMutex>
@@ -16,6 +16,7 @@
 #include <QUuid>
 #include <QtCore/QItemSelectionModel>
 
+#include <deque>
 #include <set>
 #include <unordered_map>
 
@@ -78,7 +79,6 @@ struct VariableController::VariableControllerPrivate {
             : m_WorkingMutex{},
               m_VariableModel{new VariableModel{parent}},
               m_VariableSelectionModel{new QItemSelectionModel{m_VariableModel, parent}},
-              m_VariableCacheController{std::make_unique<VariableCacheController>()},
               m_VariableCacheStrategy{std::make_unique<VariableCacheStrategy>()},
               m_VariableAcquisitionWorker{std::make_unique<VariableAcquisitionWorker>()},
               q{parent}
@@ -97,7 +97,8 @@ struct VariableController::VariableControllerPrivate {
     }
 
 
-    void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested);
+    void processRequest(std::shared_ptr<Variable> var, const SqpRange &rangeRequested,
+                        QUuid varRequestId);
 
     QVector<SqpRange> provideNotInCacheDateTimeList(std::shared_ptr<Variable> variable,
                                                     const SqpRange &dateTime);
@@ -108,6 +109,11 @@ struct VariableController::VariableControllerPrivate {
 
     void registerProvider(std::shared_ptr<IDataProvider> provider);
 
+    void storeVariableRequest(QUuid varId, QUuid varRequestId, const VariableRequest &varRequest);
+    QUuid acceptVariableRequest(QUuid varId, std::shared_ptr<IDataSeries> dataSeries);
+    void updateVariableRequest(QUuid varRequestId);
+    void cancelVariableRequest(QUuid varRequestId);
+
     QMutex m_WorkingMutex;
     /// Variable model. The VariableController has the ownership
     VariableModel *m_VariableModel;
@@ -115,7 +121,6 @@ struct VariableController::VariableControllerPrivate {
 
 
     TimeController *m_TimeController{nullptr};
-    std::unique_ptr<VariableCacheController> m_VariableCacheController;
     std::unique_ptr<VariableCacheStrategy> m_VariableCacheStrategy;
     std::unique_ptr<VariableAcquisitionWorker> m_VariableAcquisitionWorker;
     QThread m_VariableAcquisitionWorkerThread;
@@ -128,6 +133,10 @@ struct VariableController::VariableControllerPrivate {
     std::map<QUuid, QUuid> m_VariableIdGroupIdMap;
     std::set<std::shared_ptr<IDataProvider> > m_ProviderSet;
 
+    std::map<QUuid, std::map<QUuid, VariableRequest> > m_VarRequestIdToVarIdVarRequestMap;
+
+    std::map<QUuid, std::deque<QUuid> > m_VarIdToVarRequestIdQueueMap;
+
 
     VariableController *q;
 };
@@ -199,8 +208,6 @@ void VariableController::deleteVariable(std::shared_ptr<Variable> variable) noex
         << tr("Number of providers deleted for variable %1: %2")
                .arg(variable->name(), QString::number(nbProvidersDeleted));
 
-    // Clears cache
-    impl->m_VariableCacheController->clear(variable);
 
     // Deletes from model
     impl->m_VariableModel->deleteVariable(variable);
@@ -241,7 +248,10 @@ VariableController::createVariable(const QString &name, const QVariantHash &meta
         impl->m_VariableToIdentifierMap[newVariable] = identifier;
 
 
-        impl->processRequest(newVariable, range);
+        auto varRequestId = QUuid::createUuid();
+        qCInfo(LOG_VariableController()) << "processRequest for" << name << varRequestId;
+        impl->processRequest(newVariable, range, varRequestId);
+        impl->updateVariableRequest(varRequestId);
 
         return newVariable;
     }
@@ -249,41 +259,32 @@ VariableController::createVariable(const QString &name, const QVariantHash &meta
 
 void VariableController::onDateTimeOnSelection(const SqpRange &dateTime)
 {
-    // TODO check synchronisation
+    // TODO check synchronisation and Rescale
     qCDebug(LOG_VariableController()) << "VariableController::onDateTimeOnSelection"
                                       << QThread::currentThread()->objectName();
     auto selectedRows = impl->m_VariableSelectionModel->selectedRows();
+    auto varRequestId = QUuid::createUuid();
 
     for (const auto &selectedRow : qAsConst(selectedRows)) {
         if (auto selectedVariable = impl->m_VariableModel->variable(selectedRow.row())) {
             selectedVariable->setRange(dateTime);
-            impl->processRequest(selectedVariable, dateTime);
+            impl->processRequest(selectedVariable, dateTime, varRequestId);
 
             // notify that rescale operation has to be done
             emit rangeChanged(selectedVariable, dateTime);
         }
     }
+    impl->updateVariableRequest(varRequestId);
 }
 
 void VariableController::onDataProvided(QUuid vIdentifier, const SqpRange &rangeRequested,
                                         const SqpRange &cacheRangeRequested,
                                         QVector<AcquisitionDataPacket> dataAcquired)
 {
-    if (auto var = impl->findVariable(vIdentifier)) {
-        var->setRange(rangeRequested);
-        var->setCacheRange(cacheRangeRequested);
-        qCDebug(LOG_VariableController()) << tr("1: onDataProvided") << rangeRequested;
-        qCDebug(LOG_VariableController()) << tr("2: onDataProvided") << cacheRangeRequested;
-
-        auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
-        qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
-                                          << retrievedDataSeries->range();
-        var->mergeDataSeries(retrievedDataSeries);
-        qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
-        emit var->updated();
-    }
-    else {
-        qCCritical(LOG_VariableController()) << tr("Impossible to provide data to a null variable");
+    auto retrievedDataSeries = impl->retrieveDataSeries(dataAcquired);
+    auto varRequestId = impl->acceptVariableRequest(vIdentifier, retrievedDataSeries);
+    if (!varRequestId.isNull()) {
+        impl->updateVariableRequest(varRequestId);
     }
 }
 
@@ -363,22 +364,25 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
 {
     // NOTE: oldRange isn't really necessary since oldRange == variable->range().
 
-    qCDebug(LOG_VariableController()) << "VariableController::onRequestDataLoading"
-                                      << QThread::currentThread()->objectName();
     // we want to load data of the variable for the dateTime.
     // First we check if the cache contains some of them.
     // For the other, we ask the provider to give them.
 
+    auto varRequestId = QUuid::createUuid();
+    qCInfo(LOG_VariableController()) << "VariableController::onRequestDataLoading"
+                                     << QThread::currentThread()->objectName() << varRequestId;
+
     for (const auto &var : variables) {
-        qCDebug(LOG_VariableController()) << "processRequest for" << var->name();
-        impl->processRequest(var, range);
+        qCDebug(LOG_VariableController()) << "processRequest for" << var->name() << varRequestId;
+        impl->processRequest(var, range, varRequestId);
     }
 
     if (synchronise) {
         // Get the group ids
         qCDebug(LOG_VariableController())
             << "TORM VariableController::onRequestDataLoading for synchro var ENABLE";
-        auto groupIds = std::set<QUuid>();
+        auto groupIds = std::set<QUuid>{};
+        auto groupIdToOldRangeMap = std::map<QUuid, SqpRange>{};
         for (const auto &var : variables) {
             auto varToVarIdIt = impl->m_VariableToIdentifierMap.find(var);
             if (varToVarIdIt != impl->m_VariableToIdentifierMap.cend()) {
@@ -386,6 +390,7 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
                 auto varIdToGroupIdIt = impl->m_VariableIdGroupIdMap.find(vId);
                 if (varIdToGroupIdIt != impl->m_VariableIdGroupIdMap.cend()) {
                     auto gId = varIdToGroupIdIt->second;
+                    groupIdToOldRangeMap.insert(std::make_pair(gId, var->range()));
                     if (groupIds.find(gId) == groupIds.cend()) {
                         qCDebug(LOG_VariableController()) << "Synchro detect group " << gId;
                         groupIds.insert(gId);
@@ -407,9 +412,10 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
                     if (var != nullptr) {
                         qCDebug(LOG_VariableController()) << "processRequest synchro for"
                                                           << var->name();
-                        auto vSyncRangeRequested
-                            = computeSynchroRangeRequested(var->range(), range, oldRange);
-                        impl->processRequest(var, vSyncRangeRequested);
+                        auto vSyncRangeRequested = computeSynchroRangeRequested(
+                            var->range(), range, groupIdToOldRangeMap.at(gId));
+                        qCDebug(LOG_VariableController()) << "synchro RR" << vSyncRangeRequested;
+                        impl->processRequest(var, vSyncRangeRequested, varRequestId);
                     }
                     else {
                         qCCritical(LOG_VariableController())
@@ -420,6 +426,8 @@ void VariableController::onRequestDataLoading(QVector<std::shared_ptr<Variable> 
             }
         }
     }
+
+    impl->updateVariableRequest(varRequestId);
 }
 
 
@@ -463,22 +471,43 @@ AcquisitionZoomType VariableController::getZoomType(const SqpRange &range, const
 }
 
 void VariableController::VariableControllerPrivate::processRequest(std::shared_ptr<Variable> var,
-                                                                   const SqpRange &rangeRequested)
+                                                                   const SqpRange &rangeRequested,
+                                                                   QUuid varRequestId)
 {
 
-    auto varRangesRequested
-        = m_VariableCacheStrategy->computeCacheRange(var->range(), rangeRequested);
-    auto notInCacheRangeList = var->provideNotInCacheRangeList(varRangesRequested.second);
-    auto inCacheRangeList = var->provideInCacheRangeList(varRangesRequested.second);
+    // TODO: protect at
+    auto varRequest = VariableRequest{};
+    auto varId = m_VariableToIdentifierMap.at(var);
+
+    auto varStrategyRangesRequested
+        = m_VariableCacheStrategy->computeStrategyRanges(var->range(), rangeRequested);
+    auto notInCacheRangeList = var->provideNotInCacheRangeList(varStrategyRangesRequested.second);
+    auto inCacheRangeList = var->provideInCacheRangeList(varStrategyRangesRequested.second);
 
     if (!notInCacheRangeList.empty()) {
-        auto identifier = m_VariableToIdentifierMap.at(var);
+        varRequest.m_RangeRequested = varStrategyRangesRequested.first;
+        varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
+        qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest RR ") << rangeRequested;
+        qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest R  ")
+                                                 << varStrategyRangesRequested.first;
+        qCDebug(LOG_VariableAcquisitionWorker()) << tr("TORM processRequest CR ")
+                                                 << varStrategyRangesRequested.second;
+        // store VarRequest
+        storeVariableRequest(varId, varRequestId, varRequest);
+
         auto varProvider = m_VariableToProviderMap.at(var);
         if (varProvider != nullptr) {
-            m_VariableAcquisitionWorker->pushVariableRequest(
-                identifier, varRangesRequested.first, varRangesRequested.second,
+            auto varRequestIdCanceled = m_VariableAcquisitionWorker->pushVariableRequest(
+                varRequestId, varId, varStrategyRangesRequested.first,
+                varStrategyRangesRequested.second,
                 DataProviderParameters{std::move(notInCacheRangeList), var->metadata()},
                 varProvider);
+
+            if (!varRequestIdCanceled.isNull()) {
+                qCInfo(LOG_VariableAcquisitionWorker()) << tr("varRequestIdCanceled: ")
+                                                        << varRequestIdCanceled;
+                cancelVariableRequest(varRequestIdCanceled);
+            }
         }
         else {
             qCCritical(LOG_VariableController())
@@ -490,10 +519,13 @@ void VariableController::VariableControllerPrivate::processRequest(std::shared_p
         }
     }
     else {
-        var->setRange(rangeRequested);
-        var->setCacheRange(varRangesRequested.second);
-        var->setDataSeries(var->dataSeries()->subDataSeries(varRangesRequested.second));
-        emit var->updated();
+
+        varRequest.m_RangeRequested = varStrategyRangesRequested.first;
+        varRequest.m_CacheRangeRequested = varStrategyRangesRequested.second;
+        // store VarRequest
+        storeVariableRequest(varId, varRequestId, varRequest);
+        acceptVariableRequest(varId,
+                              var->dataSeries()->subDataSeries(varStrategyRangesRequested.second));
     }
 }
 
@@ -550,3 +582,157 @@ void VariableController::VariableControllerPrivate::registerProvider(
         qCDebug(LOG_VariableController()) << tr("Cannot register provider, it already exists ");
     }
 }
+
+void VariableController::VariableControllerPrivate::storeVariableRequest(
+    QUuid varId, QUuid varRequestId, const VariableRequest &varRequest)
+{
+    // First request for the variable. we can create an entry for it
+    auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
+    if (varIdToVarRequestIdQueueMapIt == m_VarIdToVarRequestIdQueueMap.cend()) {
+        auto varRequestIdQueue = std::deque<QUuid>{};
+        qCDebug(LOG_VariableController()) << tr("Store REQUEST in  QUEUE");
+        varRequestIdQueue.push_back(varRequestId);
+        m_VarIdToVarRequestIdQueueMap.insert(std::make_pair(varId, std::move(varRequestIdQueue)));
+    }
+    else {
+        qCDebug(LOG_VariableController()) << tr("Store REQUEST in EXISTING QUEUE");
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestIdQueue.push_back(varRequestId);
+    }
+
+    auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+    if (varRequestIdToVarIdVarRequestMapIt == m_VarRequestIdToVarIdVarRequestMap.cend()) {
+        auto varIdToVarRequestMap = std::map<QUuid, VariableRequest>{};
+        varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
+        qCDebug(LOG_VariableController()) << tr("Store REQUESTID in MAP");
+        m_VarRequestIdToVarIdVarRequestMap.insert(
+            std::make_pair(varRequestId, std::move(varIdToVarRequestMap)));
+    }
+    else {
+        auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+        qCDebug(LOG_VariableController()) << tr("Store REQUESTID in EXISTING MAP");
+        varIdToVarRequestMap.insert(std::make_pair(varId, varRequest));
+    }
+}
+
+QUuid VariableController::VariableControllerPrivate::acceptVariableRequest(
+    QUuid varId, std::shared_ptr<IDataSeries> dataSeries)
+{
+    QUuid varRequestId;
+    auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.find(varId);
+    if (varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.cend()) {
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestId = varRequestIdQueue.front();
+        auto varRequestIdToVarIdVarRequestMapIt
+            = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+        if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
+            auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+            auto varIdToVarRequestMapIt = varIdToVarRequestMap.find(varId);
+            if (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) {
+                qCDebug(LOG_VariableController()) << tr("acceptVariableRequest");
+                auto &varRequest = varIdToVarRequestMapIt->second;
+                varRequest.m_DataSeries = dataSeries;
+                varRequest.m_CanUpdate = true;
+            }
+            else {
+                qCDebug(LOG_VariableController())
+                    << tr("Impossible to acceptVariableRequest of a unknown variable id attached "
+                          "to a variableRequestId")
+                    << varRequestId << varId;
+            }
+        }
+        else {
+            qCCritical(LOG_VariableController())
+                << tr("Impossible to acceptVariableRequest of a unknown variableRequestId")
+                << 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()) {
+            m_VarIdToVarRequestIdQueueMap.erase(varId);
+        }
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Impossible to acceptVariableRequest of a unknown variable id") << varId;
+    }
+
+    return varRequestId;
+}
+
+void VariableController::VariableControllerPrivate::updateVariableRequest(QUuid varRequestId)
+{
+
+    auto varRequestIdToVarIdVarRequestMapIt = m_VarRequestIdToVarIdVarRequestMap.find(varRequestId);
+    if (varRequestIdToVarIdVarRequestMapIt != m_VarRequestIdToVarIdVarRequestMap.cend()) {
+        bool processVariableUpdate = true;
+        auto &varIdToVarRequestMap = varRequestIdToVarIdVarRequestMapIt->second;
+        for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
+             (varIdToVarRequestMapIt != varIdToVarRequestMap.cend()) && processVariableUpdate;
+             ++varIdToVarRequestMapIt) {
+            processVariableUpdate &= varIdToVarRequestMapIt->second.m_CanUpdate;
+            qCDebug(LOG_VariableController()) << tr("updateVariableRequest")
+                                              << processVariableUpdate;
+        }
+
+        if (processVariableUpdate) {
+            for (auto varIdToVarRequestMapIt = varIdToVarRequestMap.cbegin();
+                 varIdToVarRequestMapIt != varIdToVarRequestMap.cend(); ++varIdToVarRequestMapIt) {
+                if (auto var = findVariable(varIdToVarRequestMapIt->first)) {
+                    auto &varRequest = varIdToVarRequestMapIt->second;
+                    var->setRange(varRequest.m_RangeRequested);
+                    var->setCacheRange(varRequest.m_CacheRangeRequested);
+                    qCDebug(LOG_VariableController()) << tr("1: onDataProvided")
+                                                      << varRequest.m_RangeRequested;
+                    qCDebug(LOG_VariableController()) << tr("2: onDataProvided")
+                                                      << varRequest.m_CacheRangeRequested;
+                    var->mergeDataSeries(varRequest.m_DataSeries);
+                    qCDebug(LOG_VariableController()) << tr("3: onDataProvided")
+                                                      << varRequest.m_DataSeries->range();
+                    qCDebug(LOG_VariableController()) << tr("4: onDataProvided");
+                    emit var->updated();
+                }
+                else {
+                    qCCritical(LOG_VariableController())
+                        << tr("Impossible to update data to a null variable");
+                }
+            }
+
+            // cleaning varRequestId
+            qCDebug(LOG_VariableController()) << tr("0: erase REQUEST in  MAP ?")
+                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+            m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
+            qCDebug(LOG_VariableController()) << tr("1: erase REQUEST in  MAP ?")
+                                              << m_VarRequestIdToVarIdVarRequestMap.size();
+        }
+    }
+    else {
+        qCCritical(LOG_VariableController())
+            << tr("Cannot updateVariableRequest for a unknow varRequestId") << varRequestId;
+    }
+}
+
+void VariableController::VariableControllerPrivate::cancelVariableRequest(QUuid varRequestId)
+{
+    // cleaning varRequestId
+    m_VarRequestIdToVarIdVarRequestMap.erase(varRequestId);
+
+    for (auto varIdToVarRequestIdQueueMapIt = m_VarIdToVarRequestIdQueueMap.begin();
+         varIdToVarRequestIdQueueMapIt != m_VarIdToVarRequestIdQueueMap.end();) {
+        auto &varRequestIdQueue = varIdToVarRequestIdQueueMapIt->second;
+        varRequestIdQueue.erase(
+            std::remove(varRequestIdQueue.begin(), varRequestIdQueue.end(), varRequestId),
+            varRequestIdQueue.end());
+        if (varRequestIdQueue.empty()) {
+            varIdToVarRequestIdQueueMapIt
+                = m_VarIdToVarRequestIdQueueMap.erase(varIdToVarRequestIdQueueMapIt);
+        }
+        else {
+            ++varIdToVarRequestIdQueueMapIt;
+        }
+    }
+}
diff --git a/gui/src/Visualization/VisualizationZoneWidget.cpp b/gui/src/Visualization/VisualizationZoneWidget.cpp
index 612fd3d..c49b616 100644
--- a/gui/src/Visualization/VisualizationZoneWidget.cpp
+++ b/gui/src/Visualization/VisualizationZoneWidget.cpp
@@ -100,49 +100,49 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         auto deltaRight = oldGraphRange.m_TEnd - graphRange.m_TEnd;
                         graphChildRange.m_TStart += deltaLeft;
                         graphChildRange.m_TEnd -= deltaRight;
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                                  << deltaLeft;
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                                  << deltaRight;
-                        qCCritical(LOG_VisualizationZoneWidget())
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomIn");
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
+                                                               << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
+                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
 
                         break;
                     }
 
                     case AcquisitionZoomType::ZoomOut: {
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: ZoomOut");
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
-                                                                  << deltaLeft;
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
-                                                                  << deltaRight;
-                        qCCritical(LOG_VisualizationZoneWidget())
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaLeft")
+                                                               << deltaLeft;
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: deltaRight")
+                                                               << deltaRight;
+                        qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
                         graphChildRange.m_TEnd += deltaRight;
                         break;
                     }
                     case AcquisitionZoomType::PanRight: {
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanRight");
                         auto deltaRight = graphRange.m_TEnd - oldGraphRange.m_TEnd;
                         graphChildRange.m_TStart += deltaRight;
                         graphChildRange.m_TEnd += deltaRight;
-                        qCCritical(LOG_VisualizationZoneWidget())
+                        qCDebug(LOG_VisualizationZoneWidget())
                             << tr("TORM: dt") << graphRange.m_TEnd - graphRange.m_TStart;
                         break;
                     }
                     case AcquisitionZoomType::PanLeft: {
-                        qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
+                        qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: PanLeft");
                         auto deltaLeft = oldGraphRange.m_TStart - graphRange.m_TStart;
                         graphChildRange.m_TStart -= deltaLeft;
                         graphChildRange.m_TEnd -= deltaLeft;
                         break;
                     }
                     case AcquisitionZoomType::Unknown: {
-                        qCCritical(LOG_VisualizationZoneWidget())
+                        qCDebug(LOG_VisualizationZoneWidget())
                             << tr("Impossible to synchronize: zoom type unknown");
                         break;
                     }
@@ -153,11 +153,11 @@ VisualizationGraphWidget *VisualizationZoneWidget::createGraph(std::shared_ptr<V
                         break;
                 }
                 graphChild->enableAcquisition(false);
-                qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
-                                                          << graphChild->graphRange();
-                qCCritical(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
-                                                          << graphChildRange;
-                qCCritical(LOG_VisualizationZoneWidget())
+                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range before: ")
+                                                       << graphChild->graphRange();
+                qCDebug(LOG_VisualizationZoneWidget()) << tr("TORM: Range after : ")
+                                                       << graphChildRange;
+                qCDebug(LOG_VisualizationZoneWidget())
                     << tr("TORM: child dt") << graphChildRange.m_TEnd - graphChildRange.m_TStart;
                 graphChild->setGraphRange(graphChildRange);
                 graphChild->enableAcquisition(true);
diff --git a/plugins/amda/src/AmdaProvider.cpp b/plugins/amda/src/AmdaProvider.cpp
index a320b84..8fe1f67 100644
--- a/plugins/amda/src/AmdaProvider.cpp
+++ b/plugins/amda/src/AmdaProvider.cpp
@@ -76,8 +76,8 @@ void AmdaProvider::requestDataLoading(QUuid acqIdentifier, const DataProviderPar
     for (const auto &dateTime : qAsConst(times)) {
         this->retrieveData(acqIdentifier, dateTime, data);
 
-        // TORM
-        // QThread::msleep(200);
+        // TORM when AMDA will support quick asynchrone request
+        QThread::msleep(1000);
     }
 }
 
diff --git a/plugins/amda/tests/TestAmdaAcquisition.cpp b/plugins/amda/tests/TestAmdaAcquisition.cpp
index 5df8fc8..60662bb 100644
--- a/plugins/amda/tests/TestAmdaAcquisition.cpp
+++ b/plugins/amda/tests/TestAmdaAcquisition.cpp
@@ -130,8 +130,8 @@ void TestAmdaAcquisition::testAcquisition()
         QTimer::singleShot(timeToWaitMs, &loop, &QEventLoop::quit);
         loop.exec();
 
-        qDebug() << count << "RANGE     " << var->range();
-        qDebug() << count << "CACHERANGE" << var->cacheRange();
+        qInfo() << count << "RANGE     " << var->range();
+        qInfo() << count << "CACHERANGE" << var->cacheRange();
 
         QCOMPARE(var->range().m_TStart, nextSqpR.m_TStart);
         QCOMPARE(var->range().m_TEnd, nextSqpR.m_TEnd);
@@ -144,7 +144,7 @@ void TestAmdaAcquisition::testAcquisition()
     // 2 : pan (jump) left for one hour
     auto nextVarRS = QDateTime{QDate{2012, 01, 02}, QTime{2, 1, 0, 0}};
     auto nextVarRE = QDateTime{QDate{2012, 01, 02}, QTime{2, 2, 0, 0}};
-    // requestDataLoading(nextVarRS, nextVarRE);
+    requestDataLoading(nextVarRS, nextVarRE);
 
 
     // 3 : pan (jump) right for one hour