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;
public class JREContainerInitializer extends ClasspathContainerInitializer {
@Override
public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> initialize()");
LaunchingPlugin.trace("\tPath: " + containerPath.toString());
LaunchingPlugin.trace("\tProj: " + project.getProject().getName());
}
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());
}
container = new JREContainer(vm, containerPath, project);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** FAILED RESOLVE VM ***");
}
}
JavaCore.setClasspathContainer(containerPath, new IJavaProject[] {project}, new IClasspathContainer[] {container}, null);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** INVALID JRE CONTAINER PATH ***");
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO SEGMENTS IN CONTAINER PATH ***");
}
}
}
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());
}
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 ***");
}
}
JavaCore.setClasspathContainer(containerPath, projects, containers, null);
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** INVALID JRE CONTAINER PATH ***");
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO SEGMENTS IN CONTAINER PATH ***");
}
}
}
public static IVMInstall resolveVM(IPath containerPath) {
IVMInstall vm = null;
if (containerPath.segmentCount() > 1) {
String id = getExecutionEnvironmentId(containerPath);
if (id != null) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> resolveVM(IPath)");
LaunchingPlugin.trace("\tEE: " + id);
}
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 ***");
}
}
} else {
String vmTypeId = getVMTypeId(containerPath);
String vmName = getVMName(containerPath);
IVMInstallType vmType = JavaRuntime.getVMInstallType(vmTypeId);
if (vmType != null) {
vm = vmType.findVMInstallByName(vmName);
}
}
} else {
vm = JavaRuntime.getDefaultVMInstall();
}
return vm;
}
public static IVMInstall resolveVM(IExecutionEnvironment environment) {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("<JRE_CONTAINER> resolveVM(IExecutionEnvironment)");
}
IVMInstall vm = environment.getDefaultVM();
if (vm == null) {
IVMInstall[] installs = environment.getCompatibleVMs();
if (installs.length == 0 && LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\t*** NO COMPATIBLE VMS ***");
}
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());
}
break;
}
}
if (vm == null && installs.length > 0 && Arrays.asList(installs).contains(JavaRuntime.getDefaultVMInstall())) {
vm = JavaRuntime.getDefaultVMInstall();
}
if (vm == null && installs.length > 0) {
vm = installs[0];
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tFirst Match: " + vm.getName());
}
}
} else {
if (LaunchingPlugin.DEBUG_JRE_CONTAINER) {
LaunchingPlugin.trace("\tUser Default VM: " + vm.getName());
}
}
return vm;
}
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;
}
public static boolean isExecutionEnvironment(IPath path) {
return getExecutionEnvironmentId(path) != null;
}
public static String encodeEnvironmentId(String id) {
return id.replace('/', '%');
}
public static String decodeEnvironmentId(String id) {
return id.replace('%', '/');
}
public static String getVMTypeId(IPath path) {
return path.segment(1);
}
public static String getVMName(IPath path) {
return path.segment(2);
}
@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);
@Override
public IStatus getAccessRulesStatus(IPath containerPath, IJavaProject project) {
return READ_ONLY;
}
@Override
public IStatus getSourceAttachmentStatus(IPath containerPath, IJavaProject project) {
return Status.OK_STATUS;
}
@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;
}
@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);
}
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();
}
@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;
}
}