Attachment #131810 for bug #265550

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import org.apache.tools.ant.*;
import org.apache.tools.ant.types.FileSet;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.URIUtil;
import org.eclipse.equinox.internal.p2.artifact.repository.ant.AntMirrorLog;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;
import org.eclipse.equinox.internal.provisional.p2.query.Collector;
import org.eclipse.equinox.internal.provisional.p2.query.Query;
import org.eclipse.equinox.p2.internal.repository.tools.AbstractApplication;
import org.eclipse.equinox.p2.internal.repository.tools.Messages;
import org.eclipse.osgi.util.NLS;

public abstract class AbstractRepositoryTask extends Task {
	protected AbstractApplication application;

	protected List sourceRepos = new ArrayList();
	protected List destinations = new ArrayList();

	/*
	  * Create a special file set since the user specified a "source" sub-element.
	  */
	public FileSet createSource() {
		MyFileSet set = new MyFileSet();
		sourceRepos.add(set);
		return set;
	}

	protected void addMetadataSourceRepository(URI repoLocation) {
		application.addSourceMetadataRepository(repoLocation);
	}

	 * argument to specify both the artifact and metadata repositories.
	 */
	public void setDestination(String location) {
		// TODO depreciate 
		DestinationRepository dest = new DestinationRepository();
		dest.setLocation(location);
		destinations.add(dest);
		destinations.add(metadata);

		DestinationRepository artifact = new DestinationRepository();
		artifact.setLocation(URIUtil.toUnencodedString(new Path(location).toFile().toURI()));
		metadata.setKind("artifact"); //$NON-NLS-1$
		application.addDestination(artifact.getDescriptor());
		destinations.add(artifact);
	}

	public DestinationRepository createDestination() {
		// TODO depreciate 
		DestinationRepository destination = new DestinationRepository();
		destinations.add(destination);
		application.addDestination(destination.getDescriptor());

	}

	/*
	 * Add a repository to mirror into
	 */
	public DestinationRepository createRepository() {
		DestinationRepository destination = new DestinationRepository();
		destinations.add(destination);
		application.addDestination(destination.getDescriptor());
		return destination;
	}

	/*
	 * Add source repositories to mirror from
	 */
	public void addConfiguredSource(RepositoryList sourceList) {
		for (Iterator iter = sourceList.getRepositoryList().iterator(); iter.hasNext();) {
			DestinationRepository repo = (DestinationRepository) iter.next();
			application.addSource(repo.getDescriptor());
		}

		for (Iterator iter = sourceList.getFileSetList().iterator(); iter.hasNext();) {
			FileSet fileSet = (FileSet) iter.next();
			sourceRepos.add(fileSet);
			// Added to the application later through prepareSourceRepos
		}
	}


		if (sourceRepos == null || sourceRepos.isEmpty())
			return;
		for (Iterator iter = sourceRepos.iterator(); iter.hasNext();) {
			RepositoryFileSet fileset = (RepositoryFileSet) iter.next();

			if (fileset.getRepoLocation() == null) {
				DirectoryScanner scanner = fileset.getDirectoryScanner(getProject());
				String[][] elements = new String[][] {scanner.getIncludedDirectories(), scanner.getIncludedFiles()};
				for (int i = 0; i < 2; i++) {
					for (int j = 0; j < elements[i].length; j++) {
						File file = new File(fileset.getDir(), elements[i][j]);
						URI uri = file.toURI();

						if (file.isFile() && file.getName().endsWith(".zip")) { //$NON-NLS-1$
							uri = URIUtil.toJarURI(uri, null);
						}
						if (fileset.isBoth()) {
									uri = new URI("jar:" + uri.toString() + "!/"); //$NON-NLS-1$ //$NON-NLS-2$
								} catch (URISyntaxException e) {
									//?
									continue;
								}
							}
							application.addSourceArtifactRepository(uri);
							application.addSourceMetadataRepository(uri);
						} else if (fileset.isArtifact())
							application.addSourceArtifactRepository(uri);
						else if (fileset.isMetadata())
							application.addSourceMetadataRepository(uri);
						else
							throw new BuildException(NLS.bind(Messages.unknown_repository_type, uri));
					}
				} else {
					application.addSourceArtifactRepository(fileset.location);
					application.addSourceMetadataRepository(fileset.location);
				}
			} else {
					//TODO depreciate
					application.addSourceArtifactRepository(fileset.getRepoLocation());
					application.addSourceMetadataRepository(fileset.getRepoLocation());
			}
		}
	}

			repository.query(iuQuery, collector, null);

			if (iu.isRequired() && collector.isEmpty())
				throw new BuildException(NLS.bind(Messages.AbstractRepositoryTask_missing_IU, iu.toString()));
			result.addAll(collector.toCollection());
		}
		return result;
	}

	protected void log(IStatus status) {
		try {
			new AntMirrorLog(this).log(status);
		} catch (NoSuchMethodException e) {
			// Shouldn't occur
		}
	}
}




import org.eclipse.core.runtime.URIUtil;
import org.eclipse.equinox.internal.p2.jarprocessor.ant.JarProcessorTask;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.p2.internal.repository.tools.*;
import org.eclipse.osgi.util.NLS;

public class ProcessRepoTask extends Task {


	public void execute() throws BuildException {
		File file = URIUtil.toFile(repository);
		if (file == null || !file.exists()) {
			throw new BuildException(NLS.bind(Messages.ProcessRepo_must_be_local, repository.toString()));
		}
		if (pack | repack | signing != null) {
			if (jarProcessor == null)

		try {
			this.repository = URIUtil.fromString(repository);
		} catch (URISyntaxException e) {
			throw new IllegalArgumentException(NLS.bind(Messages.ProcessRepo_location_not_url, repository));
		}
	}





import org.apache.tools.ant.BuildException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.p2.internal.repository.tools.Messages;
import org.eclipse.equinox.p2.internal.repository.tools.Repo2Runnable;

/**

			application.initializeRepos(null);
			List ius = prepareIUs();
			if ((ius == null || ius.size() == 0) && (sourceRepos == null || sourceRepos.isEmpty()))
				throw new BuildException(Messages.no_valid_IUs);
			application.setSourceIUs(ius);
			IStatus result = application.run(null);
			if (result.matches(IStatus.ERROR))
				throw new ProvisionException(result);
		} catch (ProvisionException e) {
			throw new BuildException(Messages.Repo2RunnableTask_error_transforming_repository, e);
		}
	}
}




import java.util.*;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
import org.eclipse.equinox.p2.internal.repository.tools.Messages;
import org.eclipse.equinox.p2.internal.repository.tools.SlicingOptions;
import org.eclipse.osgi.util.NLS;

public class SlicingOption extends Task {


		}
		StringTokenizer tok = new StringTokenizer(platformFilter, ","); //$NON-NLS-1$
		if (tok.countTokens() != 3)
			throw new BuildException(NLS.bind(Messages.SlicingOption_invalid_platform, platformFilter));
		Dictionary filter = new Properties();
		filter.put("osgi.os", tok.nextToken().trim()); //$NON-NLS-1$
		filter.put("osgi.ws", tok.nextToken().trim()); //$NON-NLS-1$

Lines 10-41 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/MirrorTask.java (-4 / +78 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.equinox.p2.internal.repository.tools.tasks;	11	package org.eclipse.equinox.p2.internal.repository.tools.tasks;
12		12
		13	import java.io.File;
		14	import java.net.URISyntaxException;
13	import java.util.List;	15	import java.util.List;
14	import org.apache.tools.ant.BuildException;	16	import org.apache.tools.ant.BuildException;
15	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
		18	import org.eclipse.core.runtime.URIUtil;
		19	import org.eclipse.equinox.internal.p2.artifact.repository.ant.AntMirrorLog;
16	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;	20	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
17	import org.eclipse.equinox.p2.internal.repository.tools.MirrorApplication;	21	import org.eclipse.equinox.p2.internal.repository.tools.MirrorApplication;
18		22
19	public class MirrorTask extends AbstractRepositoryTask {	23	public class MirrorTask extends AbstractRepositoryTask {
20		24
		25	private File mirrorLog; // file to log mirror output to (optional)
		26
21	public MirrorTask() {	27	public MirrorTask() {
22	application = new MirrorApplication();	28	application = new MirrorApplication();
23	}	29	}
24		30
25	public void execute() throws BuildException {	31	public void execute() throws BuildException {
26	try {	32	try {
		33	if (mirrorLog != null)
		34	((MirrorApplication) application).setLog(mirrorLog);
		35	else
		36	((MirrorApplication) application).setLog(new AntMirrorLog(this));
27	prepareSourceRepos();	37	prepareSourceRepos();
28	application.initializeRepos(null);	38	application.initializeRepos(null);
29	List ius = prepareIUs();	39	List ius = prepareIUs();
30	if (ius == null \|\| ius.size() == 0)
31	throw new BuildException("Need to specify one or more IUs to mirror.");
32	application.setSourceIUs(ius);	40	application.setSourceIUs(ius);
33	IStatus result = application.run(null);	41	IStatus result = application.run(null);
34	if (result.matches(IStatus.ERROR)) {	42	if (result.matches(IStatus.ERROR))
35	throw new BuildException(TaskHelper.statusToString(result, null).toString());	43	throw new BuildException(TaskHelper.statusToString(result, null).toString());
36	}
37	} catch (ProvisionException e) {	44	} catch (ProvisionException e) {
38	throw new BuildException(e);	45	throw new BuildException(e);
		46	} catch (NoSuchMethodException e) {
		47	// Should not occur
		48	throw new BuildException(e);
39	}	49	}
40	}	50	}
41		51
Lines 44-47 Link Here
44	((MirrorApplication) application).setSlicingOptions(options.getOptions());	54	((MirrorApplication) application).setSlicingOptions(options.getOptions());
45	return options;	55	return options;
46	}	56	}
		57
		58	/*
		59	* Set the location of the baseline repository. (used in comparison)
		60	*/
		61	public void setBaseline(String value) {
		62	try {
		63	((MirrorApplication) application).setBaseline(URIUtil.fromString(value));
		64	} catch (URISyntaxException e) {
		65	throw new BuildException(e);
		66	}
		67	}
		68
		69	/*
		70	* Set the identifier of the comparator to use.
		71	*/
		72	public void setComparatorID(String value) {
		73	((MirrorApplication) application).setComparatorID(value);
		74	}
		75
		76	/*
		77	* Set whether or not the application should be calling a comparator when mirroring.
		78	*/
		79	public void setCompare(boolean value) {
		80	((MirrorApplication) application).setCompare(value);
		81	}
		82
		83	/*
		84	* Set the location of the comparator log
		85	*/
		86	public void setComparatorLog(String value) {
		87	((MirrorApplication) application).setComparatorLog(new File(value));
		88	}
		89
		90	/*
		91	* Set the location of the mirror log
		92	*/
		93	public void setLog(String value) {
		94	mirrorLog = new File(value);
		95	}
		96
		97	/*
		98	* Set whether or not we should ignore errors when running the mirror application.
		99	*/
		100	public void setIgnoreErrors(boolean value) {
		101	((MirrorApplication) application).setIgnoreErrors(value);
		102	}
		103
		104	/*
		105	* Set whether or not the the artifacts are raw.
		106	*/
		107	public void setRaw(boolean value) {
		108	((MirrorApplication) application).setRaw(value);
		109	}
		110
		111	/*
		112	* Set whether or not the mirror application should be run in verbose mode.
		113	*/
		114	public void setVerbose(boolean value) {
		115	((MirrorApplication) application).setVerbose(value);
		116	}
		117
		118	public void setValidate(boolean value) {
		119	((MirrorApplication) application).setValidate(value);
		120	}
47	}	121	}

