<actionSet

			id="org.eclipse.mat.ui.actionSet.openAcquireDialog"

			label="Acquire Heap Dump" visible="false">

			<action

				id="org.eclipse.mat.ui.openAcquireDialog"

				class="org.eclipse.mat.ui.acquire.AcquireSnapshotAction"

				icon="icons/open_snapshot.gif"

				label="Acquire Heap Dump ..." menubarPath="file/new.ext" style="push"

				toolbarPath="org.eclipse.ui.workbench.file/new.ext"

				tooltip="Acquire heap dump from a locally running VM" />

		</actionSet>

		<perspectiveExtension

			targetID="org.eclipse.mat.ui.perspective">

			<actionSet

				id="org.eclipse.mat.ui.actionSet.openAcquireDialog">

			</actionSet>

		</perspectiveExtension>

		<command

			id="org.eclipse.mat.ui.acquire.HeapDump"

			name="Acquire Heap Dump">

		</command>

		<handler

			commandId="org.eclipse.mat.ui.acquire.HeapDump"

			class="org.eclipse.mat.ui.acquire.AcquireSnapshotAction$Handler">

		</handler>

		<key

			commandId="org.eclipse.mat.ui.acquire.HeapDump"

			contextId="org.eclipse.ui.contexts.window"

			schemeId="org.eclipse.mat.scheme" sequence="Alt+A">

		</key>

	public static String AcquireDialog_ChooseProcess;

	public static String AcquireDialog_ColumnDescription;

	public static String AcquireDialog_ColumnPID;

	public static String AcquireDialog_DialogDescription;

	public static String AcquireDialog_DialogName;

	public static String AcquireDialog_SaveLocation;

    public static String AcquireSnapshotAction_AcquireDialogName;

	public static String AcquireSnapshotAction_Confirmation;

	public static String AcquireSnapshotAction_DirectoryDoesntExist;

	public static String AcquireSnapshotAction_FailedToCreateProvider;

	public static String AcquireSnapshotAction_FileAlreadyExists;

	public static String AcquireSnapshotAction_NoProviderError;

	public static String AcquireSnapshotAction_UnableToCreateDirectory;

	public static String AcquireSnapshotAction_UnableToOpenEditor;

	public static String AcquireSnapshotAction_UnexpectedException;

AcquireDialog_ChooseProcess=Choose a local process:

AcquireDialog_ColumnDescription=Description

AcquireDialog_ColumnPID=Process Identifier

AcquireDialog_DialogDescription=Acquire a heap dump from a locally running Java process.

AcquireDialog_DialogName=Acquire Heap Dump Dialog

AcquireDialog_SaveLocation=Specify a folder to save the snapshot to:

AcquireSnapshotAction_AcquireDialogName=Acquire dialog

AcquireSnapshotAction_Confirmation=Confirmation

AcquireSnapshotAction_DirectoryDoesntExist=Destination directory doesn't exist. Do you want to create it?

AcquireSnapshotAction_FailedToCreateProvider=Failed to instantiate IHeapDumpProvider

AcquireSnapshotAction_FileAlreadyExists=Destination file already exists. Do you want to overwrite it?

AcquireSnapshotAction_NoProviderError=No Heap Dump Provider is registered

AcquireSnapshotAction_UnableToCreateDirectory=Unable to create the destination directory.

AcquireSnapshotAction_UnableToOpenEditor=Unable to open editor for the file:\n

AcquireSnapshotAction_UnexpectedException=Unexpected exception.

/*******************************************************************************

 * Copyright (c) 2009 SAP AG.

 * 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:

 *    SAP AG - initial API and implementation

 *******************************************************************************/

package org.eclipse.mat.ui.acquire;

import java.io.File;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.jface.layout.GridDataFactory;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.mat.snapshot.acquire.IHeapDumpProvider;

import org.eclipse.mat.snapshot.acquire.VmInfo;

import org.eclipse.mat.ui.MemoryAnalyserPlugin;

import org.eclipse.mat.ui.Messages;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.DirectoryDialog;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.swt.widgets.Text;

public class AcquireDialog extends WizardPage

{

