/*******************************************************************************
* Copyright (c) 2003, 2011 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.jst.server.core.internal;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.VMRunnerConfiguration;
import org.eclipse.osgi.service.debug.DebugOptions;
import org.eclipse.osgi.service.debug.DebugOptionsListener;
import org.eclipse.osgi.util.NLS;
import org.eclipse.wst.server.core.IRuntime;
import org.eclipse.wst.server.core.IRuntimeLifecycleListener;
import org.eclipse.wst.server.core.IRuntimeType;
import org.eclipse.wst.server.core.ServerCore;
import org.eclipse.wst.server.core.ServerUtil;
import org.osgi.framework.BundleContext;
/**
* The main server tooling plugin class.
*/
public class JavaServerPlugin extends Plugin {
/**
* Java server plugin id
*/
public static final String PLUGIN_ID = "org.eclipse.jst.server.core";
// singleton instance of this class
private static JavaServerPlugin singleton;
// cached copy of all runtime classpath providers
private static List<RuntimeClasspathProviderWrapper> runtimeClasspathProviders;
// cached copy of all server profilers
private static List<ServerProfiler> serverProfilers;
// runtime listener
private static IRuntimeLifecycleListener runtimeListener;
/**
* Create the JavaServerPlugin.
*/
public JavaServerPlugin() {
super();
singleton = this;
}
/**
* Returns the singleton instance of this plugin.
*
* @return a singleton instance
*/
public static JavaServerPlugin getInstance() {
return singleton;
}
/**
* @see Plugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
super.start(context);
runtimeListener = new IRuntimeLifecycleListener() {
public void runtimeAdded(IRuntime runtime) {
handleRuntimeChange(runtime, 0);
}
public void runtimeChanged(IRuntime runtime) {
handleRuntimeChange(runtime, 1);
}
public void runtimeRemoved(IRuntime runtime) {
handleRuntimeChange(runtime, 2);
}
};
ServerCore.addRuntimeLifecycleListener(runtimeListener);
// register the debug options listener
final Hashtable<String, String> props = new Hashtable<String, String>(4);
props.put(DebugOptions.LISTENER_SYMBOLICNAME, JavaServerPlugin.PLUGIN_ID);
context.registerService(DebugOptionsListener.class.getName(), new Trace(), props);
}
/**
* @see Plugin#stop(org.osgi.framework.BundleContext)
*/
public void stop(BundleContext context2) throws Exception {
ServerCore.removeRuntimeLifecycleListener(runtimeListener);
super.stop(context2);
}
/**
* Handle a runtime change by potentially updating the classpath container.
*
* @param runtime a runtime
*/
protected void handleRuntimeChange(final IRuntime runtime, final int act) {
if (runtime == null)
throw new IllegalArgumentException();
if (Trace.FINEST) {
Trace.trace(Trace.STRING_FINEST, "Possible runtime change: " + runtime);
}
if (runtime.getRuntimeType() == null)
return;
final RuntimeClasspathProviderWrapper rcpw = findRuntimeClasspathProvider(runtime.getRuntimeType());
if (rcpw != null && (rcpw.hasRuntimeClasspathChanged(runtime) || act != 1)) {
final IPath serverContainerPath = new Path(RuntimeClasspathContainer.SERVER_CONTAINER)
.append(rcpw.getId()).append(runtime.getId());
class RebuildRuntimeReferencesJob extends Job {
public RebuildRuntimeReferencesJob() {
super(NLS.bind(Messages.updateClasspathContainers, runtime.getName()));
}
public boolean belongsTo(Object family) {
return ServerUtil.SERVER_JOB_FAMILY.equals(family);
}
public IStatus run(IProgressMonitor monitor) {
IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
if (projects != null) {
for (IProject project : projects) {
if (project.isAccessible()) {
try {
if (!project.isNatureEnabled(JavaCore.NATURE_ID))
continue;
IJavaProject javaProject = JavaCore.create(project);
boolean found = false;
IClasspathEntry[] ce = javaProject.getRawClasspath();
for (IClasspathEntry cp : ce) {
if (cp.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
if (serverContainerPath.isPrefixOf(cp.getPath()))
found = true;
}
}
if (Trace.FINEST) {
Trace.trace(Trace.STRING_FINEST, "Classpath change on: " + project + " " + found);
}
if (found) {
IRuntime runtime2 = runtime;
if (act == 2)
runtime2 = null;
RuntimeClasspathContainer container = new RuntimeClasspathContainer(project,
serverContainerPath, rcpw, runtime2, runtime.getId());
JavaCore.setClasspathContainer(serverContainerPath, new IJavaProject[] { javaProject },
new IClasspathContainer[] {container}, null);
}
} catch (Exception e) {
if (Trace.SEVERE) {
Trace.trace(Trace.STRING_SEVERE, "Could not update classpath container", e);
}
}
}
}
}
return Status.OK_STATUS;
}
}
RebuildRuntimeReferencesJob job = new RebuildRuntimeReferencesJob();
job.schedule();
}
}
/**
* Convenience method for logging.
*
* @param status a status
*/
private static void log(IStatus status) {
getInstance().getLog().log(status);
}
public static void logWarning(String msg) {
log(new Status(IStatus.WARNING, PLUGIN_ID, IStatus.OK, msg, null));
}
/**
* Returns an array of all known runtime classpath provider instances.
* <p>
* A new array is returned on each call, so clients may store or modify the
* result.
* </p>
*
* @return a possibly-empty array of runtime classpath provider instances
* {@link RuntimeClasspathProviderWrapper}
*/
public static RuntimeClasspathProviderWrapper[] getRuntimeClasspathProviders() {
if (runtimeClasspathProviders == null)
loadRuntimeClasspathProviders();
RuntimeClasspathProviderWrapper[] rth = new RuntimeClasspathProviderWrapper[runtimeClasspathProviders.size()];
runtimeClasspathProviders.toArray(rth);
return rth;
}
/**
* Returns the runtime classpath provider that supports the given runtime type, or <code>null</code>
* if none. This convenience method searches the list of known runtime
* classpath providers ({@link #getRuntimeClasspathProviders()}) for the one with
* a matching runtime type.
* The runtimeType may not be null.
*
* @param runtimeType a runtime type
* @return the runtime classpath provider instance, or <code>null</code> if
* there is no runtime classpath provider that supports the given id
*/
public static RuntimeClasspathProviderWrapper findRuntimeClasspathProvider(IRuntimeType runtimeType) {
if (runtimeType == null)
throw new IllegalArgumentException();
if (runtimeClasspathProviders == null)
loadRuntimeClasspathProviders();
Iterator iterator = runtimeClasspathProviders.iterator();
while (iterator.hasNext()) {
RuntimeClasspathProviderWrapper runtimeClasspathProvider = (RuntimeClasspathProviderWrapper) iterator.next();
if (runtimeClasspathProvider.supportsRuntimeType(runtimeType))
return runtimeClasspathProvider;
}
return null;
}
/**
* Returns the runtime classpath provider that supports the given runtime type id,
* or <code>null</code> if none. This convenience method searches the list of known
* runtime classpath providers ({@link #getRuntimeClasspathProviders()}) for the one
* with a matching runtime type id. The id may not be null.
*
* @param id a runtime type id
* @return the runtime classpath provider instance, or <code>null</code> if
* there is no runtime classpath provider that supports the given id
*/
public static RuntimeClasspathProviderWrapper findRuntimeClasspathProviderBySupport(String id) {
if (id == null)
throw new IllegalArgumentException();
if (runtimeClasspathProviders == null)
loadRuntimeClasspathProviders();
Iterator iterator = runtimeClasspathProviders.iterator();
while (iterator.hasNext()) {
RuntimeClasspathProviderWrapper runtimeClasspathProvider = (RuntimeClasspathProviderWrapper) iterator.next();
if (runtimeClasspathProvider.supportsRuntimeType(id))
return runtimeClasspathProvider;
}
return null;
}
/**
* Returns the runtime classpath provider with the given id, or <code>null</code>
* if none. This convenience method searches the list of known runtime
* classpath providers ({@link #getRuntimeClasspathProviders()}) for the one with
* a matching runtime classpath provider id ({@link RuntimeClasspathProviderWrapper#getId()}).
* The id may not be null.
*
* @param id the runtime classpath provider id
* @return the runtime classpath provider instance, or <code>null</code> if
* there is no runtime classpath provider with the given id
*/
public static RuntimeClasspathProviderWrapper findRuntimeClasspathProvider(String id) {
if (id == null)
throw new IllegalArgumentException();
if (runtimeClasspathProviders == null)
loadRuntimeClasspathProviders();
Iterator iterator = runtimeClasspathProviders.iterator();
while (iterator.hasNext()) {
RuntimeClasspathProviderWrapper runtimeClasspathProvider = (RuntimeClasspathProviderWrapper) iterator.next();
if (id.equals(runtimeClasspathProvider.getId()))
return runtimeClasspathProvider;
}
return null;
}
/**
* Load the runtime classpath providers.
*/
private static synchronized void loadRuntimeClasspathProviders() {
if (runtimeClasspathProviders != null)
return;
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, "->- Loading .runtimeClasspathProviders extension point ->-");
}
IExtensionRegistry registry = Platform.getExtensionRegistry();
IConfigurationElement[] cf = registry.getConfigurationElementsFor(JavaServerPlugin.PLUGIN_ID, "runtimeClasspathProviders");
List<RuntimeClasspathProviderWrapper> list = new ArrayList<RuntimeClasspathProviderWrapper>(cf.length);
for (IConfigurationElement ce : cf) {
try {
list.add(new RuntimeClasspathProviderWrapper(ce));
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, " Loaded runtimeClasspathProviders: " + ce.getAttribute("id"));
}
} catch (Throwable t) {
if (Trace.SEVERE) {
Trace.trace(Trace.STRING_SEVERE,
" Could not load runtimeClasspathProviders: " + ce.getAttribute("id"), t);
}
}
}
runtimeClasspathProviders = list;
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, "-<- Done loading .runtimeClasspathProviders extension point -<-");
}
}
/**
* Returns an array of all known server profiler instances.
* <p>
* A new array is returned on each call, so clients may store or modify the result.
* </p>
*
* @return a possibly-empty array of server profiler instances
* {@link ServerProfiler}
*/
public static ServerProfiler[] getServerProfilers() {
if (serverProfilers == null)
loadServerProfilers();
ServerProfiler[] sp = new ServerProfiler[serverProfilers.size()];
serverProfilers.toArray(sp);
return sp;
}
/**
* Load the server profilers.
*/
private static synchronized void loadServerProfilers() {
if (serverProfilers != null)
return;
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, "->- Loading .serverProfilers extension point ->-");
}
IExtensionRegistry registry = Platform.getExtensionRegistry();
IConfigurationElement[] cf = registry.getConfigurationElementsFor(JavaServerPlugin.PLUGIN_ID, "serverProfilers");
List<ServerProfiler> list = new ArrayList<ServerProfiler>(cf.length);
for (IConfigurationElement ce : cf) {
try {
list.add(new ServerProfiler(ce));
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, " Loaded serverProfiler: " + ce.getAttribute("id"));
}
} catch (Throwable t) {
if (Trace.SEVERE) {
Trace.trace(Trace.STRING_SEVERE, " Could not load serverProfiler: " + ce.getAttribute("id"), t);
}
}
}
serverProfilers = list;
if (Trace.CONFIG) {
Trace.trace(Trace.STRING_CONFIG, "-<- Done loading .serverProfilers extension point -<-");
}
}
public static void configureProfiling(ILaunch launch, IVMInstall vmInstall, VMRunnerConfiguration vmConfig, IProgressMonitor monitor) throws CoreException {
ServerProfiler[] sp = JavaServerPlugin.getServerProfilers();
if (sp == null || sp.length == 0)
throw new CoreException(new Status(IStatus.ERROR, JavaServerPlugin.PLUGIN_ID, 0, Messages.errorNoProfiler, null));
String id = ProfilerPreferences.getInstance().getServerProfilerId();
if ( id != null ) {
for ( int i = 0; i < sp.length; i++ ) {
if ( sp[i].getId().equals(id) ) {
sp[i].process(launch, vmInstall, vmConfig, monitor);
return;
}
}
} else {
if ( sp.length == 1 ) {
/* The user has not selected a profiler preference, but there is only one
* registered so we can just call that
*/
sp[0].process(launch, vmInstall, vmConfig, monitor);
} else {
/* We have more than one profiler registered, but the user has not yet
* configured their preference so we don't know which one to call. Throw
* an exception and notify the user must configure the profiler
* before continuing. */
throw new CoreException(new Status(IStatus.ERROR, JavaServerPlugin.PLUGIN_ID, 0,
Messages.noProfilersSelected, null));
}
}
}
}