Attachment #132421 for bug #265550

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

Lines 15-20 Link Here

(-)plugin.xml (+6 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.CompositeRepositoryTask"
		21	library="lib/repository-tools-ant.jar"
		22	name="p2.composite.repository">
		23	</antTask>
18		24
19	<antTask	25	<antTask
20	library="lib/repository-tools-ant.jar"	26	library="lib/repository-tools-ant.jar"




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);
	}

	protected IMetadataRepository initializeDestination(RepositoryDescriptor toInit, IMetadataRepositoryManager mgr) throws ProvisionException {
		try {
			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.

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

	protected IArtifactRepository initializeDestination(RepositoryDescriptor toInit, IArtifactRepositoryManager mgr) throws ProvisionException {
		try {
			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);
	}

	protected 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);
	}
}




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	}




			}

			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);
			}
		}
	}

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	}




	public static String exception_noEngineService;
	public static String exception_needIUsOrNonEmptyRepo;
	public static String exception_needDestinationRepo;
	public static String exception_onlyOneComparator;

	public static String AbstractApplication_no_valid_destinations;

	public static String AbstractRepositoryTask_unableToFind;

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




# Contributors:
#     IBM Corporation - initial API and implementation
###############################################################################
AbstractApplication_no_valid_destinations=Unable to locate a valid destination repository.
AbstractRepositoryTask_unableToFind=Unable to find: {0} 

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}

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}

SlicingOption_invalid_platform=Invalid platform filter format: {0}.
exception_destinationNotModifiable = The destination repository must be modifiable: {0}.

exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.
exception_notLocalFileRepo= {0} is not a local file based repository.
exception_noEngineService=Unable to acquire engine service.
exception_needIUsOrNonEmptyRepo=Need to specify either a non-empty source metadata repository or a valid list of IUs.
exception_needDestinationRepo=Need to set the destination artifact repository location.
exception_onlyOneComparator=Only one comparator should be defined.




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 = options.getFilter();
		if (filter == null)
			filter = new Properties();




 *******************************************************************************/
package org.eclipse.equinox.p2.internal.repository.tools.tasks;

import java.io.File;
import java.util.List;
import org.apache.tools.ant.BuildException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.equinox.internal.p2.artifact.repository.ant.AntMirrorLog;
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.MirrorApplication;

public class MirrorTask extends AbstractRepositoryTask {

	private File mirrorLog; // file to log mirror output to (optional)
	private ComparatorDescription comparator;

	public MirrorTask() {
		application = new MirrorApplication();
	}

	public void execute() throws BuildException {
		try {
			if (mirrorLog != null)
				((MirrorApplication) application).setLog(mirrorLog);
			else
				((MirrorApplication) application).setLog(new AntMirrorLog(this));

			if (comparator != null) {
				// Enable comparison
				((MirrorApplication) application).setCompare(true);
				// Set baseline location
				if (comparator.getBaseline() != null)
					((MirrorApplication) application).setBaseline(comparator.getBaseline().getDescriptor().getRepoLocation());
				// Set comparator to use
				if (comparator.getComparator() != null)
					((MirrorApplication) application).setComparatorID(comparator.getComparator());
				// Set comparator log
				if (comparator.getComparatorLog() != null)
					((MirrorApplication) application).setComparatorLog(comparator.getComparatorLog());
			}

			prepareSourceRepos();
			application.initializeRepos(null);
			List ius = prepareIUs();
			if (ius == null || ius.size() == 0)
				throw new BuildException("Need to specify one or more IUs to mirror.");
			application.setSourceIUs(ius);
			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);
		} catch (NoSuchMethodException e) {
			// Should not occur
			throw new BuildException(e);
		}
	}


		((MirrorApplication) application).setSlicingOptions(options.getOptions());
		return options;
	}

	/*
	 * Set the comparison information
	 */
	public ComparatorDescription createComparator() {
		if (comparator != null)
			throw new BuildException(Messages.exception_onlyOneComparator);
		comparator = new ComparatorDescription();
		return comparator;
	}

	/*
	 * Set the location of the mirror log
	 */
	public void setLog(String value) {
		mirrorLog = new File(value);
	}

	/*
	 * Set whether or not we should ignore errors when running the mirror application.
	 */
	public void setIgnoreErrors(boolean value) {
		((MirrorApplication) application).setIgnoreErrors(value);
	}

	/*
	 * Set whether or not the the artifacts are raw.
	 */
	public void setRaw(boolean value) {
		((MirrorApplication) application).setRaw(value);
	}

	/*
	 * Set whether or not the mirror application should be run in verbose mode.
	 */
	public void setVerbose(boolean value) {
		((MirrorApplication) application).setVerbose(value);
	}

	public void setValidate(boolean value) {
		((MirrorApplication) application).setValidate(value);
	}
}

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) {




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 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 static final String ANT_PREFIX = "${"; //$NON-NLS-1$

	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);
		application.addDestination(dest.getDescriptor());

		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) {
				//TODO depreciate
				if (!fileset.getRepoLocation().startsWith(ANT_PREFIX)) {
					application.addSourceArtifactRepository(fileset.getRepoLocation());
					application.addSourceMetadataRepository(fileset.getRepoLocation());
				}
			} else if (fileset.getDir() != 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()) {
							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));
					}
				}
			}

			repository.query(iuQuery, collector, null);

			if (iu.isRequired() && collector.isEmpty())
				throw new BuildException(NLS.bind(Messages.AbstractRepositoryTask_unableToFind, 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
		}
	}
}

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,