Lines 36-43 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/DestinationRepository.java (-2 / +6 lines)
36	}	36	}
37	}	37	}
38		38
39	public void setFormat(String format) {	39	public void setFormat(String formatLocation) {
40	descriptor.setFormat(format);	40	try {
		41	descriptor.setFormat(URIUtil.fromString(formatLocation));
		42	} catch (URISyntaxException e) {
		43	throw new BuildException(e);
		44	}
41	}	45	}
42		46
43	public void setAppend(boolean appendMode) {	47	public void setAppend(boolean appendMode) {




# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################
AbstractApplication_no_valid_destinations=Unable to locate a valid destination repository.
AbstractRepositoryTask_missing_IU=Unable to find IU: 

CompositeRepository_default_metadataRepo_name=Composite Metadata Repository
CompositeRepository_default_artifactRepo_name=Composite Artifact Repository
CompositeRepository_create_colocated_composite_repos=Creating co-located composite repositories.
CompositeRepository_composite_repository_exists=Composite repository already exists at location: {0}
CompositeRepository_creating_composite_repositories=Creating Composite Repositories
CompositeRepository_default_artifactRepo_name=Composite Artifact Repository
CompositeRepository_default_metadataRepo_name=Composite Artifact Repository

no_valid_IUs=Need to specify either a non-empty source metadata repository or a valid list of IUs.
no_artifactRepo_manager=Unable to acquire artifact repository manager service.
no_metadataRepo_manager=Unable to acquire metadata repository manager service.
no_package_admin=Unable to acquire package admin service.
no_profile_registry=Unable to acquire profile registry service.
unable_to_process_uri=Unable to process as URI: {0}
unable_to_start_exemplarysetup=Unable to start exemplarysetup bundle.
unknown_repository_type=Repository is of an unknown type: {0}

exception_destinationNotModifiable = The destination repository must be modifiable: {0}.
exception_notLocalFileRepo= {0} is not a local file based repository.
exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.

MirrorApplication_no_IUs=No IUs specified and no IUs obtained from metadata repositories.
MirrorApplication_set_source_repositories=Need to set the source repository location(s).
ProcessRepo_location_not_url=Repository location {0} must be a URL.
ProcessRepo_must_be_local=Repository must be local: {0}

Repo2Runnable_no_destination_repository=Need to set the destination artifact repository location.
Repo2Runnable_no_engine=Unable to acquire engine service.
Repo2RunnableTask_error_transforming_repository=Error occurred while transforming repository.

SlicingOption_invalid_platform=Invalid platform filter format: {0}.





public class Messages extends NLS {
	private static final String BUNDLE_NAME = "org.eclipse.equinox.p2.internal.repository.tools.messages"; //$NON-NLS-1$

	public static String AbstractApplication_no_valid_destinations;

	public static String AbstractRepositoryTask_missing_IU;

	public static String CompositeRepository_composite_repository_exists;
	public static String CompositeRepository_create_colocated_composite_repos;
	public static String CompositeRepository_creating_composite_repositories;
	public static String CompositeRepository_default_artifactRepo_name;
	public static String CompositeRepository_default_metadataRepo_name;

	public static String no_valid_IUs;
	public static String no_artifactRepo_manager;
	public static String no_metadataRepo_manager;
	public static String no_package_admin;
	public static String no_profile_registry;
	public static String unable_to_process_uri;
	public static String unable_to_start_exemplarysetup;
	public static String unknown_repository_type;

	public static String exception_destinationNotModifiable;
	public static String exception_unableToRemoveRepo;
	public static String exception_notLocalFileRepo;
	public static String exception_unableToRemoveRepo;

	public static String MirrorApplication_no_IUs;
	public static String MirrorApplication_set_source_repositories;

	public static String ProcessRepo_location_not_url;
	public static String ProcessRepo_must_be_local;

	public static String Repo2Runnable_no_destination_repository;
	public static String Repo2Runnable_no_engine;

	public static String Repo2RunnableTask_error_transforming_repository;

	public static String SlicingOption_invalid_platform;

	static {
		// initialize resource bundles
		NLS.initializeMessages(BUNDLE_NAME, Messages.class);




import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.internal.provisional.p2.engine.IProfileRegistry;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepositoryManager;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.*;
import org.osgi.service.packageadmin.PackageAdmin;


		// TODO needed to do this to ensure the profile registry was registered
		Bundle bundle = getBundle("org.eclipse.equinox.p2.exemplarysetup"); //$NON-NLS-1$
		if (bundle == null)
			throw new ProvisionException(Messages.unable_to_start_exemplarysetup);
		bundle.start(Bundle.START_TRANSIENT);
	}


		try {
			return URIUtil.fromString(spec);
		} catch (URISyntaxException e) {
			LogHelper.log(new Status(IStatus.WARNING, ID, NLS.bind(Messages.unable_to_process_uri, spec), e));
		}
		return null;
	}

	public static IArtifactRepositoryManager getArtifactRepositoryManager() throws ProvisionException {
		IArtifactRepositoryManager manager = (IArtifactRepositoryManager) ServiceHelper.getService(getBundleContext(), IArtifactRepositoryManager.class.getName());
		if (manager == null)
			throw new ProvisionException(Messages.no_artifactRepo_manager);
		return manager;
	}


	static IProfileRegistry getProfileRegistry() throws ProvisionException {
		IProfileRegistry registry = (IProfileRegistry) ServiceHelper.getService(getBundleContext(), IProfileRegistry.class.getName());
		if (registry == null)
			throw new ProvisionException(Messages.no_profile_registry);
		return registry;
	}


	public static synchronized Bundle getBundle(String symbolicName) throws ProvisionException {
		PackageAdmin packageAdmin = (PackageAdmin) ServiceHelper.getService(getBundleContext(), PackageAdmin.class.getName());
		if (packageAdmin == null)
			throw new ProvisionException(Messages.no_package_admin);
		Bundle[] bundles = packageAdmin.getBundles(symbolicName, null);
		if (bundles == null)
			return null;

	public static IMetadataRepositoryManager getMetadataRepositoryManager() throws ProvisionException {
		IMetadataRepositoryManager manager = (IMetadataRepositoryManager) ServiceHelper.getService(getBundleContext(), IMetadataRepositoryManager.class.getName());
		if (manager == null)
			throw new ProvisionException(Messages.no_metadataRepo_manager);
		return manager;
	}
}

Lines 10-54 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/MirrorApplication.java (-15 / +194 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.equinox.p2.internal.repository.tools;	11	package org.eclipse.equinox.p2.internal.repository.tools;
12		12
		13	import java.io.File;
		14	import java.net.URI;
13	import java.util.ArrayList;	15	import java.util.ArrayList;
14	import java.util.Iterator;	16	import java.util.Iterator;
15	import org.eclipse.core.runtime.*;	17	import org.eclipse.core.runtime.*;
16	import org.eclipse.equinox.app.IApplication;	18	import org.eclipse.equinox.app.IApplication;
17	import org.eclipse.equinox.app.IApplicationContext;	19	import org.eclipse.equinox.app.IApplicationContext;
18	import org.eclipse.equinox.internal.p2.artifact.mirror.Mirroring;	20	import org.eclipse.equinox.internal.p2.artifact.mirror.*;
		21	import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
19	import org.eclipse.equinox.internal.p2.director.PermissiveSlicer;	22	import org.eclipse.equinox.internal.p2.director.PermissiveSlicer;
		23	import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepository;
		24	import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepositoryManager;
20	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;	25	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
21	import org.eclipse.equinox.internal.provisional.p2.metadata.IArtifactKey;	26	import org.eclipse.equinox.internal.provisional.p2.metadata.IArtifactKey;
22	import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;	27	import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
23	import org.eclipse.equinox.internal.provisional.p2.metadata.query.InstallableUnitQuery;	28	import org.eclipse.equinox.internal.provisional.p2.metadata.query.InstallableUnitQuery;
		29	import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;
24	import org.eclipse.equinox.internal.provisional.p2.query.Collector;	30	import org.eclipse.equinox.internal.provisional.p2.query.Collector;
25	import org.eclipse.equinox.internal.provisional.p2.query.IQueryable;	31	import org.eclipse.equinox.internal.provisional.p2.query.IQueryable;
		32	import org.eclipse.equinox.internal.provisional.p2.repository.IRepositoryManager;
26		33
27	public class MirrorApplication extends AbstractApplication {	34	public class MirrorApplication extends AbstractApplication {
		35	private static final String LOG_ROOT = "p2.mirror"; //$NON-NLS-1$
		36
28	protected SlicingOptions slicingOptions = new SlicingOptions();	37	protected SlicingOptions slicingOptions = new SlicingOptions();
29		38
		39	private URI baseline;
		40	private String comparatorID;
		41	private boolean compare = false;
		42	private boolean failOnError = true;
		43	private boolean raw = true;
		44	private boolean verbose = false;
		45	private boolean validate = false;
		46
		47	private File mirrorLogFile; // file to log mirror output to (optional)
		48	private File comparatorLogFile; // file to comparator output to (optional)
		49	private IArtifactMirrorLog mirrorLog;
		50	private IArtifactMirrorLog comparatorLog;
		51
30	public Object start(IApplicationContext context) throws Exception {	52	public Object start(IApplicationContext context) throws Exception {
31	run(null);	53	run(null);
32	return IApplication.EXIT_OK;	54	return IApplication.EXIT_OK;
33	}	55	}
34		56
35	public IStatus run(IProgressMonitor monitor) throws ProvisionException {	57	public IStatus run(IProgressMonitor monitor) throws ProvisionException {
		58	IStatus mirrorStatus = Status.OK_STATUS;
36	try {	59	try {
37	validate();	60	validate();
38	initializeRepos(new NullProgressMonitor());	61	initializeRepos(new NullProgressMonitor());
		62	initializeIUs();
39	IQueryable slice = slice(new NullProgressMonitor());	63	IQueryable slice = slice(new NullProgressMonitor());
40	IStatus mirrorStatus = mirrorArtifacts(slice, new NullProgressMonitor());	64	if (destinationArtifactRepository != null) {
41	if (mirrorStatus.getSeverity() == IStatus.ERROR) {	65	initializeLogs();
42	return mirrorStatus;	66	mirrorStatus = mirrorArtifacts(slice, new NullProgressMonitor());
		67	if (mirrorStatus.getSeverity() == IStatus.ERROR)
		68	return mirrorStatus;
43	}	69	}
44	mirrorMetadata(slice, new NullProgressMonitor());	70	if (destinationMetadataRepository != null)
		71	mirrorMetadata(slice, new NullProgressMonitor());
45	} finally {	72	} finally {
46	finalizeRepositories();	73	finalizeRepositories();
		74	finalizeLogs();
47	}	75	}
48	return Status.OK_STATUS;	76	if (mirrorStatus.isOK())
		77	return Status.OK_STATUS;
		78	return mirrorStatus;
49	}	79	}
50		80
51	private IStatus mirrorArtifacts(IQueryable slice, IProgressMonitor monitor) {	81	private IStatus mirrorArtifacts(IQueryable slice, IProgressMonitor monitor) throws ProvisionException {
52	Collector ius = slice.query(InstallableUnitQuery.ANY, new Collector(), monitor);	82	Collector ius = slice.query(InstallableUnitQuery.ANY, new Collector(), monitor);
53	ArrayList keys = new ArrayList(ius.size());	83	ArrayList keys = new ArrayList(ius.size());
54	for (Iterator iterator = ius.iterator(); iterator.hasNext();) {	84	for (Iterator iterator = ius.iterator(); iterator.hasNext();) {
Lines 58-66 Link Here
58	keys.add(iuKeys[i]);	88	keys.add(iuKeys[i]);
59	}	89	}
60	}	90	}
61	Mirroring mirror = new Mirroring(getCompositeArtifactRepository(), destinationArtifactRepository, true);	91	Mirroring mirror = new Mirroring(getCompositeArtifactRepository(), destinationArtifactRepository, raw);
62	mirror.setArtifactKeys((IArtifactKey[]) keys.toArray(new IArtifactKey[keys.size()]));	92
63	return mirror.run(true, false);	93	mirror.setCompare(compare);
		94	mirror.setComparatorId(comparatorID);
		95	mirror.setBaseline(initializeBaseline());
		96	mirror.setValidate(validate);
		97
		98	// If IUs have been specified then only they should be mirrored, otherwise mirror everything.
		99	if (keys.size() > 0)
		100	mirror.setArtifactKeys((IArtifactKey[]) keys.toArray(new IArtifactKey[keys.size()]));
		101
		102	if (comparatorLog != null)
		103	mirror.setComparatorLog(comparatorLog);
		104
		105	IStatus result = mirror.run(failOnError, verbose);
		106
		107	if (mirrorLog != null)
		108	mirrorLog.log(result);
		109	else
		110	LogHelper.log(result);
		111	return result;
		112	}
		113
		114	private IArtifactRepository initializeBaseline() throws ProvisionException {
		115	if (baseline == null)
		116	return null;
		117	IArtifactRepositoryManager mgr = Activator.getArtifactRepositoryManager();
		118
		119	if (!mgr.contains(baseline))
		120	artifactReposToRemove.add(baseline);
		121	return mgr.loadRepository(baseline, IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, null);
64	}	122	}
65		123
66	private void mirrorMetadata(IQueryable slice, IProgressMonitor monitor) {	124	private void mirrorMetadata(IQueryable slice, IProgressMonitor monitor) {
Lines 75-85 Link Here
75	* to add more if they wish)	133	* to add more if they wish)
76	*/	134	*/
77	private void validate() throws ProvisionException {	135	private void validate() throws ProvisionException {
78	if (sourceMetadataRepositories == null)	136	if (sourceMetadataRepositories.isEmpty() && sourceArtifactRepositories.isEmpty() && sourceRepositories.isEmpty())
79	throw new ProvisionException("Need to set the source metadata repository location.");	137	throw new ProvisionException(Messages.MirrorApplication_set_source_repositories);
80	if (sourceIUs == null)	138	}
81	throw new ProvisionException("Mirroring root needs to be specified.");	139
82	//TODO Check that the IU is in repo	140	/*
		141	* If no IUs have been specified we want to mirror them all
		142	*/
		143	private void initializeIUs() throws ProvisionException {
		144	if (sourceIUs == null \|\| sourceIUs.isEmpty()) {
		145	sourceIUs = new ArrayList();
		146	IMetadataRepository metadataRepo = getCompositeMetadataRepository();
		147	Collector collector = metadataRepo.query(InstallableUnitQuery.ANY, new Collector(), null);
		148
		149	for (Iterator iter = collector.iterator(); iter.hasNext();) {
		150	IInstallableUnit iu = (IInstallableUnit) iter.next();
		151	sourceIUs.add(iu);
		152	}
		153
		154	if (collector.size() == 0 && destinationMetadataRepository != null) {
		155	throw new ProvisionException(Messages.MirrorApplication_no_IUs);
		156	}
		157	} else {
		158	//TODO Check that the IU is in repo
		159	}
		160	}
		161
		162	/*
		163	* Initialize logs, if applicable
		164	*/
		165	private void initializeLogs() {
		166	if (compare && comparatorLogFile != null)
		167	comparatorLog = getLog(comparatorLogFile, comparatorID);
		168	if (mirrorLog == null && mirrorLogFile != null)
		169	mirrorLog = getLog(mirrorLogFile, LOG_ROOT);
		170	}
		171
		172	/*
		173	* Finalize logs, if applicable
		174	*/
		175	private void finalizeLogs() {
		176	if (comparatorLog != null)
		177	comparatorLog.close();
		178	if (mirrorLog != null)
		179	mirrorLog.close();
		180	}
		181
		182	/*
		183	* Get the log for a location
		184	*/
		185	private IArtifactMirrorLog getLog(File location, String root) {
		186	String absolutePath = location.getAbsolutePath();
		187	if (absolutePath.toLowerCase().endsWith(".xml")) //$NON-NLS-1$
		188	return new XMLMirrorLog(absolutePath, 0, root);
		189	return new FileMirrorLog(absolutePath, 0, root);
83	}	190	}
84		191
85	private IQueryable slice(IProgressMonitor monitor) {	192	private IQueryable slice(IProgressMonitor monitor) {
Lines 92-95 Link Here
92	public void setSlicingOptions(SlicingOptions options) {	199	public void setSlicingOptions(SlicingOptions options) {
93	slicingOptions = options;	200	slicingOptions = options;
94	}	201	}
		202
		203	/*
		204	* Set the location of the baseline repository. (used in comparison)
		205	*/
		206	public void setBaseline(URI baseline) {
		207	this.baseline = baseline;
		208	compare = true;
		209	}
		210
		211	/*
		212	* Set the identifier of the comparator to use.
		213	*/
		214	public void setComparatorID(String value) {
		215	comparatorID = value;
		216	compare = true;
		217	}
		218
		219	/*
		220	* Set whether or not the application should be calling a comparator when mirroring.
		221	*/
		222	public void setCompare(boolean value) {
		223	compare = value;
		224	}
		225
		226	/*
		227	* Set whether or not we should ignore errors when running the mirror application.
		228	*/
		229	public void setIgnoreErrors(boolean value) {
		230	failOnError = !value;
		231	}
		232
		233	/*
		234	* Set whether or not the the artifacts are raw.
		235	*/
		236	public void setRaw(boolean value) {
		237	raw = value;
		238	}
		239
		240	/*
		241	* Set whether or not the mirror application should be run in verbose mode.
		242	*/
		243	public void setVerbose(boolean value) {
		244	verbose = value;
		245	}
		246
		247	/*
		248	* Set the location of the log for comparator output
		249	*/
		250	public void setComparatorLog(File comparatorLog) {
		251	this.comparatorLogFile = comparatorLog;
		252	}
		253
		254	/*
		255	* Set the location of the log for mirroring.
		256	*/
		257	public void setLog(File mirrorLog) {
		258	this.mirrorLogFile = mirrorLog;
		259	}
		260
		261	/*
		262	* Set the ArtifactMirror log
		263	*/
		264	public void setLog(IArtifactMirrorLog log) {
		265	mirrorLog = log;
266	}
267
268	/*
269	* Set if the artifact mirror should be validated
270	*/
271	public void setValidate(boolean value) {
272	validate = value;
273	}
95	}	274	}




			PhaseSet phaseSet = getPhaseSet();
			Engine engine = (Engine) ServiceHelper.getService(Activator.getBundleContext(), IEngine.SERVICE_NAME);
			if (engine == null)
				throw new ProvisionException(Messages.Repo2Runnable_no_engine);
			IStatus result = engine.perform(profile, phaseSet, operands, context, progress.newChild(1));
			if (result.matches(IStatus.ERROR))
				return result;

		}
		// get all IUs from the repos
		if (sourceMetadataRepositories == null || sourceMetadataRepositories.isEmpty())
			throw new ProvisionException(Messages.no_valid_IUs);
		for (Iterator iter = sourceMetadataRepositories.iterator(); iter.hasNext();) {
			processedIUs.addAll(getAllIUs((URI) iter.next(), monitor).toCollection());
		}
		if (processedIUs.isEmpty())
			throw new ProvisionException(Messages.no_valid_IUs);
	}

	/*
	 * If there is a destination metadata repository set, then add all our transformed
	 * IUs to it. 
	 */
	private void publishMetadata(IProgressMonitor monitor) {
		// publishing the metadata is optional
		if (destinationMetadataRepository == null)
			return;

			}

			if (option.equalsIgnoreCase("-destination")) { //$NON-NLS-1$
				RepositoryDescriptor destination = new RepositoryDescriptor();
				destination.setLocation(URIUtil.fromString(arg));
				addDestination(destination);
				addDestination(artifact);
				RepositoryDescriptor metadata = new RepositoryDescriptor();
				metadata.setLocation(URIUtil.fromString(arg));
				metadata.setKind("M"); //$NON-NLS-1$
				addDestination(metadata);
			}
		}
	}

	 */
	private void validate() throws ProvisionException {
		if (sourceMetadataRepositories == null && sourceIUs == null)
			throw new ProvisionException(Messages.no_valid_IUs);
		if (destinationArtifactRepository == null)
			throw new ProvisionException(Messages.Repo2Runnable_no_destination_repository);
	}

	/* (non-Javadoc)

Lines 10-27 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/RepositoryDescriptor.java (-12 / +44 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.equinox.p2.internal.repository.tools;	11	package org.eclipse.equinox.p2.internal.repository.tools;
12		12
13	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
14
15	import java.net.URI;	13	import java.net.URI;
		14	import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;
		15	import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
		16	import org.eclipse.osgi.util.NLS;
16		17
17	public class RepositoryDescriptor {	18	public class RepositoryDescriptor {
18		19
		20	public static final int TYPE_BOTH = -1;
		21	public static final String KIND_ARTIFACT = "A"; //$NON-NLS-1$
		22	public static final String KIND_METADATA = "M"; //$NON-NLS-1$
		23
19	private boolean compressed = true;	24	private boolean compressed = true;
20	private boolean append = true;	25	private boolean append = true;
21	private String name = null;	26	private String name = null;
22	private URI location = null;	27	private URI location = null;
23	private String format = null;	28	private URI format = null;
24	private int kind;	29	private int kind = TYPE_BOTH;
25		30
26	public void setCompressed(boolean compress) {	31	public void setCompressed(boolean compress) {
27	compressed = compress;	32	compressed = compress;
Lines 32-42 Link Here
32	}	37	}
33		38
34	public void setLocation(URI repoLocation) {	39	public void setLocation(URI repoLocation) {
35	location = repoLocation;	40	location = RepositoryHelper.localRepoURIHelper(repoLocation);
36	}	41	}
37		42
38	public void setFormat(String format) {	43	public void setFormat(URI format) {
39	this.format = format;	44	this.format = RepositoryHelper.localRepoURIHelper(format);
40	}	45	}
41		46
42	public void setAppend(boolean appendMode) {	47	public void setAppend(boolean appendMode) {
Lines 59-65 Link Here
59	return location;	64	return location;
60	}	65	}
61		66
62	public String getFormat() {	67	public URI getFormat() {
63	return format;	68	return format;
64	}	69	}
65		70
Lines 67-77 Link Here
67	return kind;	72	return kind;
68	}	73	}
69		74
		75	public boolean isBoth() {
		76	return kind == TYPE_BOTH;
		77	}
		78
		79	public boolean isArtifact() {
		80	return kind == TYPE_BOTH \|\| kind == IRepository.TYPE_ARTIFACT;
		81	}
		82
		83	public boolean isMetadata() {
		84	return kind == TYPE_BOTH \|\| kind == IRepository.TYPE_METADATA;
		85	}
		86
70	public void setKind(String repoKind) {	87	public void setKind(String repoKind) {
71	if (repoKind.startsWith("m") \|\| repoKind.startsWith("M")) //$NON-NLS-1$//$NON-NLS-2$	88	kind = determineKind(repoKind);
72	kind = IRepository.TYPE_METADATA;	89	}
73		90
74	if (repoKind.startsWith("a") \|\| repoKind.startsWith("A")) //$NON-NLS-1$//$NON-NLS-2$	91	/*
75	kind = IRepository.TYPE_ARTIFACT;	92	* Determine the repository type
		93	*/
		94	public static int determineKind(String repoKind) {
		95	if (kindMatches(repoKind, KIND_METADATA))
		96	return IRepository.TYPE_METADATA;
		97	else if (kindMatches(repoKind, KIND_ARTIFACT))
		98	return IRepository.TYPE_ARTIFACT;
		99
		100	throw new IllegalArgumentException(NLS.bind(Messages.unknown_repository_type, repoKind));
		101	}
		102
		103	/*
		104	* Determine if the repository kind matches the identifier kind
		105	*/
		106	public static boolean kindMatches(String repoKind, String kindIdentifier) {
		107	return repoKind.startsWith(kindIdentifier) \|\| repoKind.startsWith(kindIdentifier.toLowerCase());
76	}	108	}
77	}	109	}




