[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.ui / src / org / eclipse / linuxtools / internal / tmf / ui / project / handlers / SynchronizeTracesHandler.java

/*******************************************************************************
 * Copyright (c) 2013, 2014 École Polytechnique de Montréal
 *
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Geneviève Bastien - Initial implementation and API
 *******************************************************************************/

package org.eclipse.linuxtools.internal.tmf.ui.project.handlers;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.TreeSelection;
import org.eclipse.linuxtools.internal.tmf.ui.Activator;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.synchronization.SynchronizationAlgorithm;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
import org.eclipse.linuxtools.tmf.core.trace.TmfTraceManager;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
import org.eclipse.linuxtools.tmf.ui.project.model.TraceUtils;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;

/**
 * Handles the synchronization of an experiment, when the user selects this
 * option in the menu
 */
public class SynchronizeTracesHandler extends AbstractHandler {

    // ------------------------------------------------------------------------
    // Attributes
    // ------------------------------------------------------------------------

    private TreeSelection fSelection = null;
    private static final String CR = System.getProperty("line.separator"); //$NON-NLS-1$

    // ------------------------------------------------------------------------
    // Validation
    // ------------------------------------------------------------------------

    @Override
    public boolean isEnabled() {
        return true;
    }

    // ------------------------------------------------------------------------
    // Execution
    // ------------------------------------------------------------------------

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        // Check if we are closing down
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        if (window == null) {
            return null;
        }

        // Get the selection
        IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
        IWorkbenchPart part = page.getActivePart();
        if (part == null) {
            return Boolean.FALSE;
        }
        ISelectionProvider selectionProvider = part.getSite().getSelectionProvider();
        if (selectionProvider == null) {
            return Boolean.FALSE;
        }
        ISelection selection = selectionProvider.getSelection();

        // Make sure selection contains only traces
        fSelection = null;
        final ArrayList<TmfTraceElement> tl = new ArrayList<>();
        final ArrayList<TmfExperimentElement> uiexperiment = new ArrayList<>();
        if (selection instanceof TreeSelection) {
            fSelection = (TreeSelection) selection;
            Iterator<Object> iterator = fSelection.iterator();
            while (iterator.hasNext()) {
                Object element = iterator.next();
                if (element instanceof TmfTraceElement) {
                    tl.add((TmfTraceElement) element);
                } else if (element instanceof TmfExperimentElement) {
                    TmfExperimentElement exp = (TmfExperimentElement) element;
                    uiexperiment.add(exp);
                    for (TmfTraceElement trace : exp.getTraces()) {
                        tl.add(trace);
                    }
                }
            }
        }

        if ((uiexperiment.size() != 1) || (tl.size() < 2)) {
            TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_WrongTraceNumber);
            return null;
        }

        Thread thread = new Thread() {
            @Override
            public void run() {

                final ITmfTrace[] traces = new ITmfTrace[tl.size()];
                final TmfExperimentElement exp = uiexperiment.get(0);

                for (int i = 0; i < tl.size(); i++) {
                    ITmfTrace trace = tl.get(i).instantiateTrace();
                    ITmfEvent traceEvent = tl.get(i).instantiateEvent();
                    if (trace == null) {
                        TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_WrongType + tl.get(i).getName());
                        for (int j = 0; j < i; j++) {
                            traces[j].dispose();
                        }
                        return;
                    }
                    try {
                        trace.initTrace(tl.get(i).getResource(), tl.get(i).getResource().getLocation().toOSString(), traceEvent.getClass());
                        TmfTraceManager.refreshSupplementaryFiles(trace);
                    } catch (TmfTraceException e) {
                        TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_InitError + CR + CR + e);
                        trace.dispose();
                        for (int j = 0; j < i; j++) {
                            traces[j].dispose();
                        }
                        return;
                    }
                    traces[i] = trace;
                }

                /*
                 * FIXME Unlike traces, there is no instanceExperiment, so
                 * we call this function here alone. Maybe it would be
                 * better to do this on experiment's element constructor?
                 */
                exp.refreshSupplementaryFolder();
                final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, exp.getName(), traces, exp.getResource());

                final SynchronizationAlgorithm syncAlgo = experiment.synchronizeTraces(true);
                TmfTraceManager.refreshSupplementaryFiles(experiment);

                Display.getDefault().asyncExec(new Runnable() {
                    @Override
                    public void run() {
                        List<TmfTraceElement> tracesToAdd = new ArrayList<>();
                        List<TmfTraceElement> tracesToRemove = new ArrayList<>();
                        /*
                         * For each trace in the experiment, if there is
                         * a transform equation, copy the original
                         * trace, so that a new state system will be
                         * generated with sync time.
                         */
                        for (TmfTraceElement traceel : tl) {
                            /*
                             * Find the trace corresponding to this
                             * element in the experiment
                             */
                            ITmfTrace expTrace = null;
                            for (ITmfTrace t : experiment.getTraces()) {
                                if (t.getResource().equals(traceel.getResource())) {
                                    expTrace = t;
                                    break;
                                }
                            }
                            if ((expTrace != null) && syncAlgo.isTraceSynced(expTrace.getHostId())) {

                                /* Find the original trace */
                                TmfTraceElement origtrace = traceel.getElementUnderTraceFolder();

                                /*
                                 * Make sure a trace with the
                                 * new name does not exist
                                 */
                                String newname = traceel.getName();
                                IContainer parentFolder = origtrace.getResource().getParent();
                                boolean traceexists;
                                do {
                                    traceexists = false;
                                    newname += "_"; //$NON-NLS-1$
                                    if (parentFolder.findMember(newname) != null) {
                                        traceexists = true;
                                    }
                                } while (traceexists);

                                /* Copy the original trace */
                                TmfTraceElement newtrace = origtrace.copy(newname);
                                if (newtrace == null) {
                                    TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title,
                                            Messages.SynchronizeTracesHandler_Error + CR + CR + String.format(Messages.SynchronizeTracesHandler_CopyProblem, origtrace.getName()));
                                    continue;
                                }

                                /*
                                 * Instantiate the new trace
                                 * and set its sync formula
                                 */
                                ITmfTrace trace = newtrace.instantiateTrace();
                                ITmfEvent traceEvent = newtrace.instantiateEvent();

                                try {
                                    trace.initTrace(newtrace.getResource(), newtrace.getResource().getLocation().toOSString(), traceEvent.getClass());
                                } catch (TmfTraceException e) {
                                    Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingForTrace, exp.getName(), traceel.getName()), e);
                                    TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_Error + CR + CR + e.getMessage());
                                }
                                trace.setTimestampTransform(syncAlgo.getTimestampTransform(trace));
                                TmfTraceManager.refreshSupplementaryFiles(trace);
                                trace.dispose();

                                tracesToAdd.add(newtrace);
                                tracesToRemove.add(traceel);
                            }
                        }
                        experiment.dispose();

                        // Move synchronization file temporarily so that
                        // it doesn't get deleted by the experiment change
                        IFolder tmpFolder = exp.getTraceSupplementaryFolder(exp.getName() + '.' + experiment.getSynchronizationFolder(false));
                        IResource syncFile = null;
                        for (IResource resource : exp.getSupplementaryResources()) {
                            if (resource.getName().equals(experiment.getSynchronizationFolder(false))) {
                                try {
                                    resource.move(tmpFolder.getFullPath(), false, null);
                                    syncFile = resource;
                                    break;
                                } catch (CoreException e) {
                                    Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingExperiment, exp.getName()), e);
                                }
                            }
                        }

                        for (TmfTraceElement trace : tracesToRemove) {
                            try {
                                exp.removeTrace(trace);
                            } catch (CoreException e) {
                                Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingForTrace, exp.getName(), trace.getName()), e);
                                TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_Error + CR + CR + e.getMessage());
                            }
                        }
                        for (TmfTraceElement trace : tracesToAdd) {
                            exp.addTrace(trace);
                        }

                        // Move synchronization file back
                        if (tmpFolder.exists() && syncFile != null) {
                            try {
                                tmpFolder.move(syncFile.getFullPath(), false, null);
                            } catch (CoreException e) {
                                Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingExperiment, exp.getName()), e);
                            }
                        }
                    }
                });
            }
        };
        thread.start();

        return null;
    }

}
Commit	Line	Data
e73a4ba5	1	/*******************************************************************************
60ae41e1	2	* Copyright (c) 2013, 2014 École Polytechnique de Montréal
e73a4ba5 GB	3	*
	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
	8	*
	9	* Contributors:
	10	* Geneviève Bastien - Initial implementation and API
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.internal.tmf.ui.project.handlers;
	14
	15	import java.util.ArrayList;
	16	import java.util.Iterator;
f3cbd37d	17	import java.util.List;
e73a4ba5 GB	18
	19	import org.eclipse.core.commands.AbstractHandler;
	20	import org.eclipse.core.commands.ExecutionEvent;
	21	import org.eclipse.core.commands.ExecutionException;
2564d461	22	import org.eclipse.core.resources.IContainer;
f3cbd37d PT	23	import org.eclipse.core.resources.IFolder;
f3cbd37d PT	24	import org.eclipse.core.resources.IResource;
e73a4ba5 GB	25	import org.eclipse.core.runtime.CoreException;
	26	import org.eclipse.jface.viewers.ISelection;
	27	import org.eclipse.jface.viewers.ISelectionProvider;
	28	import org.eclipse.jface.viewers.TreeSelection;
	29	import org.eclipse.linuxtools.internal.tmf.ui.Activator;
	30	import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
	31	import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
	32	import org.eclipse.linuxtools.tmf.core.synchronization.SynchronizationAlgorithm;
	33	import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
	34	import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
f3cbd37d	35	import org.eclipse.linuxtools.tmf.core.trace.TmfTraceManager;
e73a4ba5 GB	36	import org.eclipse.linuxtools.tmf.ui.project.model.TmfExperimentElement;
	37	import org.eclipse.linuxtools.tmf.ui.project.model.TmfTraceElement;
	38	import org.eclipse.linuxtools.tmf.ui.project.model.TraceUtils;
	39	import org.eclipse.swt.widgets.Display;
	40	import org.eclipse.ui.IWorkbenchPage;
	41	import org.eclipse.ui.IWorkbenchPart;
	42	import org.eclipse.ui.IWorkbenchWindow;
	43	import org.eclipse.ui.PlatformUI;
	44
	45	/**
	46	* Handles the synchronization of an experiment, when the user selects this
	47	* option in the menu
	48	*/
	49	public class SynchronizeTracesHandler extends AbstractHandler {
	50
	51	// ------------------------------------------------------------------------
	52	// Attributes
	53	// ------------------------------------------------------------------------
	54
	55	private TreeSelection fSelection = null;
	56	private static final String CR = System.getProperty("line.separator"); //$NON-NLS-1$
	57
	58	// ------------------------------------------------------------------------
	59	// Validation
	60	// ------------------------------------------------------------------------
	61
	62	@Override
	63	public boolean isEnabled() {
	64	return true;
	65	}
	66
	67	// ------------------------------------------------------------------------
	68	// Execution
	69	// ------------------------------------------------------------------------
	70
	71	@Override
	72	public Object execute(ExecutionEvent event) throws ExecutionException {
	73
	74	// Check if we are closing down
	75	IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
	76	if (window == null) {
	77	return null;
	78	}
	79
	80	// Get the selection
	81	IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
	82	IWorkbenchPart part = page.getActivePart();
	83	if (part == null) {
0126a8ca	84	return Boolean.FALSE;
e73a4ba5 GB	85	}
	86	ISelectionProvider selectionProvider = part.getSite().getSelectionProvider();
	87	if (selectionProvider == null) {
0126a8ca	88	return Boolean.FALSE;
e73a4ba5 GB	89	}
	90	ISelection selection = selectionProvider.getSelection();
	91
	92	// Make sure selection contains only traces
	93	fSelection = null;
507b1336 AM	94	final ArrayList<TmfTraceElement> tl = new ArrayList<>();
507b1336 AM	95	final ArrayList<TmfExperimentElement> uiexperiment = new ArrayList<>();
e73a4ba5 GB	96	if (selection instanceof TreeSelection) {
	97	fSelection = (TreeSelection) selection;
	98	Iterator<Object> iterator = fSelection.iterator();
	99	while (iterator.hasNext()) {
	100	Object element = iterator.next();
	101	if (element instanceof TmfTraceElement) {
	102	tl.add((TmfTraceElement) element);
	103	} else if (element instanceof TmfExperimentElement) {
	104	TmfExperimentElement exp = (TmfExperimentElement) element;
	105	uiexperiment.add(exp);
	106	for (TmfTraceElement trace : exp.getTraces()) {
	107	tl.add(trace);
	108	}
	109	}
	110	}
	111	}
	112
f3cbd37d PT	113	if ((uiexperiment.size() != 1) \|\| (tl.size() < 2)) {
	114	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_WrongTraceNumber);
	115	return null;
	116	}
e73a4ba5	117
f3cbd37d PT	118	Thread thread = new Thread() {
	119	@Override
	120	public void run() {
e73a4ba5	121
f3cbd37d PT	122	final ITmfTrace[] traces = new ITmfTrace[tl.size()];
f3cbd37d PT	123	final TmfExperimentElement exp = uiexperiment.get(0);
e73a4ba5	124
f3cbd37d PT	125	for (int i = 0; i < tl.size(); i++) {
	126	ITmfTrace trace = tl.get(i).instantiateTrace();
	127	ITmfEvent traceEvent = tl.get(i).instantiateEvent();
	128	if (trace == null) {
	129	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_WrongType + tl.get(i).getName());
	130	for (int j = 0; j < i; j++) {
	131	traces[j].dispose();
e73a4ba5	132	}
f3cbd37d	133	return;
e73a4ba5	134	}
e73a4ba5	135	try {
f06ca6d0	136	trace.initTrace(tl.get(i).getResource(), tl.get(i).getResource().getLocation().toOSString(), traceEvent.getClass());
f3cbd37d PT	137	TmfTraceManager.refreshSupplementaryFiles(trace);
	138	} catch (TmfTraceException e) {
	139	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_InitError + CR + CR + e);
	140	trace.dispose();
	141	for (int j = 0; j < i; j++) {
	142	traces[j].dispose();
	143	}
	144	return;
	145	}
	146	traces[i] = trace;
	147	}
e73a4ba5	148
f3cbd37d PT	149	/*
	150	* FIXME Unlike traces, there is no instanceExperiment, so
	151	* we call this function here alone. Maybe it would be
	152	* better to do this on experiment's element constructor?
	153	*/
	154	exp.refreshSupplementaryFolder();
	155	final TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, exp.getName(), traces, exp.getResource());
	156
