/*******************************************************************************
* Copyright (c) 2015 Red Hat.
* 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:
* Red Hat - Initial Contribution
*******************************************************************************/
package org.eclipse.cdt.internal.docker.launcher;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.eclipse.cdt.core.model.CModelException;
import org.eclipse.cdt.core.model.CoreModel;
import org.eclipse.cdt.core.model.IBinary;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.debug.core.CDebugUtils;
import org.eclipse.cdt.debug.core.ICDTLaunchConfigurationConstants;
import org.eclipse.cdt.docker.launcher.DockerLaunchUIPlugin;
import org.eclipse.cdt.dsf.gdb.IGDBLaunchConfigurationConstants;
import org.eclipse.cdt.dsf.gdb.IGdbDebugPreferenceConstants;
import org.eclipse.cdt.dsf.gdb.internal.ui.GdbUIPlugin;
import org.eclipse.cdt.ui.CElementLabelProvider;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugModelPresentation;
import org.eclipse.debug.ui.ILaunchShortcut;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.window.Window;
import org.eclipse.linuxtools.docker.core.DockerConnectionManager;
import org.eclipse.linuxtools.docker.core.IDockerConnection;
import org.eclipse.linuxtools.docker.core.IDockerImage;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.dialogs.ElementListSelectionDialog;
import org.eclipse.ui.dialogs.TwoPaneElementSelector;
import org.osgi.service.prefs.Preferences;
public class LaunchShortcut implements ILaunchShortcut {
@Override
public void launch(IEditorPart editor, String mode) {
searchAndLaunch(new Object[] { editor.getEditorInput() }, mode);
}
@Override
public void launch(ISelection selection, String mode) {
if (selection instanceof IStructuredSelection) {
searchAndLaunch(((IStructuredSelection) selection).toArray(), mode);
}
}
public void launch(IBinary bin, String mode) {
ILaunchConfiguration config = findLaunchConfiguration(bin, mode);
if (config != null) {
DebugUITools.launch(config, mode);
}
}
/**
* Method getLaunchConfigType.
*
* @return ILaunchConfigurationType
*/
protected ILaunchConfigurationType getLaunchConfigType() {
return getLaunchManager()
.getLaunchConfigurationType(ILaunchConstants.LAUNCH_ID);
}
/**
* Search and launch binary.
*
* @param elements
* Binaries to search.
* @param mode
* Launch mode.
*/
private void searchAndLaunch(final Object[] elements, String mode) {
if (elements != null && elements.length > 0) {
IBinary bin = null;
if (elements.length == 1 && elements[0] instanceof IBinary) {
bin = (IBinary) elements[0];
} else {
final List<IBinary> results = new ArrayList<>();
ProgressMonitorDialog dialog = new ProgressMonitorDialog(
getActiveWorkbenchShell());
IRunnableWithProgress runnable = new IRunnableWithProgress() {
@Override
public void run(IProgressMonitor pm)
throws InterruptedException {
int nElements = elements.length;
pm.beginTask(
Messages.LaunchShortcut_Looking_for_executables,
nElements);
try {
IProgressMonitor sub = new SubProgressMonitor(pm, 1);
for (int i = 0; i < nElements; i++) {
if (elements[i] instanceof IAdaptable) {
IResource r = (IResource) ((IAdaptable) elements[i])
.getAdapter(IResource.class);
if (r != null) {
ICProject cproject = CoreModel
.getDefault().create(
r.getProject());
if (cproject != null) {
try {
IBinary[] bins = cproject
.getBinaryContainer()
.getBinaries();
for (IBinary bin : bins) {
if (bin.isExecutable()) {
results.add(bin);
}
}
} catch (CModelException e) {
// TODO should this be simply
// ignored ?
}
}
}
}
if (pm.isCanceled()) {
throw new InterruptedException();
}
sub.done();
}
} finally {
pm.done();
}
}
};
try {
dialog.run(true, true, runnable);
} catch (InterruptedException e) {
return;
} catch (InvocationTargetException e) {
handleFail(e.getMessage());
return;
}
int count = results.size();
if (count == 0) {
handleFail(Messages.LaunchShortcut_Binary_not_found);
} else if (count > 1) {
bin = chooseBinary(results, mode);
} else {
bin = results.get(0);
}
}
if (bin != null) {
launch(bin, mode);
}
} else {
handleFail(Messages.LaunchShortcut_no_project_selected);
}
}
/**
* Prompts the user to select a binary
*
* @param binList
* The list of binaries.
* @param mode
* launch mode.
*
* @return the selected binary or <code>null</code> if none.
*/
protected IBinary chooseBinary(List<IBinary> binList, String mode) {
ILabelProvider programLabelProvider = new CElementLabelProvider() {
@Override
public String getText(Object element) {
if (element instanceof IBinary) {
return ((IBinary) element).getPath().lastSegment();
}
return super.getText(element);
}
};
ILabelProvider qualifierLabelProvider = new CElementLabelProvider() {
@Override
public String getText(Object element) {
if (element instanceof IBinary) {
IBinary bin = (IBinary) element;
StringBuilder name = new StringBuilder();
name.append(bin.getCPU()
+ (bin.isLittleEndian() ? "le" : "be")); //$NON-NLS-1$ //$NON-NLS-2$
name.append(" - "); //$NON-NLS-1$
name.append(bin.getPath().toString());
return name.toString();
}
return super.getText(element);
}
};
TwoPaneElementSelector dialog = new TwoPaneElementSelector(
getActiveWorkbenchShell(), programLabelProvider,
qualifierLabelProvider);
dialog.setElements(binList.toArray());
dialog.setTitle(Messages.LaunchShortcut_Launcher);
dialog.setMessage(Messages.LaunchShortcut_Choose_a_local_application);
dialog.setUpperListLabel(Messages.LaunchShortcut_Binaries);
dialog.setLowerListLabel(Messages.LaunchShortcut_Qualifier);
dialog.setMultipleSelection(false);
if (dialog.open() == Window.OK) {
return (IBinary) dialog.getFirstResult();
}
return null;
}
protected void handleFail(String message) {
MessageDialog.openError(getActiveWorkbenchShell(),
Messages.LaunchShortcut_Launcher, message);
}
/**
* Locate a configuration to launch for the given type. If one cannot be
* found, create one.
*
* @param bin
* The binary to look launch for.
* @param mode
* Launch mode.
*
* @return A re-useable config or <code>null</code> if none.
*/
protected ILaunchConfiguration findLaunchConfiguration(IBinary bin,
String mode) {
ILaunchConfiguration configuration = null;
ILaunchConfigurationType configType = getLaunchConfigType();
List<ILaunchConfiguration> candidateConfigs = Collections.emptyList();
try {
ILaunchConfiguration[] configs = DebugPlugin.getDefault()
.getLaunchManager().getLaunchConfigurations(configType);
candidateConfigs = new ArrayList<>(configs.length);
for (ILaunchConfiguration config : configs) {
IPath programPath = CDebugUtils.getProgramPath(config);
String projectName = CDebugUtils.getProjectName(config);
IPath binPath = bin.getResource().getProjectRelativePath();
if (programPath != null && programPath.equals(binPath)) {
if (projectName != null
&& projectName.equals(bin.getCProject()
.getProject().getName())) {
candidateConfigs.add(config);
}
}
}
} catch (CoreException e) {
DockerLaunchUIPlugin.log(e);
}
// If there are no existing configurations associated with the IBinary,
// create one. If there is exactly one configuration associated with the
// IBinary, return it. Otherwise, if there is more than one
// configuration associated with the IBinary, prompt the user to choose
// one.
int candidateCount = candidateConfigs.size();
if (candidateCount < 1) {
configuration = createConfiguration(bin, mode, true);
} else if (candidateCount == 1) {
configuration = candidateConfigs.get(0);
} else {
// Prompt the user to choose a configuration. A null result means
// the user
// cancelled the dialog, in which case this method returns null,
// since canceling the dialog should also cancel launching
// anything.
configuration = chooseConfiguration(candidateConfigs, mode);
}
return configuration;
}
/**
* Create a launch configuration based on a binary, and optionally save it
* to the underlying resource.
*
* @param bin
* a representation of a binary
* @param save
* true if the configuration should be saved to the underlying
* resource, and false if it should not be saved.
* @return a launch configuration generated for the binary.
*/
protected ILaunchConfiguration createConfiguration(IBinary bin,
String mode, boolean save) {
ILaunchConfiguration config = null;
try {
String binaryPath = bin.getResource().getProjectRelativePath()
.toString();
ILaunchConfigurationType configType = getLaunchConfigType();
ILaunchConfigurationWorkingCopy wc = configType.newInstance(
null,
getLaunchManager().generateLaunchConfigurationName(
bin.getElementName()));
// DSF settings...use GdbUIPlugin preference store for defaults
IPreferenceStore preferenceStore = GdbUIPlugin.getDefault()
.getPreferenceStore();
wc.setAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUG_NAME,
preferenceStore.getString(
IGdbDebugPreferenceConstants.PREF_DEFAULT_GDB_COMMAND));
wc.setAttribute(IGDBLaunchConfigurationConstants.ATTR_GDB_INIT,
preferenceStore.getString(
IGdbDebugPreferenceConstants.PREF_DEFAULT_GDB_INIT));
wc.setAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP,
preferenceStore.getBoolean(
IGdbDebugPreferenceConstants.PREF_DEFAULT_NON_STOP));
wc.setAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_REVERSE,
IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_DEFAULT);
wc.setAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_UPDATE_THREADLIST_ON_SUSPEND,
IGDBLaunchConfigurationConstants.DEBUGGER_UPDATE_THREADLIST_ON_SUSPEND_DEFAULT);
wc.setAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_DEBUG_ON_FORK,
IGDBLaunchConfigurationConstants.DEBUGGER_DEBUG_ON_FORK_DEFAULT);
wc.setAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_TRACEPOINT_MODE,
IGDBLaunchConfigurationConstants.DEBUGGER_TRACEPOINT_MODE_DEFAULT);
wc.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROGRAM_NAME,
binaryPath);
wc.setAttribute(ICDTLaunchConfigurationConstants.ATTR_PROJECT_NAME,
bin.getCProject().getElementName());
wc.setMappedResources(new IResource[] { bin.getResource(),
bin.getResource().getProject() });
wc.setAttribute(
ICDTLaunchConfigurationConstants.ATTR_WORKING_DIRECTORY,
(String) null);
Preferences prefs = InstanceScope.INSTANCE
.getNode(DockerLaunchUIPlugin.PLUGIN_ID);
// get the connection from the ConnectionListener which waits for
// any activity
// from the DockerExplorerView
IDockerConnection connection = ConnectionListener.getInstance()
.getCurrentConnection();
if (connection == null) {
IDockerConnection[] connections = DockerConnectionManager
.getInstance().getConnections();
if (connections != null && connections.length > 0)
connection = DockerConnectionManager.getInstance()
.getConnections()[0];
}
// issue error message if no connections exist
if (connection == null) {
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
MessageDialog.openError(
Display.getCurrent().getActiveShell(),
Messages.LaunchShortcut_Error_Launching,
Messages.LaunchShortcut_No_Connections);
}
});
return null;
}
wc.setAttribute(ILaunchConstants.ATTR_CONNECTION_URI,
connection.getUri());
// get any default image if specified, otherwise use first
// image in image list for connection
String image = prefs.get(PreferenceConstants.DEFAULT_IMAGE, null);
if (image == null) {
List<IDockerImage> images = connection.getImages();
if (images != null && images.size() > 0)
image = images.get(0).repoTags().get(0);
}
// issue error msg if no images exist
if (image == null) {
Display.getDefault().syncExec(new Runnable() {
@Override
public void run() {
MessageDialog.openError(
Display.getCurrent().getActiveShell(),
Messages.LaunchShortcut_Error_Launching,
Messages.LaunchShortcut_No_Images);
}
});
return null;
}
wc.setAttribute(ILaunchConstants.ATTR_IMAGE, (String) image);
Boolean keepPref = prefs.getBoolean(
PreferenceConstants.KEEP_CONTAINER_AFTER_LAUNCH, false);
wc.setAttribute(ILaunchConstants.ATTR_KEEP_AFTER_LAUNCH, keepPref);
// For Debug mode we need to set gdbserver info as well
if (mode.equals(ILaunchManager.DEBUG_MODE)) {
wc.setAttribute(ILaunchConstants.ATTR_GDBSERVER_COMMAND,
"gdbserver"); //$NON-NLS-1$
wc.setAttribute(ILaunchConstants.ATTR_GDBSERVER_PORT, "2345"); //$NON-NLS-1$
}
if (save) {
config = wc.doSave();
} else {
config = wc;
}
} catch (CoreException e) {
e.printStackTrace();
}
return config;
}
protected ILaunchManager getLaunchManager() {
return DebugPlugin.getDefault().getLaunchManager();
}
/**
* Show a selection dialog that allows the user to choose one of the
* specified launch configurations.
*
* @param configList
* The list of launch configurations to choose from.
* @param mode
* Currently unused.
* @return The chosen config, or <code>null</code> if the user cancelled the
* dialog.
*/
protected ILaunchConfiguration chooseConfiguration(
List<ILaunchConfiguration> configList, String mode) {
IDebugModelPresentation labelProvider = DebugUITools
.newDebugModelPresentation();
ElementListSelectionDialog dialog = new ElementListSelectionDialog(
getActiveWorkbenchShell(), labelProvider);
dialog.setElements(configList.toArray());
dialog.setTitle(Messages.LaunchShortcut_Launch_Configuration_Selection);
dialog.setMessage(Messages.LaunchShortcut_Choose_a_launch_configuration);
dialog.setMultipleSelection(false);
int result = dialog.open();
labelProvider.dispose();
if (result == IStatus.OK) {
return (ILaunchConfiguration) dialog.getFirstResult();
}
return null;
}
protected Shell getActiveWorkbenchShell() {
return DockerLaunchUIPlugin.getActiveWorkbenchShell();
}
}