Attachment #164371 for bug #190711

Lines 77-82 Link Here

(-)plugin.properties (+2 lines)
77		77
78	PluginSearchPage.label = Plug-in Search	78	PluginSearchPage.label = Plug-in Search
79		79
		80	target.export.wizard.name=Target definition
		81	target.export.wizard.desc=Export the currently active target definition
80	PluginExportWizard.label=Deployable plug-ins and fragments	82	PluginExportWizard.label=Deployable plug-ins and fragments
81	PluginExportWizard.description=Export the selected plug-ins and/or fragments \	83	PluginExportWizard.description=Export the selected plug-ins and/or fragments \
82	in a form suitable for deploying in an Eclipse product.	84	in a form suitable for deploying in an Eclipse product.




               class="org.eclipse.core.resources.IContainer">
         </selection>
      </wizard>
      <wizard
            category="org.eclipse.pde.ui.PluginDevelopment"
            class="org.eclipse.pde.internal.ui.wizards.exports.TargetDefinitionExportWizard"
            icon="icons/obj16/target_profile_xml_obj.gif"
            id="org.eclipse.pde.target.wizard"
            name="%target.export.wizard.name">
         <description>
            %target.export.wizard.desc
         </description>
      </wizard>
      <category
            id="org.eclipse.pde.ui.PluginDevelopment"
            name="%PluginImportExport.category"/>




	public static String CategorySection_newCategoryName;
	public static String CategorySection_newCategoryLabel;

	// Target Export ########################################
	public static String ExportTargetDefinition_task;
	public static String ExportTargetDeleteOldData;
	public static String ExportTargetExportFeatures;
	public static String ExportTargetExportPlugins;
	public static String ExportActiveTargetDefinition;
	public static String ExportTargetCurrentTarget;
	public static String ExportTargetChooseFolder;
	public static String ExportTargetBrowse;
	public static String ExportTargetSelectDestination;
	public static String ExportTargetSpecifyDestination;
	public static String ExportTargetClearDestination;
	public static String ExportTargetError_ChooseDestination;

	public static String CategoryDetails_title;
	public static String CategoryDetails_sectionDescription;
	public static String CategoryDetails_name;




CategorySection_newCategoryName = new_category_{0}
CategorySection_newCategoryLabel = New Category {0}

######### Target Export Wizard ###################################33
ExportTargetDefinition_task = Exporting current target definition...
ExportTargetDeleteOldData = Deleting old data...
ExportTargetExportFeatures = Exporting features...
ExportTargetExportPlugins = Exporting plugins...
ExportActiveTargetDefinition = Export Active Target Definition
ExportTargetCurrentTarget = Active &Target: 
ExportTargetChooseFolder = &Destination:
ExportTargetBrowse = &Browse...
ExportTargetSelectDestination = Select Destination
ExportTargetSpecifyDestination = Specify the destination directory for the current target
ExportTargetClearDestination = &Clear destination directory before exporting
ExportTargetError_ChooseDestination = Please choose a destination directory


CategoryDetails_title = Category Properties
CategoryDetails_sectionDescription = Provide a unique id, a name and a description for each category.\n\
"*" denotes a required field.




/*******************************************************************************
 * Copyright (c) 2010 EclipseSource Corporation and others.
 * 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:
 *     Chris Aniszczyk <caniszczyk@gmail.com> - initial API and implementation
 *     Ian Bull <irbull@eclipsesource.com> - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.wizards.exports;

import java.net.URI;
import org.eclipse.core.filesystem.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.equinox.p2.engine.IProfile;
import org.eclipse.pde.core.plugin.IPluginModelBase;
import org.eclipse.pde.core.plugin.PluginRegistry;
import org.eclipse.pde.internal.core.FeatureModelManager;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.feature.ExternalFeatureModel;
import org.eclipse.pde.internal.core.ifeature.IFeatureModel;
import org.eclipse.pde.internal.core.target.TargetDefinition;
import org.eclipse.pde.internal.core.target.TargetPlatformService;
import org.eclipse.pde.internal.ui.PDEPlugin;
import org.eclipse.pde.internal.ui.PDEUIMessages;

/**
 * This job exports the bundles and features that make up your target. 
 */
