java/execution/impl/src/com/intellij/execution/util/JavaParametersUtil.java

   1 /*
   2  * Copyright 2000-2011 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.execution.util;
  17
  18 import com.intellij.execution.CantRunException;
  19 import com.intellij.execution.CommonJavaRunConfigurationParameters;
  20 import com.intellij.execution.ExecutionBundle;
  21 import com.intellij.execution.JavaExecutionUtil;
  22 import com.intellij.execution.configurations.JavaParameters;
  23 import com.intellij.execution.configurations.RunConfigurationModule;
  24 import com.intellij.execution.configurations.RuntimeConfigurationWarning;
  25 import com.intellij.execution.configurations.SimpleJavaParameters;
  26 import com.intellij.execution.junit.JUnitUtil;
  27 import com.intellij.openapi.module.Module;
  28 import com.intellij.openapi.project.Project;
  29 import com.intellij.openapi.projectRoots.JavaSdk;
  30 import com.intellij.openapi.projectRoots.Sdk;
  31 import com.intellij.openapi.projectRoots.ex.PathUtilEx;
  32 import com.intellij.openapi.roots.ModuleRootManager;
  33 import com.intellij.openapi.util.text.StringUtil;
  34 import com.intellij.openapi.vfs.VirtualFile;
  35 import com.intellij.psi.PsiClass;
  36 import com.intellij.psi.PsiFile;
  37
  38 import java.util.Map;
  39
  40 /**
  41  * @author lex
  42  * @since Nov 26, 2003
  43  */
  44 public class JavaParametersUtil {
  45   private JavaParametersUtil() { }
  46
  47   public static void configureConfiguration(SimpleJavaParameters parameters, CommonJavaRunConfigurationParameters configuration) {
  48     ProgramParametersUtil.configureConfiguration(parameters, configuration);
  49
  50     Project project = configuration.getProject();
  51     Module module = ProgramParametersUtil.getModule(configuration);
  52
  53     String vmParameters = configuration.getVMParameters();
  54     if (vmParameters != null) {
  55       vmParameters = ProgramParametersUtil.expandPath(vmParameters, module, project);
  56
  57       if (parameters.getEnv() != null) {
  58         for (Map.Entry<String, String> each : parameters.getEnv().entrySet()) {
  59           vmParameters = StringUtil.replace(vmParameters, "$" + each.getKey() + "$", each.getValue(), false); //replace env usages
  60         }
  61       }
  62     }
  63
  64     parameters.getVMParametersList().addParametersString(vmParameters);
  65   }
  66
  67   public static int getClasspathType(final RunConfigurationModule configurationModule, final String mainClassName,
  68                                      final boolean classMustHaveSource) throws CantRunException {
  69     final Module module = configurationModule.getModule();
  70     if (module == null) throw CantRunException.noModuleConfigured(configurationModule.getModuleName());
  71     final PsiClass psiClass = JavaExecutionUtil.findMainClass(module, mainClassName);
  72     if (psiClass == null) {
  73       if (!classMustHaveSource) return JavaParameters.JDK_AND_CLASSES_AND_TESTS;
  74       throw CantRunException.classNotFound(mainClassName, module);
  75     }
  76     final PsiFile psiFile = psiClass.getContainingFile();
  77     if (psiFile == null) throw CantRunException.classNotFound(mainClassName, module);
  78     final VirtualFile virtualFile = psiFile.getVirtualFile();
  79     if (virtualFile == null) throw CantRunException.classNotFound(mainClassName, module);
  80     Module classModule = new JUnitUtil.ModuleOfClass().convert(psiClass);
  81     if (classModule == null) classModule = module;
  82     return ModuleRootManager.getInstance(classModule).getFileIndex().
  83       isInTestSourceContent(virtualFile) ? JavaParameters.JDK_AND_CLASSES_AND_TESTS : JavaParameters.JDK_AND_CLASSES;
  84   }
  85
  86   public static void configureModule(final RunConfigurationModule runConfigurationModule,
  87                                      final JavaParameters parameters,
  88                                      final int classPathType,
  89                                      final String jreHome) throws CantRunException {
  90     Module module = runConfigurationModule.getModule();
  91     if (module == null) {
  92       throw CantRunException.noModuleConfigured(runConfigurationModule.getModuleName());
  93     }
  94     configureModule(module, parameters, classPathType, jreHome);
  95   }
  96
  97   public static void configureModule(Module module, JavaParameters parameters, int classPathType, String jreHome) throws CantRunException {
  98     parameters.configureByModule(module, classPathType, createModuleJdk(module, jreHome));
  99   }
 100
 101   public static void configureProject(Project project, final JavaParameters parameters, final int classPathType, final String jreHome)
 102     throws CantRunException {
 103     parameters.configureByProject(project, classPathType, createProjectJdk(project, jreHome));
 104   }
 105
 106   private static Sdk createModuleJdk(final Module module, final String jreHome) throws CantRunException {
 107     return jreHome == null ? JavaParameters.getModuleJdk(module) : createAlternativeJdk(jreHome);
 108   }
 109
 110   private static Sdk createProjectJdk(final Project project, final String jreHome) throws CantRunException {
 111     return jreHome == null ? createProjectJdk(project) : createAlternativeJdk(jreHome);
 112   }
 113
 114   private static Sdk createProjectJdk(final Project project) throws CantRunException {
 115     final Sdk jdk = PathUtilEx.getAnyJdk(project);
 116     if (jdk == null) {
 117       throw CantRunException.noJdkConfigured();
 118     }
 119     return jdk;
 120   }
 121
 122   private static Sdk createAlternativeJdk(final String jreHome) throws CantRunException {
 123     final Sdk jdk = JavaSdk.getInstance().createJdk("", jreHome);
 124     if (jdk == null) throw CantRunException.noJdkConfigured();
 125     return jdk;
 126   }
 127
 128   public static void checkAlternativeJRE(CommonJavaRunConfigurationParameters configuration) throws RuntimeConfigurationWarning {
 129     if (configuration.isAlternativeJrePathEnabled()) {
 130       if (configuration.getAlternativeJrePath() == null ||
 131           configuration.getAlternativeJrePath().length() == 0 ||
 132           !JavaSdk.checkForJre(configuration.getAlternativeJrePath())) {
 133         throw new RuntimeConfigurationWarning(
 134           ExecutionBundle.message("jre.path.is.not.valid.jre.home.error.mesage", configuration.getAlternativeJrePath()));
 135       }
 136     }
 137   }
 138 }