import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository;
import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository;
import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;

import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepositoryManager;
import org.eclipse.equinox.internal.provisional.p2.repository.*;
import org.eclipse.osgi.util.NLS;

public abstract class AbstractApplication {
	protected boolean removeUnknownRepositories = true;

	protected List sourceRepositories = new ArrayList();
	protected List sourceArtifactRepositories = new ArrayList();
	protected List sourceMetadataRepositories = new ArrayList();
	protected List artifactReposToRemove = new ArrayList();

	private CompositeMetadataRepository compositeMetadataRepository = null;
	private CompositeArtifactRepository compositeArtifactRepository = null;

	/*
	 * Add a source metadata repository
	 */
	public void addSourceMetadataRepository(String location) {
		URI uri = Activator.getURI(location);
		if (uri != null)

	}

	protected void finalizeRepositories() throws ProvisionException {
		if (removeUnknownRepositories) {
			IArtifactRepositoryManager artifactRepositoryManager = Activator.getArtifactRepositoryManager();
			for (Iterator iter = artifactReposToRemove.iterator(); iter.hasNext();)
				artifactRepositoryManager.removeRepository((URI) iter.next());
			IMetadataRepositoryManager metadataRepositoryManager = Activator.getMetadataRepositoryManager();
			for (Iterator iter = metadataReposToRemove.iterator(); iter.hasNext();)
				metadataRepositoryManager.removeRepository((URI) iter.next());
		}
	}

