/*******************************************************************************
* Copyright (c) 2000, 2016 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
* Frits Jalvingh - Contribution for Bug 459831 - [launching] Support attaching
* external annotations to a JRE container
*******************************************************************************/
package org.eclipse.jdt.internal.launching;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.ClasspathContainerInitializer;
import org.eclipse.jdt.core.IClasspathAttribute;
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.IJavaLaunchConfigurationConstants;
import org.eclipse.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.IVMInstallType;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.LibraryLocation;
import org.eclipse.jdt.launching.VMStandin;
import org.eclipse.jdt.launching.environments.IExecutionEnvironment;
import org.eclipse.jdt.launching.environments.IExecutionEnvironmentsManager;
import org.eclipse.osgi.util.NLS;
/**
* Resolves a container for a JRE classpath container entry.
*/
public class JREContainerInitializer extends ClasspathContainerInitializer {
/**
* @see ClasspathContainerInitializer#initialize(IPath, IJavaProject)
*/
@Override
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> initialize()"); //$NON-NLS-1$
LaunchingPlugin.trace("\tPath: " + containerPath.toString()); //$NON-NLS-1$
LaunchingPlugin.trace("\tProj: " + project.getProject().getName()); //$NON-NLS-1$
}
int size = containerPath.segmentCount();
if (size > 0) {
if (containerPath.segment(0).equals(JavaRuntime.JRE_CONTAINER)) {
IVMInstall vm = resolveVM(containerPath);
JREContainer container = null;
if (vm != null) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tResolved VM: " + vm.getName()); //$NON-NLS-1$
}
container = new JREContainer(vm, containerPath, project);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** FAILED RESOLVE VM ***"); //$NON-NLS-1$
}
}
JavaCore.setClasspathContainer(containerPath, new IJavaProject[] {project}, new IClasspathContainer[] {container}, null);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** INVALID JRE CONTAINER PATH ***"); //$NON-NLS-1$
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO SEGMENTS IN CONTAINER PATH ***"); //$NON-NLS-1$
}
}
}
/**
* Sets the specified class path container for all of the given projects.
*
* @param containerPath JRE container path
* @param projects projects set the container on
* @throws CoreException on failure
*/
public void initialize(IPath containerPath, IJavaProject[] projects) throws CoreException {
int size = containerPath.segmentCount();
if (size > 0) {
if (containerPath.segment(0).equals(JavaRuntime.JRE_CONTAINER)) {
int length = projects.length;
IVMInstall vm = resolveVM(containerPath);
IClasspathContainer[] containers = new JREContainer[length];
if (vm != null) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tResolved VM: " + vm.getName()); //$NON-NLS-1$
}
for (int i=0; i<length; i++) {
containers[i] = new JREContainer(vm, containerPath, projects[i]);
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** FAILED RESOLVE VM ***"); //$NON-NLS-1$
}
}
JavaCore.setClasspathContainer(containerPath, projects, containers, null);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** INVALID JRE CONTAINER PATH ***"); //$NON-NLS-1$
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO SEGMENTS IN CONTAINER PATH ***"); //$NON-NLS-1$
}
}
}
/**
* Returns the VM install associated with the container path, or <code>null</code>
* if it does not exist.
* @param containerPath the path to the container
* @return the {@link IVMInstall} or <code>null</code>
*/
public static IVMInstall resolveVM(IPath containerPath) {
IVMInstall vm = null;
if (containerPath.segmentCount() > 1) {
// specific JRE
String id = getExecutionEnvironmentId(containerPath);
if (id != null) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> resolveVM(IPath)"); //$NON-NLS-1$
LaunchingPlugin.trace("\tEE: " + id); //$NON-NLS-1$
}
IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
IExecutionEnvironment environment = manager.getEnvironment(id);
if (environment != null) {
vm = resolveVM(environment);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO ENVIRONMENT ***"); //$NON-NLS-1$
}
}
} else {
String vmTypeId = getVMTypeId(containerPath);
String vmName = getVMName(containerPath);
IVMInstallType vmType = JavaRuntime.getVMInstallType(vmTypeId);
if (vmType != null) {
vm = vmType.findVMInstallByName(vmName);
}
}
} else {
// workspace default JRE
vm = JavaRuntime.getDefaultVMInstall();
}
return vm;
}
/**
* Returns the VM install bound to the given execution environment
* or <code>null</code>.
*
* @param environment the environment
* @return VM install or <code>null</code>
* @since 3.2
*/
public static IVMInstall resolveVM(IExecutionEnvironment environment) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> resolveVM(IExecutionEnvironment)"); //$NON-NLS-1$
}
IVMInstall vm = environment.getDefaultVM();
if (vm == null) {
IVMInstall[] installs = environment.getCompatibleVMs();
// take the first strictly compatible VM if there is no default
if (installs.length == 0 && LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO COMPATIBLE VMS ***"); //$NON-NLS-1$
}
for (int i = 0; i < installs.length; i++) {
IVMInstall install = installs[i];
if (environment.isStrictlyCompatible(install)) {
vm = install;
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tPerfect Match: " + vm.getName()); //$NON-NLS-1$
}
break;
}
}
//try the default VM install: https://bugs.eclipse.org/bugs/show_bug.cgi?id=371300
// if default vm is a match https://bugs.eclipse.org/bugs/show_bug.cgi?id=484026
if (vm == null && installs.length > 0 && Arrays.asList(installs).contains(JavaRuntime.getDefaultVMInstall())) {
vm = JavaRuntime.getDefaultVMInstall();
}
// use the first VM failing that
if (vm == null && installs.length > 0) {
vm = installs[0];
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tFirst Match: " + vm.getName()); //$NON-NLS-1$
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tUser Default VM: " + vm.getName()); //$NON-NLS-1$
}
}
return vm;
}
/**
* Returns the segment from the path containing the execution environment id
* or <code>null</code>
*
* @param path container path
* @return EE id
*/
public static String getExecutionEnvironmentId(IPath path) {
String name = getVMName(path);
if (name != null) {
name = decodeEnvironmentId(name);
IExecutionEnvironmentsManager manager = JavaRuntime.getExecutionEnvironmentsManager();
IExecutionEnvironment environment = manager.getEnvironment(name);
if (environment != null) {
return environment.getId();
}
}
return null;
}
/**
* Returns whether the given path identifies a VM by execution environment.
*
* @param path the path
* @return whether the given path identifies a VM by execution environment
*/
public static boolean isExecutionEnvironment(IPath path) {
return getExecutionEnvironmentId(path) != null;
}
/**
* Escapes forward slashes in environment id.
*
* @param id the environment id
* @return escaped name
*/
public static String encodeEnvironmentId(String id) {
return id.replace('/', '%');
}
public static String decodeEnvironmentId(String id) {
return id.replace('%', '/');
}
/**
* Returns the VM type identifier from the given container ID path.
*
* @param path the path
* @return the VM type identifier from the given container ID path
*/
public static String getVMTypeId(IPath path) {
return path.segment(1);
}
/**
* Returns the VM name from the given container ID path.
*
* @param path the path
* @return the VM name from the given container ID path
*/
public static String getVMName(IPath path) {
return path.segment(2);
}
/**
* The container can be updated if it refers to an existing VM.
*
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#canUpdateClasspathContainer(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject)
*/
@Override
public boolean canUpdateClasspathContainer(IPath containerPath, IJavaProject project) {
if (containerPath != null && containerPath.segmentCount() > 0) {
if (JavaRuntime.JRE_CONTAINER.equals(containerPath.segment(0))) {
return resolveVM(containerPath) != null;
}
}
return false;
}
private static final IStatus READ_ONLY= new Status(IStatus.ERROR, LaunchingPlugin.ID_PLUGIN, ClasspathContainerInitializer.ATTRIBUTE_READ_ONLY, new String(), null);
private static final IStatus NOT_SUPPORTED= new Status(IStatus.ERROR, LaunchingPlugin.ID_PLUGIN, ClasspathContainerInitializer.ATTRIBUTE_NOT_SUPPORTED, new String(), null);
/* (non-Javadoc)
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#getAccessRulesStatus(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject)
*/
@Override
public IStatus getAccessRulesStatus(IPath containerPath, IJavaProject project) {
return READ_ONLY;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#getSourceAttachmentStatus(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject)
*/
@Override
public IStatus getSourceAttachmentStatus(IPath containerPath, IJavaProject project) {
return Status.OK_STATUS;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#getAttributeStatus(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject, java.lang.String)
*/
@Override
public IStatus getAttributeStatus(IPath containerPath, IJavaProject project, String attributeKey) {
if (attributeKey.equals(IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME)) {
return Status.OK_STATUS;
}
if (attributeKey.equals(IClasspathAttribute.EXTERNAL_ANNOTATION_PATH)) {
return Status.OK_STATUS;
}
if (attributeKey.equals(JavaRuntime.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY)) {
return Status.OK_STATUS;
}
return NOT_SUPPORTED;
}
/**
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#requestClasspathContainerUpdate(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject, org.eclipse.jdt.core.IClasspathContainer)
*/
@Override
public void requestClasspathContainerUpdate(IPath containerPath, IJavaProject project, IClasspathContainer containerSuggestion) throws CoreException {
IVMInstall vm = resolveVM(containerPath);
if (vm == null) {
IStatus status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), IJavaLaunchConfigurationConstants.ERR_VM_INSTALL_DOES_NOT_EXIST, NLS.bind(LaunchingMessages.JREContainerInitializer_JRE_referenced_by_classpath_container__0__does_not_exist__1, new String[]{containerPath.toString()}), null);
throw new CoreException(status);
}
// update of the VM with new library locations
IClasspathEntry[] entries = containerSuggestion.getClasspathEntries();
LibraryLocation[] libs = new LibraryLocation[entries.length];
for (int i = 0; i < entries.length; i++) {
IClasspathEntry entry = entries[i];
if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
IPath path = entry.getPath();
File lib = path.toFile();
if (lib.exists() && lib.isFile()) {
IPath srcPath = entry.getSourceAttachmentPath();
if (srcPath == null) {
srcPath = Path.EMPTY;
}
IPath rootPath = entry.getSourceAttachmentRootPath();
if (rootPath == null) {
rootPath = Path.EMPTY;
}
URL javadocLocation = null;
IPath externalAnnotations = null;
IClasspathAttribute[] extraAttributes = entry.getExtraAttributes();
for (int j = 0; j < extraAttributes.length; j++) {
IClasspathAttribute attribute = extraAttributes[j];
if (attribute.getName().equals(IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME)) {
String url = attribute.getValue();
if (url != null && url.trim().length() > 0) {
try {
javadocLocation = new URL(url);
} catch (MalformedURLException e) {
LaunchingPlugin.log(e);
}
}
} else if (attribute.getName().equals(IClasspathAttribute.EXTERNAL_ANNOTATION_PATH)) {
String xpath = attribute.getValue();
if (null != xpath && xpath.trim().length() > 0) {
try {
externalAnnotations = Path.fromPortableString(xpath);
} catch (Exception x) {
LaunchingPlugin.log(x);
}
}
}
}
libs[i] = new LibraryLocation(path, srcPath, rootPath, javadocLocation, null, externalAnnotations);
} else {
IStatus status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR, NLS.bind(LaunchingMessages.JREContainerInitializer_Classpath_entry__0__does_not_refer_to_an_existing_library__2, new String[]{entry.getPath().toString()}), null);
throw new CoreException(status);
}
} else {
IStatus status = new Status(IStatus.ERROR, LaunchingPlugin.getUniqueIdentifier(), IJavaLaunchConfigurationConstants.ERR_INTERNAL_ERROR, NLS.bind(LaunchingMessages.JREContainerInitializer_Classpath_entry__0__does_not_refer_to_a_library__3, new String[]{entry.getPath().toString()}), null);
throw new CoreException(status);
}
}
VMStandin standin = new VMStandin(vm);
standin.setLibraryLocations(libs);
standin.convertToRealVM();
JavaRuntime.saveVMConfiguration();
}
/**
* @see org.eclipse.jdt.core.ClasspathContainerInitializer#getDescription(org.eclipse.core.runtime.IPath, org.eclipse.jdt.core.IJavaProject)
*/
@Override
public String getDescription(IPath containerPath, IJavaProject project) {
String tag = getExecutionEnvironmentId(containerPath);
if (tag == null && containerPath.segmentCount() > 2) {
tag = getVMName(containerPath);
}
if (tag != null) {
return NLS.bind(LaunchingMessages.JREContainer_JRE_System_Library_1, new String[]{tag});
}
return LaunchingMessages.JREContainerInitializer_Default_System_Library_1;
}
}