publisher/eclipse/EclipseInstallAction.java

/*******************************************************************************
 * Copyright (c) 2008, 2017 Code 9 and others.
 *
 * This
 * program and the accompanying materials are made available under the terms of
 * the Eclipse Public License 2.0 which accompanies this distribution, and is
 * available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *   Code 9 - initial API and implementation
 *   IBM - ongoing development
 ******************************************************************************/
package org.eclipse.equinox.p2.publisher.eclipse;

import java.io.File;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.p2.publisher.eclipse.ExecutablesDescriptor;
import org.eclipse.equinox.p2.metadata.IVersionedId;
import org.eclipse.equinox.p2.metadata.Version;
import org.eclipse.equinox.p2.publisher.*;
import org.eclipse.equinox.p2.publisher.actions.*;

public class EclipseInstallAction extends AbstractPublisherAction {
	protected String source;
	protected String id;
	protected Version version;
	protected String name;
	protected String executableName;
	protected String flavor;
	protected IVersionedId[] topLevel;
	protected String[] nonRootFiles;
	protected boolean start = false;

	protected EclipseInstallAction() {
		//hidden
	}

	public EclipseInstallAction(String source, String id, Version version, String name, String executableName, String flavor, IVersionedId[] topLevel, String[] nonRootFiles, boolean start) {
		this.source = source;
		this.id = id;
		this.version = version;
		this.name = name == null ? id : name;
		this.executableName = executableName == null ? "eclipse" : executableName; //$NON-NLS-1$
		this.flavor = flavor;
		this.topLevel = topLevel;
		this.nonRootFiles = nonRootFiles;
		this.start = start;
	}

	@Override
	public IStatus perform(IPublisherInfo publisherInfo, IPublisherResult results, IProgressMonitor monitor) {
		monitor = SubMonitor.convert(monitor);
		this.info = publisherInfo;
		IPublisherAction[] actions = createActions();
		MultiStatus finalStatus = new MultiStatus(EclipseInstallAction.class.getName(), 0, "publishing result", null); //$NON-NLS-1$
		for (IPublisherAction action : actions) {
			if (monitor.isCanceled())
				return Status.CANCEL_STATUS;
			finalStatus.merge(action.perform(publisherInfo, results, monitor));
		}
		if (!finalStatus.isOK())
			return finalStatus;
		return Status.OK_STATUS;
	}

	protected IPublisherAction[] createActions() {
		createAdvice();
		ArrayList<IPublisherAction> actions = new ArrayList<>();
		// create an action that just publishes the raw bundles and features
		IPublisherAction action = new MergeResultsAction(new IPublisherAction[] {createFeaturesAction(), createBundlesAction()}, IPublisherResult.MERGE_ALL_ROOT);
		actions.add(action);
		actions.add(createApplicationExecutableAction(info.getConfigurations()));
		actions.add(createRootFilesAction());
		actions.addAll(createAccumulateConfigDataActions(info.getConfigurations()));
		actions.add(createJREAction());
		actions.add(createConfigCUsAction());
		actions.add(createDefaultCUsAction());
		actions.add(createRootIUAction());
		return actions.toArray(new IPublisherAction[actions.size()]);
	}

	private void createAdvice() {
		createRootFilesAdvice();
		createRootAdvice();
	}

	protected void createRootAdvice() {
		if (topLevel != null)
			info.addAdvice(new RootIUAdvice(getTopLevel()));
		info.addAdvice(new RootIUResultFilterAdvice(null));
	}

	protected IPublisherAction createDefaultCUsAction() {
		return new DefaultCUsAction(info, flavor, 4, start);
	}

	protected IPublisherAction createRootIUAction() {
		return new RootIUAction(id, version, name);
	}

	protected Collection<IVersionedId> getTopLevel() {
		return Arrays.asList(topLevel);
	}

	protected IPublisherAction createJREAction() {
		return new JREAction((File) null);
	}

	protected IPublisherAction createApplicationExecutableAction(String[] configSpecs) {
		return new ApplicationLauncherAction(id, version, flavor, executableName, getExecutablesLocation(), configSpecs);
	}

