| /******************************************************************************* | |
| * Copyright (c) 2010 Angelo Zerr 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: | |
| * Angelo Zerr <angelo.zerr@gmail.com> - Initial API and implementation | |
| *******************************************************************************/ | |
| package org.eclipse.jst.server.jetty.core.internal; | |
| import java.io.File; | |
| import java.io.IOException; | |
| import java.text.MessageFormat; | |
| import java.util.Collection; | |
| import java.util.HashMap; | |
| import java.util.Map; | |
| import java.util.concurrent.ConcurrentHashMap; | |
| import org.eclipse.core.runtime.IPath; | |
| import org.eclipse.core.runtime.IProgressMonitor; | |
| import org.eclipse.core.runtime.IStatus; | |
| import org.eclipse.core.runtime.Path; | |
| import org.eclipse.core.runtime.Status; | |
| import org.eclipse.debug.core.ILaunch; | |
| import org.eclipse.debug.core.ILaunchManager; | |
| import org.eclipse.debug.core.Launch; | |
| import org.eclipse.debug.core.model.IStreamsProxy; | |
| import org.eclipse.jdt.launching.IRuntimeClasspathEntry; | |
| import org.eclipse.jdt.launching.IVMInstall; | |
| import org.eclipse.jdt.launching.IVMInstallType; | |
| import org.eclipse.jdt.launching.IVMRunner; | |
| import org.eclipse.jdt.launching.JavaRuntime; | |
| import org.eclipse.jdt.launching.VMRunnerConfiguration; | |
| import org.eclipse.jst.server.jetty.core.IJettyRuntimeWorkingCopy; | |
| import org.eclipse.jst.server.jetty.core.JettyPlugin; | |
| import org.eclipse.jst.server.jetty.core.internal.util.StringUtils; | |
| import org.eclipse.wst.server.core.IRuntimeType; | |
| import org.eclipse.wst.server.core.model.RuntimeDelegate; | |
| /** | |
| * Jetty Runtime. | |
| * | |
| */ | |
| public class JettyRuntime extends RuntimeDelegate implements IJettyRuntime, IJettyRuntimeWorkingCopy | |
| { | |
| // private static final String TOOLS_JAR_PATH = "lib" + File.separator + "tools.jar"; | |
| private static final String __JAVAC_MAIN = "com.sun.tools.javac.Main"; | |
| private static final String __CLASS_DETECTOR = "org.eclipse.jst.server.jetty.core.internal.ClassDetector"; | |
| protected static final String __PROP_VM_INSTALL_TYPE_ID = "vm-install-type-id"; | |
| protected static final String __PROP_VM_INSTALL_ID = "vm-install-id"; | |
| protected final static Map<File, Boolean> __SDK_MAP = new HashMap<File, Boolean>(2); | |
| private static Map<String, Integer> __JAVA_VERSION_MAP = new ConcurrentHashMap<String, Integer>(); | |
| public JettyRuntime() | |
| { | |
| super(); // possible error | |
| // do nothing | |
| } | |
| public IJettyVersionHandler getVersionHandler() | |
| { | |
| IRuntimeType type = getRuntime().getRuntimeType(); | |
| return JettyPlugin.getJettyVersionHandler(type.getId()); | |
| } | |
| protected String getVMInstallTypeId() | |
| { | |
| return getAttribute(__PROP_VM_INSTALL_TYPE_ID,(String)null); | |
| } | |
| protected String getVMInstallId() | |
| { | |
| return getAttribute(__PROP_VM_INSTALL_ID,(String)null); | |
| } | |
| public boolean isUsingDefaultJRE() | |
| { | |
| return getVMInstallTypeId() == null; | |
| } | |
| public IVMInstall getVMInstall() | |
| { | |
| if (getVMInstallTypeId() == null) | |
| return JavaRuntime.getDefaultVMInstall(); | |
| try | |
| { | |
| IVMInstallType vmInstallType = JavaRuntime.getVMInstallType(getVMInstallTypeId()); | |
| IVMInstall[] vmInstalls = vmInstallType.getVMInstalls(); | |
| int size = vmInstalls.length; | |
| String id = getVMInstallId(); | |
| for (int i = 0; i < size; i++) | |
| { | |
| if (id.equals(vmInstalls[i].getId())) | |
| return vmInstalls[i]; | |
| } | |
| } | |
| catch (Exception e) | |
| { | |
| JettyPlugin.log(e); | |
| } | |
| return null; | |
| } | |
| public Collection<IRuntimeClasspathEntry> getRuntimeClasspath(IPath configPath) | |
| { | |
| IPath installPath = getRuntime().getLocation(); | |
| // If installPath is relative, convert to canonical path and hope for | |
| // the best | |
| if (!installPath.isAbsolute()) | |
| { | |
| try | |
| { | |
| String installLoc = (new File(installPath.toOSString())).getCanonicalPath(); | |
| installPath = new Path(installLoc); | |
| } | |
| catch (IOException e) | |
| { | |
| JettyPlugin.log(e); | |
| } | |
| } | |
| return getVersionHandler().getRuntimeClasspath(installPath,configPath); | |
| } | |
| /** | |
| * Verifies the Jetty installation directory. If it is correct, true is returned. Otherwise, the user is notified and false is returned. | |
| * | |
| * @return boolean | |
| */ | |
| public IStatus verifyLocation() | |
| { | |
| return getVersionHandler().verifyInstallPath(getRuntime().getLocation()); | |
| } | |
| /* | |
| * Validate the runtime | |
| */ | |
| public IStatus validate() | |
| { | |
| IStatus status = super.validate(); | |
| if (!status.isOK()) | |
| return status; | |
| status = verifyLocation(); | |
| if (!status.isOK()) | |
| return status; | |
| // don't accept trailing space since that can cause startup problems | |
| if (getRuntime().getLocation().hasTrailingSeparator()) | |
| return new Status(IStatus.ERROR,JettyPlugin.PLUGIN_ID,0,Messages.errorInstallDirTrailingSlash,null); | |
| if (getVMInstall() == null) | |
| return new Status(IStatus.ERROR,JettyPlugin.PLUGIN_ID,0,Messages.errorJRE,null); | |
| // check for tools.jar (contains the javac compiler on Windows & Linux) | |
| // to see whether | |
| // Jetty will be able to compile JSPs. | |
| // boolean found = false; | |
| // File file = getVMInstall().getInstallLocation(); | |
| // if (file != null) { | |
| // File toolsJar = new File(file, TOOLS_JAR_PATH); | |
| // if (toolsJar.exists()) | |
| // found = true; | |
| // } | |
| status = getVersionHandler().validate(getRuntime().getLocation(),getVMInstall()); | |
| if (status != null) | |
| { | |
| return status; | |
| } | |
| return Status.OK_STATUS; | |
| // // on Jetty 5.5 and 6.0, the Eclipse JDT compiler is used for JSP's | |
| // String id = getRuntime().getRuntimeType().getId(); | |
| // if (!found) { | |
| // if (id != null && (id.indexOf("55") > 0 || id.indexOf("60") > 0)) | |
| // found = true; | |
| // } | |
| // | |
| // // on Mac, tools.jar is merged into classes.zip. if tools.jar wasn't | |
| // // found, | |
| // // try loading the javac class by running a check inside the VM | |
| // if (!found) { | |
| // String os = Platform.getOS(); | |
| // if (os != null && os.toLowerCase().indexOf("mac") >= 0) | |
| // found = checkForCompiler(); | |
| // } | |
| // | |
| // if (!found) | |
| // return new Status(IStatus.WARNING, JettyPlugin.PLUGIN_ID, 0, | |
| // Messages.warningJRE, null); | |
| // | |
| // File f = getRuntime().getLocation().append("conf").toFile(); | |
| // File[] conf = f.listFiles(); | |
| // if (conf != null) { | |
| // int size = conf.length; | |
| // for (int i = 0; i < size; i++) { | |
| // if (!f.canRead()) | |
| // return new Status(IStatus.WARNING, JettyPlugin.PLUGIN_ID, | |
| // 0, Messages.warningCantReadConfig, null); | |
| // } | |
| // } | |
| // | |
| // // For Jetty 6.0, ensure we have J2SE 5.0 | |
| // if (id != null && id.indexOf("60") > 0) { | |
| // IVMInstall vmInstall = getVMInstall(); | |
| // if (vmInstall instanceof IVMInstall2) { | |
| // String javaVersion = ((IVMInstall2) vmInstall).getJavaVersion(); | |
| // if (javaVersion != null | |
| // && !isVMMinimumVersion(javaVersion, 105)) { | |
| // return new Status(IStatus.ERROR, JettyPlugin.PLUGIN_ID, 0, | |
| // Messages.errorJREJetty60, null); | |
| // } | |
| // } | |
| // } | |
| // // Else for Jetty 7.0, ensure we have J2SE 6.0 | |
| // else if (id != null && id.indexOf("70") > 0) { | |
| // IVMInstall vmInstall = getVMInstall(); | |
| // if (vmInstall instanceof IVMInstall2) { | |
| // String javaVersion = ((IVMInstall2) vmInstall).getJavaVersion(); | |
| // if (javaVersion != null | |
| // && !isVMMinimumVersion(javaVersion, 106)) { | |
| // return new Status(IStatus.ERROR, JettyPlugin.PLUGIN_ID, 0, | |
| // Messages.errorJREJetty70, null); | |
| // } | |
| // } | |
| // } | |
| // return Status.OK_STATUS; | |
| } | |
| /** | |
| * @see RuntimeDelegate#setDefaults(IProgressMonitor) | |
| */ | |
| public void setDefaults(IProgressMonitor monitor) | |
| { | |
| IRuntimeType type = getRuntimeWorkingCopy().getRuntimeType(); | |
| getRuntimeWorkingCopy().setLocation(new Path(JettyPlugin.getPreference("location" + type.getId()))); | |
| } | |
| public void setVMInstall(IVMInstall vmInstall) | |
| { | |
| if (vmInstall == null) | |
| { | |
| setVMInstall(null,null); | |
| } | |
| else | |
| { | |
| setVMInstall(vmInstall.getVMInstallType().getId(),vmInstall.getId()); | |
| } | |
| } | |
| protected void setVMInstall(String typeId, String id) | |
| { | |
| if (typeId == null) | |
| { | |
| setAttribute(__PROP_VM_INSTALL_TYPE_ID,(String)null); | |
| } | |
| else | |
| { | |
| setAttribute(__PROP_VM_INSTALL_TYPE_ID,typeId); | |
| } | |
| if (id == null) | |
| { | |
| setAttribute(__PROP_VM_INSTALL_ID,(String)null); | |
| } | |
| else | |
| { | |
| setAttribute(__PROP_VM_INSTALL_ID,id); | |
| } | |
| } | |
| /** | |
| * Checks for the existence of the Java compiler in the given java executable. A main program is run (<code>org.eclipse.jst.Jetty.core. | |
| * internal.ClassDetector</code>), that dumps a true or false value depending on whether the compiler is found. This output is then parsed and cached for | |
| * future reference. | |
| * | |
| * @return true if the compiler was found | |
| */ | |
| protected boolean checkForCompiler() | |
| { | |
| // first try the cache | |
| File javaHome = getVMInstall().getInstallLocation(); | |
| try | |
| { | |
| Boolean b = (Boolean)__SDK_MAP.get(javaHome); | |
| return b.booleanValue(); | |
| } | |
| catch (Exception e) | |
| { | |
| // ignore | |
| } | |
| // locate Jettycore.jar - it contains the class detector main program | |
| File file = JettyPlugin.getPlugin(); | |
| if (file != null && file.exists()) | |
| { | |
| IVMRunner vmRunner = getVMInstall().getVMRunner(ILaunchManager.RUN_MODE); | |
| VMRunnerConfiguration config = new VMRunnerConfiguration(__CLASS_DETECTOR,new String[] | |
| { file.getAbsolutePath() }); | |
| config.setProgramArguments(new String[] | |
| { __JAVAC_MAIN }); | |
| ILaunch launch = new Launch(null,ILaunchManager.RUN_MODE,null); | |
| try | |
| { | |
| vmRunner.run(config,launch,null); | |
| for (int i = 0; i < 600; i++) | |
| { | |
| // wait no more than 30 seconds (600 * 50 mils) | |
| if (launch.isTerminated()) | |
| { | |
| break; | |
| } | |
| try | |
| { | |
| Thread.sleep(50); | |
| } | |
| catch (InterruptedException e) | |
| { | |
| // ignore | |
| } | |
| } | |
| IStreamsProxy streamsProxy = launch.getProcesses()[0].getStreamsProxy(); | |
| String text = null; | |
| if (streamsProxy != null) | |
| { | |
| text = streamsProxy.getOutputStreamMonitor().getContents(); | |
| if (text != null && text.length() > 0) | |
| { | |
| boolean found = false; | |
| if (StringUtils.isTrue(text)) | |
| found = true; | |
| __SDK_MAP.put(javaHome,Boolean.valueOf(found)); | |
| return found; | |
| } | |
| } | |
| } | |
| catch (Exception e) | |
| { | |
| Trace.trace(Trace.SEVERE,"Error checking for JDK",e); | |
| } | |
| finally | |
| { | |
| if (!launch.isTerminated()) | |
| { | |
| try | |
| { | |
| launch.terminate(); | |
| } | |
| catch (Exception ex) | |
| { | |
| // ignore | |
| } | |
| } | |
| } | |
| } | |
| // log error that we were unable to check for the compiler | |
| JettyPlugin.log(MessageFormat.format("Failed compiler check for {0}",javaHome.getAbsolutePath())); | |
| return false; | |
| } | |
| private boolean isVMMinimumVersion(String javaVersion, int minimumVersion) | |
| { | |
| Integer version = (Integer)__JAVA_VERSION_MAP.get(javaVersion); | |
| if (version == null) | |
| { | |
| int index = javaVersion.indexOf('.'); | |
| if (index > 0) | |
| { | |
| try | |
| { | |
| int major = Integer.parseInt(javaVersion.substring(0,index)) * 100; | |
| index++; | |
| int index2 = javaVersion.indexOf('.',index); | |
| if (index2 > 0) | |
| { | |
| int minor = Integer.parseInt(javaVersion.substring(index,index2)); | |
| version = Integer.valueOf(major + minor); | |
| __JAVA_VERSION_MAP.put(javaVersion,version); | |
| } | |
| } | |
| catch (NumberFormatException e) | |
| { | |
| // Ignore | |
| } | |
| } | |
| } | |
| // If we have a version, and it's less than the minimum, fail the check | |
| if (version != null && version.intValue() < minimumVersion) | |
| { | |
| return false; | |
| } | |
| return true; | |
| } | |
| } |