/*******************************************************************************
 * 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
		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;

import java.util.*;
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 CompositeRepositoryApplication extends AbstractApplication {
	private List childrenToAdd = new ArrayList();
	private List childrenToRemove = new ArrayList();
	private boolean failOnExists = false;

	public IStatus run(IProgressMonitor monitor) throws ProvisionException {
		try {
			initializeRepos(new NullProgressMonitor());
			// load repository
			ICompositeRepository metadataRepo = (ICompositeRepository) destinationMetadataRepository;
			ICompositeRepository artifactRepo = (ICompositeRepository) destinationArtifactRepository;

			// Remove children from the Composite Repositories
			for (Iterator iterator = childrenToRemove.iterator(); iterator.hasNext();) {
				RepositoryDescriptor child = (RepositoryDescriptor) iterator.next();
				if (child.isArtifact() && artifactRepo != null)
					artifactRepo.removeChild(child.getRepoLocation());
				if (child.isMetadata() && metadataRepo != null)
					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 != null)
					artifactRepo.addChild(child.getRepoLocation());
				if (child.isMetadata() && metadataRepo != null)
					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);
	}

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

	protected IArtifactRepository initializeDestination(RepositoryDescriptor toInit, IArtifactRepositoryManager mgr) throws ProvisionException {
		// remove the repo first.
		mgr.removeRepository(toInit.getRepoLocation());

		// first try and load to see if one already exists at that location.
		try {
			IArtifactRepository repository = mgr.loadRepository(toInit.getRepoLocation(), null);
			if (validRepositoryLocation(repository) && initDestinationRepository(repository, toInit))
				return repository;
			throw new ProvisionException(new Status(IStatus.INFO, Activator.ID, NLS.bind(Messages.CompositeRepository_composite_repository_exists, toInit.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 (toInit.getFormat() != null)
				source = mgr.loadRepository(toInit.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 repo = mgr.createRepository(toInit.getRepoLocation(), toInit.getName() != null ? toInit.getName() : (source != null ? source.getName() : Messages.CompositeRepository_default_artifactRepo_name), IArtifactRepositoryManager.TYPE_COMPOSITE_REPOSITORY, source != null ? source.getProperties() : null);
			initRepository(repo, toInit);
			return repo;
		} catch (IllegalStateException e) {
			mgr.removeRepository(toInit.getRepoLocation());
			throw e;
		}
	}

	protected IMetadataRepository initializeDestination(RepositoryDescriptor toInit, IMetadataRepositoryManager mgr) throws ProvisionException {
		// remove the repo first.
		mgr.removeRepository(toInit.getRepoLocation());

		// first try and load to see if one already exists at that location.
		try {
			IMetadataRepository repository = mgr.loadRepository(toInit.getRepoLocation(), null);
			if (!validRepositoryLocation(repository) && initDestinationRepository(repository, toInit))
				throw new ProvisionException(new Status(IStatus.INFO, Activator.ID, NLS.bind(Messages.CompositeRepository_composite_repository_exists, toInit.getRepoLocation())));
			return repository;
		} 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 (toInit.getFormat() != null)
				source = mgr.loadRepository(toInit.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 repo = mgr.createRepository(toInit.getRepoLocation(), toInit.getName() != null ? toInit.getName() : (source != null ? source.getName() : Messages.CompositeRepository_default_metadataRepo_name), IMetadataRepositoryManager.TYPE_COMPOSITE_REPOSITORY, source != null ? source.getProperties() : null);
			initRepository(repo, toInit);
			return repo;
		} catch (IllegalStateException e) {
			mgr.removeRepository(toInit.getRepoLocation());
			throw e;
		}
	}

	/*
	 * Determine if the repository is valid for this operation
	 */
	private boolean validRepositoryLocation(IRepository repository) throws ProvisionException {
		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 ProvisionException(NLS.bind(Messages.CompositeRepository_composite_repository_exists, repository.getLocation()));
			RepositoryHelper.validDestinationRepository(repository);
			return true;
		}
		// 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.io.File;
import org.apache.tools.ant.types.DataType;