	public void initializeRepos(IProgressMonitor progress) throws ProvisionException {
		for (Iterator iter = sourceRepositories.iterator(); iter.hasNext();) {
			RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();
			if (repo.isBoth()) {
				sourceArtifactRepositories.add(repo.getRepoLocation());
				sourceMetadataRepositories.add(repo.getRepoLocation());
			} else if (repo.isArtifact())
				sourceArtifactRepositories.add(repo.getRepoLocation());
			else if (repo.isMetadata())
				sourceMetadataRepositories.add(repo.getRepoLocation());
			else
				throw new ProvisionException(NLS.bind(Messages.unknown_repository_type, repo.getRepoLocation()));
		}

		IArtifactRepositoryManager artifactRepositoryManager = Activator.getArtifactRepositoryManager();
		if (sourceArtifactRepositories != null && !sourceArtifactRepositories.isEmpty()) {
			for (Iterator iter = sourceArtifactRepositories.iterator(); iter.hasNext();) {

		}

		processDestinationRepos(artifactRepositoryManager, metadataRepositoryManager);

	}

	private void processDestinationRepos(IArtifactRepositoryManager artifactRepositoryManager, IMetadataRepositoryManager metadataRepositoryManager) throws ProvisionException {
		RepositoryDescriptor artifactRepoDescriptor = null;
		RepositoryDescriptor metadataRepoDescriptor = null;

		Iterator iter = destinationRepos.iterator();
		while (iter.hasNext() && (artifactRepoDescriptor == null || metadataRepoDescriptor == null)) {
			RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();
			if (repo.isArtifact() && artifactRepoDescriptor == null)
				artifactRepoDescriptor = repo;
			if (repo.isMetadata() && metadataRepoDescriptor == null)
				metadataRepoDescriptor = repo;
		}

		if (artifactRepoDescriptor != null)
			destinationArtifactRepository = initializeDestination(artifactRepoDescriptor, artifactRepositoryManager);
		if (metadataRepoDescriptor != null)
			destinationMetadataRepository = initializeDestination(metadataRepoDescriptor, metadataRepositoryManager);

		if (destinationMetadataRepository == null && destinationArtifactRepository == null)
			throw new ProvisionException(Messages.AbstractApplication_no_valid_destinations);
	}

	private IMetadataRepository initializeDestination(RepositoryDescriptor toInit, IMetadataRepositoryManager mgr) throws ProvisionException {

			if (!mgr.contains(toInit.getRepoLocation()))
				metadataReposToRemove.add(toInit.getRepoLocation());
			IMetadataRepository repository = mgr.loadRepository(toInit.getRepoLocation(), IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, null);
			if (initDestinationRepository(repository, toInit))
				if (toInit.getName() != null)
					repository.setName(toInit.getName());
				if (!toInit.isAppend())
					repository.removeAll();
				return repository;
			}
		} catch (ProvisionException e) {
			//fall through and create a new repository below
		}

