/*******************************************************************************
* Copyright (c) 2000, 2010 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.update.search;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.IFeatureReference;
import org.eclipse.update.core.ISite;
import org.eclipse.update.core.ISiteWithMirrors;
import org.eclipse.update.core.IURLEntry;
import org.eclipse.update.core.SiteManager;
import org.eclipse.update.internal.core.ExtendedSite;
import org.eclipse.update.internal.core.Messages;
import org.eclipse.update.internal.operations.UpdateUtils;
import org.eclipse.update.internal.search.SiteSearchCategory;
import org.eclipse.update.internal.search.UpdatePolicy;
import org.eclipse.update.internal.search.UpdateSiteAdapter;
import org.eclipse.update.internal.search.UpdatesSearchCategory;
/**
* This class is central to update search. The search pattern
* is encapsulated in update search category, while the search
* scope is defined in the scope object. When these two objects
* are defined and set, search can be performed using the
* provided method. Search results are reported to the
* result collector, while search progress is tracked using
* the progress monitor.
* <p>Classes that implement <samp>IUpdateSearchResultCollector</samp>
* should call 'accept' to test if the match should be
* accepted according to the filters added to the request.
*
* <p>
* <b>Note:</b> This class/interface is part of an interim API that is still under development and expected to
* change significantly before reaching stability. It is being made available at this early stage to solicit feedback
* from pioneering adopters on the understanding that any code that uses this API will almost certainly be broken
* (repeatedly) as the API evolves.
* </p>
* @see UpdateSearchScope
* @see IUpdateSearchCategory
* @since 3.0
* @deprecated The org.eclipse.update component has been replaced by Equinox p2.
* This API will be deleted in a future release. See bug 311590 for details.
*/
public class UpdateSearchRequest {
private IUpdateSearchCategory category;
private UpdateSearchScope scope;
private boolean searchInProgress = false;
private AggregateFilter aggregateFilter = new AggregateFilter();
private static class UpdateSearchSite
extends UpdateSiteAdapter
implements IUpdateSearchSite {
private String[] categoriesToSkip;
public UpdateSearchSite(
String label,
URL siteURL,
String[] categoriesToSkip) {
super(label, siteURL);
this.categoriesToSkip = categoriesToSkip;
}
public String[] getCategoriesToSkip() {
return categoriesToSkip;
}
}
class MirroredUpdateSiteAdapter extends UpdateSiteAdapter {
public MirroredUpdateSiteAdapter(IURLEntry mirror) {
super(mirror.getAnnotation(), mirror.getURL());
}
}
class AggregateFilter implements IUpdateSearchFilter {
private ArrayList filters;
public void addFilter(IUpdateSearchFilter filter) {
if (filters == null)
filters = new ArrayList();
if (filters.contains(filter) == false)
filters.add(filter);
}
public void removeFilter(IUpdateSearchFilter filter) {
if (filters == null)
return;
filters.remove(filter);
}
/**
* @deprecated In 3.1 only the accept (IFeatureReference) will be used
*/
public boolean accept(IFeature match) {
if (filters == null)
return true;
for (int i = 0; i < filters.size(); i++) {
IUpdateSearchFilter filter = (IUpdateSearchFilter) filters.get(i);
if (filter.accept(match) == false)
return false;
}
return true;
}
public boolean accept(IFeatureReference match) {
if (filters == null)
return true;
for (int i = 0; i < filters.size(); i++) {
IUpdateSearchFilter filter = (IUpdateSearchFilter) filters.get(i);
if (filter.accept(match) == false)
return false;
}
return true;
}
}
/**
* Returns an updates search category for use in discovering updates
* to existing function on update sites.
*
* @return an updates search category
* @since 3.1
*/
public static IUpdateSearchCategory createDefaultUpdatesSearchCategory() {
return new UpdatesSearchCategory();
}
/**
* Returns a site search category for use in discovering new function on update sites.
*
* @return a site search category
* @since 3.1
*/
public static IUpdateSearchCategory createDefaultSiteSearchCategory() {
return new SiteSearchCategory();
}
/**
* The constructor that accepts the search category and
* scope objects.
* @param category the actual search pattern that should be applied
* @param scope a list of sites that need to be scanned during the search
*/
public UpdateSearchRequest(
IUpdateSearchCategory category,
UpdateSearchScope scope) {
this.category = category;
this.scope = scope;
}
/**
* Returns the search catagory used in this request.
* @return the search category
*/
public IUpdateSearchCategory getCategory() {
return category;
}
/**
* Returns the scope of this search request.
* @return search scope
*/
public UpdateSearchScope getScope() {
return scope;
}
/**
* Adds a filter to this request. This method does nothing
* if search is alrady in progress.
* @param filter the filter
* @see UpdateSearchRequest#removeFilter
*/
public void addFilter(IUpdateSearchFilter filter) {
if (searchInProgress)
return;
aggregateFilter.addFilter(filter);
}
/**
* Removes the filter from this request. This method does
* nothing if search is alrady in progress.
* @param filter the filter to remove
* @see UpdateSearchRequest#addFilter
*/
public void removeFilter(IUpdateSearchFilter filter) {
if (searchInProgress)
return;
aggregateFilter.removeFilter(filter);
}
/**
* Sets the scope object. It is possible to reuse the search request
* object by modifying the scope and re-running the search.
* @param scope the new search scope
*/
public void setScope(UpdateSearchScope scope) {
this.scope = scope;
}
/**
* Tests whether this search request is current running.
* @return <samp>true</samp> if the search is currently running, <samp>false</samp> otherwise.
*/
public boolean isSearchInProgress() {
return searchInProgress;
}
/**
* Runs the search using the category and scope configured into
* this request. As results arrive, they are passed to the
* search result collector object.
* @param collector matched features are passed to this object
* @param monitor used to track the search progress
* @throws CoreException
*/
public void performSearch(
IUpdateSearchResultCollector collector,
IProgressMonitor monitor)
throws CoreException, OperationCanceledException {
ArrayList statusList = new ArrayList();
searchInProgress = true;
IUpdateSearchQuery[] queries = category.getQueries();
IUpdateSearchSite[] candidates = scope.getSearchSites();
Set visitedSitesURL = new HashSet();
Set visitedSites = new HashSet();
for(int i = 0; i < candidates.length; i++) {
visitedSitesURL.add(candidates[i].getURL());
//visitedSites.add(candidates[i]);
}
URL updateMapURL = scope.getUpdateMapURL();
boolean searchFeatureProvidedSites = scope.isFeatureProvidedSitesEnabled();
if (!monitor.isCanceled()) {
int nsearchsites = 0;
try {
for (int i = 0; i < queries.length; i++) {
if (queries[i].getQuerySearchSite() != null)
nsearchsites++;
}
} catch (Throwable t) {
t.printStackTrace();
}
int ntasks = nsearchsites + queries.length * candidates.length;
if (updateMapURL!=null) ntasks++;
monitor.beginTask(Messages.UpdateSearchRequest_searching, ntasks);
try {
UpdatePolicy updatePolicy=null;
if (updateMapURL!=null) {
updatePolicy = new UpdatePolicy();
IStatus status =UpdateUtils.loadUpdatePolicy(updatePolicy, updateMapURL, new SubProgressMonitor(monitor, 1));
if (status != null)
statusList.add(status);
}
List combinedAssociateSites = new ArrayList();
for (int i = 0; i < queries.length; i++) {
IUpdateSearchQuery query = queries[i];
IQueryUpdateSiteAdapter qsite = query.getQuerySearchSite();
// currently, the next conditional is only executed (qsite!=null) when
// running an update search.
if (qsite != null && searchFeatureProvidedSites) {
// do not update features that are installed in read-only locations
if (query instanceof UpdatesSearchCategory.UpdateQuery) {
IFeature feature = ((UpdatesSearchCategory.UpdateQuery)query).getFeature();
if (feature != null && !feature.getSite().getCurrentConfiguredSite().verifyUpdatableStatus().isOK())
continue;
}
// check for mapping
IUpdateSiteAdapter mappedSite = getMappedSite(updatePolicy, qsite);
// when there is no mapped site the feature is not updatable
if (mappedSite == null || mappedSite.getURL() == null)
continue;
SubProgressMonitor subMonitor =
new SubProgressMonitor(monitor, 1);
List associateSites = new ArrayList();
IStatus status =
searchOneSite(
mappedSite,
null,
query,
collector,
associateSites,
subMonitor,
true);
if (status != null)
statusList.add(status);
if (monitor.isCanceled())
break;
combinedAssociateSites = combineAssociateSites( combinedAssociateSites, associateSites, visitedSitesURL, visitedSites);
}
for (int j = 0; j < candidates.length; j++) {
if (monitor.isCanceled()) {
break;
}
IUpdateSearchSite source = candidates[j];
SubProgressMonitor subMonitor =
new SubProgressMonitor(monitor, 1);
List associateSites = new ArrayList();
IStatus status =
searchOneSite(
source,
source.getCategoriesToSkip(),
query,
collector,
associateSites,
subMonitor,
true);
if (status != null)
statusList.add(status);
combinedAssociateSites = combineAssociateSites( combinedAssociateSites, associateSites, visitedSitesURL, visitedSites);
}
if (monitor.isCanceled())
break;
for(int associateSitesDepth = 0; associateSitesDepth < 5; associateSitesDepth++) {
List tempCombinedSites = new ArrayList();
Iterator combinedAssociateSitesIterator = combinedAssociateSites.iterator();
while(combinedAssociateSitesIterator.hasNext()) {
IUpdateSearchSite source = (IUpdateSearchSite)combinedAssociateSitesIterator.next();
List associateSites = new ArrayList();
SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 1);
IStatus status =
searchOneSite(
source,
source.getCategoriesToSkip(),
query,
collector,
associateSites,
subMonitor,
true);
combinedAssociateSites = combineAssociateSites( tempCombinedSites, associateSites, visitedSitesURL, visitedSites);
if (status != null)
statusList.add(status);
}
combinedAssociateSites = tempCombinedSites;
}
if (monitor.isCanceled())
break;
}
} catch (CoreException e) {
searchInProgress = false;
monitor.done();
throw e;
}
}
searchInProgress = false;
monitor.done();
Iterator visitedSitesIterator = visitedSites.iterator();
while (visitedSitesIterator.hasNext()) {
IUpdateSearchSite associateSite = (IUpdateSearchSite)visitedSitesIterator.next();
scope.addSearchSite(associateSite.getLabel(), associateSite.getURL(), null);
}
if (statusList.size() > 0) {
if (statusList.size()==1 && ((IStatus)statusList.get(0)).getSeverity()==IStatus.CANCEL)
throw new OperationCanceledException();
IStatus[] children =
(IStatus[]) statusList.toArray(new IStatus[statusList.size()]);
MultiStatus multiStatus =
new MultiStatus(
"org.eclipse.update.core", //$NON-NLS-1$
ISite.SITE_ACCESS_EXCEPTION,
children,
Messages.Search_networkProblems,
null);
throw new CoreException(multiStatus);
}
}
private List combineAssociateSites(List combinedAssociateSites, List associateSites, Set visitedSitesURL, Set visitedSites) {
Iterator iterator = associateSites.iterator();
while(iterator.hasNext()) {
UpdateSearchSite associateSite = (UpdateSearchSite)iterator.next();
if ( !visitedSitesURL.contains(associateSite.getURL())) {
combinedAssociateSites.add(associateSite);
visitedSitesURL.add(associateSite.getURL());
visitedSites.add(associateSite);
}
}
return combinedAssociateSites;
}
/*
* See if this query site adapter is mapped in the map file
* to a different URL.
*/
private IUpdateSiteAdapter getMappedSite(UpdatePolicy policy, IQueryUpdateSiteAdapter qsite) {
if (policy!=null && policy.isLoaded()) {
IUpdateSiteAdapter mappedSite = policy.getMappedSite(qsite.getMappingId());
if (mappedSite!=null)
return mappedSite;
else // no match - use original site if fallback allowed, or nothing.
return policy.isFallbackAllowed()? qsite : null;
}
return qsite;
}
/*
* Search one site using the provided query.
*/
private IStatus searchOneSite(
IUpdateSiteAdapter siteAdapter,
String[] categoriesToSkip,
IUpdateSearchQuery query,
IUpdateSearchResultCollector collector,
List associateSites,
SubProgressMonitor monitor,
boolean checkMirrors)
throws CoreException {
String text = NLS.bind(Messages.UpdateSearchRequest_contacting, siteAdapter.getLabel());
monitor.subTask(text);
monitor.beginTask("", 10); //$NON-NLS-1$
URL siteURL = siteAdapter.getURL();
ISite site;
try {
site =
SiteManager.getSite(
siteURL,
new SubProgressMonitor(monitor, 1));
// If frozen connection was canceled, there will be no site.
if (site == null) {
monitor.worked(9);
return null;
}
// prompt the user to pick up a site (do not recursively go into mirror sites on the mirror site)
if ((collector instanceof IUpdateSearchResultCollectorFromMirror) &&
(site instanceof ISiteWithMirrors) &&
!(siteAdapter instanceof MirroredUpdateSiteAdapter)) {
IURLEntry mirror = null;
try {
mirror = ((IUpdateSearchResultCollectorFromMirror)collector).getMirror((ISiteWithMirrors)site, siteAdapter.getLabel());
if (site instanceof ExtendedSite) {
((ExtendedSite)site).setSelectedMirror(mirror);
}
}
catch (OperationCanceledException e) {
monitor.setCanceled(true);
return Status.CANCEL_STATUS;
}
if (mirror != null)
return searchOneSite(new MirroredUpdateSiteAdapter(mirror), categoriesToSkip, query, collector, associateSites, new SubProgressMonitor(monitor,1), false);
}
} catch (CoreException e) {
// Test the exception. If the exception is
// due to the site connection problems,
// allow the search to move on to
// the next site. Otherwise,
// rethrow the exception, causing the search
// to terminate.
IStatus status = e.getStatus();
if (status == null)
// || status.getCode() != ISite.SITE_ACCESS_EXCEPTION)
throw e;
monitor.worked(10);
return status;
}
text = NLS.bind(Messages.UpdateSearchRequest_checking, siteAdapter.getLabel());
monitor.getWrappedProgressMonitor().subTask(text);
if (site instanceof ExtendedSite) {
//System.out.println("ExtendedSite is here"); //$NON-NLS-1$
IURLEntry[] associateSitesList = ((ExtendedSite)site).getAssociateSites();
if (associateSitesList != null) {
for(int i = 0; i < associateSitesList.length; i++) {
associateSites.add(new UpdateSearchSite(associateSitesList[i].getAnnotation(), associateSitesList[i].getURL(), null));
}
}
}
query.run(
site,
categoriesToSkip,
aggregateFilter,
collector,
new SubProgressMonitor(monitor, 9));
return null;
}
}