import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Queries a repository for a specific {@link IInstallableUnit} (IU).
 *
 * @param repositoryURI the repository URI
 * @param installableUnitID the ID of the IU
 * @return the {@link IQueryResult}
 */
private IQueryResult<IInstallableUnit> queryRepositoryForInstallableUnit(URI repositoryURI, String installableUnitID) {

	// --- Load the repository ------------
	IQueryResult<IInstallableUnit> queryResult = null;
	try {
		IMetadataRepository metadataRepository = this.getMetadataRepositoryManager().loadRepository(repositoryURI, this.getProgressMonitor());
		// --- Query for the IU of interest -----
		if (metadataRepository != null) {
			queryResult = metadataRepository.query(QueryUtil.createIUQuery(installableUnitID), this.getProgressMonitor());
		}
		
	} catch (ProvisionException | OperationCanceledException e) {
		System.err.println("Error loading the repository at " + repositoryURI);
		e.printStackTrace();
	}

	return queryResult;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Creates the product meta-data repository.
 * Clients should call {@link #dispose()} when the repository is no longer needed.
 * 
 * @throws CoreException on failure
 * @see #dispose()
 */
public IMetadataRepository createRepository() throws CoreException {
	try {
		// Create temporary directory for product repository
		repositoryDirectory = Files.createTempDirectory(null).toFile();
		
		// Create the P2 repository for meta-data information
		metadataRepository = getMetadataRepositoryManager().createRepository(repositoryDirectory.toURI(), getProductName(),
				IMetadataRepositoryManager.TYPE_SIMPLE_REPOSITORY, null);
		
		Installer.log("Created product repository at: " + repositoryDirectory.getAbsolutePath());
	}
	catch (Exception e) {
		Installer.fail(e);
	}
	
	return metadataRepository;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
private Iterator<IInstallableUnit> queryP2Repository(IProgressMonitor monitor, String updateURL)
		throws URISyntaxException {
	if (monitor == null) {
		monitor = new NullProgressMonitor();
	}

	SubMonitor progress = SubMonitor.convert(monitor, "", 6);
	// get all available IUs in update repository
	IMetadataRepository metadataRepo = null;
	try {
		metadataRepo = metadataRepoManager.loadRepository(new URI(updateURL), progress.newChild(1));
	} catch (ProvisionException e) {
		System.exit(1);
	}
	IQuery<IInstallableUnit> allIUQuery = QueryUtil.createIUAnyQuery();
	IQueryResult<IInstallableUnit> allIUQueryResult = metadataRepo.query(allIUQuery, progress.newChild(1));

	Iterator<IInstallableUnit> iterator = allIUQueryResult.iterator();

	if (progress.isCanceled()) {
		throw new OperationCanceledException();
	}
	return iterator;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
public void process ( final IProgressMonitor pm ) throws Exception
{
    this.output.mkdirs ();

    System.out.println ( "Loading metadata..." );
    this.metaRepo = this.metaManager.loadRepository ( this.repositoryLocation, pm );
    System.out.println ( "Loading artifacts..." );
    this.artRepo = this.artManager.loadRepository ( this.repositoryLocation, pm );
    System.out.println ( "done!" );

    for ( final URI uri : this.validationRepositoryUris )
    {
        System.out.format ( "Loading validation repository: %s%n", uri );
        final IMetadataRepository repo = this.metaManager.loadRepository ( uri, pm );
        this.validationRepositories.put ( uri, repo );
        System.out.println ( "Done!" );
    }

    final IQuery<IInstallableUnit> query = QueryUtil.createIUAnyQuery ();
    final IQueryResult<IInstallableUnit> result = this.metaRepo.query ( query, pm );

    for ( final IInstallableUnit iu : result )
    {
        processUnit ( iu, pm );
    }

    writeUploadScript ();

    for ( final Map.Entry<MavenReference, Set<String>> entry : this.metadata.entrySet () )
    {
        writeMetaData ( entry.getKey (), entry.getValue () );
    }

}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Finds the latest version of an installable unit in local repositories.
 * 
 * @param spec Version specification
 * @return Installable unit or <code>null</code>.
 * @throws CoreException on failure
 */
public IInstallableUnit findUnit(IVersionedId spec) throws CoreException {
	String id = spec.getId();
	if (id == null) {
		Installer.fail(InstallMessages.Error_NoId);
	}
	Version version = spec.getVersion();
	VersionRange range = VersionRange.emptyRange;
	if (version != null && !version.equals(Version.emptyVersion))
		range = new VersionRange(version, true, version, true);
	
	URI[] locations = manager.getKnownRepositories(IRepositoryManager.REPOSITORIES_LOCAL);
	List<IMetadataRepository> queryables = new ArrayList<IMetadataRepository>(locations.length);
	for (URI location : locations) {
		queryables.add(getManager().loadRepository(location, new NullProgressMonitor()));
	}

	IQuery<IInstallableUnit> query = QueryUtil.createIUQuery(id, range);
	IQueryable<IInstallableUnit> compoundQueryable = QueryUtil.compoundQueryable(queryables);
	IQueryResult<IInstallableUnit> queryResult = compoundQueryable.query(query, new NullProgressMonitor());
	
	Iterator<IInstallableUnit> matches = queryResult.iterator();
	// pick the newest match
	IInstallableUnit newest = null;
	while (matches.hasNext()) {
		IInstallableUnit candidate = matches.next();
		if (newest == null || (newest.getVersion().compareTo(candidate.getVersion()) < 0))
			newest = candidate;
	}

	return newest;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * @return Returns the meta-data repository locations.
 */
public URI[] getMetadataRepositoryLocations() {
	ArrayList<URI> locations = new ArrayList<URI>();
	for (IMetadataRepository repository : getMetadataRepositories()) {
		locations.add(repository.getLocation());
	}
	
	return locations.toArray(new URI[locations.size()]);
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Generates a list of all the Installable Units from a repository
 * @param repo the metadata repository that is the source of the installable units
 * @return array list of all installable units in a repository
 */
public static ArrayList<IInstallableUnit> generateIUList(IMetadataRepository repo){
	ArrayList<IInstallableUnit> iuList = new ArrayList<IInstallableUnit>();
	IQueryResult<IInstallableUnit> results = repo.query(QueryUtil.createIUAnyQuery(), new NullProgressMonitor());
	for (IInstallableUnit iu : results.toUnmodifiableSet()) {
		if(!iu.getId().contains("feature"))
			iuList.add(iu);
	}
	return iuList;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Establishes all the repositories and repository managers needed for the install job
 * 
 * @param agent the current ProvisioningAgent
 * @param repositoryLocation the valid p2 repository location 
 * @return metadata repository object from a valid p2 repository
 * @throws ProvisionException
 */
@SuppressWarnings("restriction")
public static IMetadataRepository loadRepository(IProvisioningAgent agent, URI repositoryLocation) throws ProvisionException{
	final ProvisioningUI ui = ProvUIActivator.getDefault().getProvisioningUI();
	IArtifactRepositoryManager artifactManager = ProvUI.getArtifactRepositoryManager(ui.getSession());
	IMetadataRepositoryManager manager = (IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME);
	artifactManager.addRepository(repositoryLocation);
	IMetadataRepository repository = manager.loadRepository(repositoryLocation, new NullProgressMonitor());
	return repository;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * @return The meta-data repository
 */
public IMetadataRepository getRepository() {
	return repository;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * @return The product meta-data repository.
 */
protected IMetadataRepository getMetadataRepository() {
	return metadataRepository;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * @return Meta-data repositories
 */
public IMetadataRepository[] getMetadataRepositories() {
	return metadataRepositories.toArray(new IMetadataRepository[metadataRepositories.size()]);
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Finds available WSO2 features in current profile and search for updates
 * to them in WSO2 p2 repository for updates.
 * 
 * @param monitor
 * @throws Exception
 */
public void checkForAvailableUpdates(IProgressMonitor monitor) throws Exception {
	if (monitor == null) {
		monitor = new NullProgressMonitor();
	}
	SubMonitor progress = SubMonitor.convert(monitor, Messages.UpdateManager_18, 6);

	// get all available IUs in update repository
	IMetadataRepository metadataRepo = null;
	try {
		metadataRepo = metadataRepoManager.loadRepository(getDevStudioUpdateSite(), progress.newChild(1));
	} catch (ProvisionException e) {
		UpdateMetaFileReaderJob.promptUserError(
				"The P2 Does not existed at the given location, please set the update/releases P2 for Developer Studio in the Preference Store",
				"P2 Repository Error");
		throw e;
	}
	IQuery<IInstallableUnit> allIUQuery = QueryUtil.createIUAnyQuery();
	IQueryResult<IInstallableUnit> allIUQueryResult = metadataRepo.query(allIUQuery, progress.newChild(1));

	// read artifact repository for updates
	IArtifactRepository artifactRepo = artifactRepoManager.loadRepository(getDevStudioUpdateSite(),
			progress.newChild(1));

	// read meta-data of all available features
	Map<String, EnhancedFeature> unsortedMap = loadWSO2FeaturesInRepo(artifactRepo, allIUQueryResult,
			progress.newChild(1));
	// sort the map in alphabetical order
	Map<String, EnhancedFeature> allFeaturesInUpdateRepo = new TreeMap<String, EnhancedFeature>(unsortedMap);
	// get all installed wso2 features
	Collection<IInstallableUnit> installedWSO2Features = getInstalledWSO2Features(progress.newChild(1));

	installedWSO2FeaturesMap = new HashMap<String, IInstallableUnit>();
	for (IInstallableUnit iInstallableUnit : installedWSO2Features) {
		installedWSO2FeaturesMap.put(iInstallableUnit.getId(), iInstallableUnit);
	}

	if (progress.isCanceled()) {
		throw new OperationCanceledException();
	}

	URI[] repos = new URI[] { getDevStudioUpdateSite() };
	updateOperation = new UpdateOperation(session, installedWSO2Features);
	updateOperation.getProvisioningContext().setArtifactRepositories(repos);
	updateOperation.getProvisioningContext().setMetadataRepositories(repos);

	// resolve update operation
	IStatus status = updateOperation.resolveModal(progress.newChild(1));
	// user cancelled the job while resolving
	if (status.getSeverity() == IStatus.CANCEL || progress.isCanceled()) {
		throw new OperationCanceledException();
	}
	// there is nothing to update
	if (status.getCode() == UpdateOperation.STATUS_NOTHING_TO_UPDATE) {
		featuresWithPossibleUpdates = new HashMap<String, EnhancedFeature>();
		log.info(Messages.UpdateManager_19);
	} else if (status.getSeverity() == IStatus.ERROR) { // resolution errors
		// something wrong with the updates
		log.info(Messages.UpdateManager_20);
	} else {
		// good to proceed installing updates
		setPossibleUpdates(updateOperation.getPossibleUpdates(), allFeaturesInUpdateRepo);
	}
	// sort the available updates in alphabetical order

}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Searches available features in WSO2 p2 repository for the current version
 * of Developer Studio and filters new features that can be installed.
 * 
 * @param monitor
 * @throws Exception
 */
public void checkForAvailableFeatures(IProgressMonitor monitor) throws Exception {
	if (monitor == null) {
		monitor = new NullProgressMonitor();
	}
	SubMonitor progress = SubMonitor.convert(monitor, Messages.UpdateManager_21, 5);

	// get all available IUs in release repository
	IMetadataRepository metadataRepository = null;
	try {
		metadataRepository = metadataRepoManager.loadRepository(getDevStudioReleaseSite(), progress.newChild(1));
	} catch (ProvisionException e) {
		UpdateMetaFileReaderJob.promptUserError(
				"The P2 Does not existed at the given location, please set the update/releases P2 for Developer Studio in the Preference Store",
				"P2 Repository Error");
		throw e;
	}
	IQuery<IInstallableUnit> allIUQuery = QueryUtil.createIUAnyQuery();
	IQueryResult<IInstallableUnit> allIUQueryResult = metadataRepository.query(allIUQuery, progress.newChild(1));

	// load artifact repository for releases
	IArtifactRepository artifactRepository = artifactRepoManager.loadRepository(getDevStudioReleaseSite(),
			progress.newChild(1));

	// read meta-data of all available features
	Map<String, EnhancedFeature> allFeaturesInReleaseRepo = loadWSO2FeaturesInRepo(artifactRepository,
			allIUQueryResult, progress.newChild(1));

	Collection<IInstallableUnit> filteredIUs = filterInstallableUnits(WSO2_FEATURE_PREFIX, FEATURE_GROUP_IU_ID_SFX,
			allIUQueryResult, progress.newChild(1));
	allAvailableFeatures = new HashMap<String, IInstallableUnit>();
	unsortedAvailableNewFeatures = new HashMap<String, EnhancedFeature>();
	for (IInstallableUnit iInstallableUnit : filteredIUs) {
		allAvailableFeatures.put(iInstallableUnit.getId(), iInstallableUnit);
		if (!installedWSO2FeaturesMap.containsKey(iInstallableUnit.getId())) {
			unsortedAvailableNewFeatures.put(iInstallableUnit.getId(),
					allFeaturesInReleaseRepo.get(iInstallableUnit.getId()));
		} else {
			Version versionInstalled = installedWSO2FeaturesMap.get(iInstallableUnit.getId()).getVersion();
			// if the version we have is greater than the installed version
			// view it in the available feature list
			if (versionInstalled != null && (iInstallableUnit.getVersion().compareTo(versionInstalled) == 1)) {
				unsortedAvailableNewFeatures.put(iInstallableUnit.getId(),
						allFeaturesInReleaseRepo.get(iInstallableUnit.getId()));
			}
		}
	}
	// sort the available new features according to alphabetical order
	availableNewFeatures = new TreeMap<String, EnhancedFeature>(unsortedAvailableNewFeatures);
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
public IMetadataRepository getMetaRepo(){
	return metaRepo;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Constructor
 * 
 * @param repository meta-data repository
 */
public RepositoryAdapter(IMetadataRepository repository) {
	this.repository = repository;
}
 

import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository; //导入依赖的package包/类
/**
 * Queries a repository to get a collection of results
 * 
 * @param repository
 * @return
 */
public static IQueryResult<IInstallableUnit> getInstallable(IMetadataRepository repository){
	return repository.query(QueryUtil.createIUAnyQuery(), new NullProgressMonitor());
}