		IMetadataRepository source = null;
		try {
			if (toInit.getFormat() != null)
				source = mgr.loadRepository(toInit.getFormat(), 0, null);
		} catch (ProvisionException e) {
			//Ignore.
		} catch (URISyntaxException e) {
			//Ignore
		}
		//This code assumes source has been successfully loaded before this point
		//No existing repository; create a new repository at destinationLocation but with source's attributes.

			if (!mgr.contains(toInit.getRepoLocation()))
				artifactReposToRemove.add(toInit.getRepoLocation());
			IArtifactRepository repository = mgr.loadRepository(toInit.getRepoLocation(), IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, null);
			if (initDestinationRepository(repository, toInit))
				if (toInit.getName() != null)
					repository.setName(toInit.getName());
				if (!toInit.isAppend())
					repository.removeAll();
				return repository;
			}
		} catch (ProvisionException e) {
			//fall through and create a new repository below
		}
		IArtifactRepository source = null;
		try {
			if (toInit.getFormat() != null)
				source = mgr.loadRepository(toInit.getFormat(), 0, null);
		} catch (ProvisionException e) {
			//Ignore.
		} catch (URISyntaxException e) {
			//Ignore
		}
		//This code assumes source has been successfully loaded before this point
		//No existing repository; create a new repository at destinationLocation but with source's attributes.

		return (IArtifactRepository) RepositoryHelper.validDestinationRepository(result);
	}

	private boolean initDestinationRepository(IRepository repository, RepositoryDescriptor descriptor) {
		if (repository != null && repository.isModifiable()) {
			if (descriptor.getName() != null)
				repository.setName(descriptor.getName());
			if (repository instanceof ICompositeRepository && !descriptor.isAppend())
				((ICompositeRepository) repository).removeAllChildren();
			else if (repository instanceof IMetadataRepository && !descriptor.isAppend())
				((IMetadataRepository) repository).removeAll();
			else if (repository instanceof IArtifactRepository && !descriptor.isAppend())
				((IArtifactRepository) repository).removeAll();
			return true;
		}
		return false;
	}

	public IMetadataRepository getCompositeMetadataRepository() {
		if (compositeMetadataRepository == null) {
			try {

	public IArtifactRepository getCompositeArtifactRepository() {
		if (compositeArtifactRepository == null) {
			try {
				compositeArtifactRepository = new CompositeArtifactRepository(new URI("memory:/composite"), "parent artifact repo", null);//$NON-NLS-1$ //$NON-NLS-2$
			} catch (URISyntaxException e) {
				//Can't happen
			}

	public void addDestination(RepositoryDescriptor descriptor) {
		destinationRepos.add(descriptor);
	}

	public void addSource(RepositoryDescriptor repo) {
		sourceRepositories.add(repo);
	}
}

Lines 12-17 Link Here

(-)META-INF/MANIFEST.MF (+1 lines)
12	org.eclipse.equinox.app;version="1.0.0",	12	org.eclipse.equinox.app;version="1.0.0",
13	org.eclipse.equinox.internal.p2.artifact.mirror,	13	org.eclipse.equinox.internal.p2.artifact.mirror,
14	org.eclipse.equinox.internal.p2.artifact.repository,	14	org.eclipse.equinox.internal.p2.artifact.repository,
		15	org.eclipse.equinox.internal.p2.artifact.repository.ant,
15	org.eclipse.equinox.internal.p2.artifact.repository.simple,	16	org.eclipse.equinox.internal.p2.artifact.repository.simple,
16	org.eclipse.equinox.internal.p2.core.helpers,	17	org.eclipse.equinox.internal.p2.core.helpers,
17	org.eclipse.equinox.internal.p2.director,	18	org.eclipse.equinox.internal.p2.director,




            library="lib/repository-tools-ant.jar"
            name="p2.mirror">
      </antTask>

     <antTask
            class="org.eclipse.equinox.p2.internal.repository.tools.tasks.ModifyRepositoryChildrenTask"
            library="lib/repository-tools-ant.jar"
            name="p2.modify.composite.repository.children">
      </antTask>

     <antTask
            class="org.eclipse.equinox.p2.internal.repository.tools.tasks.CreateCompositeRepositoryTask"
            library="lib/repository-tools-ant.jar"
            name="p2.create.composite.repository">
      </antTask>
      
      <antTask
			library="lib/repository-tools-ant.jar"




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools;

import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository;
import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;

public class ModifyCompositeRepositoryApplication extends AbstractApplication {
	private List childrenToAdd = new ArrayList();
	private List childrenToRemove = new ArrayList();

	public IStatus run(IProgressMonitor monitor) throws ProvisionException {

		try {
			initializeRepos(new NullProgressMonitor());
			// load repository
			CompositeMetadataRepository metadataRepo = (CompositeMetadataRepository) destinationMetadataRepository;
			CompositeArtifactRepository artifactRepo = (CompositeArtifactRepository) destinationArtifactRepository;

			// Remove children from the Composite Repositories
			for (Iterator iterator = childrenToRemove.iterator(); iterator.hasNext();) {
				RepositoryDescriptor child = (RepositoryDescriptor) iterator.next();
				if (child.isArtifact())
					artifactRepo.removeChild(child.getRepoLocation());
				if (child.isMetadata())
					metadataRepo.removeChild(child.getRepoLocation());
			}

			// Add children to the Composite Repositories
			for (Iterator iterator = childrenToAdd.iterator(); iterator.hasNext();) {
				RepositoryDescriptor child = (RepositoryDescriptor) iterator.next();
				if (child.isArtifact())
					artifactRepo.addChild(child.getRepoLocation());
				if (child.isMetadata())
					metadataRepo.addChild(child.getRepoLocation());
			}
			return Status.OK_STATUS;
		} finally {
			finalizeRepositories();
		}
	}

	public void setRemoveUnknownRepositories(boolean value) {
		removeUnknownRepositories = value;
	}

	public void addChild(RepositoryDescriptor child) {
		childrenToAdd.add(child);
	}

	public void removeChild(RepositoryDescriptor child) {
		childrenToRemove.add(child);
	}
}




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools.tasks;

import java.util.Iterator;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.p2.internal.repository.tools.CreateCompositeRepositoryApplication;
import org.eclipse.equinox.p2.internal.repository.tools.ModifyCompositeRepositoryApplication;

public class CreateCompositeRepositoryTask extends Task {
	CreateCompositeRepositoryApplication createApp;
	ModifyCompositeRepositoryApplication modifyApp;
	boolean add = false;

	public CreateCompositeRepositoryTask() {
		createApp = new CreateCompositeRepositoryApplication();
		modifyApp = new ModifyCompositeRepositoryApplication();
		modifyApp.setRemoveUnknownRepositories(false);
	}

	/* (non-Javadoc)
	 * @see org.apache.tools.ant.Task#execute()
	 */
	public void execute() throws BuildException {
		try {
			IStatus result = createApp.run(null);
			if (result.matches(IStatus.ERROR)) {
				throw new BuildException(TaskHelper.statusToString(result, null).toString());
			}
			if (add) {
				result = modifyApp.run(null);
				if (result.matches(IStatus.ERROR)) {
					throw new BuildException(TaskHelper.statusToString(result, null).toString());
				}
			}
		} catch (ProvisionException e) {
			throw new BuildException(e);
		}
	}

	/*
	 * Add a repository to create
	 */
	public DestinationRepository createRepository() {
		DestinationRepository repo = new DestinationRepository();
		createApp.addRepository(repo.getDescriptor());
		modifyApp.addDestination(repo.getDescriptor());
		return repo;
	}

	/*
	 * Set whether the task should fail if the repository already exists
	 */
	public void setFailOnExists(boolean value) {
		createApp.setFailOnExists(value);
	}

	/*
	 * Add a list of child repositories to add to the newly created repository
	 */
	public void addConfiguredAdd(RepositoryList addList) {
		add = true;
		for (Iterator iter = addList.getRepositoryList().iterator(); iter.hasNext();) {
			DestinationRepository repo = (DestinationRepository) iter.next();
			modifyApp.addChild(repo.getDescriptor());
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools;

import java.util.*;
import org.apache.tools.ant.BuildException;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;
import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepository;
import org.eclipse.equinox.internal.provisional.p2.artifact.repository.IArtifactRepositoryManager;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepository;
import org.eclipse.equinox.internal.provisional.p2.metadata.repository.IMetadataRepositoryManager;
import org.eclipse.equinox.internal.provisional.p2.repository.ICompositeRepository;
import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
import org.eclipse.osgi.util.NLS;

public class CreateCompositeRepositoryApplication {

	private List repositories = new ArrayList();
	private boolean failOnExists = false;
	private IArtifactRepositoryManager artifactManager;
	private IMetadataRepositoryManager metadataManager;

	public IStatus run(IProgressMonitor monitor) throws ProvisionException {
		artifactManager = Activator.getArtifactRepositoryManager();
		metadataManager = Activator.getMetadataRepositoryManager();

		MultiStatus status = new MultiStatus(Activator.ID, 0, Messages.CompositeRepository_creating_composite_repositories, null);
		status.add(Status.OK_STATUS);
		for (Iterator iterator = repositories.iterator(); iterator.hasNext();)
			status.add(createRepository((RepositoryDescriptor) iterator.next()));

		return status;
	}

	public void addRepository(RepositoryDescriptor repo) {
		repositories.add(repo);
	}

	public void setFailOnExists(boolean value) {
		failOnExists = value;
	}

	private IStatus createRepository(RepositoryDescriptor repo) throws ProvisionException {
		try {
			if (repo.isBoth()) {
				MultiStatus status = new MultiStatus(Activator.ID, 0, Messages.CompositeRepository_create_colocated_composite_repos, null);
				status.add(createArtifactRepository(repo));
				status.add(createMetadataRepository(repo));
				return status;
			} else if (repo.isArtifact())
				return createArtifactRepository(repo);
			else if (repo.isMetadata())
				return createMetadataRepository(repo);
			else
				throw new ProvisionException(Messages.unknown_repository_type + repo.getRepoLocation());
		} catch (IllegalStateException e) {
			throw new ProvisionException(e.getMessage(), e);
		}
	}

	private IStatus createArtifactRepository(RepositoryDescriptor repo) throws ProvisionException {
		// remove the repo first.
		artifactManager.removeRepository(repo.getRepoLocation());

		// first try and load to see if one already exists at that location.
		try {
			IArtifactRepository repository = artifactManager.loadRepository(repo.getRepoLocation(), null);
			if (!validRepositoryLocation(repository))
				return new Status(IStatus.INFO, Activator.ID, NLS.bind(Messages.CompositeRepository_composite_repository_exists, repo.getRepoLocation()));
		} catch (ProvisionException e) {
			// re-throw the exception if we got anything other than "repo not found"
			if (e.getStatus().getCode() != ProvisionException.REPOSITORY_NOT_FOUND)
				throw e;
		}

		IArtifactRepository source = null;
		try {
			if (repo.getFormat() != null)
				source = artifactManager.loadRepository(repo.getFormat(), 0, null);
		} catch (ProvisionException e) {
			//Ignore.
		}
		//This code assumes source has been successfully loaded before this point
		try {
			//No existing repository; create a new repository at destinationLocation but with source's attributes.
			IArtifactRepository result = null;
			result = artifactManager.createRepository(repo.getRepoLocation(), repo.getName() != null ? repo.getName() : (source != null ? source.getName() : Messages.CompositeRepository_default_artifactRepo_name), IArtifactRepositoryManager.TYPE_COMPOSITE_REPOSITORY, source != null ? source.getProperties() : null);
			initRepository(result, repo);
		} catch (IllegalStateException e) {
			artifactManager.removeRepository(repo.getRepoLocation());
			throw e;
		}
		return Status.OK_STATUS;
	}

	private IStatus createMetadataRepository(RepositoryDescriptor repo) throws ProvisionException {
		// remove the repo first.
		metadataManager.removeRepository(repo.getRepoLocation());

		// first try and load to see if one already exists at that location.
		try {
			IMetadataRepository repository = metadataManager.loadRepository(repo.getRepoLocation(), null);
			if (!validRepositoryLocation(repository))
				return new Status(IStatus.INFO, Activator.ID, NLS.bind(Messages.CompositeRepository_composite_repository_exists, repo.getRepoLocation()));
		} catch (ProvisionException e) {
			// re-throw the exception if we got anything other than "repo not found"
			if (e.getStatus().getCode() != ProvisionException.REPOSITORY_NOT_FOUND)
				throw e;
		}

		IMetadataRepository source = null;
		try {
			if (repo.getFormat() != null)
				source = metadataManager.loadRepository(repo.getFormat(), 0, null);
		} catch (ProvisionException e) {
			//Ignore
		}
		//This code assumes source has been successfully loaded before this point
		try {
			//No existing repository; create a new repository at destinationLocation but with source's attributes.
			IMetadataRepository result = metadataManager.createRepository(repo.getRepoLocation(), repo.getName() != null ? repo.getName() : (source != null ? source.getName() : Messages.CompositeRepository_default_metadataRepo_name), IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, source != null ? source.getProperties() : null);
			initRepository(result, repo);
		} catch (IllegalStateException e) {
			metadataManager.removeRepository(repo.getRepoLocation());
			throw e;
		}

		return Status.OK_STATUS;
	}

	/*
	 * Determine if the repository is valid for this operation
	 */
	private boolean validRepositoryLocation(IRepository repository) {
		if (repository instanceof ICompositeRepository) {
			// if we have an already existing repository at that location, then throw an error
			// if the user told us to
			if (failOnExists)
				throw new BuildException(NLS.bind(Messages.CompositeRepository_composite_repository_exists, repository.getLocation()));
			RepositoryHelper.validDestinationRepository(repository);
			return false;
		}
		// we have a non-composite repo at this location. that is ok because we can co-exist.
		return true;
	}

	/*
	 * Initialize a new repository
	 */
	private void initRepository(IRepository repository, RepositoryDescriptor desc) {
		RepositoryHelper.validDestinationRepository(repository);
		if (desc.isCompressed() && !repository.getProperties().containsKey(IRepository.PROP_COMPRESSED))
			repository.setProperty(IRepository.PROP_COMPRESSED, String.valueOf(true));
	}

}




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools.tasks;

import org.apache.tools.ant.types.FileSet;
import org.eclipse.equinox.internal.provisional.p2.repository.IRepository;
import org.eclipse.equinox.p2.internal.repository.tools.RepositoryDescriptor;

public class RepositoryFileSet extends FileSet {
	public final static int TYPE_ARTIFACT = IRepository.TYPE_ARTIFACT;
	public final static int TYPE_METADATA = IRepository.TYPE_METADATA;

	private int kind = RepositoryDescriptor.TYPE_BOTH;
	protected String myLocation = null;

	public void setKind(String repoKind) {
		kind = RepositoryDescriptor.determineKind(repoKind);
	}

	public int getKind() {
		return kind;
	}

	public boolean isBoth() {
		return kind == RepositoryDescriptor.TYPE_BOTH;
	}

	public boolean isArtifact() {
		return kind == RepositoryDescriptor.TYPE_BOTH || kind == IRepository.TYPE_ARTIFACT;
	}

	public boolean isMetadata() {
		return kind == RepositoryDescriptor.TYPE_BOTH || kind == IRepository.TYPE_METADATA;
	}

	public void setLocation(String value) {
		// TODO depreciate 
		myLocation = value;
	}

	public String getRepoLocation() {
		// TODO depreciate 
		return myLocation;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools.tasks;

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

public class RepositoryList extends RepositoryFileSet {
	// TODO this class should extend DataType, currently RepoFileSet to support <source location="xxx" /> 
	List repositories = new ArrayList();
	List sourceFileSets = new ArrayList();

	public DestinationRepository createRepository() {
		DestinationRepository repo = new DestinationRepository();
		repositories.add(repo);
		return repo;
	}

	public RepositoryFileSet createFileSet() {
		RepositoryFileSet fileSet = new RepositoryFileSet();
		sourceFileSets.add(fileSet);
		return fileSet;
	}

	public List getRepositoryList() {
		return repositories;
	}

	public List getFileSetList() {
		//TODO this should eventually be removed
		if (myLocation != null)
			sourceFileSets.add(this);
		return sourceFileSets;
	}
}




/*******************************************************************************
 * Copyright (c) 2009 IBM 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools.tasks;

import java.util.Iterator;
import org.apache.tools.ant.BuildException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
import org.eclipse.equinox.p2.internal.repository.tools.ModifyCompositeRepositoryApplication;

public class ModifyRepositoryChildrenTask extends AbstractRepositoryTask {

	public ModifyRepositoryChildrenTask() {
		application = new ModifyCompositeRepositoryApplication();
	}

	/* (non-Javadoc)
	 * @see org.apache.tools.ant.Task#execute()
	 */
	public void execute() throws BuildException {
		try {
			IStatus result = application.run(null);
			if (result.matches(IStatus.ERROR)) {
				throw new BuildException(TaskHelper.statusToString(result, null).toString());
			}
		} catch (ProvisionException e) {
			throw new BuildException(e);
		}
	}

	/*
	 * Add the listed repositories to the composite repository
	 */
	public void addConfiguredAdd(RepositoryList list) {
		for (Iterator iter = list.getRepositoryList().iterator(); iter.hasNext();) {
			DestinationRepository repo = (DestinationRepository) iter.next();
			((ModifyCompositeRepositoryApplication) application).addChild(repo.getDescriptor());
		}
	}

	/*	
	 * Remove the listed repositories from the composite repository
	 */
	public void addConfiguredRemove(RepositoryList list) {
		for (Iterator iter = list.getRepositoryList().iterator(); iter.hasNext();) {
			DestinationRepository repo = (DestinationRepository) iter.next();
			((ModifyCompositeRepositoryApplication) application).removeChild(repo.getDescriptor());
		}
	}
}

Return to bug 265550

Lines 13-19 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/SlicingOption.java (-1 / +3 lines)
13	import java.util.*;	13	import java.util.*;
14	import org.apache.tools.ant.BuildException;	14	import org.apache.tools.ant.BuildException;
15	import org.apache.tools.ant.Task;	15	import org.apache.tools.ant.Task;
		16	import org.eclipse.equinox.p2.internal.repository.tools.Messages;
16	import org.eclipse.equinox.p2.internal.repository.tools.SlicingOptions;	17	import org.eclipse.equinox.p2.internal.repository.tools.SlicingOptions;
		18	import org.eclipse.osgi.util.NLS;
17		19
18	public class SlicingOption extends Task {	20	public class SlicingOption extends Task {
19		21
Lines 50-56 Link Here
50	}	52	}
51	StringTokenizer tok = new StringTokenizer(platformFilter, ","); //$NON-NLS-1$	53	StringTokenizer tok = new StringTokenizer(platformFilter, ","); //$NON-NLS-1$
52	if (tok.countTokens() != 3)	54	if (tok.countTokens() != 3)
53	throw new BuildException("Invalid platform filter format: " + platformFilter + ".");	55	throw new BuildException(NLS.bind(Messages.SlicingOption_invalid_platform, platformFilter));
54	Dictionary filter = new Properties();	56	Dictionary filter = new Properties();
55	filter.put("osgi.os", tok.nextToken().trim()); //$NON-NLS-1$	57	filter.put("osgi.os", tok.nextToken().trim()); //$NON-NLS-1$
56	filter.put("osgi.ws", tok.nextToken().trim()); //$NON-NLS-1$	58	filter.put("osgi.ws", tok.nextToken().trim()); //$NON-NLS-1$

Lines 8-14 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/messages.properties (-2 / +32 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	###############################################################################	10	###############################################################################
11	exception_destinationNotModifiable = The destination repository must be modifiable: {0}.	11	AbstractApplication_no_valid_destinations=Unable to locate a valid destination repository.
		12	AbstractRepositoryTask_missing_IU=Unable to find IU:
		13
		14	CompositeRepository_default_metadataRepo_name=Composite Metadata Repository
		15	CompositeRepository_default_artifactRepo_name=Composite Artifact Repository
		16	CompositeRepository_create_colocated_composite_repos=Creating co-located composite repositories.
		17	CompositeRepository_composite_repository_exists=Composite repository already exists at location: {0}
		18	CompositeRepository_creating_composite_repositories=Creating Composite Repositories
		19	CompositeRepository_default_artifactRepo_name=Composite Artifact Repository
		20	CompositeRepository_default_metadataRepo_name=Composite Artifact Repository
12		21
		22	no_valid_IUs=Need to specify either a non-empty source metadata repository or a valid list of IUs.
		23	no_artifactRepo_manager=Unable to acquire artifact repository manager service.
		24	no_metadataRepo_manager=Unable to acquire metadata repository manager service.
		25	no_package_admin=Unable to acquire package admin service.
		26	no_profile_registry=Unable to acquire profile registry service.
		27	unable_to_process_uri=Unable to process as URI: {0}
		28	unable_to_start_exemplarysetup=Unable to start exemplarysetup bundle.
		29	unknown_repository_type=Repository is of an unknown type: {0}
		30
		31	exception_destinationNotModifiable = The destination repository must be modifiable: {0}.
		32	exception_notLocalFileRepo= {0} is not a local file based repository.
13	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.	33	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.
14	exception_notLocalFileRepo= {0} is not a local file based repository.	34
		35	MirrorApplication_no_IUs=No IUs specified and no IUs obtained from metadata repositories.
		36	MirrorApplication_set_source_repositories=Need to set the source repository location(s).
		37	ProcessRepo_location_not_url=Repository location {0} must be a URL.
		38	ProcessRepo_must_be_local=Repository must be local: {0}
		39
		40	Repo2Runnable_no_destination_repository=Need to set the destination artifact repository location.
		41	Repo2Runnable_no_engine=Unable to acquire engine service.
		42	Repo2RunnableTask_error_transforming_repository=Error occurred while transforming repository.
		43
		44	SlicingOption_invalid_platform=Invalid platform filter format: {0}.

Lines 14-22 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/Messages.java (-1 / +35 lines)
14		14
15	public class Messages extends NLS {	15	public class Messages extends NLS {
16	private static final String BUNDLE_NAME = "org.eclipse.equinox.p2.internal.repository.tools.messages"; //$NON-NLS-1$	16	private static final String BUNDLE_NAME = "org.eclipse.equinox.p2.internal.repository.tools.messages"; //$NON-NLS-1$
		17
		18	public static String AbstractApplication_no_valid_destinations;
		19
		20	public static String AbstractRepositoryTask_missing_IU;
		21
		22	public static String CompositeRepository_composite_repository_exists;
		23	public static String CompositeRepository_create_colocated_composite_repos;
		24	public static String CompositeRepository_creating_composite_repositories;
		25	public static String CompositeRepository_default_artifactRepo_name;
		26	public static String CompositeRepository_default_metadataRepo_name;
		27
		28	public static String no_valid_IUs;
		29	public static String no_artifactRepo_manager;
		30	public static String no_metadataRepo_manager;
		31	public static String no_package_admin;
		32	public static String no_profile_registry;
		33	public static String unable_to_process_uri;
		34	public static String unable_to_start_exemplarysetup;
		35	public static String unknown_repository_type;
		36
17	public static String exception_destinationNotModifiable;	37	public static String exception_destinationNotModifiable;
18	public static String exception_unableToRemoveRepo;
19	public static String exception_notLocalFileRepo;	38	public static String exception_notLocalFileRepo;
		39	public static String exception_unableToRemoveRepo;
		40
		41	public static String MirrorApplication_no_IUs;
		42	public static String MirrorApplication_set_source_repositories;
		43
		44	public static String ProcessRepo_location_not_url;
		45	public static String ProcessRepo_must_be_local;
		46
		47	public static String Repo2Runnable_no_destination_repository;
		48	public static String Repo2Runnable_no_engine;
		49
		50	public static String Repo2RunnableTask_error_transforming_repository;
		51
		52	public static String SlicingOption_invalid_platform;
		53
20	static {	54	static {
21	// initialize resource bundles	55	// initialize resource bundles
22	NLS.initializeMessages(BUNDLE_NAME, Messages.class);	56	NLS.initializeMessages(BUNDLE_NAME, Messages.class);

Lines 65-71 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/Repo2Runnable.java (-14 / +9 lines)
65	PhaseSet phaseSet = getPhaseSet();	65	PhaseSet phaseSet = getPhaseSet();
66	Engine engine = (Engine) ServiceHelper.getService(Activator.getBundleContext(), IEngine.SERVICE_NAME);	66	Engine engine = (Engine) ServiceHelper.getService(Activator.getBundleContext(), IEngine.SERVICE_NAME);
67	if (engine == null)	67	if (engine == null)
68	throw new ProvisionException("Unable to acquire engine service.");	68	throw new ProvisionException(Messages.Repo2Runnable_no_engine);
69	IStatus result = engine.perform(profile, phaseSet, operands, context, progress.newChild(1));	69	IStatus result = engine.perform(profile, phaseSet, operands, context, progress.newChild(1));
70	if (result.matches(IStatus.ERROR))	70	if (result.matches(IStatus.ERROR))
71	return result;	71	return result;
Lines 97-115 Link Here
97	}	97	}
98	// get all IUs from the repos	98	// get all IUs from the repos
99	if (sourceMetadataRepositories == null \|\| sourceMetadataRepositories.isEmpty())	99	if (sourceMetadataRepositories == null \|\| sourceMetadataRepositories.isEmpty())
100	throw new ProvisionException("Need to specify either a non-empty source metadata repository or a valid list of IUs.");	100	throw new ProvisionException(Messages.no_valid_IUs);
101	for (Iterator iter = sourceMetadataRepositories.iterator(); iter.hasNext();) {	101	for (Iterator iter = sourceMetadataRepositories.iterator(); iter.hasNext();) {
102	processedIUs.addAll(getAllIUs((URI) iter.next(), monitor).toCollection());	102	processedIUs.addAll(getAllIUs((URI) iter.next(), monitor).toCollection());
103	}	103	}
104	if (processedIUs.isEmpty())	104	if (processedIUs.isEmpty())
105	throw new ProvisionException("Need to specify either a non-empty source metadata repository or a valid list of IUs.");	105	throw new ProvisionException(Messages.no_valid_IUs);
106	}	106	}
107		107
108	/*	108	/*
109	* If there is a destination metadata repository set, then add all our transformed	109	* If there is a destination metadata repository set, then add all our transformed
110	* IUs to it.	110	* IUs to it.
111	*/	111	*/
112	private void publishMetadata(IProgressMonitor monitor) throws ProvisionException {	112	private void publishMetadata(IProgressMonitor monitor) {
113	// publishing the metadata is optional	113	// publishing the metadata is optional
114	if (destinationMetadataRepository == null)	114	if (destinationMetadataRepository == null)
115	return;	115	return;
Lines 178-191 Link Here
178	}	178	}
179		179
180	if (option.equalsIgnoreCase("-destination")) { //$NON-NLS-1$	180	if (option.equalsIgnoreCase("-destination")) { //$NON-NLS-1$
181	RepositoryDescriptor artifact = new RepositoryDescriptor();	181	RepositoryDescriptor destination = new RepositoryDescriptor();
182	artifact.setLocation(URIUtil.fromString(arg));	182	destination.setLocation(URIUtil.fromString(arg));
183	artifact.setKind("A"); //$NON-NLS-1$	183	addDestination(destination);
184	addDestination(artifact);
185	RepositoryDescriptor metadata = new RepositoryDescriptor();
186	metadata.setLocation(URIUtil.fromString(arg));
187	metadata.setKind("M"); //$NON-NLS-1$
188	addDestination(metadata);
189	}	184	}
190	}	185	}
191	}	186	}
Lines 198-206 Link Here
198	*/	193	*/
199	private void validate() throws ProvisionException {	194	private void validate() throws ProvisionException {
200	if (sourceMetadataRepositories == null && sourceIUs == null)	195	if (sourceMetadataRepositories == null && sourceIUs == null)
201	throw new ProvisionException("Need to set the source metadata repository location or set a list of IUs to process.");	196	throw new ProvisionException(Messages.no_valid_IUs);
202	if (destinationArtifactRepository == null)	197	if (destinationArtifactRepository == null)
203	throw new ProvisionException("Need to set the destination artifact repository location.");	198	throw new ProvisionException(Messages.Repo2Runnable_no_destination_repository);
204	}	199	}
205		200
206	/* (non-Javadoc)	201	/* (non-Javadoc)

Lines 15-20 Link Here

(-)plugin.xml (+12 lines)
15	library="lib/repository-tools-ant.jar"	15	library="lib/repository-tools-ant.jar"
16	name="p2.mirror">	16	name="p2.mirror">
17	</antTask>	17	</antTask>
		18
		19	<antTask
		20	class="org.eclipse.equinox.p2.internal.repository.tools.tasks.ModifyRepositoryChildrenTask"
		21	library="lib/repository-tools-ant.jar"
		22	name="p2.modify.composite.repository.children">
		23	</antTask>
		24
		25	<antTask
		26	class="org.eclipse.equinox.p2.internal.repository.tools.tasks.CreateCompositeRepositoryTask"
		27	library="lib/repository-tools-ant.jar"
		28	name="p2.create.composite.repository">
		29	</antTask>
18		30
19	<antTask	31	<antTask
20	library="lib/repository-tools-ant.jar"	32	library="lib/repository-tools-ant.jar"

Added Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/ModifyCompositeRepositoryApplication.java (+65 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM 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	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.equinox.p2.internal.repository.tools;
12
13	import java.util.*;
14	import org.eclipse.core.runtime.*;
15	import org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository;
16	import org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository;
17	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
18
19	public class ModifyCompositeRepositoryApplication extends AbstractApplication {
20	private List childrenToAdd = new ArrayList();
21	private List childrenToRemove = new ArrayList();
22
23	public IStatus run(IProgressMonitor monitor) throws ProvisionException {
24
25	try {
26	initializeRepos(new NullProgressMonitor());
27	// load repository
28	CompositeMetadataRepository metadataRepo = (CompositeMetadataRepository) destinationMetadataRepository;
29	CompositeArtifactRepository artifactRepo = (CompositeArtifactRepository) destinationArtifactRepository;
30
31	// Remove children from the Composite Repositories
32	for (Iterator iterator = childrenToRemove.iterator(); iterator.hasNext();) {
33	RepositoryDescriptor child = (RepositoryDescriptor) iterator.next();
34	if (child.isArtifact())
35	artifactRepo.removeChild(child.getRepoLocation());
36	if (child.isMetadata())
37	metadataRepo.removeChild(child.getRepoLocation());
38	}
39
40	// Add children to the Composite Repositories
41	for (Iterator iterator = childrenToAdd.iterator(); iterator.hasNext();) {
42	RepositoryDescriptor child = (RepositoryDescriptor) iterator.next();
43	if (child.isArtifact())
44	artifactRepo.addChild(child.getRepoLocation());
45	if (child.isMetadata())
46	metadataRepo.addChild(child.getRepoLocation());
47	}
48	return Status.OK_STATUS;
49	} finally {
50	finalizeRepositories();
51	}
52	}
53
54	public void setRemoveUnknownRepositories(boolean value) {
55	removeUnknownRepositories = value;
56	}
57
58	public void addChild(RepositoryDescriptor child) {
59	childrenToAdd.add(child);
60	}
61
62	public void removeChild(RepositoryDescriptor child) {
63	childrenToRemove.add(child);
64	}
65	}