    private static final String LAST_DIRECTORY_KEY = AcquireDialog.class.getName() + ".lastDir"; //$NON-NLS-1$

    private Table localVMsTable;

    private Text folderText;

    private List<IHeapDumpProvider> dumpProviders;

    public AcquireDialog(List<IHeapDumpProvider> dumpProviders)

    {

        super("acq"); //$NON-NLS-1$

        this.dumpProviders = dumpProviders;

    }

    public void createControl(Composite parent)

    {

        setTitle(Messages.AcquireDialog_DialogName);

        setDescription(Messages.AcquireDialog_DialogDescription);

        final Composite top = new Composite(parent, SWT.NONE);

        top.setLayout(new GridLayout(2, false));

        Label l1 = new Label(top, SWT.NONE);

        l1.setText(Messages.AcquireDialog_ChooseProcess);

        GridDataFactory.swtDefaults().span(2, 1).applyTo(l1);

        localVMsTable = new Table(top, SWT.BORDER | SWT.SINGLE | SWT.V_SCROLL | SWT.FULL_SELECTION);

        localVMsTable.setHeaderVisible(true);

        localVMsTable.setLinesVisible(true);

        GridDataFactory.fillDefaults().grab(true, true).span(2, 1).minSize(0, 100).applyTo(localVMsTable);

        localVMsTable.addSelectionListener(new SelectionAdapter()

        {

            public void widgetSelected(SelectionEvent e)

            {

                getContainer().updateButtons();

                String proposedFileName = getProcess().getProposedFileName();

                if (proposedFileName == null)

                	proposedFileName = "java_%pid%"; //$NON-NLS-1$

                proposedFileName = proposedFileName.replace("%pid%", String.valueOf(getProcess().getPid())); //$NON-NLS-1$

                proposedFileName = getSelectedDirectory() + File.separatorChar + proposedFileName;

                folderText.setText(proposedFileName);

            }

            public void widgetDefaultSelected(SelectionEvent e)

            {

                if (getWizard().performFinish())

                    getShell().close();

            }

        });

        TableColumn column = new TableColumn(localVMsTable, SWT.RIGHT);

        column.setText(Messages.AcquireDialog_ColumnDescription);

        column.setWidth(230);

        column = new TableColumn(localVMsTable, SWT.LEFT);

        column.setText(Messages.AcquireDialog_ColumnPID);

        column.setWidth(90);

        List<VmInfo> vms = getAvailableVms();

        if (vms != null)

        {

        	for (VmInfo process : vms)

        	{

        		TableItem item = new TableItem(localVMsTable, SWT.NONE);

        		item.setText(0, process.getDescription());

        		item.setText(1, Integer.toString(process.getPid()));

        		item.setData(process);

        	}

        }

        folderText = new Text(top, SWT.BORDER);

        GridDataFactory.fillDefaults().minSize(300, 0).grab(true, false).applyTo(folderText);

        folderText.setText(MemoryAnalyserPlugin.getDefault().getPluginPreferences().getString(LAST_DIRECTORY_KEY));

        folderText.addModifyListener(new ModifyListener()

        {

        	public void modifyText(ModifyEvent e)

        	{

        		getContainer().updateButtons();

        	}

        });

        Label l2 = new Label(top, SWT.NONE);

        l2.setText(Messages.AcquireDialog_SaveLocation);

        GridDataFactory.swtDefaults().span(2, 1).applyTo(l2);

        Button b = new Button(top, SWT.NONE);

        b.setText("..."); //$NON-NLS-1$

        b.addSelectionListener(new SelectionAdapter()

        {

            public void widgetSelected(SelectionEvent e)

            {

                DirectoryDialog dialog = new DirectoryDialog(top.getShell());

                String folder = dialog.open();

                if (folder != null && folder.length() > 0)

                    folderText.setText(folder);

            }

        });

        localVMsTable.setFocus();

        setControl(top);

    }

    private List<VmInfo> getAvailableVms()

	{

    	List<VmInfo> vms = new ArrayList<VmInfo>();

    	for (IHeapDumpProvider provider : dumpProviders)

		{

    		List<VmInfo> providerVMs = provider.getAvailableVMs();

    		if (providerVMs != null)

			{

    			vms.addAll(providerVMs);

			}

		}

		return vms;

	}