04ba3554 GB	157	final SynchronizationAlgorithm syncAlgo = experiment.synchronizeTraces(true);
	158	TmfTraceManager.refreshSupplementaryFiles(experiment);
	159
	160	Display.getDefault().asyncExec(new Runnable() {
	161	@Override
	162	public void run() {
	163	List<TmfTraceElement> tracesToAdd = new ArrayList<>();
	164	List<TmfTraceElement> tracesToRemove = new ArrayList<>();
	165	/*
	166	* For each trace in the experiment, if there is
	167	* a transform equation, copy the original
	168	* trace, so that a new state system will be
	169	* generated with sync time.
	170	*/
	171	for (TmfTraceElement traceel : tl) {
f3cbd37d	172	/*
04ba3554 GB	173	* Find the trace corresponding to this
04ba3554 GB	174	* element in the experiment
f3cbd37d	175	*/
04ba3554 GB	176	ITmfTrace expTrace = null;
	177	for (ITmfTrace t : experiment.getTraces()) {
	178	if (t.getResource().equals(traceel.getResource())) {
	179	expTrace = t;
	180	break;
f3cbd37d	181	}
04ba3554 GB	182	}
04ba3554 GB	183	if ((expTrace != null) && syncAlgo.isTraceSynced(expTrace.getHostId())) {
f3cbd37d	184
04ba3554 GB	185	/* Find the original trace */
04ba3554 GB	186	TmfTraceElement origtrace = traceel.getElementUnderTraceFolder();
f3cbd37d	187
04ba3554 GB	188	/*
	189	* Make sure a trace with the
	190	* new name does not exist
	191	*/
	192	String newname = traceel.getName();
	193	IContainer parentFolder = origtrace.getResource().getParent();
	194	boolean traceexists;
	195	do {
	196	traceexists = false;
	197	newname += "_"; //$NON-NLS-1$
	198	if (parentFolder.findMember(newname) != null) {
	199	traceexists = true;
e73a4ba5	200	}
04ba3554 GB	201	} while (traceexists);
	202
	203	/* Copy the original trace */
	204	TmfTraceElement newtrace = origtrace.copy(newname);
	205	if (newtrace == null) {
	206	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title,
	207	Messages.SynchronizeTracesHandler_Error + CR + CR + String.format(Messages.SynchronizeTracesHandler_CopyProblem, origtrace.getName()));
	208	continue;
f3cbd37d	209	}
f3cbd37d	210
04ba3554 GB	211	/*
	212	* Instantiate the new trace
	213	* and set its sync formula
	214	*/
	215	ITmfTrace trace = newtrace.instantiateTrace();
	216	ITmfEvent traceEvent = newtrace.instantiateEvent();
e73a4ba5	217
f3cbd37d	218	try {
f06ca6d0	219	trace.initTrace(newtrace.getResource(), newtrace.getResource().getLocation().toOSString(), traceEvent.getClass());
04ba3554 GB	220	} catch (TmfTraceException e) {
04ba3554 GB	221	Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingForTrace, exp.getName(), traceel.getName()), e);
f3cbd37d PT	222	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_Error + CR + CR + e.getMessage());
f3cbd37d PT	223	}
04ba3554 GB	224	trace.setTimestampTransform(syncAlgo.getTimestampTransform(trace));
	225	TmfTraceManager.refreshSupplementaryFiles(trace);
	226	trace.dispose();
e73a4ba5	227
04ba3554 GB	228	tracesToAdd.add(newtrace);
	229	tracesToRemove.add(traceel);
	230	}
	231	}
	232	experiment.dispose();
	233
	234	// Move synchronization file temporarily so that
	235	// it doesn't get deleted by the experiment change