public class ComparatorDescription extends DataType {

	DestinationRepository baseline;
	String comparatorId;
	File comparatorLog;

	/*
	 * Set the baseline repository to compare to
	 */
	public void addRepository(DestinationRepository value) {
		this.baseline = value;
	}

	/*
	 * Set the comparator to use
	 */
	public void setComparator(String value) {
		comparatorId = value;
	}

	/*
	 * Set the log location for the comparator
	 */
	public void setComparatorLog(File value) {
		comparatorLog = value;
	}

	public DestinationRepository getBaseline() {
		return baseline;
	}

	public String getComparator() {
		return comparatorId;
	}

	public File getComparatorLog() {
		return comparatorLog;
	}
}




/*******************************************************************************
 * 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.CompositeRepositoryApplication;

public class CompositeRepositoryTask extends AbstractRepositoryTask {

	public CompositeRepositoryTask() {
		application = new CompositeRepositoryApplication();
	}

	/* (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();
			((CompositeRepositoryApplication) 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();
			((CompositeRepositoryApplication) application).removeChild(repo.getDescriptor());
		}
	}

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

Return to bug 265550

Lines 247-260 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/Repo2Runnable.java (-8 / +3 lines)
247	}	247	}
248		248
249	if (option.equalsIgnoreCase("-destination")) { //$NON-NLS-1$	249	if (option.equalsIgnoreCase("-destination")) { //$NON-NLS-1$
250	RepositoryDescriptor artifact = new RepositoryDescriptor();	250	RepositoryDescriptor destination = new RepositoryDescriptor();
251	artifact.setLocation(URIUtil.fromString(arg));	251	destination.setLocation(URIUtil.fromString(arg));
252	artifact.setKind("A"); //$NON-NLS-1$	252	addDestination(destination);
253	addDestination(artifact);
254	RepositoryDescriptor metadata = new RepositoryDescriptor();
255	metadata.setLocation(URIUtil.fromString(arg));
256	metadata.setKind("M"); //$NON-NLS-1$
257	addDestination(metadata);
258	}	253	}
259	}	254	}
260	}	255	}

Lines 20-25 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/Messages.java (+33 lines)
20	public static String exception_noEngineService;	20	public static String exception_noEngineService;
21	public static String exception_needIUsOrNonEmptyRepo;	21	public static String exception_needIUsOrNonEmptyRepo;
22	public static String exception_needDestinationRepo;	22	public static String exception_needDestinationRepo;
		23	public static String exception_onlyOneComparator;
		24
		25	public static String AbstractApplication_no_valid_destinations;
		26
		27	public static String AbstractRepositoryTask_unableToFind;
		28
		29	public static String CompositeRepository_composite_repository_exists;
		30	public static String CompositeRepository_create_colocated_composite_repos;
		31	public static String CompositeRepository_creating_composite_repositories;
		32	public static String CompositeRepository_default_artifactRepo_name;
		33	public static String CompositeRepository_default_metadataRepo_name;
		34
		35	public static String no_valid_IUs;
		36	public static String no_artifactRepo_manager;
		37	public static String no_metadataRepo_manager;
		38	public static String no_package_admin;
		39	public static String no_profile_registry;
		40	public static String unable_to_process_uri;
		41	public static String unable_to_start_exemplarysetup;
		42	public static String unknown_repository_type;
		43
		44	public static String MirrorApplication_no_IUs;
		45	public static String MirrorApplication_set_source_repositories;
		46
		47	public static String ProcessRepo_location_not_url;
		48	public static String ProcessRepo_must_be_local;
		49
		50	public static String Repo2Runnable_no_destination_repository;
		51	public static String Repo2Runnable_no_engine;
		52
		53	public static String Repo2RunnableTask_error_transforming_repository;
		54
		55	public static String SlicingOption_invalid_platform;
23		56
24	static {	57	static {
25	// initialize resource bundles	58	// initialize resource bundles

Lines 8-17 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/messages.properties (-1 / +28 lines)
8	# Contributors:	8	# Contributors:
9	# IBM Corporation - initial API and implementation	9	# IBM Corporation - initial API and implementation
10	###############################################################################	10	###############################################################################
		11	AbstractApplication_no_valid_destinations=Unable to locate a valid destination repository.
		12	AbstractRepositoryTask_unableToFind=Unable to find: {0}
		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
		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	MirrorApplication_no_IUs=No IUs specified and no IUs obtained from metadata repositories.
		32	MirrorApplication_set_source_repositories=Need to set the source repository location(s).
		33	ProcessRepo_location_not_url=Repository location {0} must be a URL.
		34	ProcessRepo_must_be_local=Repository must be local: {0}
		35
		36	SlicingOption_invalid_platform=Invalid platform filter format: {0}.
11	exception_destinationNotModifiable = The destination repository must be modifiable: {0}.	37	exception_destinationNotModifiable = The destination repository must be modifiable: {0}.
12		38
13	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.	39	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.
14	exception_notLocalFileRepo= {0} is not a local file based repository.	40	exception_notLocalFileRepo= {0} is not a local file based repository.
15	exception_noEngineService=Unable to acquire engine service.	41	exception_noEngineService=Unable to acquire engine service.
16	exception_needIUsOrNonEmptyRepo=Need to specify either a non-empty source metadata repository or a valid list of IUs.	42	exception_needIUsOrNonEmptyRepo=Need to specify either a non-empty source metadata repository or a valid list of IUs.
17	exception_needDestinationRepo=Need to set the destination artifact repository location.	43	exception_needDestinationRepo=Need to set the destination artifact repository location.
		44	exception_onlyOneComparator=Only one comparator should be defined.

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 51-57 Link Here
51	}	53	}
52	StringTokenizer tok = new StringTokenizer(platformFilter, ","); //$NON-NLS-1$	54	StringTokenizer tok = new StringTokenizer(platformFilter, ","); //$NON-NLS-1$
53	if (tok.countTokens() != 3)	55	if (tok.countTokens() != 3)
54	throw new BuildException("Invalid platform filter format: " + platformFilter + ".");	56	throw new BuildException(NLS.bind(Messages.SlicingOption_invalid_platform, platformFilter));
55	Dictionary filter = options.getFilter();	57	Dictionary filter = options.getFilter();
56	if (filter == null)	58	if (filter == null)
57	filter = new Properties();	59	filter = new Properties();

Lines 21-28 Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/ProcessRepoTask.java (-4 / +4 lines)
21	import org.eclipse.core.runtime.URIUtil;	21	import org.eclipse.core.runtime.URIUtil;
22	import org.eclipse.equinox.internal.p2.jarprocessor.ant.JarProcessorTask;	22	import org.eclipse.equinox.internal.p2.jarprocessor.ant.JarProcessorTask;
23	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;	23	import org.eclipse.equinox.internal.provisional.p2.core.ProvisionException;
24	import org.eclipse.equinox.p2.internal.repository.tools.RecreateRepositoryApplication;	24	import org.eclipse.equinox.p2.internal.repository.tools.*;
25	import org.eclipse.equinox.p2.internal.repository.tools.RepositoryDescriptor;	25	import org.eclipse.osgi.util.NLS;
26		26
27	public class ProcessRepoTask extends Task {	27	public class ProcessRepoTask extends Task {
28		28
Lines 64-70 Link Here
64	public void execute() throws BuildException {	64	public void execute() throws BuildException {
65	File file = URIUtil.toFile(repository);	65	File file = URIUtil.toFile(repository);
66	if (file == null \|\| !file.exists()) {	66	if (file == null \|\| !file.exists()) {
67	throw new BuildException("Repository must be local: " + repository.toString()); //$NON-NLS-1$	67	throw new BuildException(NLS.bind(Messages.ProcessRepo_must_be_local, repository.toString()));
68	}	68	}
69	if (pack \| repack \| signing != null) {	69	if (pack \| repack \| signing != null) {
70	if (jarProcessor == null)	70	if (jarProcessor == null)
Lines 113-119 Link Here
113	try {	113	try {
114	this.repository = URIUtil.fromString(repository);	114	this.repository = URIUtil.fromString(repository);
115	} catch (URISyntaxException e) {	115	} catch (URISyntaxException e) {
116	throw new IllegalArgumentException("Repository location (" + repository + ") must be a URL."); //$NON-NLS-1$ //$NON-NLS-2$	116	throw new IllegalArgumentException(NLS.bind(Messages.ProcessRepo_location_not_url, repository));
117	}	117	}
118	}	118	}
119		119

Added Link Here

(-)src_ant/org/eclipse/equinox/p2/internal/repository/tools/tasks/RepositoryList.java (+42 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.tasks;
12
13	import java.util.ArrayList;
14	import java.util.List;
15
16	public class RepositoryList extends RepositoryFileSet {
17	// TODO this class should extend DataType, currently RepoFileSet to support <source location="xxx" />
18	List repositories = new ArrayList();
19	List sourceFileSets = new ArrayList();
20
21	public DestinationRepository createRepository() {
22	DestinationRepository repo = new DestinationRepository();
23	repositories.add(repo);
24	return repo;
25	}
26
27	public RepositoryFileSet createFileSet() {
28	RepositoryFileSet fileSet = new RepositoryFileSet();
29	sourceFileSets.add(fileSet);
30	return fileSet;
31	}
32
33	public List getRepositoryList() {
34	return repositories;
35	}
36
37	public List getFileSetList() {
38	//TODO this should eventually be removed
39	sourceFileSets.add(this);
40	return sourceFileSets;
41	}
42	}