	protected Collection<IPublisherAction> createAccumulateConfigDataActions(String[] configs) {
		File configuration = new File(source, "configuration/config.ini"); //$NON-NLS-1$
		if (!configuration.exists())
			configuration = null;

		Collection<IPublisherAction> result = new ArrayList<>(configs.length);
		for (String configSpec : configs) {
			String os = AbstractPublisherAction.parseConfigSpec(configSpec)[1];
			File executable = ExecutablesDescriptor.findExecutable(os, computeExecutableLocation(configSpec), "eclipse"); //$NON-NLS-1$
			if (!executable.exists())
				executable = null;
			IPublisherAction action = new AccumulateConfigDataAction(info, configSpec, configuration, executable);
			result.add(action);
		}

		return result;
	}

	protected IPublisherAction createConfigCUsAction() {
		return new ConfigCUsAction(info, flavor, id, version);
	}

	protected IPublisherAction createFeaturesAction() {
		return new FeaturesAction(new File[] {new File(source, "features")}); //$NON-NLS-1$
	}

	protected Collection<IPublisherAction> createExecutablesActions(String[] configSpecs) {
		Collection<IPublisherAction> result = new ArrayList<>(configSpecs.length);
		for (String configSpec : configSpecs) {
			ExecutablesDescriptor executables = computeExecutables(configSpec);
			IPublisherAction action = new EquinoxExecutableAction(executables, configSpec, id, version, flavor);
			result.add(action);
		}
		return result;
	}

	protected IPublisherAction createRootFilesAction() {
		return new RootFilesAction(info, id, version, flavor);
	}

	protected void createRootFilesAdvice() {
		File[] baseExclusions = computeRootFileExclusions();
		if (baseExclusions != null)
			info.addAdvice(new RootFilesAdvice(null, null, baseExclusions, null));
		String[] configs = info.getConfigurations();
		for (String config : configs) {
			info.addAdvice(computeRootFileAdvice(config));
		}
	}

	protected IPublisherAdvice computeRootFileAdvice(String configSpec) {
		File root = computeRootFileRoot(configSpec);
		File[] inclusions = computeRootFileInclusions(configSpec);
		File[] exclusions = computeRootFileExclusions(configSpec);
		return new RootFilesAdvice(root, inclusions, exclusions, configSpec);
	}

	protected File[] computeRootFileExclusions(String configSpec) {
		ExecutablesDescriptor executables = computeExecutables(configSpec);
		File[] files = executables.getFiles();
		File[] result = new File[files.length + 1];
		System.arraycopy(files, 0, result, 0, files.length);
		result[files.length] = executables.getIniLocation();
		return result;
	}

	protected File[] computeRootFileExclusions() {
		if (nonRootFiles == null || nonRootFiles.length == 0)
			return null;
		ArrayList<File> result = new ArrayList<>();
		for (String filename : nonRootFiles) {
			File file = new File(filename);
			if (file.isAbsolute())
				result.add(file);
			else
				result.add(new File(source, filename));
		}
		return result.toArray(new File[result.size()]);
	}

	protected ExecutablesDescriptor computeExecutables(String configSpec) {
		String os = AbstractPublisherAction.parseConfigSpec(configSpec)[1];
		// TODO here we should not assume that the executable is called "eclipse"
		return ExecutablesDescriptor.createDescriptor(os, "eclipse", computeExecutableLocation(configSpec)); //$NON-NLS-1$
	}

	protected File computeRootFileRoot(String configSpec) {
		return new File(source);
	}

	protected File[] computeRootFileInclusions(String configSpec) {
		return new File[] {new File(source)};
	}

	protected File computeExecutableLocation(String configSpec) {
		return new File(source);
	}

	protected File getExecutablesLocation() {
		return new File(source);
	}

	protected IPublisherAction createBundlesAction() {
		// TODO need to add in the simple configorator and reconciler bundle descriptions.
		// TODO bundles action needs to take bundleDescriptions directly rather than just files.
		return new BundlesAction(new File[] {new File(source, "plugins")}); //$NON-NLS-1$
	}
}