tmf: Ensure order of trace updated and trace range updated signals

When the trace index already exists and doesn't need to be build
from scratch the signal TmfTraceUpdatedSignal is sent once in the
method buildIndex() of the TmfCheckpointIndexer. However, buildIndex()
is called from the signal handler of class TmfTrace for the
signal TmfTraceRangeUpdatedSignal. That causes that signal
TmfTraceUpdatedSignal is sent before TmfTraceRangeUpdatedSignal
is processed by all other signal handlers. This causes problems
for example in the Histogram view where the trace end time is not
set correctly because this wrong order of signal handling.

This patch fixes that problem by wrapping the sending of signal
TmfTraceUpdatedSignal in a TmfEventRequest which is only dispatched
by the TmfEventProvider (=TmfTrace) after the first signal
(TmfTraceRangeUpdatedSignal) is processed by all signal handlers.

Change-Id: I96dfdb4cc678722ff5b48a8881c67f5a8c11ff36
Signed-off-by: Bernd Hufmann <Bernd.Hufmann@ericsson.com>
Reviewed-on: https://git.eclipse.org/r/20216
Tested-by: Hudson CI
Reviewed-by: Genevieve Bastien <gbastien+lttng@versatic.net>
IP-Clean: Genevieve Bastien <gbastien+lttng@versatic.net>
Tested-by: Genevieve Bastien <gbastien+lttng@versatic.net>
Reviewed-by: Bernd Hufmann <bernd.hufmann@ericsson.com>

1 files changed, 58 insertions, 38 deletions

diff --git a/lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/trace/indexer/checkpoint/TmfCheckpointIndexer.java b/lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/trace/indexer/checkpoint/TmfCheckpointIndexer.java
index e47045bed6..7129db33d1 100644
--- a/lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/trace/indexer/checkpoint/TmfCheckpointIndexer.java
+++ b/lttng/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/trace/indexer/checkpoint/TmfCheckpointIndexer.java
@@ -22,6 +22,7 @@ import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider;
 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest.ExecutionType;
 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal;
 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
@@ -150,13 +151,6 @@ public class TmfCheckpointIndexer implements ITmfTraceIndexer {
             fIsIndexing = true;
         }
 
-        // No need to build the index, it has been restored
-        if (!fTraceIndex.isCreatedFromScratch()) {
-            // Set some trace attributes that depends on indexing
-            fTrace.broadcast(new TmfTraceUpdatedSignal(this, fTrace, new TmfTimeRange(fTraceIndex.getTimeRange().getStartTime(), fTraceIndex.getTimeRange().getEndTime()), fTraceIndex.getNbEvents()));
-            return;
-        }
-
         // The monitoring job
         final Job job = new Job("Indexing " + fTrace.getName() + "...") { //$NON-NLS-1$ //$NON-NLS-2$
             @Override
@@ -164,6 +158,7 @@ public class TmfCheckpointIndexer implements ITmfTraceIndexer {
                 monitor.beginTask("", IProgressMonitor.UNKNOWN); //$NON-NLS-1$
                 while (!monitor.isCanceled()) {
                     try {
+
                         long prevNbEvents = fTrace.getNbEvents();
                         Thread.sleep(250);
                         long nbEvents = fTrace.getNbEvents();
@@ -181,43 +176,68 @@ public class TmfCheckpointIndexer implements ITmfTraceIndexer {
         };
         job.schedule();
 
-        // Build a background request for all the trace data. The index is
-        // updated as we go by readNextEvent().
-        fIndexingRequest = new TmfEventRequest(ITmfEvent.class,
-                range, offset, ITmfEventRequest.ALL_DATA,
-                ITmfEventRequest.ExecutionType.BACKGROUND) {
-            @Override
-            public void handleData(final ITmfEvent event) {
-                super.handleData(event);
-                if (event != null) {
-                    // Update the trace status at regular intervals
-                    if ((getNbRead() % fCheckpointInterval) == 0) {
-                        updateTraceStatus();
+        if (fTraceIndex.isCreatedFromScratch()) {
+            // Build a background request for all the trace data. The index is
+            // updated as we go by readNextEvent().
+            fIndexingRequest = new TmfEventRequest(ITmfEvent.class,
+                    range, offset, ITmfEventRequest.ALL_DATA,
+                    ITmfEventRequest.ExecutionType.BACKGROUND) {
+                @Override
+                public void handleData(final ITmfEvent event) {
+                    super.handleData(event);
+                    if (event != null) {
+                        // Update the trace status at regular intervals
+                        if ((getNbRead() % fCheckpointInterval) == 0) {
+                            updateTraceStatus();
+                        }
                     }
                 }
-            }
 
-            @Override
-            public void handleSuccess() {
-                fTraceIndex.setTimeRange(fTrace.getTimeRange());
-                fTraceIndex.setNbEvents(fTrace.getNbEvents());
-                fTraceIndex.setIndexComplete();
-                updateTraceStatus();
-            }
+                @Override
+                public void handleSuccess() {
+                    fTraceIndex.setTimeRange(fTrace.getTimeRange());
+                    fTraceIndex.setNbEvents(fTrace.getNbEvents());
+                    fTraceIndex.setIndexComplete();
+                    updateTraceStatus();
+                }
 
-            @Override
-            public void handleCompleted() {
-                job.cancel();
-                super.handleCompleted();
-                fIsIndexing = false;
-            }
+                @Override
+                public void handleCompleted() {
+                    job.cancel();
+                    super.handleCompleted();
+                    fIsIndexing = false;
+                }
 
-            private void updateTraceStatus() {
-                if (fTrace.getNbEvents() > 0) {
-                    signalNewTimeRange(fTrace.getStartTime(), fTrace.getEndTime());
+                private void updateTraceStatus() {
+                    if (fTrace.getNbEvents() > 0) {
+                        signalNewTimeRange(fTrace.getStartTime(), fTrace.getEndTime());
+                    }
                 }
-            }
-        };
+            };
+        } else {
+            // Trace index already exists. Send TmfTraceUpdatedSignal to set
+            // trace attributes.
+
+            // Note: buildIndex() is called from a signal handler. To make sure
+            // that all other signal handlers are executed before signal
+            // TmfTraceUpdatedSignal is sent the sending of signal
+            // TmfTraceUpdatedSignal is wrapped in a request.
+            fIndexingRequest = new TmfEventRequest(ITmfEvent.class,
+                    TmfTimeRange.ETERNITY, 0, 1, ExecutionType.FOREGROUND) {
+                @Override
+                public void handleCompleted() {
+                    super.handleCompleted();
+                    // Set some trace attributes that depends on indexing
+                    fTrace.broadcast(new TmfTraceUpdatedSignal(
+                            TmfCheckpointIndexer.this,
+                            fTrace,
+                            new TmfTimeRange(fTraceIndex.getTimeRange().getStartTime(), fTraceIndex.getTimeRange().getEndTime()),
+                            fTraceIndex.getNbEvents()));
+                    job.cancel();
+                    fIsIndexing = false;
+                }
+            };
+        }
 
         // Submit the request and wait for completion if required
         fTrace.sendRequest(fIndexingRequest);