execution: extract check for alternative jre; check for working directory (IDEA-77754)
[idea/community.git] / 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 }