public class ExportActiveTargetJob extends Job {

	private URI fDestination;
	private boolean fclearDestinationDirectory = false;

	public ExportActiveTargetJob(URI destination, boolean clearDestinationDirectory) {
		super("Export Current Target Definition Job"); //$NON-NLS-1$
		fDestination = destination;
		fclearDestinationDirectory = clearDestinationDirectory;
	}

	protected IStatus run(IProgressMonitor monitor) {

		IFileSystem fileSystem = EFS.getLocalFileSystem();
		if (!fileSystem.canWrite()) {
			return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Destination directory not writable."); //$NON-NLS-1$ 
		}
		IFileStore destination = fileSystem.getStore(fDestination);

		FeatureModelManager featureManager = PDECore.getDefault().getFeatureModelManager();
		IFeatureModel[] featureModels = featureManager.getModels();
		IPluginModelBase[] pluginModels = PluginRegistry.getExternalModels();

		IFileStore featureDir = destination.getChild("features"); //$NON-NLS-1$
		IFileStore pluginDir = destination.getChild("plugins"); //$NON-NLS-1$
		IFileStore metadataXML = destination.getChild("content.xml"); //$NON-NLS-1$
		IFileStore metadataJAR = destination.getChild("content.jar"); //$NON-NLS-1$

		int totalWork = featureModels.length + pluginModels.length;

		try {
			monitor.beginTask(PDEUIMessages.ExportTargetDefinition_task, totalWork);
			if (fclearDestinationDirectory) {
				monitor.subTask(PDEUIMessages.ExportTargetDeleteOldData); //Deleting old data...
			}

			try {
				if (fclearDestinationDirectory) {
					ExportTargetMetadata.getDefault().clearExporedRepository(fDestination);

					if (featureDir.fetchInfo().exists()) {
						featureDir.delete(EFS.NONE, new NullProgressMonitor());
					}
					if (pluginDir.fetchInfo().exists()) {
						pluginDir.delete(EFS.NONE, new NullProgressMonitor());
					}
					if (metadataJAR.fetchInfo().exists()) {
						metadataJAR.delete(EFS.NONE, new NullProgressMonitor());
					}
					if (metadataXML.fetchInfo().exists()) {
						metadataXML.delete(EFS.NONE, new NullProgressMonitor());
					}
				}

				if (!featureDir.fetchInfo().exists()) {
					featureDir.mkdir(EFS.NONE, new NullProgressMonitor());
				}
				if (!pluginDir.fetchInfo().exists()) {
					pluginDir.mkdir(EFS.NONE, new NullProgressMonitor());
				}
			} catch (CoreException e1) {
				return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to create destination directory.", e1); //$NON-NLS-1$
			}

			monitor.subTask(PDEUIMessages.ExportTargetExportFeatures);
			for (int i = 0; i < featureModels.length; i++) {
				IFeatureModel model = featureModels[i];
				if (model.isEnabled() && model instanceof ExternalFeatureModel) {
					copy(model.getInstallLocation(), featureDir, fileSystem, monitor);
				}
			}

			monitor.subTask(PDEUIMessages.ExportTargetExportPlugins);
			for (int i = 0; i < pluginModels.length; i++) {
				IPluginModelBase model = pluginModels[i];
				//if (model.isEnabled()) {
				copy(model.getInstallLocation(), pluginDir, fileSystem, monitor);
				//}
			}

			try {
				TargetDefinition definition = ((TargetDefinition) TargetPlatformService.getDefault().getWorkspaceTargetHandle().getTargetDefinition());
				IProfile profile = definition.getProfile();
				ExportTargetMetadata component = ExportTargetMetadata.getDefault();
				IStatus status = component.exportMetadata(profile, fDestination, definition.getName());
				if (status.isOK())
					return status;
			} catch (CoreException e) {
				return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to export the target", e); //$NON-NLS-1$ 
			}
		} catch (CoreException e) {
			return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to export the target", e); //$NON-NLS-1$ 
		}

		finally {
			monitor.done();
		}
		return Status.OK_STATUS;
	}

