1 /*******************************************************************************
2 * Copyright (c) 2013 École Polytechnique de Montréal
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Geneviève Bastien - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.core
.analysis
;
15 import java
.util
.ArrayList
;
16 import java
.util
.HashMap
;
17 import java
.util
.List
;
19 import java
.util
.concurrent
.CountDownLatch
;
20 import java
.util
.concurrent
.TimeUnit
;
22 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
23 import org
.eclipse
.core
.runtime
.IStatus
;
24 import org
.eclipse
.core
.runtime
.Status
;
25 import org
.eclipse
.core
.runtime
.jobs
.Job
;
26 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.Activator
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.component
.TmfComponent
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.exceptions
.TmfAnalysisException
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfSignalHandler
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfStartAnalysisSignal
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTraceClosedSignal
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.ITmfTrace
;
33 import org
.eclipse
.linuxtools
.tmf
.core
.trace
.TmfTrace
;
34 import org
.eclipse
.osgi
.util
.NLS
;
37 * Base class that analysis modules main class may extend. It provides default
38 * behavior to some methods of the analysis module
40 * @author Geneviève Bastien
43 public abstract class TmfAbstractAnalysisModule
extends TmfComponent
implements IAnalysisModule
{
45 private String fName
, fId
;
46 private boolean fAutomatic
= false, fStarted
= false;
47 private ITmfTrace fTrace
;
48 private final Map
<String
, Object
> fParameters
= new HashMap
<>();
49 private final List
<String
> fParameterNames
= new ArrayList
<>();
50 private final List
<IAnalysisOutput
> fOutputs
= new ArrayList
<>();
51 private List
<IAnalysisParameterProvider
> fParameterProviders
= new ArrayList
<>();
52 private Job fJob
= null;
54 private final Object syncObj
= new Object();
56 /* Latch tracking if the analysis is completed or not */
57 private CountDownLatch fFinishedLatch
= new CountDownLatch(0);
59 private boolean fAnalysisCancelled
= false;
62 public boolean isAutomatic() {
67 public String
getName() {
72 public void setName(String name
) {
77 public void setId(String id
) {
82 public String
getId() {
87 public void setAutomatic(boolean auto
) {
92 public void setTrace(ITmfTrace trace
) throws TmfAnalysisException
{
94 throw new TmfAnalysisException(NLS
.bind(Messages
.TmfAbstractAnalysisModule_TraceSetMoreThanOnce
, getName()));
97 /* Check that analysis can be executed */
98 if (!canExecute(trace
)) {
99 throw new TmfAnalysisException(NLS
.bind(Messages
.TmfAbstractAnalysisModule_AnalysisCannotExecute
, getName()));
102 /* Get the parameter providers for this trace */
103 fParameterProviders
= TmfAnalysisManager
.getParameterProviders(this, fTrace
);
104 for (IAnalysisParameterProvider provider
: fParameterProviders
) {
105 provider
.registerModule(this);
116 protected ITmfTrace
getTrace() {
121 public void addParameter(String name
) {
122 fParameterNames
.add(name
);
126 public synchronized void setParameter(String name
, Object value
) {
127 if (!fParameterNames
.contains(name
)) {
128 throw new RuntimeException(NLS
.bind(Messages
.TmfAbstractAnalysisModule_InvalidParameter
, name
, getName()));
130 Object oldValue
= fParameters
.get(name
);
131 fParameters
.put(name
, value
);
132 if ((value
!= null) && !(value
.equals(oldValue
))) {
133 parameterChanged(name
);
138 public synchronized void notifyParameterChanged(String name
) {
139 if (!fParameterNames
.contains(name
)) {
140 throw new RuntimeException(NLS
.bind(Messages
.TmfAbstractAnalysisModule_InvalidParameter
, name
, getName()));
142 Object oldValue
= fParameters
.get(name
);
143 Object value
= getParameter(name
);
144 if ((value
!= null) && !(value
.equals(oldValue
))) {
145 parameterChanged(name
);
150 * Used to indicate that a parameter value has been changed
153 * The name of the modified parameter
155 protected void parameterChanged(String name
) {
160 public Object
getParameter(String name
) {
161 Object paramValue
= fParameters
.get(name
);
162 /* The parameter is not set, maybe it can be provided by someone else */
163 if ((paramValue
== null) && (fTrace
!= null)) {
164 for (IAnalysisParameterProvider provider
: fParameterProviders
) {
165 paramValue
= provider
.getParameter(name
);
166 if (paramValue
!= null) {
175 public boolean canExecute(ITmfTrace trace
) {
180 * Set the countdown latch back to 1 so the analysis can be executed again
182 protected void resetAnalysis() {
183 fFinishedLatch
.countDown();
184 fFinishedLatch
= new CountDownLatch(1);
188 * Actually executes the analysis itself
192 * @return Whether the analysis was completed successfully or not
193 * @throws TmfAnalysisException
194 * Method may throw an analysis exception
196 protected abstract boolean executeAnalysis(final IProgressMonitor monitor
) throws TmfAnalysisException
;
199 * Indicate the analysis has been canceled. It is abstract to force
200 * implementing class to cleanup what they are running. This is called by
201 * the job's canceling. It does not need to be called directly.
203 protected abstract void canceling();
206 * To be called when the analysis is completed, whether normally or because
207 * it was cancelled or for any other reason.
209 * It has to be called inside a synchronized block
211 private void setAnalysisCompleted() {
214 fFinishedLatch
.countDown();
215 if (fTrace
instanceof TmfTrace
) {
216 ((TmfTrace
) fTrace
).refreshSupplementaryFiles();
221 * Cancels the analysis if it is executing
224 public final void cancel() {
225 synchronized (syncObj
) {
228 fAnalysisCancelled
= true;
229 setAnalysisCompleted();
236 private void execute() {
239 * TODO: The analysis in a job should be done at the analysis manager
240 * level instead of depending on this abstract class implementation,
241 * otherwise another analysis implementation may block the main thread
244 /* Do not execute if analysis has already run */
245 if (fFinishedLatch
.getCount() == 0) {
249 /* Do not execute if analysis already running */
250 synchronized (syncObj
) {
258 * Actual analysis will be run on a separate thread
260 fJob
= new Job(NLS
.bind(Messages
.TmfAbstractAnalysisModule_RunningAnalysis
, getName())) {
262 protected IStatus
run(final IProgressMonitor monitor
) {
264 monitor
.beginTask("", IProgressMonitor
.UNKNOWN
); //$NON-NLS-1$
265 broadcast(new TmfStartAnalysisSignal(TmfAbstractAnalysisModule
.this, TmfAbstractAnalysisModule
.this));
266 fAnalysisCancelled
= !executeAnalysis(monitor
);
267 } catch (TmfAnalysisException e
) {
268 Activator
.logError("Error executing analysis with trace " + getTrace().getName(), e
); //$NON-NLS-1$
270 synchronized (syncObj
) {
272 setAnalysisCompleted();
275 if (!fAnalysisCancelled
) {
276 return Status
.OK_STATUS
;
278 // Reset analysis so that it can be executed again.
280 return Status
.CANCEL_STATUS
;
284 protected void canceling() {
285 TmfAbstractAnalysisModule
.this.canceling();
293 public IStatus
schedule() {
294 if (fTrace
== null) {
295 return new Status(IStatus
.ERROR
, Activator
.PLUGIN_ID
, String
.format("No trace specified for analysis %s", getName())); //$NON-NLS-1$
299 return Status
.OK_STATUS
;
303 public Iterable
<IAnalysisOutput
> getOutputs() {
308 public void registerOutput(IAnalysisOutput output
) {
309 if (!fOutputs
.contains(output
)) {
310 fOutputs
.add(output
);
315 public boolean waitForCompletion(IProgressMonitor monitor
) {
317 while (!fFinishedLatch
.await(500, TimeUnit
.MILLISECONDS
)) {
318 if (fAnalysisCancelled
|| monitor
.isCanceled()) {
319 fAnalysisCancelled
= true;
323 } catch (InterruptedException e
) {
324 Activator
.logError("Error while waiting for module completion", e
); //$NON-NLS-1$
326 return !fAnalysisCancelled
;
330 * Signal handler for trace closing
333 * Trace closed signal
336 public void traceClosed(TmfTraceClosedSignal signal
) {
337 /* Is the closing trace the one that was requested? */
338 if (signal
.getTrace() == fTrace
) {
345 * Returns a full help text to display
347 * @return Full help text for the module
349 protected String
getFullHelpText() {
350 return NLS
.bind(Messages
.TmfAbstractAnalysisModule_AnalysisModule
, getName());
354 * Gets a short help text, to display as header to other help text
357 * The trace to show help for
359 * @return Short help text describing the module
361 protected String
getShortHelpText(ITmfTrace trace
) {
362 return NLS
.bind(Messages
.TmfAbstractAnalysisModule_AnalysisForTrace
, getName(), trace
.getName());
366 * Gets the help text specific for a trace who does not have required
367 * characteristics for module to execute
370 * The trace to apply the analysis to
373 protected String
getTraceCannotExecuteHelpText(ITmfTrace trace
) {
374 return Messages
.TmfAbstractAnalysisModule_AnalysisCannotExecute
;
378 public String
getHelpText() {
379 return getFullHelpText();
383 public String
getHelpText(ITmfTrace trace
) {
385 return getHelpText();
387 String text
= getShortHelpText(trace
);
388 if (!canExecute(trace
)) {
389 text
= text
+ getTraceCannotExecuteHelpText(trace
);