public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env)
throws ExecutionException {
CommandLineState state =
new CommandLineState(env) {
protected GeneralCommandLine createCommandLine() throws ExecutionException {
GeneralCommandLine commandLine = new GeneralCommandLine();
String exeName = myRunnerParameters.getExecutableName();
commandLine.setExePath(exeName != null ? exeName : "<unknown-exe-name>");
fillStateCommandLine(commandLine);
return commandLine;
}
protected OSProcessHandler startProcess() throws ExecutionException {
GeneralCommandLine commandLine = createCommandLine();
final OSProcessHandler processHandler =
new OSProcessHandler(
commandLine.createProcess(),
commandLine.getCommandLineString(),
commandLine.getCharset());
ProcessTerminatedListener.attach(processHandler);
return processHandler;
}
};
state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
return state;
}
private TextConsoleBuilder createConsoleBuilder(Project project) {
if (isDebug()) {
return new PyDebugConsoleBuilder(
project, PythonSdkType.findSdkByPath(myConfig.getInterpreterPath()));
} else {
return TextConsoleBuilderFactory.getInstance().createBuilder(project);
}
}
public RunProfileState getState(
@NotNull Executor executor, @NotNull ExecutionEnvironment environment)
throws ExecutionException {
final VirtualFile script = getScriptFile();
if (script == null) {
throw new CantRunException("Cannot find script " + scriptPath);
}
final GroovyScriptRunner scriptRunner = findConfiguration();
if (scriptRunner == null) {
throw new CantRunException("Unknown script type " + scriptPath);
}
final Module module = getModule();
if (!scriptRunner.ensureRunnerConfigured(module, this, executor, getProject())) {
return null;
}
final boolean tests =
ProjectRootManager.getInstance(getProject()).getFileIndex().isInTestSourceContent(script);
final JavaCommandLineState state =
new JavaCommandLineState(environment) {
@NotNull
@Override
protected OSProcessHandler startProcess() throws ExecutionException {
final OSProcessHandler handler = super.startProcess();
handler.setShouldDestroyProcessRecursively(true);
if (scriptRunner.shouldRefreshAfterFinish()) {
handler.addProcessListener(
new ProcessAdapter() {
@Override
public void processTerminated(ProcessEvent event) {
if (!ApplicationManager.getApplication().isDisposed()) {
VirtualFileManager.getInstance().refresh(true);
}
}
});
}
return handler;
}
protected JavaParameters createJavaParameters() throws ExecutionException {
JavaParameters params = createJavaParametersWithSdk(module);
ProgramParametersUtil.configureConfiguration(params, GroovyScriptRunConfiguration.this);
scriptRunner.configureCommandLine(
params, module, tests, script, GroovyScriptRunConfiguration.this);
return params;
}
};
state.setConsoleBuilder(TextConsoleBuilderFactory.getInstance().createBuilder(getProject()));
return state;
}
public BaseTestsOutputConsoleView(final TestConsoleProperties properties) {
myProperties = properties;
myConsole =
TextConsoleBuilderFactory.getInstance().createBuilder(properties.getProject()).getConsole();
myPrinter = new TestsOutputConsolePrinter(myConsole, properties);
myProperties.setConsole(this);
Disposer.register(this, myProperties);
Disposer.register(this, myConsole);
}
@Override
public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment env)
throws ExecutionException {
final JavaCommandLineState state =
new JavaApplicationCommandLineState<JavaScratchConfiguration>(this, env) {
@Override
protected void setupJavaParameters(JavaParameters params) throws ExecutionException {
super.setupJavaParameters(params);
final File scrachesOutput =
JavaScratchCompilationSupport.getScratchOutputDirectory(getProject());
if (scrachesOutput != null) {
params
.getClassPath()
.addFirst(
FileUtil.toCanonicalPath(scrachesOutput.getAbsolutePath())
.replace('/', File.separatorChar));
}
}
@NotNull
@Override
protected OSProcessHandler startProcess() throws ExecutionException {
final OSProcessHandler handler = super.startProcess();
if (getRunnerSettings() instanceof DebuggingRunnerData) {
final VirtualFile vFile = getConfiguration().getScratchVirtualFile();
if (vFile != null) {
DebuggerManager.getInstance(getProject())
.addDebugProcessListener(
handler,
new DebugProcessListener() {
@Override
public void processAttached(DebugProcess process) {
if (vFile.isValid()) {
process.appendPositionManager(
new JavaScratchPositionManager(
(DebugProcessImpl) process, vFile));
}
process.removeDebugProcessListener(this);
}
});
}
}
return handler;
}
};
state.setConsoleBuilder(
TextConsoleBuilderFactory.getInstance()
.createBuilder(getProject(), getConfigurationModule().getSearchScope()));
return state;
}
public static void addThreadDump(
Project project,
List<ThreadState> threads,
final RunnerLayoutUi ui,
DebuggerSession session) {
final TextConsoleBuilder consoleBuilder =
TextConsoleBuilderFactory.getInstance().createBuilder(project);
consoleBuilder.filters(ExceptionFilters.getFilters(session.getSearchScope()));
final ConsoleView consoleView = consoleBuilder.getConsole();
final DefaultActionGroup toolbarActions = new DefaultActionGroup();
consoleView.allowHeavyFilters();
final ThreadDumpPanel panel =
new ThreadDumpPanel(project, consoleView, toolbarActions, threads);
final String id = THREAD_DUMP_CONTENT_PREFIX + " #" + myCurrentThreadDumpId;
final Content content = ui.createContent(id, panel, id, null, null);
content.putUserData(RunnerContentUi.LIGHTWEIGHT_CONTENT_MARKER, Boolean.TRUE);
content.setCloseable(true);
content.setDescription("Thread Dump");
ui.addContent(content);
ui.selectAndFocus(content, true, true);
myThreadDumpsCount++;
myCurrentThreadDumpId++;
Disposer.register(
content,
new Disposable() {
@Override
public void dispose() {
myThreadDumpsCount--;
if (myThreadDumpsCount == 0) {
myCurrentThreadDumpId = 1;
}
}
});
Disposer.register(content, consoleView);
ui.selectAndFocus(content, true, false);
if (threads.size() > 0) {
panel.selectStackFrame(0);
}
}
public PythonDebugLanguageConsoleView(final Project project, Sdk sdk) {
this(project, sdk, TextConsoleBuilderFactory.getInstance().createBuilder(project).getConsole());
}
@NotNull
public ExecutionConsole createConsole() {
return TextConsoleBuilderFactory.getInstance()
.createBuilder(getSession().getProject())
.getConsole();
}
@Override
@NotNull
public ExecutionResult execute(
@NotNull final Executor executor, @NotNull final ProgramRunner runner)
throws ExecutionException {
log.debug("execute: about to call startProcess");
OSProcessHandler processHandler = startProcess();
ConsoleView consoleView =
TextConsoleBuilderFactory.getInstance()
.createBuilder(this.getEnvironment().getProject())
.getConsole();
consoleView.print("Starting substeps test...", ConsoleViewContentType.NORMAL_OUTPUT);
SubstepsRunConfiguration runConfig =
(SubstepsRunConfiguration) this.getEnvironment().getRunProfile();
boolean substepsServerLogsToConsole = true;
if (substepsServerLogsToConsole) {
consoleView.attachToProcess(processHandler);
} else {
Semaphore consoleSemaphore = new Semaphore(1, true);
InputStreamConsumer consumer =
new InputStreamConsumer(
processHandler.getProcess().getInputStream(),
log,
false,
consoleView,
consoleSemaphore);
final Thread t = new Thread(consumer);
t.start();
InputStreamConsumer errorConsumer =
new InputStreamConsumer(
processHandler.getProcess().getErrorStream(),
log,
true,
consoleView,
consoleSemaphore);
final Thread t2 = new Thread(errorConsumer);
t2.start();
}
processHandler.startNotify();
//
//
//
// boolean exceptionThrown = false;
// try {
// this.log.info("waiting for process to start...");
// processStarted.await(30, TimeUnit.SECONDS);
//
// this.log.info("waited..");
//
// if (!processStartedOk.get()) {
// exceptionThrown = true;
// throw new ExecutionException("Unable to launch VM process");
// }
//
// this.log.info("process started");
// } catch (final InterruptedException e) {
//
// e.printStackTrace();
// }
// try {
// Thread.currentThread().sleep(5000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
log.debug("startProcess called");
SubstepsRunnerConfigurationModel model = runConfig.getModel();
boolean actualRunnerStarted = false;
// TODO - this is a bit messy, concerns not well separated
SubstepsJMXClient jmxClient = null;
try {
jmxClient = new SubstepsJMXClient();
if (!jmxClient.init(jmxPort)) {
log.error("jmx init failed");
processHandler.destroyProcess();
return new DefaultExecutionResult();
}
SubstepsExecutionConfig substepsExecutionConfig = new SubstepsExecutionConfig();
substepsExecutionConfig.setFeatureFile(model.getPathToFeature());
String[] stepImplsArray =
model
.getStepImplentationClassNames(); // .toArray(new
// String[model.getStepImplentationClassNames().size()]);
substepsExecutionConfig.setDescription("Substeps Tests");
substepsExecutionConfig.setStepImplementationClassNames(stepImplsArray);
substepsExecutionConfig.setSubStepsFileName(model.getSubStepDefinitionDirectory());
substepsExecutionConfig.setScenarioName(model.getScenarioName());
log.debug(
"SubstepsExecutionConfig details\nFeature: "
+ model.getPathToFeature()
+ "\nsubstep dir: "
+ model.getSubStepDefinitionDirectory()
+ " scenarioName: "
+ model.getScenarioName());
for (String s : model.getStepImplentationClassNames()) {
log.debug("step impl classname: " + s);
}
/*
private String description;
private String tags;
private String nonFatalTags;
private String subStepsFileName;
private boolean strict = true;
private boolean fastFailParseErrors = true;
private Properties systemProperties;
private String[] nonStrictKeywordPrecedence;
private String[] stepImplementationClassNames;
private String[] initialisationClass;
private List<Class<?>> stepImplementationClasses;
private Class<?>[] initialisationClasses;
private String[] executionListeners;
*/
log.debug("preparing config");
byte[] bytes = jmxClient.prepareExecutionConfigAsBytes(substepsExecutionConfig);
RootNode rn = getRootNodeFromBytes(bytes);
log.debug("got root node description: " + rn.getDescription());
final SubstepsTestProxy unboundOutputRoot = new SubstepsTestProxy(rn);
final SubstepsConsoleProperties consoleProperties =
new SubstepsConsoleProperties(runConfig, executor);
final SubstepsConsoleView substepsConsoleView =
new SubstepsConsoleView(
consoleView, consoleProperties, this.getEnvironment(), unboundOutputRoot);
DefaultExecutionResult execResult =
new DefaultExecutionResult(
substepsConsoleView,
processHandler,
createActions(substepsConsoleView, processHandler, executor));
Disposer.register(this.getEnvironment().getProject(), substepsConsoleView);
substepsConsoleView.initUI();
substepsConsoleView.attachToProcess(processHandler);
unboundOutputRoot.setPrinter(substepsConsoleView.getPrinter());
Disposer.register(substepsConsoleView, unboundOutputRoot);
SubstepsRunningModel runModel =
new SubstepsRunningModel(unboundOutputRoot, consoleProperties);
SubstepsListenersNotifier eventsConsumer = unboundOutputRoot.getEventsConsumer();
substepsConsoleView.attachToModel(runModel);
RunningTestTracker.install(runModel);
log.debug("rootNode result from prepare config: " + rn.getResult().getResult());
if (rn.getResult().getResult().isFailure()) {
// bail out early
unboundOutputRoot.setState(SubstepTestState.FAILED);
eventsConsumer.onEvent(new StateChangedEvent(unboundOutputRoot));
jmxClient.shutdown();
log.debug("shut down done!");
} else {
log.debug("config prepared");
List<SubstepsTestProxy> allTestNodes = unboundOutputRoot.getAllTests();
Map<Long, SubstepsTestProxy> proxyMap = new HashMap<>();
for (SubstepsTestProxy proxy : allTestNodes) {
proxyMap.put(proxy.getExecutionNodeId(), proxy);
}
ActualRunner actualRunner =
new ActualRunner(jmxClient, log, eventsConsumer, proxyMap, unboundOutputRoot);
new Thread(actualRunner).start();
actualRunnerStarted = true;
}
return execResult;
} finally {
if (!actualRunnerStarted && jmxClient != null) {
// if we've got to the end and not actually kicked off the runner, make sure we shut down.
jmxClient.shutdown();
}
}
}
public LoggingHandlerImpl(@NotNull Project project) {
myConsole = TextConsoleBuilderFactory.getInstance().createBuilder(project).getConsole();
}