	private IStatus copy(String src, IFileStore destinationParent, IFileSystem fileSystem, IProgressMonitor monitor) throws CoreException {
		Path srcPath = new Path(src);
		IFileStore source = fileSystem.getStore(srcPath);
		String elementName = srcPath.segment(srcPath.segmentCount() - 1);
		IFileStore destinationDirectory = destinationParent.getChild(elementName);
		if (destinationDirectory.fetchInfo().exists()) {
			monitor.worked(1);
			return Status.OK_STATUS;
		}
		if (source.fetchInfo().isDirectory()) {
			destinationDirectory.mkdir(EFS.NONE, new NullProgressMonitor());
		}
		source.copy(destinationDirectory, EFS.OVERWRITE, new SubProgressMonitor(monitor, 1));
		return Status.OK_STATUS;
	}

}




/*******************************************************************************
 * Copyright (c) 2010 EclipseSource Corporation and others.
 * 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:
 *     Ian Bull <irbull@eclipsesource.com> - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.wizards.exports;

import java.net.URI;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.p2.core.IProvisioningAgent;
import org.eclipse.equinox.p2.core.ProvisionException;
import org.eclipse.equinox.p2.engine.IProfile;
import org.eclipse.equinox.p2.query.IQueryResult;
import org.eclipse.equinox.p2.query.QueryUtil;
import org.eclipse.equinox.p2.repository.IRepositoryManager;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepositoryManager;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.ui.PDEPlugin;

public class ExportTargetMetadata {

	IProvisioningAgent agent = null;
	public static ExportTargetMetadata instance = null;

	public void start() {
		instance = this;
	}

	public void stop() {
		instance = null;

	}

	public static ExportTargetMetadata getDefault() {
		return instance;
	}

	public synchronized void clearExporedRepository(URI destination) {
		agent = (IProvisioningAgent) PDECore.getDefault().acquireService(IProvisioningAgent.SERVICE_NAME);
		if (agent == null)
			return;
		if (((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).contains(destination))
			((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).removeRepository(destination);
	}

	public synchronized IStatus exportMetadata(IProfile profile, URI destination, String targetName) {
		if (agent == null)
			return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to mirror the metadata."); //$NON-NLS-1$
		boolean removeRepoAfterLoad = false;
		try {
			IMetadataRepository repository = null;

			try {
				//TODO: There appears to be a small (5 byte) difference from when I do the load vs. the create
				//      The create gives the repo a version 1, while the load gives it 1.0.0
				//      this might be worth looking into
				removeRepoAfterLoad = !((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).contains(destination);
				repository = ((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).loadRepository(destination, IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, new NullProgressMonitor());
			} catch (ProvisionException e) {
				// The repository cannot be loaded
			}
			if (repository == null) {
				repository = ((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).createRepository(destination, targetName, IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);
			}

			if (repository != null) {
				mirrorMetadata(profile, repository);
			} else {
				return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to mirror the metadata."); //$NON-NLS-1$
			}

		} catch (ProvisionException e) {
			return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to mirror the metadata.", e); //$NON-NLS-1$
		} finally {
			if (removeRepoAfterLoad) {
				((IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME)).removeRepository(destination);
			}
		}

		return Status.OK_STATUS;
	}

	private void mirrorMetadata(IProfile profile, IMetadataRepository repository) {
		IQueryResult results = profile.query(QueryUtil.createIUAnyQuery(), new NullProgressMonitor());
		repository.addInstallableUnits(results.toUnmodifiableSet());
	}

}




/*******************************************************************************
 * Copyright (c) 2010 EclipseSource Corporation and others.
 * 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:
 *     Chris Aniszczyk <caniszczyk@gmail.com> - initial API and implementation
 *     Ian Bull <irbull@eclipsesource.com> - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.wizards.exports;

import java.io.File;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.ui.IExportWizard;
import org.eclipse.ui.IWorkbench;

public class TargetDefinitionExportWizard extends Wizard implements IExportWizard {

	private TargetDefinitionExportWizardPage fPage = null;

	public TargetDefinitionExportWizard() {
		setNeedsProgressMonitor(true);
		setWindowTitle(PDEUIMessages.ExportActiveTargetDefinition);
	}

	public void addPages() {
		fPage = new TargetDefinitionExportWizardPage();
		addPage(fPage);
	}

	public boolean performFinish() {
		String destDir = fPage.getDestinationDirectory();
		boolean clearDestDir = fPage.isClearDestinationDirectory();
		File file = new File(destDir);

		Job job = new ExportActiveTargetJob(file.toURI(), clearDestDir);
		job.schedule(200);

		return true;
	}

	public void init(IWorkbench workbench, IStructuredSelection selection) {
		// do nothing atm
	}

}




/*******************************************************************************
 * Copyright (c) 2010 EclipseSource Corporation and others.
 * 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:
 *     Chris Aniszczyk <caniszczyk@gmail.com> - initial API and implementation
 *     Ian Bull <irbull@eclipsesource.com> - initial API and implementation
 *******************************************************************************/