7f38b742	236	IFolder tmpFolder = exp.getTraceSupplementaryFolder(exp.getName() + '.' + experiment.getSynchronizationFolder(false));
04ba3554 GB	237	IResource syncFile = null;
04ba3554 GB	238	for (IResource resource : exp.getSupplementaryResources()) {
7f38b742	239	if (resource.getName().equals(experiment.getSynchronizationFolder(false))) {
f3cbd37d	240	try {
04ba3554 GB	241	resource.move(tmpFolder.getFullPath(), false, null);
	242	syncFile = resource;
	243	break;
f3cbd37d PT	244	} catch (CoreException e) {
	245	Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingExperiment, exp.getName()), e);
	246	}
	247	}
	248	}
f3cbd37d	249
04ba3554 GB	250	for (TmfTraceElement trace : tracesToRemove) {
	251	try {
	252	exp.removeTrace(trace);
	253	} catch (CoreException e) {
	254	Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingForTrace, exp.getName(), trace.getName()), e);
	255	TraceUtils.displayErrorMsg(Messages.SynchronizeTracesHandler_Title, Messages.SynchronizeTracesHandler_Error + CR + CR + e.getMessage());
	256	}
	257	}
	258	for (TmfTraceElement trace : tracesToAdd) {
	259	exp.addTrace(trace);
	260	}
	261
	262	// Move synchronization file back
	263	if (tmpFolder.exists() && syncFile != null) {
	264	try {
	265	tmpFolder.move(syncFile.getFullPath(), false, null);
	266	} catch (CoreException e) {
	267	Activator.getDefault().logError(String.format(Messages.SynchronizeTracesHandler_ErrorSynchingExperiment, exp.getName()), e);
	268	}
	269	}
	270	}
	271	});
f3cbd37d PT	272	}
	273	};
	274	thread.start();
e73a4ba5 GB	275
	276	return null;
	277	}
	278
	279	}