plugins/org.eclipse.wst.server.ui/serverui/org/eclipse/wst/server/ui/internal/extension/ExtensionUtility.java

/*******************************************************************************
 * Copyright (c) 2007 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.wst.server.ui.internal.extension;

import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.update.configuration.IConfiguredSite;
import org.eclipse.update.configuration.ILocalSite;
import org.eclipse.update.core.IFeature;
import org.eclipse.update.core.IFeatureReference;
import org.eclipse.update.core.ISite;
import org.eclipse.update.core.IURLEntry;
import org.eclipse.update.core.IVerificationListener;
import org.eclipse.update.core.IVerificationResult;
import org.eclipse.update.core.SiteManager;
import org.eclipse.update.core.VersionedIdentifier;
import org.eclipse.wst.server.core.internal.IInstallableServer;
import org.eclipse.wst.server.core.internal.IMemento;
import org.eclipse.wst.server.core.internal.InstallableServer;
import org.eclipse.wst.server.core.internal.ServerPlugin;
import org.eclipse.wst.server.core.internal.XMLMemento;
import org.eclipse.wst.server.ui.internal.Messages;
import org.eclipse.wst.server.ui.internal.ProgressUtil;
import org.eclipse.wst.server.ui.internal.ServerUIPlugin;
import org.eclipse.wst.server.ui.internal.Trace;
import org.eclipse.wst.server.ui.internal.wizard.ExtensionWizard;

public class ExtensionUtility {
	public static boolean launchExtensionWizard(Shell shell, String title, String message) {
		ExtensionWizard wizard2 = new ExtensionWizard(title, message);
		WizardDialog dialog = new WizardDialog(shell, wizard2);
		if (dialog.open() != Window.CANCEL)
			return true;
		return false;
	}

	public static ExtensionSite[] getExtensionItems(URL url) throws CoreException {
		InputStream in = null;
		try {
			in = url.openStream();
		} catch (Exception e) {
			Trace.trace(Trace.SEVERE, "Could not load URL " + url);
		}
		
		if (in == null)
			throw new CoreException(new Status(IStatus.ERROR, ServerUIPlugin.PLUGIN_ID, 0, "Could not load extensions", null));
		
		try {
			IMemento memento = XMLMemento.loadMemento(in);
			IMemento children[] = memento.getChildren("site");
			int size = children.length;
			List list = new ArrayList(size);
			for (int i = 0; i < size; i++) {
				ExtensionSite item = new ExtensionSite(children[i]);
				list.add(item);
			}
			
			ExtensionSite[] items = new ExtensionSite[list.size()];
			list.toArray(items);
			return items;
		} catch (Exception e) {
			throw new CoreException(new Status(IStatus.ERROR, ServerUIPlugin.PLUGIN_ID, 0, e.getMessage(), e));
		}
	}

	/**
	 * Returns an array of all known extension items.
	 * <p>
	 * A new array is returned on each call, so clients may store or modify the result.
	 * </p>
	 * 
	 * @return the array of extensions items {@link ExtensionSite}
	 */
	public static ExtensionSite[] getExtensionItems() {
		URL url = ServerUIPlugin.getInstance().getBundle().getEntry("serverAdapterSites.xml");
		
		try {
			return getExtensionItems(url);
		} catch (CoreException ce) {
			Trace.trace(Trace.SEVERE, "Could not get extension items");
			return null;
		}
	}

	public static void addFeature(List list, List existing, IFeature newFeature, FeatureListener listener) {
		if (existing.contains(newFeature))
			return;
		
		VersionedIdentifier newVi = newFeature.getVersionedIdentifier();
		IFeature remove = null;
		
		Iterator iterator = list.iterator();
		while (iterator.hasNext()) {
			IFeature feature = (IFeature) iterator.next();
			VersionedIdentifier vi = feature.getVersionedIdentifier(); 
			if (vi.getIdentifier().equals(newVi.getIdentifier())) {
				//Version nextCand = new Version(features[i].getVersionedIdentifier().getVersion().toString());
				if (newVi.getVersion().isGreaterOrEqualTo(vi.getVersion())) {
					remove = feature;
				} else // new feature is older
					return;
			}
		}
		if (remove != null) {
			list.remove(remove);
			listener.featureRemoved(remove);
		}
		
		list.add(newFeature);
		listener.featureFound(newFeature);
		
		try {
			Thread.sleep(800);
		} catch (Exception s) {
			//
		}
	}

	public static void addFeatures(List list, List existing, List newFeatures, FeatureListener listener) {
		Iterator iterator = newFeatures.iterator();
		while (iterator.hasNext()) {
			addFeature(list, existing, (IFeature) iterator.next(), listener);
		}
	}

	public interface FeatureListener {
		public void featureFound(IFeature feature);
		public void featureRemoved(IFeature feature);
		public void siteFailure(ISite site, CoreException ce);
	}

	protected static List getExistingFeatures(IProgressMonitor monitor) throws CoreException {
		monitor.beginTask(Messages.installableServerLocal, 100);
		ILocalSite site = SiteManager.getLocalSite();
		IConfiguredSite[] sites = site.getCurrentConfiguration().getConfiguredSites();
		int size = sites.length;
		List list = new ArrayList(200);
		for (int i = 0; i < size; i++) {
			IFeatureReference[] refs = sites[i].getFeatureReferences();
			int size2 = refs.length;
			for (int j = 0; j < size2; j++) {
				IFeature f = refs[j].getFeature(ProgressUtil.getSubMonitorFor(monitor, 5));
				if (!list.contains(f))
					list.add(f);
			}
		}
		monitor.done();
		
		return list;
	}

	public static IFeature[] getAllFeatures(String id, FeatureListener listener, IProgressMonitor monitor) throws CoreException {
		monitor = ProgressUtil.getMonitorFor(monitor);
		monitor.beginTask("", 1100);
		
		monitor.subTask(Messages.installableServerLocal);
		List existing = getExistingFeatures(ProgressUtil.getSubMonitorFor(monitor, 100));
		
		ExtensionSite[] items = ExtensionUtility.getExtensionItems();
		IInstallableServer[] servers = ServerPlugin.getInstallableServers();
		int x = 1000 / (items.length + servers.length);
		
		monitor.worked(50);
		List list = new ArrayList();
		int size = items.length;
		
		for (int i = 0; i < size; i++) {
			try {
				if (monitor.isCanceled())
					return null;
				
				monitor.subTask(NLS.bind(Messages.installableServerSearching, items[i].getUrl()));
				List list2 = items[i].getFeatures(id, ProgressUtil.getSubMonitorFor(monitor, x));
				addFeatures(list, existing, list2, listener);
			} catch (CoreException ce) {
				ce.printStackTrace();
			}
		}
		
		// add installable servers
		size = servers.length;
		for (int i = 0; i < size; i++) {
			if (monitor.isCanceled())
				return null;
			
			InstallableServer is = (InstallableServer) servers[i];
			monitor.subTask(NLS.bind(Messages.installableServerSearching, is.getFromSite()));
			IFeature feature = is.getFeature(ProgressUtil.getSubMonitorFor(monitor, x));
			if (feature != null)
				addFeature(list, existing, feature, listener);
		}
		
		IFeature[] ef = new IFeature[list.size()];
		list.toArray(ef);
		monitor.done();
		return ef;
	}

	public static String getLicense(IFeature feature) {
		IURLEntry license = feature.getLicense();
		if (license != null)
			return license.getAnnotation();
		
		return null;
	}

	public static String getDescription(IFeature feature) {
		IURLEntry license = feature.getDescription();
		if (license != null)
			return license.getAnnotation();
		
		return null;
	}

	/*
	 * @see IInstallableServer#install(IProgressMonitor)
	 */
	public static void install(IFeature feature, IProgressMonitor monitor) throws CoreException {
		try {
			IVerificationListener verificationListener = new IVerificationListener() {
				public int prompt(IVerificationResult result) {
					return CHOICE_INSTALL_TRUST_ONCE;
				}
			};
			SiteManager.getLocalSite().getCurrentConfiguration().getConfiguredSites()[0].install(feature, verificationListener, monitor);
		} catch (CoreException ce) {
			ce.printStackTrace();
		}
		
		try {
			Thread.sleep(1000);
		} catch (Exception e) {
			// ignore
		}
	}
}