package org.eclipse.pde.internal.ui.wizards.exports;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.pde.internal.core.target.TargetDefinition;
import org.eclipse.pde.internal.core.target.TargetPlatformService;
import org.eclipse.pde.internal.ui.PDEUIMessages;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.*;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.*;

public class TargetDefinitionExportWizardPage extends WizardPage {

	private static final String PAGE_ID = "org.eclipse.pde.target.exportPage"; //$NON-NLS-1$
	private Button browseButton = null;
	private Text destDirText = null;
	private Button clearDestinationDirCheck = null;

	protected TargetDefinitionExportWizardPage() {
		super(PAGE_ID);
		setPageComplete(false);
		setTitle(PDEUIMessages.ExportActiveTargetDefinition);
		// TODO setImage(...)
	}

	public void createControl(Composite parent) {
		Composite container = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout(1, false);
		container.setLayout(layout);
		createExportDirectoryControl(container);

		//TODO initSettings();

		Dialog.applyDialogFont(container);
		setControl(container);
		setPageComplete(validate());
	}

	private void createExportDirectoryControl(Composite parent) {
		parent.setLayout(new GridLayout(3, false));
		parent.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		new Label(parent, SWT.NONE).setText(PDEUIMessages.ExportTargetCurrentTarget);
		Label l = new Label(parent, SWT.NONE);

		try {
			// TODO this is a bit dirty
			TargetDefinition definition = ((TargetDefinition) TargetPlatformService.getDefault().getWorkspaceTargetHandle().getTargetDefinition());
			l.setText(definition.getName());
		} catch (CoreException e) {
			// TODO log something?
		}

		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
		gd.horizontalSpan = 2;
		l.setLayoutData(gd);
		new Label(parent, SWT.NONE).setText(PDEUIMessages.ExportTargetChooseFolder);

		destDirText = new Text(parent, SWT.BORDER);
		destDirText.setEditable(false);
		destDirText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		destDirText.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
				controlChanged();
			}
		});
		browseButton = new Button(parent, SWT.PUSH);
		browseButton.setText(PDEUIMessages.ExportTargetBrowse);
		browseButton.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
				DirectoryDialog dialog = new DirectoryDialog(getShell());
				dialog.setText(PDEUIMessages.ExportTargetSelectDestination);
				dialog.setMessage(PDEUIMessages.ExportTargetSpecifyDestination);
				String dir = destDirText.getText();
				dialog.setFilterPath(dir);
				dir = dialog.open();
				if (dir == null || dir.equals("")) { //$NON-NLS-1$
					return;
				}
				destDirText.setText(dir);
				controlChanged();
			}
		});

		clearDestinationDirCheck = new Button(parent, SWT.CHECK);
		clearDestinationDirCheck.setText(PDEUIMessages.ExportTargetClearDestination);
		gd = new GridData();
		gd.horizontalSpan = 2;
		clearDestinationDirCheck.setLayoutData(gd);
	}

	public String getDestinationDirectory() {
		return destDirText.getText();
	}

	public boolean isClearDestinationDirectory() {
		return clearDestinationDirCheck.getSelection();
	}

	public void controlChanged() {
		setPageComplete(validate());
	}

	protected boolean validate() {
		setMessage(null);

		if (destDirText.getText().equals("")) { //$NON-NLS-1$
			setMessage(PDEUIMessages.ExportTargetError_ChooseDestination, IStatus.WARNING);
			return false;
		}

		return true;
	}

}

