Attachment #132929 for bug #265550

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

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




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




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




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.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.*;
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) {
		RepositoryDescriptor source = new RepositoryDescriptor();
		source.setLocation(repoLocation);
		source.setKind(RepositoryDescriptor.KIND_METADATA);
		application.addSource(source);
	}

	protected void addArtifactSourceRepository(URI repoLocation) {
		RepositoryDescriptor source = new RepositoryDescriptor();
		source.setLocation(repoLocation);
		source.setKind(RepositoryDescriptor.KIND_ARTIFACT);
		application.addSource(source);
	}

	/*

	 * argument to specify both the artifact and metadata repositories.
	 */
	public void setSource(String location) {
		RepositoryDescriptor source = new RepositoryDescriptor();
		try {
			source.setLocation(URIUtil.fromString(location));
			application.addSource(source);
		} catch (URISyntaxException e) {
			throw new BuildException(e);
		}
	}

	/*

	 * 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)) {
					addArtifactSourceRepository(fileset.getRepoLocationURI());
					addMetadataSourceRepository(fileset.getRepoLocationURI());
				}
			} 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);
								}
							}
							application.addSourceArtifactRepository(uri);
							application.addSourceMetadataRepository(uri);
						}
						if (fileset.isBoth()) {
							addArtifactSourceRepository(uri);
							addMetadataSourceRepository(uri);
						} else if (fileset.isArtifact())
							addArtifactSourceRepository(uri);
						else if (fileset.isMetadata())
							addMetadataSourceRepository(uri);
						else
							throw new BuildException(NLS.bind(Messages.unknown_repository_type, uri));
					}
				}
			}
		}
		sourceRepos.clear();
	}

	protected List prepareIUs() {

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




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

import java.net.*;
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 removeAddedRepositories = true;

	protected List sourceRepositories = new ArrayList(); //List of repository descriptors
	protected List sourceMetadataRepositories = new ArrayList();
	protected List artifactReposToRemove = new ArrayList();
	protected List metadataReposToRemove = new ArrayList();
	protected List sourceIUs = new ArrayList();

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

	public void addSourceMetadataRepository(String location) {
		URI uri = Activator.getURI(location);
		if (uri != null)
			sourceMetadataRepositories.add(RepositoryHelper.localRepoURIHelper(uri));
	}

	public void addSourceMetadataRepository(URI location) {
		if (location != null)
			sourceMetadataRepositories.add(RepositoryHelper.localRepoURIHelper(location));
	}

	public List getSourceMetadataRepositories() {
		return sourceMetadataRepositories;
	}

	public void addSourceArtifactRepository(String location) {
		URI uri = Activator.getURI(location);
		if (uri != null)
			sourceArtifactRepositories.add(RepositoryHelper.localRepoURIHelper(uri));
	}

	public void addSourceArtifactRepository(URI location) {
		if (location != null)
			sourceArtifactRepositories.add(RepositoryHelper.localRepoURIHelper(location));
	}

	public void setSourceIUs(List ius) {
		sourceIUs = ius;
	}

	protected void finalizeRepositories() throws ProvisionException {
		if (removeAddedRepositories) {
			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 {
		IArtifactRepositoryManager artifactRepositoryManager = Activator.getArtifactRepositoryManager();
		if (sourceArtifactRepositories != null && !sourceArtifactRepositories.isEmpty()) {
			for (Iterator iter = sourceArtifactRepositories.iterator(); iter.hasNext();) {
				URI repoLocation = (URI) iter.next();
				if (!artifactRepositoryManager.contains(repoLocation))
					artifactReposToRemove.add(repoLocation);
				artifactRepositoryManager.loadRepository(repoLocation, 0, progress);
			}
		}

		IMetadataRepositoryManager metadataRepositoryManager = Activator.getMetadataRepositoryManager();
		URI curLocation = null;
		try {
			for (Iterator iter = sourceRepositories.iterator(); iter.hasNext();) {
				RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();
				curLocation = repo.getRepoLocation();
				if (repo.isBoth()) {
					addRepository(artifactRepositoryManager, curLocation, 0, progress);
					addRepository(metadataRepositoryManager, curLocation, 0, progress);
				} else if (repo.isArtifact())
					addRepository(artifactRepositoryManager, curLocation, 0, progress);
				else if (repo.isMetadata())
					addRepository(metadataRepositoryManager, curLocation, 0, progress);
				else
					throw new ProvisionException(NLS.bind(Messages.unknown_repository_type, repo.getRepoLocation()));
			}
		} catch (ProvisionException e) {
			if (e.getCause() instanceof MalformedURLException) {
				throw new ProvisionException(NLS.bind(Messages.exception_invalidSource, curLocation), e);
			}
			throw e;
		}

		processDestinationRepos(artifactRepositoryManager, metadataRepositoryManager);
	}

	//Helper to add a repository. It takes care of adding the repos to the deletion list and loading it 
	protected IMetadataRepository addRepository(IMetadataRepositoryManager manager, URI location, int flags, IProgressMonitor monitor) throws ProvisionException {
		if (!manager.contains(location))
			metadataReposToRemove.add(location);
		return manager.loadRepository(location, flags, monitor);
	}

	//Helper to add a repository. It takes care of adding the repos to the deletion list and loading it
	protected IArtifactRepository addRepository(IArtifactRepositoryManager manager, URI location, int flags, IProgressMonitor monitor) throws ProvisionException {
		if (!manager.contains(location))
			artifactReposToRemove.add(location);
		return manager.loadRepository(location, flags, monitor);
	}

	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 {
			IMetadataRepository repository = addRepository(mgr, toInit.getRepoLocation(), IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, null);
			if (initDestinationRepository(repository, toInit))
				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.
		try {
			IMetadataRepository result = mgr.createRepository(toInit.getRepoLocation(), toInit.getName() != null ? toInit.getName() : (source != null ? source.getName() : toInit.getRepoLocation().toString()), IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, source != null ? source.getProperties() : null);
			if (toInit.isCompressed() && !result.getProperties().containsKey(IRepository.PROP_COMPRESSED))
				result.setProperty(IRepository.PROP_COMPRESSED, "true"); //$NON-NLS-1$
			return (IMetadataRepository) RepositoryHelper.validDestinationRepository(result);
		} catch (UnsupportedOperationException e) {
			throw new ProvisionException(NLS.bind(Messages.exception_invalidDestination, toInit.getRepoLocation()), e.getCause());
		}
	}

	protected IArtifactRepository initializeDestination(RepositoryDescriptor toInit, IArtifactRepositoryManager mgr) throws ProvisionException {
		try {
			IArtifactRepository repository = addRepository(mgr, toInit.getRepoLocation(), IRepositoryManager.REPOSITORY_HINT_MODIFIABLE, null);
			if (initDestinationRepository(repository, toInit))
				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.
		// TODO for now create a Simple repo by default.
		try {
			IArtifactRepository result = mgr.createRepository(toInit.getRepoLocation(), toInit.getName() != null ? toInit.getName() : (source != null ? source.getName() : toInit.getRepoLocation().toString()), IArtifactRepositoryManager.TYPE_SIMPLE_REPOSITORY, source != null ? source.getProperties() : null);
			if (toInit.isCompressed() && !result.getProperties().containsKey(IRepository.PROP_COMPRESSED))
				result.setProperty(IRepository.PROP_COMPRESSED, "true"); //$NON-NLS-1$
			return (IArtifactRepository) RepositoryHelper.validDestinationRepository(result);
		} catch (UnsupportedOperationException e) {
			throw new ProvisionException(NLS.bind(Messages.exception_invalidDestination, toInit.getRepoLocation()), e.getCause());
		}
	}

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

			} catch (URISyntaxException e) {
				//Can't happen
			}
			for (Iterator iter = sourceRepositories.iterator(); iter.hasNext();) {
				RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();
				if (repo.isMetadata())
					compositeMetadataRepository.addChild(repo.getRepoLocation());
			}
		}
		return compositeMetadataRepository;

	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
			}
			for (Iterator iter = sourceRepositories.iterator(); iter.hasNext();) {
				RepositoryDescriptor repo = (RepositoryDescriptor) iter.next();
				if (repo.isArtifact())
					compositeArtifactRepository.addChild(repo.getRepoLocation());
			}
		}
		return compositeArtifactRepository;
	}

	protected boolean hasArtifactSources() {
		return !((ICompositeRepository) getCompositeArtifactRepository()).getChildren().isEmpty();
	}

	protected boolean hasMetadataSources() {
		return !((ICompositeRepository) getCompositeMetadataRepository()).getChildren().isEmpty();
	}

	public abstract IStatus run(IProgressMonitor monitor) throws ProvisionException;

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




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

import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import org.eclipse.core.runtime.*;

import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.InstallableUnitQuery;
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.query.Collector;

/**

			return;
		}
		// get all IUs from the repos
		if (!hasMetadataSources())
			throw new ProvisionException(Messages.exception_needIUsOrNonEmptyRepo);

		processedIUs.addAll(getAllIUs(getCompositeMetadataRepository(), monitor).toCollection());

		if (processedIUs.isEmpty())
			throw new ProvisionException(Messages.exception_needIUsOrNonEmptyRepo);
	}

	/*
	 * Return a collector over all the IUs contained in the given repository.
	 */
	private Collector getAllIUs(IMetadataRepository repository, IProgressMonitor monitor) {
		SubMonitor progress = SubMonitor.convert(monitor, 2);
		try {
			return repository.query(InstallableUnitQuery.ANY, new Collector(), progress.newChild(1));
		} finally {
			progress.done();
		}
		repository.query(InstallableUnitQuery.ANY, result, progress.newChild(1)).iterator();
		return result;
	}

	/*

			String arg = args[++i];

			if (option.equalsIgnoreCase("-source")) { //$NON-NLS-1$
				RepositoryDescriptor source = new RepositoryDescriptor();
				source.setLocation(URIUtil.fromString(arg));
				addSource(source);
			}

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

	 * to add more if they wish)
	 */
	private void validate() throws ProvisionException {
		if (!hasMetadataSources() && sourceIUs == null)
			throw new ProvisionException(Messages.exception_needIUsOrNonEmptyRepo);
		if (destinationArtifactRepository == null)
			throw new ProvisionException(Messages.exception_needDestinationRepo);

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;
	public static String exception_invalidDestination;
	public static String exception_invalidSource;

	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_invalidDestination=Invalid destination repository location: {0}.
exception_invalidSource=Invalid source repository location: {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.

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.net.MalformedURLException;
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 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) {
				if (e.getCause() instanceof MalformedURLException)
					throw new ProvisionException(NLS.bind(Messages.exception_invalidDestination, toInit.getRepoLocation()), e.getCause());
				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) {
				if (e.getCause() instanceof MalformedURLException)
					throw new ProvisionException(NLS.bind(Messages.exception_invalidDestination, toInit.getRepoLocation()), e.getCause());
				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 java.net.URI;
import java.net.URISyntaxException;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.FileSet;
import org.eclipse.core.runtime.URIUtil;
import org.eclipse.equinox.internal.p2.repository.helpers.RepositoryHelper;
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;
	}

	public URI getRepoLocationURI() {
		// TODO depreciate 
		try {
			return RepositoryHelper.localRepoURIHelper(URIUtil.fromString(getRepoLocation()));
		} catch (URISyntaxException e) {
			throw new BuildException(e);
		}
	}
}




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

Lines 20-25 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/Messages.java (+35 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;
		56	public static String exception_invalidDestination;
		57	public static String exception_invalidSource;
23		58
24	static {	59	static {
25	// initialize resource bundles	60	// initialize resource bundles

Lines 8-17 Link Here

(-)src/org/eclipse/equinox/p2/internal/repository/tools/messages.properties (-2 / +30 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_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}
12		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}.
		37	exception_destinationNotModifiable = The destination repository must be modifiable: {0}.
		38	exception_invalidDestination=Invalid destination repository location: {0}.
		39	exception_invalidSource=Invalid source repository location: {0}.
13	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.	40	exception_unableToRemoveRepo=Unable to remove artifact repository file: {0}.
14	exception_notLocalFileRepo= {0} is not a local file based repository.	41	exception_notLocalFileRepo= {0} is not a local file based repository.
15	exception_noEngineService=Unable to acquire engine service.	42	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.	43	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.	44	exception_needDestinationRepo=Need to set the destination artifact repository location.
		45	exception_onlyOneComparator=Only one comparator should be defined.

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	}