/*******************************************************************************
* Copyright (c) 2010, 2013 The Eclipse Foundation 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:
* The Eclipse Foundation - initial API and implementation
* Yatta Solutions - news (bug 401721), public API (bug 432803)
* JBoss (Pascal Rapicault) - Bug 406907 - Add p2 remediation page to MPC install flow
*******************************************************************************/
package org.eclipse.epp.internal.mpc.ui.wizards;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.epp.internal.mpc.core.MarketplaceClientCore;
import org.eclipse.epp.internal.mpc.core.model.News;
import org.eclipse.epp.internal.mpc.ui.CatalogRegistry;
import org.eclipse.epp.internal.mpc.ui.MarketplaceClientUi;
import org.eclipse.epp.internal.mpc.ui.MarketplaceClientUiPlugin;
import org.eclipse.epp.internal.mpc.ui.catalog.MarketplaceCatalog;
import org.eclipse.epp.internal.mpc.ui.catalog.MarketplaceDiscoveryStrategy;
import org.eclipse.epp.internal.mpc.ui.commands.MarketplaceWizardCommand;
import org.eclipse.epp.internal.mpc.ui.operations.AbstractProvisioningOperation;
import org.eclipse.epp.internal.mpc.ui.operations.ProfileChangeOperationComputer;
import org.eclipse.epp.internal.mpc.ui.operations.ProfileChangeOperationComputer.OperationType;
import org.eclipse.epp.internal.mpc.ui.wizards.MarketplaceViewer.ContentType;
import org.eclipse.epp.internal.mpc.ui.wizards.SelectionModel.CatalogItemEntry;
import org.eclipse.epp.internal.mpc.ui.wizards.SelectionModel.FeatureEntry;
import org.eclipse.epp.mpc.core.model.ICategory;
import org.eclipse.epp.mpc.core.model.IMarket;
import org.eclipse.epp.mpc.core.model.INews;
import org.eclipse.epp.mpc.core.model.INode;
import org.eclipse.epp.mpc.ui.CatalogDescriptor;
import org.eclipse.epp.mpc.ui.MarketplaceUrlHandler;
import org.eclipse.epp.mpc.ui.Operation;
import org.eclipse.equinox.internal.p2.discovery.AbstractDiscoveryStrategy;
import org.eclipse.equinox.internal.p2.discovery.model.CatalogItem;
import org.eclipse.equinox.internal.p2.ui.ProvUI;
import org.eclipse.equinox.internal.p2.ui.discovery.util.WorkbenchUtil;
import org.eclipse.equinox.internal.p2.ui.discovery.wizards.DiscoveryWizard;
import org.eclipse.equinox.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.p2.operations.ProfileChangeOperation;
import org.eclipse.equinox.p2.operations.ProvisioningJob;
import org.eclipse.equinox.p2.operations.RemediationOperation;
import org.eclipse.equinox.p2.operations.UninstallOperation;
import org.eclipse.equinox.p2.ui.AcceptLicensesWizardPage;
import org.eclipse.equinox.p2.ui.ProvisioningUI;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.IWizardContainer;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.browser.IWebBrowser;
import org.eclipse.ui.browser.IWorkbenchBrowserSupport;
import org.eclipse.ui.internal.browser.WorkbenchBrowserSupport;
import org.eclipse.ui.statushandlers.StatusManager;
/**
* A wizard for interacting with a marketplace service.
*
* @author David Green
* @author Carsten Reckord
*/
public class MarketplaceWizard extends DiscoveryWizard implements InstallProfile, IMarketplaceWebBrowser {
private static final String PREF_DEFAULT_CATALOG = CatalogDescriptor.class.getSimpleName();
private static final String DEBUG_NEWS_FLAG = MarketplaceClientUi.BUNDLE_ID + "/news/debug"; //$NON-NLS-1$
private static final String DEBUG_NEWS_TITLE = MarketplaceClientUi.BUNDLE_ID + "/news/title"; //$NON-NLS-1$
private static final String DEBUG_NEWS_URL = MarketplaceClientUi.BUNDLE_ID + "/news/url"; //$NON-NLS-1$
public static class WizardState {
private ContentType contentType;
private Set<INode> content;
private IMarket filterMarket;
private ICategory filterCategory;
private String filterQuery;
private Boolean proceedWithInstallation;
public ContentType getContentType() {
return contentType;
}
public void setContentType(ContentType contentType) {
this.contentType = contentType;
}
public Set<INode> getContent() {
return content;
}
public void setContent(Set<INode> content) {
this.content = content;
}
public IMarket getFilterMarket() {
return filterMarket;
}
public void setFilterMarket(IMarket filterMarket) {
this.filterMarket = filterMarket;
}
public ICategory getFilterCategory() {
return filterCategory;
}
public void setFilterCategory(ICategory filterCategory) {
this.filterCategory = filterCategory;
}
public String getFilterQuery() {
return filterQuery;
}
public void setFilterQuery(String filterQuery) {
this.filterQuery = filterQuery;
}
public Boolean getProceedWithInstallation() {
return proceedWithInstallation;
}
public void setProceedWithInstallation(Boolean proceedWithInstallation) {
this.proceedWithInstallation = proceedWithInstallation;
}
}
private Set<String> installedFeatures;
private SelectionModel selectionModel;
private MarketplaceBrowserIntegration browserListener;
private ProfileChangeOperation profileChangeOperation;
private FeatureSelectionWizardPage featureSelectionWizardPage;
private AcceptLicensesWizardPage acceptLicensesPage;
private IInstallableUnit[] operationIUs;
private Set<CatalogItem> operationNewInstallItems;
private boolean initialSelectionInitialized;
private Set<URI> addedRepositoryLocations;
private boolean withRemediation;
private String errorMessage;
private WizardState initialState;
public String getErrorMessage() {
return errorMessage;
}
public MarketplaceWizard(MarketplaceCatalog catalog, MarketplaceCatalogConfiguration configuration) {
super(catalog, configuration);
setWindowTitle(Messages.MarketplaceWizard_eclipseSolutionCatalogs);
createSelectionModel();
withRemediation = true;
String withRemediationOverride = System.getProperty("marketplace.remediation.enabled"); //$NON-NLS-1$
if (withRemediationOverride != null) {
withRemediation = Boolean.parseBoolean(withRemediationOverride);
}
}
private void createSelectionModel() {
selectionModel = new SelectionModel(this) {
@Override
public void selectionChanged() {
super.selectionChanged();
profileChangeOperation = null;
}
};
}
@Override
public MarketplaceCatalogConfiguration getConfiguration() {
return (MarketplaceCatalogConfiguration) super.getConfiguration();
}
@Override
public MarketplaceCatalog getCatalog() {
return (MarketplaceCatalog) super.getCatalog();
}
@Override
protected MarketplacePage doCreateCatalogPage() {
return new MarketplacePage(getCatalog(), getConfiguration());
}
public ProfileChangeOperation getProfileChangeOperation() {
return profileChangeOperation;
}
public void setProfileChangeOperation(ProfileChangeOperation profileChangeOperation) {
this.profileChangeOperation = profileChangeOperation;
}
void initializeInitialSelection() throws CoreException {
if (!wantInitializeInitialSelection()) {
throw new IllegalStateException();
}
initialSelectionInitialized = true;
initializeCatalog();
if (getConfiguration().getInitialState() != null || getConfiguration().getInitialOperations() != null) {
try {
getContainer().run(true, true, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
new SelectionModelStateSerializer(getCatalog(), getSelectionModel()).deserialize(
getConfiguration().getInitialState(), getConfiguration().getInitialOperations(),
monitor);
}
});
} catch (InvocationTargetException e) {
throw new CoreException(MarketplaceClientCore.computeStatus(e, Messages.MarketplaceViewer_unexpectedException));
} catch (InterruptedException e) {
// user canceled
throw new CoreException(Status.CANCEL_STATUS);
}
List<Entry<CatalogItem, Operation>> itemToSelectedOperation = new ArrayList<Entry<CatalogItem, Operation>>(
getSelectionModel().getItemToSelectedOperation().entrySet());
final List<CatalogItem> noninstallableItems = new ArrayList<CatalogItem>();
for (Entry<CatalogItem, Operation> entry : itemToSelectedOperation) {
if (entry.getValue() != Operation.NONE) {
boolean unavailableInstall = (Boolean.FALSE.equals(entry.getKey().getAvailable()) || entry.getKey()
.getSiteUrl() == null)
&& (entry.getValue() == Operation.INSTALL || entry.getValue() == Operation.UPDATE);
if (unavailableInstall) {
getSelectionModel().select(entry.getKey(), Operation.NONE);
noninstallableItems.add(entry.getKey());
} else {
entry.getKey().setSelected(true);
}
}
}
if (!noninstallableItems.isEmpty()) {
notifyNonInstallableItems(noninstallableItems);
}
}
}
protected void notifyNonInstallableItems(final List<CatalogItem> noninstallableItems) {
MessageDialog dialog = new MessageDialog(getShell(), Messages.MarketplaceWizard_UnableToInstallSolutions, null, Messages.MarketplaceWizard_IncompatibleSolutionsMessage, MessageDialog.ERROR,
new String[] { IDialogConstants.OK_LABEL }, 0) {
@Override
protected Control createCustomArea(Composite parent) {
parent.setLayout(new GridLayout());
TableViewer tableViewer = new TableViewer(parent, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL
| SWT.BORDER);
tableViewer.setLabelProvider(createLabelProvider());
tableViewer.setContentProvider(createContentProvider());
tableViewer.setInput(noninstallableItems);
Control tableControl = tableViewer.getControl();
GridDataFactory.fillDefaults()
.grab(true, true)
.align(SWT.FILL, SWT.FILL)
.hint(SWT.DEFAULT,
Math.max(40,
Math.min(120, tableControl.computeSize(SWT.DEFAULT, SWT.DEFAULT).y)))
.applyTo(tableControl);
return tableControl;
}
private LabelProvider createLabelProvider() {
return new LabelProvider() {
@Override
public String getText(Object element) {
//TODO it would be great to know the compatible version range
//we could show that with an IStyledLabelProvider behind the name
return ((CatalogItem) element).getName();
}
@Override
public Image getImage(Object element) {
return MarketplaceClientUiPlugin.getInstance()
.getImageRegistry()
.get(MarketplaceClientUiPlugin.IU_ICON_ERROR);
}
};
}
private IStructuredContentProvider createContentProvider() {
return new IStructuredContentProvider() {
public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
}
public void dispose() {
}
public Object[] getElements(Object inputElement) {
return ((List<?>) inputElement).toArray();
}
};
}
};
dialog.open();
}
boolean wantInitializeInitialSelection() {
if (initialSelectionInitialized) {
return false;
} else if (getConfiguration().getInitialState() != null || getConfiguration().getInitialOperations() != null) {
return true;
} else if (initialState != null) {
WizardState initialState = getInitialState();
if ((initialState.getContent() != null && !initialState.getContent().isEmpty())
|| (initialState.getContentType() != null && initialState.getContentType() != ContentType.SEARCH)
|| (initialState.getFilterCategory() != null || initialState.getFilterMarket() != null || initialState.getFilterQuery() != null)) {
return true;
}
}
return false;
}
@Override
public boolean canFinish() {
if (computeMustCheckLicenseAcceptance()) {
if (acceptLicensesPage == null && getContainer().getCurrentPage() == getFeatureSelectionWizardPage()) {
getNextPage(getFeatureSelectionWizardPage(), false);
}
if (acceptLicensesPage == null || !acceptLicensesPage.isPageComplete()) {
return false;
}
}
if (profileChangeOperation != null) {
IStatus resolutionResult = profileChangeOperation.getResolutionResult();
switch (resolutionResult.getSeverity()) {
case IStatus.OK:
case IStatus.WARNING:
case IStatus.INFO:
return true;
}
}
return false;
}
@Override
public IWizardPage getNextPage(IWizardPage page) {
return getNextPage(page, true);
}
IWizardPage getNextPage(IWizardPage page, boolean nextpressed) {
boolean skipFeatureSelection = false;
MarketplacePage catalogPage = getCatalogPage();
if (page == catalogPage && nextpressed) {
profileChangeOperation = null;
featureSelectionWizardPage.updateMessage();
if (catalogPage.canSkipFeatureSelection()) {
skipFeatureSelection = true;
}
}
if (page == featureSelectionWizardPage || (page == catalogPage && skipFeatureSelection)) {
if (nextpressed && profileChangeOperation != null
&& profileChangeOperation instanceof RemediationOperation) {
try {
getContainer().run(true, false, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) {
((RemediationOperation) profileChangeOperation).setCurrentRemedy(featureSelectionWizardPage.getRemediationGroup()
.getCurrentRemedy());
profileChangeOperation.resolveModal(monitor);
}
});
} catch (InterruptedException e) {
// Nothing to report if thread was interrupted
} catch (InvocationTargetException e) {
ProvUI.handleException(e.getCause(), null, StatusManager.SHOW | StatusManager.LOG);
}
}
IWizardPage nextPage = null;
boolean operationUpdated = false;
if (profileChangeOperation == null) {
if (nextpressed) {
updateProfileChangeOperation();
operationUpdated = true;
}
if (profileChangeOperation == null || !profileChangeOperation.getResolutionResult().isOK()) {
// can't compute a change operation, so there must be some kind of error
// we show these on the the feature selection wizard page
nextPage = featureSelectionWizardPage;
} else if (profileChangeOperation instanceof UninstallOperation) {
// next button was used to resolve errors on an uninstall.
// by returning the same page the finish button will be enabled, allowing the user to finish.
nextPage = featureSelectionWizardPage;
} else if (profileChangeOperation instanceof RemediationOperation) {
nextPage = featureSelectionWizardPage;
}
}
if (nextPage == null && nextpressed && profileChangeOperation instanceof RemediationOperation
&& !featureSelectionWizardPage.isInRemediationMode()) {
featureSelectionWizardPage.flipToRemediationComposite();
nextPage = featureSelectionWizardPage;
}
if (nextPage == null && computeMustCheckLicenseAcceptance()) {
if (acceptLicensesPage == null) {
acceptLicensesPage = new AcceptLicensesWizardPage(
ProvisioningUI.getDefaultUI().getLicenseManager(), operationIUs, profileChangeOperation);
addPage(acceptLicensesPage);
} else {
acceptLicensesPage.update(operationIUs, profileChangeOperation);
}
if (nextpressed || acceptLicensesPage.hasLicensesToAccept()
|| profileChangeOperation instanceof RemediationOperation) {
nextPage = acceptLicensesPage;
}
}
if (nextPage == null && page == catalogPage) {
nextPage = featureSelectionWizardPage;
}
if (operationUpdated && nextPage == getContainer().getCurrentPage()) {
getContainer().updateButtons();
}
return nextPage;
}
if (page instanceof ImportFavoritesPage) {
return catalogPage;
}
return getNextPageInList(page);
}
protected IWizardPage getNextPageInList(IWizardPage page) {
return super.getNextPage(page);
}
public boolean computeMustCheckLicenseAcceptance() {
return profileChangeOperation != null && !(profileChangeOperation instanceof UninstallOperation);
}
@Override
public void addPages() {
doDefaultCatalogSelection();
super.addPages();
featureSelectionWizardPage = new FeatureSelectionWizardPage();
addPage(featureSelectionWizardPage);
}
FeatureSelectionWizardPage getFeatureSelectionWizardPage() {
return featureSelectionWizardPage;
}
@Override
public IWizardPage getStartingPage() {
if (getConfiguration().getCatalogDescriptor() != null) {
if (wantInitializeInitialSelection()) {
WizardState initialState = getInitialState();
if (initialState == null || !Boolean.FALSE.equals(initialState.getProceedWithInstallation())) {
return getFeatureSelectionWizardPage();
}
}
return getCatalogPage();
}
return super.getStartingPage();
}
private void doDefaultCatalogSelection() {
if (getConfiguration().getCatalogDescriptor() == null) {
String defaultCatalogUrl = MarketplaceClientUiPlugin.getInstance()
.getPreferenceStore()
.getString(PREF_DEFAULT_CATALOG);
// if a preferences was set, we default to that catalog descriptor
if (defaultCatalogUrl != null && defaultCatalogUrl.length() > 0) {
for (CatalogDescriptor descriptor : getConfiguration().getCatalogDescriptors()) {
URL url = descriptor.getUrl();
try {
if (url.toURI().toString().equals(defaultCatalogUrl)) {
getConfiguration().setCatalogDescriptor(descriptor);
break;
}
} catch (URISyntaxException e) {
// ignore
}
}
}
// if no catalog is selected, pick one
if (getConfiguration().getCatalogDescriptor() == null
&& getConfiguration().getCatalogDescriptors().size() > 0) {
// fall back to first catalog
getConfiguration().setCatalogDescriptor(getConfiguration().getCatalogDescriptors().get(0));
}
}
}
@Override
public void dispose() {
removeAddedRepositoryLocations();
if (getConfiguration().getCatalogDescriptor() != null) {
// remember the catalog for next time.
try {
MarketplaceClientUiPlugin.getInstance()
.getPreferenceStore()
.setValue(PREF_DEFAULT_CATALOG,
getConfiguration().getCatalogDescriptor().getUrl().toURI().toString());
} catch (URISyntaxException e) {
// ignore
}
}
if (getCatalog() != null) {
getCatalog().dispose();
}
super.dispose();
}
@Override
public boolean performFinish() {
if (profileChangeOperation != null
&& profileChangeOperation.getResolutionResult().getSeverity() != IStatus.ERROR) {
if (computeMustCheckLicenseAcceptance()) {
if (acceptLicensesPage != null && acceptLicensesPage.isPageComplete()) {
acceptLicensesPage.performFinish();
}
}
ProvisioningJob provisioningJob = profileChangeOperation.getProvisioningJob(null);
if (provisioningJob != null) {
if (!operationNewInstallItems.isEmpty()) {
provisioningJob.addJobChangeListener(new ProvisioningJobListener(operationNewInstallItems));
}
ProvisioningUI.getDefaultUI().schedule(provisioningJob, StatusManager.SHOW | StatusManager.LOG);
addedRepositoryLocations = null;
return true;
}
}
return false;
}
@Override
public MarketplacePage getCatalogPage() {
return (MarketplacePage) super.getCatalogPage();
}
public synchronized Set<String> getInstalledFeatures() {
if (installedFeatures == null) {
try {
if (Display.getCurrent() != null) {
getContainer().run(true, false, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException,
InterruptedException {
installedFeatures = MarketplaceClientUi.computeInstalledFeatures(monitor);
}
});
} else {
installedFeatures = MarketplaceClientUi.computeInstalledFeatures(new NullProgressMonitor());
}
} catch (InvocationTargetException e) {
MarketplaceClientUi.error(e.getCause());
installedFeatures = Collections.emptySet();
} catch (InterruptedException e) {
// should never happen (not cancelable)
throw new IllegalStateException(e);
}
}
return installedFeatures;
}
public SelectionModel getSelectionModel() {
return selectionModel;
}
public void openUrl(String url) {
String catalogUrl = getCatalogUrl();
if (WorkbenchBrowserSupport.getInstance().isInternalWebBrowserAvailable()
&& url.toLowerCase().startsWith(catalogUrl.toLowerCase())) {
int style = IWorkbenchBrowserSupport.AS_EDITOR | IWorkbenchBrowserSupport.LOCATION_BAR
| IWorkbenchBrowserSupport.NAVIGATION_BAR;
String browserId = "MPC-" + catalogUrl.replaceAll("[^a-zA-Z0-9_-]", "_"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
try {
CatalogDescriptor catalogDescriptor = getConfiguration().getCatalogDescriptor();
IWebBrowser browser = WorkbenchBrowserSupport.getInstance().createBrowser(style, browserId,
catalogDescriptor.getLabel(), catalogDescriptor.getDescription());
final String originalUrl = url;
url = appendWizardState(url);
browser.openURL(new URL(url)); // ORDER DEPENDENCY //don't encode/validate URL - browser can be quite lenient
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell().setActive();
if (!hookLocationListener(browser)) { // ORDER DEPENDENCY
browser.openURL(new URL(originalUrl));
}
} catch (PartInitException e) {
MarketplaceClientUi.handle(e.getStatus(),
StatusManager.SHOW | StatusManager.BLOCK | StatusManager.LOG);
} catch (MalformedURLException e) {
IStatus status = new Status(IStatus.ERROR, MarketplaceClientUi.BUNDLE_ID, NLS.bind(
Messages.MarketplaceWizard_cannotOpenUrl, new Object[] { url, e.getMessage() }), e);
MarketplaceClientUi.handle(status, StatusManager.SHOW | StatusManager.BLOCK | StatusManager.LOG);
}
} else {
WorkbenchUtil.openUrl(url, IWorkbenchBrowserSupport.AS_EXTERNAL);
}
}
private String getCatalogUrl() {
CatalogDescriptor catalogDescriptor = getConfiguration().getCatalogDescriptor();
URL catalogUrl = catalogDescriptor.getUrl();
URI catalogUri;
try {
catalogUri = catalogUrl.toURI();
} catch (URISyntaxException e) {
// should never happen
throw new IllegalStateException(e);
}
return catalogUri.toString();
}
private String appendWizardState(String url) {
try {
if (url.indexOf('?') == -1) {
url += '?';
} else {
url += '&';
}
String state = new SelectionModelStateSerializer(getCatalog(), getSelectionModel()).serialize();
url += "mpc=true&mpc_state=" + URLEncoder.encode(state, "UTF-8"); //$NON-NLS-1$//$NON-NLS-2$
return url;
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e); // should never happen
}
}
private boolean hookLocationListener(IWebBrowser webBrowser) {
try {
Field partField = findField(webBrowser.getClass(), "part", IWorkbenchPart.class); //$NON-NLS-1$
if (partField != null) {
partField.setAccessible(true);
IWorkbenchPart part = (IWorkbenchPart) partField.get(webBrowser);
if (part != null) {
Field browserViewerField = findField(part.getClass(), "webBrowser", null); //$NON-NLS-1$
if (browserViewerField != null) {
browserViewerField.setAccessible(true);
Object browserViewer = browserViewerField.get(part);
if (browserViewer != null) {
Field browserField = findField(browserViewer.getClass(), "browser", Browser.class); //$NON-NLS-1$
if (browserField != null) {
browserField.setAccessible(true);
Browser browser = (Browser) browserField.get(browserViewer);
if (browser != null) {
// only hook the listener once
if (browser.getData(MarketplaceBrowserIntegration.class.getName()) == null) {
if (browserListener == null) {
browserListener = new MarketplaceBrowserIntegration();
}
browser.setData(MarketplaceBrowserIntegration.class.getName(), browserListener);
// hook in listeners
browser.addLocationListener(browserListener);
browser.addOpenWindowListener(browserListener);
}
return true;
}
}
}
}
}
}
} catch (Throwable t) {
// ignore
}
return false;
}
private Field findField(Class<?> clazz, String fieldName, Class<?> fieldClass) {
while (clazz != Object.class) {
for (Field field : clazz.getDeclaredFields()) {
if (field.getName().equals(fieldName)
&& (fieldClass == null || fieldClass.isAssignableFrom(field.getType()))) {
return field;
}
}
clazz = clazz.getSuperclass();
}
return null;
}
public void updateProfileChangeOperation() {
removeAddedRepositoryLocations();
addedRepositoryLocations = null;
profileChangeOperation = null;
operationIUs = null;
IWizardContainer wizardContainer = getContainer();
if (getSelectionModel().computeProvisioningOperationViable()) {
ProfileChangeOperationComputer provisioningOperation = null;
try {
final Map<CatalogItem, Operation> itemToOperation = getSelectionModel().getItemToSelectedOperation();
final Set<CatalogItem> selectedItems = getSelectionModel().getSelectedCatalogItems();
OperationType operationType = null;
for (Map.Entry<CatalogItem, Operation> entry : itemToOperation.entrySet()) {
if (!selectedItems.contains(entry.getKey())) {
continue;
}
OperationType entryOperationType = OperationType.map(entry.getValue());
if (entryOperationType != null) {
if (operationType == null || operationType == OperationType.UPDATE || entryOperationType == OperationType.CHANGE) {
operationType = entryOperationType;
}
}
}
Map<FeatureEntry, Operation> featureEntries = getSelectionModel().getFeatureEntryToOperation(false,
false);
if (operationType == OperationType.CHANGE || operationType == OperationType.UPDATE) {
Set<OperationType> featureOperations = EnumSet.noneOf(OperationType.class);
for (Entry<FeatureEntry, Operation> entry : featureEntries.entrySet()) {
OperationType operation = OperationType.map(entry.getValue());
if (operation != null) {
featureOperations.add(operation);
}
}
if (featureOperations.contains(OperationType.INSTALL)
&& featureOperations.contains(OperationType.UPDATE)) {
//just perform install instead, which covers update
featureOperations.remove(OperationType.UPDATE);
}
if (featureOperations.size() == 1) {
operationType = featureOperations.iterator().next();
}
}
URI dependenciesRepository = null;
if (getConfiguration().getCatalogDescriptor().getDependenciesRepository() != null) {
try {
dependenciesRepository = getConfiguration().getCatalogDescriptor()
.getDependenciesRepository()
.toURI();
} catch (URISyntaxException e) {
throw new InvocationTargetException(e);
}
}
provisioningOperation = new ProfileChangeOperationComputer(
operationType,
selectedItems,
featureEntries.keySet(),
dependenciesRepository,
getConfiguration().getCatalogDescriptor().isInstallFromAllRepositories() ? ProfileChangeOperationComputer.ResolutionStrategy.FALLBACK_STRATEGY
: ProfileChangeOperationComputer.ResolutionStrategy.SELECTED_REPOSITORIES,
withRemediation);
wizardContainer.run(true, true, provisioningOperation);
profileChangeOperation = provisioningOperation.getOperation();
operationIUs = provisioningOperation.getIus();
addedRepositoryLocations = provisioningOperation.getAddedRepositoryLocations();
operationNewInstallItems = computeNewInstallCatalogItems();
errorMessage = provisioningOperation.getErrorMessage();
final IStatus result = profileChangeOperation.getResolutionResult();
if (result != null && operationIUs != null && operationIUs.length > 0
&& operationType == OperationType.INSTALL) {
switch (result.getSeverity()) {
case IStatus.ERROR:
Job job = new Job(Messages.MarketplaceWizard_errorNotificationJob) {
IStatus r = result;
Set<CatalogItem> items = new HashSet<CatalogItem>(itemToOperation.keySet());
IInstallableUnit[] ius = operationIUs;
String details = profileChangeOperation.getResolutionDetails();
{
setSystem(false);
setUser(false);
setPriority(LONG);
}
@Override
protected IStatus run(IProgressMonitor monitor) {
getCatalog().installErrorReport(monitor, r, items, ius, details);
return monitor.isCanceled() ? Status.CANCEL_STATUS : Status.OK_STATUS;
}
};
job.schedule();
}
}
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
IStatus status;
if (cause instanceof CoreException) {
status = ((CoreException) cause).getStatus();
} else {
status = new Status(IStatus.ERROR, MarketplaceClientUi.BUNDLE_ID, NLS.bind(
Messages.MarketplaceWizard_problemsPerformingProvisioningOperation,
new Object[] { cause.getMessage() }), cause);
}
MarketplaceClientUi.handle(status, StatusManager.SHOW | StatusManager.BLOCK | StatusManager.LOG);
} catch (InterruptedException e) {
// canceled
MarketplaceClientUi.log(IStatus.CANCEL, MarketplaceClientUi.BUNDLE_ID,
Messages.MarketplaceWizard_ProvisioningOperationCancelled, e);
} finally {
if (provisioningOperation != null) {
addedRepositoryLocations = provisioningOperation.getAddedRepositoryLocations();
}
}
}
//re-get the container - in case the wizard was closed in the meantime, this will be null...
wizardContainer = getContainer();
if (wizardContainer != null && wizardContainer.getCurrentPage() == featureSelectionWizardPage) {
featureSelectionWizardPage.updateMessage();
}
}
private void removeAddedRepositoryLocations() {
AbstractProvisioningOperation.removeRepositoryLocations(addedRepositoryLocations);
addedRepositoryLocations = null;
}
private Set<CatalogItem> computeNewInstallCatalogItems() {
Set<CatalogItem> items = new HashSet<CatalogItem>();
Map<CatalogItem, Collection<String>> iusByCatalogItem = new HashMap<CatalogItem, Collection<String>>();
for (CatalogItemEntry entry : getSelectionModel().getCatalogItemEntries()) {
List<FeatureEntry> features = entry.getChildren();
Collection<String> featureIds = new ArrayList<String>(features.size());
for (FeatureEntry feature : features) {
if (feature.computeChangeOperation() == Operation.INSTALL) {
featureIds.add(feature.getFeatureDescriptor().getId());
}
}
if (!featureIds.isEmpty()) {
iusByCatalogItem.put(entry.getItem(), featureIds);
}
}
for (IInstallableUnit unit : operationIUs) {
for (Entry<CatalogItem, Collection<String>> entry : iusByCatalogItem.entrySet()) {
if (entry.getValue().contains(unit.getId())) {
items.add(entry.getKey());
}
}
}
return items;
}
void initializeCatalog() {
final MarketplaceCatalog catalog = getCatalog();
synchronized (catalog) {
List<AbstractDiscoveryStrategy> discoveryStrategies = catalog.getDiscoveryStrategies();
for (AbstractDiscoveryStrategy strategy : discoveryStrategies) {
strategy.dispose();
}
discoveryStrategies.clear();
if (getConfiguration().getCatalogDescriptor() != null) {
MarketplaceDiscoveryStrategy discoveryStrategy = new MarketplaceDiscoveryStrategy(
getConfiguration().getCatalogDescriptor());
discoveryStrategy.setShellProvider(this);
discoveryStrategies.add(discoveryStrategy);
}
}
}
protected void updateNews() {
CatalogDescriptor catalogDescriptor = getConfiguration().getCatalogDescriptor();
INews news = null;
if (Boolean.parseBoolean(Platform.getDebugOption(DEBUG_NEWS_FLAG))) {
// use debug override values
String debugNewsUrl = Platform.getDebugOption(DEBUG_NEWS_URL);
if (debugNewsUrl != null && debugNewsUrl.length() > 0) {
News debugNews = new News();
news = debugNews;
debugNews.setUrl(debugNewsUrl);
String debugNewsTitle = Platform.getDebugOption(DEBUG_NEWS_TITLE);
if (debugNewsTitle == null || debugNewsTitle.length() == 0) {
debugNews.setShortTitle("Debug News"); //$NON-NLS-1$
} else {
debugNews.setShortTitle(debugNewsTitle);
}
debugNews.setTimestamp(System.currentTimeMillis());
}
}
if (news == null) {
// try requesting news from marketplace
try {
final INews[] result = new INews[1];
getContainer().run(true, true, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
IStatus status = getCatalog().performNewsDiscovery(monitor);
if (!status.isOK() && status.getSeverity() != IStatus.CANCEL) {
// don't bother user with missing news
MarketplaceClientUi.handle(status, StatusManager.LOG);
}
result[0] = getCatalog().getNews();
}
});
if (result[0] != null) {
news = result[0];
}
} catch (InvocationTargetException e) {
final IStatus status = MarketplaceClientCore.computeStatus(e, Messages.MarketplaceViewer_unexpectedException);
MarketplaceClientUi.handle(status, StatusManager.LOG);
} catch (InterruptedException e) {
// cancelled by user
}
}
if (news == null) {
// use news from catalog
news = CatalogRegistry.getInstance().getCatalogNews(catalogDescriptor);
}
CatalogRegistry.getInstance().addCatalogNews(catalogDescriptor, news);
}
public Object suspendWizard() {
String catalogUrl = getCatalogUrl();
String key = appendWizardState(catalogUrl);
getContainer().getShell().close();
return key;
}
public void setInitialState(WizardState initialState) {
this.initialState = initialState;
}
public WizardState getInitialState() {
return initialState;
}
public static void resumeWizard(Display display, Object state, boolean proceedWithInstall) {
String catalogUrl = (String) state;
if (proceedWithInstall) {
org.eclipse.epp.mpc.ui.MarketplaceUrlHandler.SolutionInstallationInfo installInfo = MarketplaceUrlHandler.createSolutionInstallInfo(catalogUrl);
if (installInfo != null) {
MarketplaceUrlHandler.triggerInstall(installInfo);
return;
}
}
CatalogDescriptor descriptor = catalogUrl == null ? null : CatalogRegistry.getInstance().findCatalogDescriptor(
catalogUrl);
final MarketplaceWizardCommand command = new MarketplaceWizardCommand();
if (descriptor != null) {
descriptor = new CatalogDescriptor(descriptor);
descriptor.setLabel(MarketplaceUrlHandler.DESCRIPTOR_HINT);
command.setSelectedCatalogDescriptor(descriptor);
}
String mpcState = MarketplaceUrlHandler.getMPCState(catalogUrl);
if (mpcState != null && mpcState.length() > 0) {
try {
command.setWizardState(URLDecoder.decode(mpcState, "UTF-8")); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e); // should never happen
}
if (!proceedWithInstall) {
WizardState wizardState = new WizardState();
wizardState.setProceedWithInstallation(false);
command.setWizardDialogState(wizardState);
}
}
display.asyncExec(new Runnable() {
public void run() {
try {
command.execute(new ExecutionEvent());
} catch (ExecutionException e) {
IStatus status = MarketplaceClientCore.computeStatus(e, Messages.MarketplaceBrowserIntegration_cannotOpenMarketplaceWizard);
MarketplaceClientUi.handle(status,
StatusManager.SHOW | StatusManager.BLOCK | StatusManager.LOG);
}
}
});
}
}