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(); }