/*******************************************************************************
* Copyright (c) 2004, 2006 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.jem.internal.proxy.core;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.*;
import java.util.logging.Level;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.IJobManager;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.debug.core.*;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants;
import org.osgi.framework.Bundle;
import org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo.ContainerPaths;
import org.eclipse.jem.internal.proxy.core.ProxyPlugin.FoundIDs;
import org.eclipse.jem.util.PerformanceMonitorUtil;
import org.eclipse.jem.util.TimerTests;
/**
* This is the used to launch the proxy registries.
* This is a static helper class, it is not meant to be instantiated.
*
* @since 1.0.0
*/
public class ProxyLaunchSupport {
// The key for the persisten property is in ProxyPlugin so that it can set it on startup without
// causing this class to be initialized. We don't want this class initialized until the very last
// moment when needed. This is because it needs UI to be active when initialized to query some
// values and if ProxyPlugin.start() causes this class to initialize, it may be too soon.
//
// If a project's persistent property is set with this value, that means there is at least one
// launch configuration with this project, but none are selected as the default. This is here
// so that we can check in the object contribution that if not set then don't show the menu
// item at all. This is to clean up the popup menu so not so cluttered.
// If the property is trully not set, then there is no default and there are no configurations for it.
public static final String NOT_SET = "...not..set.."; //$NON-NLS-1$
public static final String EXPRESSION_TRACING = "/debug/traceexpressions"; // Trace IExpressions. //$NON-NLS-1$
/**
* Timer threshold for indicating any expressions that took longer than this.
* If not set, then threshold will default to 100ms.
* It will only be used if traceexpressions is true.
*/
public static final String EXPRESSION_TRACEING_TIMER_THRESHOLD = "/debug/traceexpressionstimethreshold"; //$NON-NLS-1$
/*
* Registry of launch key to LaunchInfo classes.
*/
private static Map LAUNCH_INFO = new HashMap(2);
/**
* Public only for access by other launch delegates to set up if they go outside of ProxyLaunchSupport,
* e.g. IDE proxy. Must not be used for any purpose.
*
* @since 1.0.0
*/
public static class LaunchSupportIConfigurationContributionInfo implements IConfigurationContributionInfo {
/**
* Construct with no settings. This is to be used by other launch delegates that
* don't have a {@link FoundIDs} available to fill in the fields. Those
* delegates must fill the fields themselves.
*
*
* @since 1.2.0
*/
public LaunchSupportIConfigurationContributionInfo(IJavaProject javaProject) {
this.javaProject = javaProject;
}
public LaunchSupportIConfigurationContributionInfo(IJavaProject javaProject, FoundIDs foundIDs) {
this(javaProject);
containerIds = foundIDs.containerIds;
containers = foundIDs.containers;
pluginIds = foundIDs.pluginIds;
projectPaths = foundIDs.projects;
}
/* (non-Javadoc)
* Map of containers (IClasspathContainer) found in classpath (including required projects).
* This is for each project found. If there was a container in more than one project with the
* id, this set will contain the container from each such project. They are not considered the
* same because they come from a different project.
* <p>
* The key will be the containers, and the value will be a <code>Boolean</code>, where true means it
* is visible to the top-level project.
* <p>
* This is used for determining if a project's container implements the desired contributor.
*
* Will be empty if no project sent in to launch configuration.
*
* @see org.eclipse.jdt.core.IClasspathContainer
*
*/
public Map containers = Collections.EMPTY_MAP;
/* (non-Javadoc)
* Map of unique container id strings found in classpath (including required projects).
* If a container with the same id was found in more than one project, only one id will
* be in this set since they are the same.
* <p>
* The key will be the container ids, and the value will be ContainerPaths
*
* Will be empty if no project sent in to launch configuration.
*
*/
public Map containerIds = Collections.EMPTY_MAP;
/* (non-Javadoc)
* Set of unique plugin id strings found in classpath (including required projects).
* If a required plugin with the same id was found in more than one project, only one id will
* be in this set since they are the same.
* <p>
* The key will be the plugin ids, and the value will be a <code>Boolean</code>, where true means it
* is visible to the top-level project.
*
* Will be empty if no project sent in to launch configuration.
*/
public Map pluginIds = Collections.EMPTY_MAP;;
/* (non-Javadoc)
* Map of unique projects found in classpath (including required projects), but not including top-level project.
* <p>
* The key will be the <code>IPath</code> for the project, and the value will be a <code>Boolean</code>, where true means it
* is visible to the top-level project.
*
* Will be <code>null</code> if no project sent in to launch configuration.
*/
public Map projectPaths;
/* (non-Javadoc)
* Java project for this launch. <code>null</code> if not for a project.
*/
public IJavaProject javaProject;
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getContainerIds()
*/
public Map getContainerIds() {
return containerIds;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getContainers()
*/
public Map getContainers() {
return containers;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getJavaProject()
*/
public IJavaProject getJavaProject() {
return javaProject;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getPluginIds()
*/
public Map getPluginIds() {
return pluginIds;
}
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getProjectPaths()
*/
public Map getProjectPaths() {
return projectPaths;
}
}
/**
* LaunchInfo for a launch. Stored by key and retrievable by the key.
* This is only passed to launch delegates. It should not be passed on to
* others, though the IConfigurationContributionInfo may be.
*
* <p>
* This class is not intended to be subclassed by clients.
* </p>
*
* @see ProxyLaunchSupport#getInfo(String)
* @see IConfigurationContributionInfo
* @since 1.0.0
*/
public static class LaunchInfo {
/**
* Contributors for this launch. It will never be <code>null</code>. It may be empty.
*/
public IConfigurationContributor[] contributors;
/**
* The registry returned from the launch. The launch needs to set this before it returns.
*/
public ProxyFactoryRegistry resultRegistry;
/* (non-Javadoc)
* @see org.eclipse.jem.internal.proxy.core.IConfigurationContributionInfo#getJavaProject()
*/
public IJavaProject getJavaProject() {
return configInfo.getJavaProject();
}
/**
* Return the IConfigurationContributionInfo for this launch.
* @return
*
* @since 1.0.0
*/
public IConfigurationContributionInfo getConfigInfo() {
return configInfo;
}
protected IConfigurationContributionInfo configInfo;
}
/**
* Start an implementation using the default config for the given project.
* <p>
* This will wait for build. If you
* know the build has been suspended by your thread, then you must use the other method that takes a waitForThread
* boolean, and you must pass in false. Otherwise it will deadlock.
*
* @param project The project. It must be a java project, and it cannot be <code>null</code>.
* @param vmTitle title for VM. It may be <code>null</code>.
* @param aContribs The contributions array. It may be <code>null</code>.
* @param pm
* @return The created registry.
* @throws CoreException
*
* @see ProxyLaunchSupport#startImplementation(IProject, String, IConfigurationContributor[], boolean, IProgressMonitor)
* @since 1.0.0
*/
public static ProxyFactoryRegistry startImplementation(
IProject project,
String vmTitle,
IConfigurationContributor[] aContribs,
IProgressMonitor pm)
throws CoreException {
return startImplementation(project, vmTitle, aContribs, true, pm);
}
/**
* Start an implementation using the default config for the given project.
* <p>
* If you know the build has been suspended by your thread, then you must use call this with false for waitForThread. Otherwise it will deadlock.
*
* @param project The project. It must be a java project, and it cannot be <code>null</code>.
* @param vmTitle title for VM. It may be <code>null</code>.
* @param aContribs The contributions array. It may be <code>null</code>.
* @param waitForBuild wait for the build. If caller knows that the build has been suspended by this thread, then it must call this with false. Otherwise a deadlock will occur.
* @param pm
* @return The created registry.
* @throws CoreException
*
* @since 1.0.0
*/
public static ProxyFactoryRegistry startImplementation(
IProject project,
String vmTitle,
IConfigurationContributor[] aContribs,
boolean waitForBuild,
IProgressMonitor pm)
throws CoreException {
// First find the appropriate launch configuration to use for this project.
// The process is:
// 1) See if the project's persistent property has a setting for "proxyLaunchConfiguration", if it does,
// get the configuration of that name and create a working copy of it.
// 2) If not, then get the "org.eclipse.jem.proxy.LocalProxyLaunchConfigurationType"
// and create a new instance working copy.
IJavaProject javaProject = JavaCore.create(project);
if (javaProject == null) {
throw new CoreException(
new Status(
IStatus.WARNING,
ProxyPlugin.getPlugin().getBundle().getSymbolicName(),
0,
MessageFormat.format(
ProxyMessages.Not_Java_Project_WARN_,
new Object[] { project.getName()}),
null));
}
// First if specific set.
String launchName = project.getPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION);
ILaunchConfiguration config = null;
if (launchName != null && !NOT_SET.equals(launchName)) {
ILaunchConfiguration[] configs = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurations();
for (int i = 0; i < configs.length; i++) {
if (configs[i].getName().equals(launchName)) {
config = configs[i];
break;
}
}
if (config == null || !config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, "").equals(project.getName())) { //$NON-NLS-1$
project.setPersistentProperty(ProxyPlugin.PROPERTY_LAUNCH_CONFIGURATION, (String) null); // Config not found, or for a different project, so no longer the default.
config = null;
}
}
if (config == null) {
ILaunchConfigurationWorkingCopy configwc = DebugPlugin.getDefault().getLaunchManager().getLaunchConfigurationType(IProxyConstants.LOCAL_LAUNCH_TYPE).newInstance(null, DebugPlugin.getDefault().getLaunchManager().generateUniqueLaunchConfigurationNameFrom("LocalProxy_"+project.getName())); //$NON-NLS-1$
configwc.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, project.getName());
config = configwc;
}
return startImplementation(config, vmTitle, aContribs, waitForBuild, pm);
}
/**
* Launch a registry using the given configuration.
* <p>
* This will wait for build. If you
* know the build has been suspended by your thread, then you must use the other method that takes a waitForThread
* boolean, and you must pass in false. Otherwise it will deadlock.
*
* @param config
* @param vmTitle title for VM. It may be <code>null</code>.
* @param aContribs The contributions array. It may be <code>null</code>.
* @param pm
* @return The registry from this configuration.
* @throws CoreException
*
* @see ProxyLaunchSupport#startImplementation(ILaunchConfiguration, String, IConfigurationContributor[], boolean, IProgressMonitor)
* @since 1.0.0
*/
public static ProxyFactoryRegistry startImplementation(
ILaunchConfiguration config,
String vmTitle,
IConfigurationContributor[] aContribs,
IProgressMonitor pm)
throws CoreException {
return startImplementation(config, vmTitle, aContribs, true, pm);
}
/**
* Launch a registry using the given configuration.
* <p>
* If you know the build has been suspended by your thread, then you must use you must pass in false for waitForThread. Otherwise it will deadlock.
*
* @param config
* @param vmTitle title for VM. It may be <code>null</code>.
* @param aContribs The contributions array. It may be <code>null</code>.
* @param waitForBuild wait for the build. If caller knows that the build has been suspended by this thread, then it must call this with false. Otherwise a deadlock will occur.
* @param pm
* @return The registry from this configuration.
* @throws CoreException
*
* @since 1.0.0
*/
public static ProxyFactoryRegistry startImplementation(
ILaunchConfiguration config,
String vmTitle,
IConfigurationContributor[] aContribs,
boolean waitForBuild,
IProgressMonitor pm)
throws CoreException {
if (pm == null)
pm = new NullProgressMonitor();
String stepId = "Pre-launch VM ( " + vmTitle + " )"; //$NON-NLS-1$ //$NON-NLS-2$
TimerTests.basicTest.startStep(stepId);
if (vmTitle.equals("Beaninfo")) //$NON-NLS-1$
PerformanceMonitorUtil.getMonitor().snapshot(125);
final ILaunchConfigurationWorkingCopy configwc = config.getWorkingCopy();
pm.beginTask("", 400); //$NON-NLS-1$
pm.subTask(ProxyMessages.ProxyLaunch);
if (waitForBuild) {
// See if build needed or waiting or inprogress, if so, wait for it to complete. We've
// decided too difficult to determine if build would affect us or not, so just wait.
if (UI_RUNNER != null)
UI_RUNNER.handleBuild(new SubProgressMonitor(pm, 100));
else
runBuild(new SubProgressMonitor(pm, 100));
if (pm.isCanceled())
return null;
}
if (aContribs != null) {
IConfigurationContributor[] newContribs = new IConfigurationContributor[aContribs.length+1];
System.arraycopy(aContribs, 0, newContribs, 1, aContribs.length);
newContribs[0] = new ProxyContributor();
aContribs = newContribs;
} else
aContribs = new IConfigurationContributor[] {new ProxyContributor()};
String launchKey = String.valueOf(System.currentTimeMillis());
LaunchInfo launchInfo = new LaunchInfo();
synchronized (ProxyLaunchSupport.class) {
while (LAUNCH_INFO.containsKey(launchKey)) {
launchKey += 'a'; // Just add something on to make it unique.
}
LAUNCH_INFO.put(launchKey, launchInfo);
}
String projectName = configwc.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, (String) null);
aContribs = fillInLaunchInfo(aContribs, launchInfo, projectName);
try {
configwc.setAttribute(IProxyConstants.ATTRIBUTE_LAUNCH_KEY, launchKey);
if (vmTitle != null && vmTitle.length()>0)
configwc.setAttribute(IProxyConstants.ATTRIBUTE_VM_TITLE, vmTitle);
if (ATTR_PRIVATE != null)
configwc.setAttribute(ATTR_PRIVATE, true);
// Let contributors modify the configuration.
final IConfigurationContributor[] contribs = aContribs;
final LaunchInfo linfo = launchInfo;
for (int i = 0; i < contribs.length; i++) {
// First run the initialize.
// Run in safe mode so that anything happens we don't go away.
final int ii = i;
SafeRunner.run(new ISafeRunnable() {
public void handleException(Throwable exception) {
// Don't need to do anything. Platform.run logs it for me.
}
public void run() throws Exception {
contribs[ii].initialize(linfo.getConfigInfo());
}
});
// Now run the contribute to configuration.
// Run in safe mode so that anything happens we don't go away.
SafeRunner.run(new ISafeRunnable() {
public void handleException(Throwable exception) {
// Don't need to do anything. Platform.run logs it for me.
}
public void run() throws Exception {
contribs[ii].contributeToConfiguration(configwc);
}
});
}
pm.worked(100);
configwc.launch(ILaunchManager.RUN_MODE, new SubProgressMonitor(pm, 100));
final ProxyFactoryRegistry reg = launchInfo.resultRegistry;
if (!pm.isCanceled() && reg == null)
throw new CoreException(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, ProxyMessages.ProxyLaunchSupport_RegistryCouldNotStartForSomeReason_WARN_, null));
if (pm.isCanceled()) {
if (reg != null)
reg.terminateRegistry();
return null;
}
performExtensionRegistrations((BaseProxyFactoryRegistry) reg, launchInfo);
// TimerTests.basicTest.startStep("contribute to registry");
for (int i = 0; i < contribs.length; i++) {
final int ii = i;
// Run in safe mode so that anything happens we don't go away.
SafeRunner.run(new ISafeRunnable() {
public void handleException(Throwable exception) {
// Don't need to do anything. Platform.run logs it for me.
}
public void run() throws Exception {
// String stepid = "contribute to registry for " + contribs[ii].getClass();
// TimerTests.basicTest.startStep(stepid);
contribs[ii].contributeToRegistry(reg);
// TimerTests.basicTest.stopStep(stepid);
}
});
}
// TimerTests.basicTest.stopStep("contribute to registry");
} finally {
// Clean up and return.
LAUNCH_INFO.remove(launchKey);
}
pm.done();
if (vmTitle.equals("Beaninfo")) //$NON-NLS-1$
PerformanceMonitorUtil.getMonitor().snapshot(126);
TimerTests.basicTest.stopStep(stepId);
return launchInfo.resultRegistry;
}
/**
* Create a default IConfigurationContributionInfo for the given project. This is useful info even when not launching a
* vm.
*
* @param javaProject
* @return new contrib info.
* @throws JavaModelException
*
* @since 1.1.0
*/
public static IConfigurationContributionInfo createDefaultConfigurationContributionInfo(IJavaProject javaProject) throws JavaModelException {
LaunchSupportIConfigurationContributionInfo configInfo = new LaunchSupportIConfigurationContributionInfo(javaProject,
ProxyPlugin.getPlugin().getIDsFound(javaProject));
return configInfo;
}
/**
* Use in calling {@link ProxyLaunchSupport#fillInLaunchInfo(IConfigurationContributor[], LaunchInfo, String)} for the configuration
* contributors array if there are no incoming contributors.
*
* @since 1.1.0
*/
public static final IConfigurationContributor[] EMPTY_CONFIG_CONTRIBUTORS = new IConfigurationContributor[0];
/**
* Fill in the launch info config info and contribs. The contribs sent in may be expanded due to extension
* points and a new one created. Either the expanded copy or the original (if no change) will be stored in
* the launchinfo and returned from this call.
*
* @param aContribs this should never be <code>null</code>. Pass in {@link ProxyLaunchSupport#EMPTY_CONFIG_CONTRIBUTORS} in that case.
* @param launchInfo
* @param projectName
* @return a modified aContribs if any change was made to it. This will never be <code>null</code>. It will return an empty list if aContribs was null and no changes were made.
* @throws JavaModelException
* @throws CoreException
*
* @since 1.0.0
*/
public static IConfigurationContributor[] fillInLaunchInfo(IConfigurationContributor[] aContribs, LaunchInfo launchInfo, String projectName) throws JavaModelException, CoreException {
if (projectName != null) {
projectName = projectName.trim();
if (projectName.length() > 0) {
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
IJavaProject javaProject = JavaCore.create(project);
if (javaProject != null && javaProject.exists()) {
launchInfo.configInfo = createDefaultConfigurationContributionInfo(javaProject);
if (!launchInfo.configInfo.getContainerIds().isEmpty() || !launchInfo.configInfo.getContainers().isEmpty() || !launchInfo.configInfo.getPluginIds().isEmpty()) {
List computedContributors = new ArrayList(launchInfo.configInfo.getContainerIds().size()+launchInfo.configInfo.getContainers().size()+launchInfo.configInfo.getPluginIds().size());
// Note: We don't care about the visibility business here. For contributors to proxy it means
// some classes in the projects/plugins/etc. need configuration whether they are visible or not.
// This is because even though not visible, some other visible class may instantiate it. So it
// needs the configuration.
// First handle explicit classpath containers that implement IConfigurationContributor
for (Iterator iter = launchInfo.configInfo.getContainers().keySet().iterator(); iter.hasNext();) {
IClasspathContainer container = (IClasspathContainer) iter.next();
if (container instanceof IConfigurationContributor)
computedContributors.add(container);
}
// Second add in contributors that exist for a container id.
for (Iterator iter = launchInfo.configInfo.getContainerIds().values().iterator(); iter.hasNext();) {
ContainerPaths paths = (ContainerPaths) iter.next();
IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getContainerConfigurations(paths.getContainerId(), paths.getAllPaths());
if (contributors != null)
for (int i = 0; i < contributors.length; i++) {
Object contributor = contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
if (contributor instanceof IConfigurationContributor)
computedContributors.add(contributor);
}
}
// Finally add in contributors that exist for a plugin id.
for (Iterator iter = launchInfo.configInfo.getPluginIds().keySet().iterator(); iter.hasNext();) {
String pluginId = (String) iter.next();
IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getPluginConfigurations(pluginId);
if (contributors != null)
for (int i = 0; i < contributors.length; i++) {
Object contributor = contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
if (contributor instanceof IConfigurationContributor)
computedContributors.add(contributor);
}
}
// Now turn into array
if (!computedContributors.isEmpty()) {
IConfigurationContributor[] newContribs = new IConfigurationContributor[aContribs.length
+ computedContributors.size()];
System.arraycopy(aContribs, 0, newContribs, 0, aContribs.length);
IConfigurationContributor[] cContribs = (IConfigurationContributor[]) computedContributors
.toArray(new IConfigurationContributor[computedContributors.size()]);
System.arraycopy(cContribs, 0, newContribs, aContribs.length, cContribs.length);
aContribs = newContribs;
}
}
}
}
}
launchInfo.contributors = aContribs;
return aContribs;
}
/**
* Execute the extension registrations that are valid for this type of registry and the launchinfo paths.
* <p>
* This is meant to be called only by registry implementations that do not launch through a launch configration after the registry is created but
* before the {@link IConfigurationContributor#contributeToRegistry(ProxyFactoryRegistry)} is called. This will be called automatically
* by registries that used a launch configuration to launch.
*
* @param baseRegistry
* @param launchInfo
* @throws CoreException
*
* @since 1.1.0
*/
public static void performExtensionRegistrations(final BaseProxyFactoryRegistry baseRegistry, LaunchInfo launchInfo) throws CoreException {
IConfigurationContributionInfo configInfo = launchInfo.configInfo;
if (configInfo != null && (!configInfo.getContainerIds().isEmpty() || !configInfo.getPluginIds().isEmpty())) {
String registryID = baseRegistry.getRegistryTypeID();
// Note: We don't care about the visibility business here. For contributors to proxy it means
// some classes in the projects/plugins/etc. need configuration whether they are visible or not.
// This is because even though not visible, some other visible class may instantiate it. So it
// needs the configuration.
// First call registrations that exist for a container id.
for (Iterator iter = configInfo.getContainerIds().values().iterator(); iter.hasNext();) {
ContainerPaths paths = (ContainerPaths) iter.next();
IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getContainerExtensions(paths.getContainerId(), paths.getAllPaths());
if (contributors != null)
for (int i = 0; i < contributors.length; i++) {
if (registryID.equals(contributors[i].getAttribute(ProxyPlugin.PI_REGISTRY_TYPE))) {
try {
final IExtensionRegistration contributor = (IExtensionRegistration) contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
SafeRunner.run(new ISafeRunnable() {
public void run() throws Exception {
contributor.register(baseRegistry);
}
public void handleException(Throwable exception) {
// Don't need to do anything, Platform logs it for me.
}
});
} catch (ClassCastException e) {
// If not right class, just ignore it.
}
}
}
}
// Finally add in contributors that exist for a plugin id.
for (Iterator iter = configInfo.getPluginIds().keySet().iterator(); iter.hasNext();) {
String pluginId = (String) iter.next();
IConfigurationElement[] contributors = ProxyPlugin.getPlugin().getPluginExtensions(pluginId);
if (contributors != null)
for (int i = 0; i < contributors.length; i++) {
if (registryID.equals(contributors[i].getAttribute(ProxyPlugin.PI_REGISTRY_TYPE))) {
try {
final IExtensionRegistration contributor = (IExtensionRegistration) contributors[i].createExecutableExtension(ProxyPlugin.PI_CLASS);
SafeRunner.run(new ISafeRunnable() {
public void run() throws Exception {
contributor.register(baseRegistry);
}
public void handleException(Throwable exception) {
// Don't need to do anything, Platform logs it for me.
}
});
} catch (ClassCastException e) {
// If not right class, just ignore it.
}
}
}
}
}
}
/*
* Run the build. If the original launch was in the UI thread, this will
* be called under control of an IProgressService so that it is in a separate
* thread and the UI will remain responsive (in that either a busy cursor comes
* up or eventually a progress dialog).
* If the pm is canceled, this will just return, but the caller must check if the pm is canceled.
*
* <package-protected> so that only the UI handler will access it.
*/
static void runBuild(IProgressMonitor pm) throws CoreException {
boolean autobuilding = ResourcesPlugin.getWorkspace().isAutoBuilding();
if (!autobuilding) {
try {
// We are not autobuilding. So kick off a build right here and
// wait for it. (If we already within a build on this thread, then this
// will return immediately without building. We will take that risk. If
// some other thread is building, we will wait for it finish before we
// can get it and do our build.
ResourcesPlugin.getWorkspace().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, pm);
} catch (OperationCanceledException e) {
// The pm is already marked canceled, so caller can check that instead.
}
} else {
pm.beginTask("", 200); //$NON-NLS-1$
IJobManager jobManager = Job.getJobManager();
Job currentJob = jobManager.currentJob();
if (currentJob == null || (!currentJob.belongsTo(ResourcesPlugin.FAMILY_AUTO_BUILD) && !currentJob.belongsTo(ResourcesPlugin.FAMILY_MANUAL_BUILD))) {
if (jobManager.find(ResourcesPlugin.FAMILY_AUTO_BUILD).length > 0 || jobManager.find(ResourcesPlugin.FAMILY_MANUAL_BUILD).length >0) {
// We are not within a build job. If we were, then we don't do the build. We will take
// that risk. The problem is that if within the build, we can't wait for it to finish because
// we would stop the thread and so the build would not complete.
pm.subTask(ProxyMessages.ProxyWaitForBuild);
try {
while (true) {
try {
jobManager.join(ResourcesPlugin.FAMILY_AUTO_BUILD, new SubProgressMonitor(pm, 100));
jobManager.join(ResourcesPlugin.FAMILY_MANUAL_BUILD, new SubProgressMonitor(pm, 100));
break;
} catch (InterruptedException e) {
}
}
} catch (OperationCanceledException e) {
}
}
}
pm.done();
}
}
/*
* This prevents the launch from being shown. However these constants are in UI component, and we don't
* want to pre-req that. So we will get them reflectively instead.
* public but only so that launch delegate can get to it.
*/
public static String ATTR_PRIVATE;
private static IUIRunner UI_RUNNER = null;
static {
ATTR_PRIVATE = null;
try {
// See if we have a UI bundle and it is active. If it exists but is not active,
// then we won't do anything. If we were running a UI application, it should already
// of been active before we got here.
Bundle uiBundle = Platform.getBundle("org.eclipse.ui"); //$NON-NLS-1$
if (uiBundle != null && uiBundle.getState() == Bundle.ACTIVE) {
try {
// We have a UI bundle, so we can load our UIRunner class and it will load fine.
UI_RUNNER = (IUIRunner) Class.forName("org.eclipse.jem.internal.proxy.core.UIRunner").newInstance(); //$NON-NLS-1$
} catch (InstantiationException e1) {
ProxyPlugin.getPlugin().getLogger().log(e1, Level.WARNING);
}
// So that we can run headless (w/o ui), need to do class forName for debugui contants
Bundle debuguiBundle = Platform.getBundle("org.eclipse.debug.ui"); //$NON-NLS-1$
if (debuguiBundle != null && debuguiBundle.getState() == Bundle.ACTIVE) {
Class debugUIConstants = debuguiBundle.loadClass("org.eclipse.debug.ui.IDebugUIConstants"); //$NON-NLS-1$
ATTR_PRIVATE = (String) debugUIConstants.getField("ATTR_PRIVATE").get(null); //$NON-NLS-1$
}
}
} catch (SecurityException e) {
} catch (ClassNotFoundException e) {
} catch (NoSuchFieldException e) {
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
}
}
/* (non-Javadoc)
* Only referenced by launch delegates. public because they are in other packages,
* or even external developers packages. Not meant to be generally available.
*
* This is needed because we can't pass the generic info into a launch configuration
* because a launch configuration can't take objects. Only can take strings and numbers.
*/
public static synchronized LaunchInfo getInfo(String key) {
return (LaunchInfo) LAUNCH_INFO.get(key);
}
/**
* Convert the string path into a valid url.
* @param path
* @return the url or <code>null</code> if not convertable (i.e. not well-formed).
*
* @since 1.0.0
*/
public static URL convertStringPathToURL(String path) {
try {
return path != null ? new File(path).toURL() : null;
} catch (MalformedURLException e) {
return null;
}
}
/**
* Convert the string paths into a valid urls.
*
* @param paths
* @return the urls or <code>null</code> if paths is null. Any path not convertable (i.e. not well-formed) will not be in the final list.
* So this means the result length may be smaller than the paths length.
*
* @since 1.0.0
*/
public static URL[] convertStringPathsToURL(String[] paths) {
if (paths != null) {
URL[] result = new URL[paths.length];
int nextURL = 0;
for (int i = 0; i < paths.length; i++) {
URL url = convertStringPathToURL(paths[i]);
if (url != null)
result[nextURL++] = url;
}
if (nextURL == 0)
return null; // None were found.
if (nextURL != result.length) {
URL[] nr = new URL[nextURL];
System.arraycopy(result, 0, nr, 0, nr.length);
result = nr;
}
return result;
} else
return null;
}
/**
* Convert the urls to string array. It is assumed the urls are in file protocol. It handles platform and JDK reqts. too.
* @param urls
* @return string paths or <code>null</code> if urls is <code>null</code>. Any <code>null</code> entry of urls will result in
* a corresponding <code>null</code> in the strings.
*
* @since 1.0.0
*/
public static String[] convertURLsToStrings(URL[] urls) {
if (urls != null) {
String[] strings = new String[urls.length];
for (int i = 0; i < urls.length; i++) {
// [132378] There is a problem with IBM JDK's. They can't handle the getFile() from a URL in the java lib path on Windows.
// That is because the normalized format of a file url on windows is "file:/D:/asdfasf". But IBM JDKs can't handle the
// leading slash. Sun JDKs do.
URL url = urls[i];
if (url != null) {
strings[i] = url.getFile();
if(strings[i].startsWith("/") && Platform.getOS().equals(Platform.OS_WIN32)) //$NON-NLS-1$
strings[i] = strings[i].substring(1);
}
}
return strings;
} else
return null;
}
/* (non-Javadoc)
* Local contributor used to make sure that certain jars are in the path.
*
* @since 1.0.0
*/
static class ProxyContributor extends ConfigurationContributorAdapter {
public void contributeClasspaths(IConfigurationContributionController controller) {
// Add the required jars to the end of the classpath. (We want proxyCommon and initParser (+ initParser NLS), but they are in the runtime of the proxy bundle (which is jarred up), so we contribute the bundle instead.
controller.contributeClasspath(ProxyPlugin.getPlugin().getBundle(), (IPath) null, IConfigurationContributionController.APPEND_USER_CLASSPATH, true); //$NON-NLS-1$
}
}
}