Return to bug 190711

Lines 312-317 Link Here

(-)plugin.xml (+10 lines)
312	class="org.eclipse.core.resources.IContainer">	312	class="org.eclipse.core.resources.IContainer">
313	</selection>	313	</selection>
314	</wizard>	314	</wizard>
		315	<wizard
		316	category="org.eclipse.pde.ui.PluginDevelopment"
		317	class="org.eclipse.pde.internal.ui.wizards.exports.TargetDefinitionExportWizard"
		318	icon="icons/obj16/target_profile_xml_obj.gif"
		319	id="org.eclipse.pde.target.wizard"
		320	name="%target.export.wizard.name">
		321	<description>
		322	%target.export.wizard.desc
		323	</description>
		324	</wizard>
315	<category	325	<category
316	id="org.eclipse.pde.ui.PluginDevelopment"	326	id="org.eclipse.pde.ui.PluginDevelopment"
317	name="%PluginImportExport.category"/>	327	name="%PluginImportExport.category"/>

Lines 1678-1683 Link Here

(-)src/org/eclipse/pde/internal/ui/PDEUIMessages.java (+14 lines)
1678	public static String CategorySection_newCategoryName;	1678	public static String CategorySection_newCategoryName;
1679	public static String CategorySection_newCategoryLabel;	1679	public static String CategorySection_newCategoryLabel;
1680		1680
		1681	// Target Export ########################################
		1682	public static String ExportTargetDefinition_task;
		1683	public static String ExportTargetDeleteOldData;
		1684	public static String ExportTargetExportFeatures;
		1685	public static String ExportTargetExportPlugins;
		1686	public static String ExportActiveTargetDefinition;
		1687	public static String ExportTargetCurrentTarget;
		1688	public static String ExportTargetChooseFolder;
		1689	public static String ExportTargetBrowse;
		1690	public static String ExportTargetSelectDestination;
		1691	public static String ExportTargetSpecifyDestination;
		1692	public static String ExportTargetClearDestination;
		1693	public static String ExportTargetError_ChooseDestination;
		1694
1681	public static String CategoryDetails_title;	1695	public static String CategoryDetails_title;
1682	public static String CategoryDetails_sectionDescription;	1696	public static String CategoryDetails_sectionDescription;
1683	public static String CategoryDetails_name;	1697	public static String CategoryDetails_name;

Lines 1553-1558 Link Here

