/*******************************************************************************
* Copyright (c) 2013, 2016 Pivotal Software, Inc.
* 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:
* Pivotal Software, Inc. - initial API and implementation
*******************************************************************************/
package org.springframework.ide.eclipse.boot.wizard.guides;
import static org.springsource.ide.eclipse.commons.ui.UiUtil.openUrl;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.springframework.ide.eclipse.boot.wizard.BootWizardActivator;
import org.springframework.ide.eclipse.boot.wizard.content.BuildType;
import org.springframework.ide.eclipse.boot.wizard.content.CodeSet;
import org.springframework.ide.eclipse.boot.wizard.content.ContentManager;
import org.springframework.ide.eclipse.boot.wizard.content.ContentManager.DownloadState;
import org.springframework.ide.eclipse.boot.wizard.content.Describable;
import org.springframework.ide.eclipse.boot.wizard.content.GSContent;
import org.springframework.ide.eclipse.boot.wizard.content.GettingStartedContent;
import org.springframework.ide.eclipse.boot.wizard.content.GettingStartedGuide;
import org.springframework.ide.eclipse.boot.wizard.importing.ImportConfiguration;
import org.springframework.ide.eclipse.boot.wizard.importing.ImportStrategies;
import org.springframework.ide.eclipse.boot.wizard.importing.ImportStrategy;
import org.springframework.ide.eclipse.boot.wizard.importing.ImportUtils;
import org.springsource.ide.eclipse.commons.frameworks.core.downloadmanager.UIThreadDownloadDisallowed;
import org.springsource.ide.eclipse.commons.livexp.core.LiveExpression;
import org.springsource.ide.eclipse.commons.livexp.core.LiveSet;
import org.springsource.ide.eclipse.commons.livexp.core.LiveVariable;
import org.springsource.ide.eclipse.commons.livexp.core.SelectionModel;
import org.springsource.ide.eclipse.commons.livexp.core.ValidationResult;
import org.springsource.ide.eclipse.commons.livexp.core.Validator;
import org.springsource.ide.eclipse.commons.livexp.util.ExceptionUtil;
/**
* Core counterpart of <b>GSImportWizard</b> (essentially this is a 'model' for the wizard
* UI.
*
* @author Kris De Volder
* @author Nieraj Singh
*/
public class GSImportWizardModel {
/**
* ContentManager instance that provides all the content that this wizard can import.
* By default this is content discovered automatically with the default content manager
* instance. However it is possible to set the Content manager to browser / import
* content provided another way.
*/
private ContentManager contentManager = GettingStartedContent.getInstance();
// Tracks the download state of content from content manager
private final LiveVariable<DownloadState> prefetchContentTracker = contentManager.getPrefetchContentTracker();
// Tracks the download state for content providers properties from content manager
private final LiveVariable<DownloadState> prefetchContentProviderPropsTracker = contentManager.getPrefetchContentProviderPropertiesTracker();
/**
* The chosen guide to import stuff from.
*/
private final LiveVariable<GSContent> guide = new LiveVariable<GSContent>();
private final LiveExpression<ValidationResult> guideValidator = new Validator() {
{
dependsOn(guide);
dependsOn(prefetchContentProviderPropsTracker);
dependsOn(prefetchContentTracker);
}
@Override
protected ValidationResult compute() {
DownloadState state = prefetchContentProviderPropsTracker.getValue();
if (state == DownloadState.IS_DOWNLOADING) {
return ValidationResult.info("Registering content providers. Please wait...");
} else {
state = prefetchContentTracker.getValue();
if (state == DownloadState.IS_DOWNLOADING) {
return ValidationResult.info("Downloading all content. Please wait...");
}
}
if (guide.getValue() == null) {
return ValidationResult.error("No GS content selected");
} else {
return ValidationResult.OK;
}
}
};
static final ValidationResult isDownloadingMessage(GSContent g) {
return ValidationResult.info(g.getDisplayName()+" is downloading...");
}
public class CodeSetValidator extends LiveExpression<ValidationResult> {
private final LiveVariable<GSContent> codesetProvider;
private final LiveSet<String> selectedNames;
private final LiveExpression<String[]> validCodesetNames;
public CodeSetValidator(LiveVariable<GSContent> guide, LiveSet<String> codesets, LiveExpression<String[]> validCodeSetNames) {
this.codesetProvider = guide;
this.selectedNames = codesets;
this.validCodesetNames = validCodeSetNames;
this.dependsOn(guide);
this.dependsOn(codesets);
this.dependsOn(validCodeSetNames);
}
@Override
protected ValidationResult compute() {
try {
GSContent g = codesetProvider.getValue();
if (g!=null) { //Don't check or produce errors unless a content provider has been selected.
boolean codesetSelected = false;
try {
Set<String> names = selectedNames.getValue();
if (names != null && !names.isEmpty()) {
for (String name : names) {
CodeSet cs = g.getCodeSet(name);
if (cs!=null) {
codesetSelected = true;
ImportConfiguration conf = ImportUtils.importConfig(g, cs);
ValidationResult valid = ImportUtils.validateImportConfiguration(conf);
if (!valid.isOk()) {
return valid;
}
}
}
}
if (!codesetSelected) {
//Selectiong nothing is only allowed if there is in fact nothing to select
//otherwise at least on codeset must be selected for import.
String[] validNames = validCodesetNames.getValue();
if (validNames!=null && validNames.length>0) {
return ValidationResult.error("At least one codeset should be selected");
}
}
} catch (UIThreadDownloadDisallowed e) {
scheduleDownloadJob();
return isDownloadingMessage(g);
}
}
} catch (Throwable e) {
//Unexpected. So log it for more info but also try to create a sensible error message in
// the wizard.
BootWizardActivator.log(e);
return ValidationResult.error(ExceptionUtil.getMessage(e));
}
return ValidationResult.OK;
}
}
/**
* Chosen element in the content picker whether it is an actual GSContent item
* or a ContentType. Used to update description instead of 'c
*/
private final LiveVariable<Object> rawSelection = new LiveVariable<Object>();
/**
* The names of the codesets selected for import.
*/
private final LiveSet<String> codesets = new LiveSet<String>(new HashSet<String>());
{
codesets.addAll(GettingStartedGuide.defaultCodesetNames()); //Select all codesets by default.
}
/**
* The valid codeset names w.r.t. the currently selected guide
*/
public final LiveExpression<String[]> validCodesetNames = new LiveExpression<String[]>(null) {
@Override
protected String[] compute() {
try {
GSContent g = guide.getValue();
if (g!=null) {
List<CodeSet> validSets = g.getCodeSets();
if (validSets!=null) {
String[] names = new String[validSets.size()];
for (int i = 0; i < names.length; i++) {
names[i] = validSets.get(i).getName();
}
return names;
}
}
} catch (UIThreadDownloadDisallowed e) {
//Failed because content is not yet downloade but this is ok...
//just schedule download to happen later and in the mean time return something sensible
scheduleDownloadJob();
} catch (Throwable e) {
BootWizardActivator.log(e);
}
return GettingStartedGuide.defaultCodesetNames();
}
};
/**
* The import strategy chosen by user
*/
private final LiveVariable<ImportStrategy> importStrategy = new LiveVariable<ImportStrategy>(BuildType.DEFAULT.getDefaultStrategy());
private final LiveExpression<ValidationResult> codesetValidator = new CodeSetValidator(guide, codesets, validCodesetNames);
private final LiveExpression<ValidationResult> importStrategyValidator = new Validator() {
@Override
protected ValidationResult compute() {
GSContent g = guide.getValue();
ImportStrategy bt = importStrategy.getValue();
return validateImportStrategy(g, bt);
}
};
private ValidationResult validateImportStrategy(GSContent g, ImportStrategy importStrategy) {
try {
if (g!=null) {
try {
if (importStrategy==null) {
return ValidationResult.error("No build type selected");
} else {
List<String> codesetNames = codesets.getValues();
if (codesetNames!=null) {
for (String csname : codesetNames) {
CodeSet cs = g.getCodeSet(csname);
if (cs!=null) {
ValidationResult result = cs.validateBuildType(importStrategy.getBuildType());
if (!result.isOk()) {
return result.withMessage("CodeSet '"+csname+"': "+result.msg);
}
if (!importStrategy.isSupported()) {
//This means some required STS component like m2e or gradle tooling is not installed
return ValidationResult.error(importStrategy.getNotInstalledMessage());
}
}
}
}
}
} catch (UIThreadDownloadDisallowed e) {
//Careful... check some of the validation will trigger downloads. This is not allowed in UI thread.
scheduleDownloadJob();
return isDownloadingMessage(g);
}
}
return ValidationResult.OK;
} catch (Throwable e) {
BootWizardActivator.log(e);
return ValidationResult.error(ExceptionUtil.getMessage(e));
}
}
public final LiveExpression<Boolean> isDownloaded = new LiveExpression<Boolean>(false) {
@Override
protected Boolean compute() {
GSContent g = guide.getValue();
return g == null || g.isDownloaded();
}
};
/**
* Tries to select a valid build type when a guide is selected.
* The tricky bit is that validity of build types can not be determined until guide
* content has been downloaded locally. At this point if user clicks around rapidly
* another guide may already have been selected. Thus, this code should be run
* any time the guide selection changes as well as any time the download
* status changes.
*/
private final LiveExpression<Void> autoSelectBuildType = new LiveExpression<Void>() {
{
dependsOn(isDownloaded);
dependsOn(guide);
}
@Override
protected Void compute() {
GSContent g = guide.getValue();
if (g!=null) {
if (g.isDownloaded()) {
//Yes, we depend on the value of buildType but shouldn't respond to changes on it.
// We do not want to autoselect a buildType when a user selects one. That would be
// mighty annoying.
ImportStrategy is = importStrategy.getValue();
if (!validateImportStrategy(g, is).isOk()) {
for (ImportStrategy other : ImportStrategies.all()) {
if (other!=is) {
if (validateImportStrategy(g,other).isOk()) {
importStrategy.setValue(other);
}
}
}
}
}
}
return null;
};
};
public final LiveExpression<ValidationResult> downloadStatus = new Validator() {
@Override
protected ValidationResult compute() {
GSContent g = guide.getValue();
if (g == null) {
return ValidationResult.OK;
} else {
return ValidationResult.from(g.getZip().getDownloadStatus());
}
}
};
/**
* The description of the current guide.
*/
public final LiveExpression<String> description = new LiveExpression<String>("<no description>") {
@Override
protected String compute() {
Object g = rawSelection.getValue();
if (g!=null && g instanceof Describable) {
return ((Describable) g).getDescription();
}
return "Select Getting Started Content to see its Description";
}
};
public final LiveExpression<URL> homePage = new LiveExpression<URL>(null) {
@Override
protected URL compute() {
GSContent g = guide.getValue();
if (g!=null) {
return g.getHomePage();
}
return null;
}
};
/**
* Indicates whether the user has selected the option to open the home page.
*/
private final LiveVariable<Boolean> enableOpenHomePage = new LiveVariable<Boolean>(true);
{
importStrategyValidator.dependsOn(guide);
importStrategyValidator.dependsOn(isDownloaded);
importStrategyValidator.dependsOn(importStrategy);
importStrategyValidator.dependsOn(codesets);
isDownloaded.dependsOn(guide);
downloadStatus.dependsOn(guide);
description.dependsOn(rawSelection);
homePage.dependsOn(guide);
validCodesetNames.dependsOn(guide);
validCodesetNames.dependsOn(isDownloaded);
codesetValidator.dependsOn(isDownloaded);
//Note: some other dependsOn are registered inside CodeSetValidator class itself.
// isDownloaded is an exception because is still null when CodeSetValidator class gets
// instantiated.
}
/**
* Downloads currently selected guide content (if it is not already cached locally.
*/
public void performDownload(IProgressMonitor mon) {
mon.beginTask("Downloading", 1);
try {
GSContent g = guide.getValue();
if (g!=null) {
g.getZip().getFile(); //This forces download
}
} catch (Exception e) {
//Don't throw exceptions they are now tracked via downloadStatus.
BootWizardActivator.log(e); //Log for more details than downloadStatus message (i.e. stack trace).
} finally {
isDownloaded.refresh();
downloadStatus.refresh();
mon.done();
}
}
private void scheduleDownloadJob() {
Job job = new Job("Downloading guide content") {
@Override
protected IStatus run(IProgressMonitor mon) {
try {
performDownload(mon);
} catch (Throwable e) {
return ExceptionUtil.status(e);
}
return Status.OK_STATUS;
}
};
job.schedule();
}
/**
* Performs the final step of the wizard when user clicks on Finish button.
* @throws InterruptedException
* @throws InvocationTargetException
*/
public boolean performFinish(IProgressMonitor mon) throws InvocationTargetException, InterruptedException {
//The import will be carried out with whatever the currently selected values are
// in all the input fields / variables / widgets.
GSContent g = guide.getValue();
ImportStrategy is = importStrategy.getValue();
Set<String> codesetNames = codesets.getValue();
mon.beginTask("Import guide content", codesetNames.size()+1);
try {
for (String name : codesetNames) {
CodeSet cs = g.getCodeSet(name);
if (cs==null) {
//Ignore 'invalid' codesets. This is a bit of a hack so that we can retain selected codeset names
// across guide selection changes. To do that we remember 'selected' cs names even if they
// aren't valid for the current guide. That way the checkbox state stays consistent
// when switching between guides (otherwise 'invalid' names would have to be cleared when switching to
// a guide).
mon.worked(1);
} else {
IRunnableWithProgress oper = is.createOperation(ImportUtils.importConfig(
g,
cs
));
oper.run(SubMonitor.convert(mon, 1));
}
}
if (enableOpenHomePage.getValue()) {
openHomePage();
}
return true;
} catch (UIThreadDownloadDisallowed e) {
//This shouldn't be possible... Finish button won't be enabled unless all is validated.
//This implies the content has been downloaded (can't be validated otherwise).
BootWizardActivator.log(e);
return false;
} finally {
mon.done();
}
}
public void openHomePage() {
URL url = homePage.getValue();
if (url!=null) {
openUrl(url.toString());
}
}
// public void setGuide(GettingStartedGuide guide) {
// this.guide.setValue(guide);
// }
//
// public GettingStartedGuide getGuide() {
// return guide.getValue();
// }
public SelectionModel<ImportStrategy> getImportStrategyModel() {
return new SelectionModel<ImportStrategy>(importStrategy, importStrategyValidator);
}
public SelectionModel<GSContent> getGSContentSelectionModel() {
return new SelectionModel<GSContent>(guide, guideValidator);
}
public MultiSelectionModel<String> getCodeSetModel() {
return new MultiSelectionModel<String>(codesets, codesetValidator);
}
public LiveExpression<Boolean> isDownloaded() {
return isDownloaded;
}
public LiveVariable<Boolean> getEnableOpenHomePage() {
return enableOpenHomePage;
}
public void setItem(GSContent guide) {
this.guide.setValue(guide);
}
/**
* The 'raw' selection in the UI will be sent here. I.e. selected object will
* be sent whether it is actual content or a ContentTypeNode.
* <p>
* Normally clients shouldn't be interested in this selection. It is used
* to allow the Description section of the UI to display descriptions for
* any selected item, including non-content nodes in the tree.
*/
public LiveVariable<Object> getRawSelection() {
return this.rawSelection;
}
public ContentManager getContentManager() {
return contentManager;
}
public void setContentManager(ContentManager contentManager) {
this.contentManager = contentManager;
}
}