	@Override

    public boolean isPageComplete()

    {

        return localVMsTable.getSelectionIndex() != -1 && folderText.getText().length() > 0;

    }

	public VmInfo getProcess()

	{

		if (localVMsTable.getSelectionIndex() == -1) return null;

		return (VmInfo) localVMsTable.getSelection()[0].getData();

	}

    public String getSelectedPath()

    {

        return folderText.getText();

    }

    private String getSelectedDirectory()

    {

    	String selectedPath = folderText.getText();

    	if (selectedPath == null)

    		return ""; //$NON-NLS-1$

    	// if the selection is a folder, just return it

    	File f = new File(selectedPath);

    	if (f.exists() && f.isDirectory())

    		return selectedPath;

    	// otherwise return what seems to be the deepest folder

    	int i = selectedPath.lastIndexOf(File.separatorChar);

    	return i == -1 ? selectedPath : selectedPath.substring(0, i);

    }

    public void saveSettings()

    {

        MemoryAnalyserPlugin.getDefault().getPluginPreferences().setValue(LAST_DIRECTORY_KEY, getSelectedDirectory());

    }

}

/*******************************************************************************

 * Copyright (c) 2009 SAP AG.

 * 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:

 *    SAP AG - initial API and implementation

 *******************************************************************************/

package org.eclipse.mat.ui.acquire;

import java.io.File;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IConfigurationElement;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.dialogs.ErrorDialog;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableContext;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.mat.snapshot.acquire.IHeapDumpProvider;

import org.eclipse.mat.snapshot.acquire.VmInfo;

import org.eclipse.mat.ui.Messages;

import org.eclipse.mat.ui.editor.PathEditorInput;

import org.eclipse.mat.ui.util.ErrorHelper;

import org.eclipse.mat.ui.util.ProgressMonitorWrapper;

import org.eclipse.mat.util.IProgressListener;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IEditorDescriptor;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.IWorkbenchWindowActionDelegate;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.ide.IDE;

public class AcquireSnapshotAction extends Action implements IWorkbenchWindowActionDelegate

{

	public void run()

	{

		final Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();

		List<IHeapDumpProvider> dumpProviders = getProviders();

		if (dumpProviders == null || dumpProviders.size() == 0)

		{

			showError(Messages.AcquireSnapshotAction_NoProviderError);

			return;

		}

		final AcquireDialog acquireDialog = new AcquireDialog(dumpProviders);

		Wizard wizard = new Wizard() {

			public boolean performFinish()

			{

				VmInfo selectedProcess = acquireDialog.getProcess();

				try

				{

					String selectedPath = acquireDialog.getSelectedPath();

					File preferredLocation = new File(selectedPath);

					if (!validatePath(preferredLocation)) return false;

					// request the heap dump and check if result is OK

					AcquireDumpOperation dumpOperation = new AcquireDumpOperation(selectedProcess, preferredLocation, getContainer());

					if (!dumpOperation.run().isOK()) return false;

					File destFile = dumpOperation.getResult();

					// open the heapdump

					Path path = new Path(destFile.getAbsolutePath());

					IEditorDescriptor descriptor = PlatformUI.getWorkbench().getEditorRegistry().getDefaultEditor(path.toOSString());

					try

					{

						IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), new PathEditorInput(path), descriptor.getId(),

								true);

						if (PlatformUI.getWorkbench().getIntroManager().getIntro() != null)

						{

							// if this action was called with open welcome page

							// - set it to standby mode.

							PlatformUI.getWorkbench().getIntroManager().setIntroStandby(PlatformUI.getWorkbench().getIntroManager().getIntro(), true);

						}

					}

					catch (Exception e)

					{

						ErrorHelper.logThrowableAndShowMessage(e, Messages.AcquireSnapshotAction_UnableToOpenEditor + path);

					}

					if (new File(acquireDialog.getSelectedPath()).exists()) acquireDialog.saveSettings();

				}

				catch (Exception e)

				{

					ErrorHelper.logThrowableAndShowMessage(e);

					return false;

				}

				return true;

			}