(-)src/org/eclipse/pde/internal/ui/pderesources.properties (+15 lines)
1553	CategorySection_newCategoryName = new_category_{0}	1553	CategorySection_newCategoryName = new_category_{0}
1554	CategorySection_newCategoryLabel = New Category {0}	1554	CategorySection_newCategoryLabel = New Category {0}
1555		1555
		1556	######### Target Export Wizard ###################################33
		1557	ExportTargetDefinition_task = Exporting current target definition...
		1558	ExportTargetDeleteOldData = Deleting old data...
		1559	ExportTargetExportFeatures = Exporting features...
		1560	ExportTargetExportPlugins = Exporting plugins...
		1561	ExportActiveTargetDefinition = Export Active Target Definition
		1562	ExportTargetCurrentTarget = Active &Target:
		1563	ExportTargetChooseFolder = &Destination:
		1564	ExportTargetBrowse = &Browse...
		1565	ExportTargetSelectDestination = Select Destination
		1566	ExportTargetSpecifyDestination = Specify the destination directory for the current target
		1567	ExportTargetClearDestination = &Clear destination directory before exporting
		1568	ExportTargetError_ChooseDestination = Please choose a destination directory
		1569
		1570
1556	CategoryDetails_title = Category Properties	1571	CategoryDetails_title = Category Properties
1557	CategoryDetails_sectionDescription = Provide a unique id, a name and a description for each category.\n\	1572	CategoryDetails_sectionDescription = Provide a unique id, a name and a description for each category.\n\
1558	"*" denotes a required field.	1573	"*" denotes a required field.

Added Link Here

(-)src/org/eclipse/pde/internal/ui/wizards/exports/ExportActiveTargetJob.java (+149 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 EclipseSource Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Chris Aniszczyk <caniszczyk@gmail.com> - initial API and implementation
10	* Ian Bull <irbull@eclipsesource.com> - initial API and implementation
11	*******************************************************************************/
12	package org.eclipse.pde.internal.ui.wizards.exports;
13
14	import java.net.URI;
15	import org.eclipse.core.filesystem.*;
16	import org.eclipse.core.runtime.*;
17	import org.eclipse.core.runtime.jobs.Job;
18	import org.eclipse.equinox.p2.engine.IProfile;
19	import org.eclipse.pde.core.plugin.IPluginModelBase;
20	import org.eclipse.pde.core.plugin.PluginRegistry;
21	import org.eclipse.pde.internal.core.FeatureModelManager;
22	import org.eclipse.pde.internal.core.PDECore;
23	import org.eclipse.pde.internal.core.feature.ExternalFeatureModel;
24	import org.eclipse.pde.internal.core.ifeature.IFeatureModel;
25	import org.eclipse.pde.internal.core.target.TargetDefinition;
26	import org.eclipse.pde.internal.core.target.TargetPlatformService;
27	import org.eclipse.pde.internal.ui.PDEPlugin;
28	import org.eclipse.pde.internal.ui.PDEUIMessages;
29
30	/**
31	* This job exports the bundles and features that make up your target.
32	*/
33	public class ExportActiveTargetJob extends Job {
34
35	private URI fDestination;
36	private boolean fclearDestinationDirectory = false;
37
38	public ExportActiveTargetJob(URI destination, boolean clearDestinationDirectory) {
39	super("Export Current Target Definition Job"); //$NON-NLS-1$
40	fDestination = destination;
41	fclearDestinationDirectory = clearDestinationDirectory;
42	}
43
44	protected IStatus run(IProgressMonitor monitor) {
45
46	IFileSystem fileSystem = EFS.getLocalFileSystem();
47	if (!fileSystem.canWrite()) {
48	return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Destination directory not writable."); //$NON-NLS-1$
49	}
50	IFileStore destination = fileSystem.getStore(fDestination);
51
52	FeatureModelManager featureManager = PDECore.getDefault().getFeatureModelManager();
53	IFeatureModel[] featureModels = featureManager.getModels();
54	IPluginModelBase[] pluginModels = PluginRegistry.getExternalModels();
55
56	IFileStore featureDir = destination.getChild("features"); //$NON-NLS-1$
57	IFileStore pluginDir = destination.getChild("plugins"); //$NON-NLS-1$
58	IFileStore metadataXML = destination.getChild("content.xml"); //$NON-NLS-1$
59	IFileStore metadataJAR = destination.getChild("content.jar"); //$NON-NLS-1$
60
61	int totalWork = featureModels.length + pluginModels.length;
62
63	try {
64	monitor.beginTask(PDEUIMessages.ExportTargetDefinition_task, totalWork);
65	if (fclearDestinationDirectory) {
66	monitor.subTask(PDEUIMessages.ExportTargetDeleteOldData); //Deleting old data...
67	}
68
69	try {
70	if (fclearDestinationDirectory) {
71	ExportTargetMetadata.getDefault().clearExporedRepository(fDestination);
72
73	if (featureDir.fetchInfo().exists()) {
74	featureDir.delete(EFS.NONE, new NullProgressMonitor());
75	}
76	if (pluginDir.fetchInfo().exists()) {
77	pluginDir.delete(EFS.NONE, new NullProgressMonitor());
78	}
79	if (metadataJAR.fetchInfo().exists()) {
80	metadataJAR.delete(EFS.NONE, new NullProgressMonitor());
81	}
82	if (metadataXML.fetchInfo().exists()) {
83	metadataXML.delete(EFS.NONE, new NullProgressMonitor());
84	}
85	}
86
87	if (!featureDir.fetchInfo().exists()) {
88	featureDir.mkdir(EFS.NONE, new NullProgressMonitor());
89	}
90	if (!pluginDir.fetchInfo().exists()) {
91	pluginDir.mkdir(EFS.NONE, new NullProgressMonitor());
92	}
93	} catch (CoreException e1) {
94	return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to create destination directory.", e1); //$NON-NLS-1$
95	}
96
97	monitor.subTask(PDEUIMessages.ExportTargetExportFeatures);
98	for (int i = 0; i < featureModels.length; i++) {
99	IFeatureModel model = featureModels[i];
100	if (model.isEnabled() && model instanceof ExternalFeatureModel) {
101	copy(model.getInstallLocation(), featureDir, fileSystem, monitor);
102	}
103	}
104
105	monitor.subTask(PDEUIMessages.ExportTargetExportPlugins);
106	for (int i = 0; i < pluginModels.length; i++) {
107	IPluginModelBase model = pluginModels[i];
108	//if (model.isEnabled()) {
109	copy(model.getInstallLocation(), pluginDir, fileSystem, monitor);
110	//}
111	}
112
113	try {
114	TargetDefinition definition = ((TargetDefinition) TargetPlatformService.getDefault().getWorkspaceTargetHandle().getTargetDefinition());
115	IProfile profile = definition.getProfile();
116	ExportTargetMetadata component = ExportTargetMetadata.getDefault();
117	IStatus status = component.exportMetadata(profile, fDestination, definition.getName());
118	if (status.isOK())
119	return status;
120	} catch (CoreException e) {
121	return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to export the target", e); //$NON-NLS-1$
122	}
123	} catch (CoreException e) {
124	return new Status(IStatus.ERROR, PDEPlugin.getPluginId(), "Failed to export the target", e); //$NON-NLS-1$
125	}
126
127	finally {
128	monitor.done();
129	}
130	return Status.OK_STATUS;
131	}
132
133	private IStatus copy(String src, IFileStore destinationParent, IFileSystem fileSystem, IProgressMonitor monitor) throws CoreException {
134	Path srcPath = new Path(src);
135	IFileStore source = fileSystem.getStore(srcPath);
136	String elementName = srcPath.segment(srcPath.segmentCount() - 1);
137	IFileStore destinationDirectory = destinationParent.getChild(elementName);
138	if (destinationDirectory.fetchInfo().exists()) {
139	monitor.worked(1);
140	return Status.OK_STATUS;
141	}
142	if (source.fetchInfo().isDirectory()) {
143	destinationDirectory.mkdir(EFS.NONE, new NullProgressMonitor());
144	}
145	source.copy(destinationDirectory, EFS.OVERWRITE, new SubProgressMonitor(monitor, 1));
146	return Status.OK_STATUS;
147	}
148
149	}