			private boolean validatePath(File destFile)

			{

				if (destFile.exists())

				{

					if (MessageDialog.openConfirm(shell, Messages.AcquireSnapshotAction_Confirmation, Messages.AcquireSnapshotAction_FileAlreadyExists))

					{

						destFile.delete();

					}

					else

					{

						return false;

					}

				}

				else if (!destFile.getParentFile().exists())

				{

					if (MessageDialog.openConfirm(shell, Messages.AcquireSnapshotAction_Confirmation, Messages.AcquireSnapshotAction_DirectoryDoesntExist))

					{

						if (!destFile.getParentFile().mkdirs())

						{

							showError(Messages.AcquireSnapshotAction_UnableToCreateDirectory);

							destFile = null;

						}

					}

					else

					{

						return false;

					}

				}

				return true;

			}

		};

		wizard.addPage(acquireDialog);

		wizard.setWindowTitle(Messages.AcquireSnapshotAction_AcquireDialogName);

		wizard.setNeedsProgressMonitor(true);

		new WizardDialog(shell, wizard).open();

	}

	private List<IHeapDumpProvider> getProviders()

	{

		IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor("org.eclipse.mat.api.heapDumpProvider"); //$NON-NLS-1$

		if (config.length == 0) return null;

		List<IHeapDumpProvider> providers = new ArrayList<IHeapDumpProvider>();

		for (IConfigurationElement configurationElement : config)

		{

			String bundleName = configurationElement.getContributor().getName();

			Logger.getLogger(getClass().getName()).info("Loaded heapDumpProvider from " + bundleName); //$NON-NLS-1$

			try

			{

				Object provider = configurationElement.createExecutableExtension("impl"); //$NON-NLS-1$

				providers.add((IHeapDumpProvider) provider);

			}

			catch (CoreException e)

			{

				Logger.getLogger(getClass().getName()).log(Level.SEVERE, Messages.AcquireSnapshotAction_FailedToCreateProvider, e);

			}

		}

		return providers;

	}

	private void showError(String msg)

	{

		ErrorDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), "Error", null, ErrorHelper.createErrorStatus(msg)); //$NON-NLS-1$

	}

	public void dispose()

	{}

	public void init(IWorkbenchWindow window)

	{}

	public void run(IAction action)

	{

		run();

	}

	public void selectionChanged(IAction action, ISelection selection)

	{}

	public static class Handler extends AbstractHandler

	{

		public Handler()

		{}

		public Object execute(ExecutionEvent executionEvent)

		{

			new AcquireSnapshotAction().run();

			return null;

		}

	}

	static class AcquireDumpOperation implements IRunnableWithProgress

	{

		private IStatus status;

		private IRunnableContext context;

		private VmInfo vmInfo;

		private File preferredLocation;

		private File result;

		public AcquireDumpOperation(VmInfo vmInfo, File preferredLocation, IRunnableContext context)

		{

			this.vmInfo = vmInfo;

			this.preferredLocation = preferredLocation;

			this.context = context;

		}

		private IStatus doOperation(IProgressMonitor monitor)

		{

			IProgressListener listener = new ProgressMonitorWrapper(monitor);

			try

			{

				result = vmInfo.getHeapDumpProvider().acquireDump(vmInfo, preferredLocation, listener);

				if (listener.isCanceled()) return Status.CANCEL_STATUS;

			}

			catch (InterruptedException ignore)

			{

				// $JL-EXC$

			}

			catch (Exception e)

			{

				return ErrorHelper.createErrorStatus(e);

			}

			return Status.OK_STATUS;

		}

		private File getResult()

		{

			return result;

		}

		public final void run(final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException

		{

			status = doOperation(monitor);

		}

		public final IStatus run()

		{

			try

			{

				context.run(true, true, this);

			}

			catch (Exception e)

			{

				status = ErrorHelper.createErrorStatus(Messages.AcquireSnapshotAction_UnexpectedException, e);

			}

			// report error if any occurred

			if (!status.isOK() && status != Status.CANCEL_STATUS)

				ErrorDialog.openError(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), "Error", null, status); //$NON-NLS-1$

			return status;

		}

	}

}