@Nullable public static ExecutionEnvironmentBuilder createEnvironment( @NotNull Executor executor, @NotNull RunnerAndConfigurationSettings settings) { try { return ExecutionEnvironmentBuilder.create(executor, settings); } catch (ExecutionException e) { handleExecutionError( settings.getConfiguration().getProject(), executor.getToolWindowId(), settings.getConfiguration().getName(), e); return null; } }
private ValidationResult getValidationResult() { if (!myValidationResultValid) { myLastValidationResult = null; try { RunnerAndConfigurationSettings snapshot = getSnapshot(); if (snapshot != null) { snapshot.setName(getNameText()); snapshot.checkSettings(); for (ProgramRunner runner : RunnerRegistry.getInstance().getRegisteredRunners()) { for (Executor executor : ExecutorRegistry.getInstance().getRegisteredExecutors()) { if (runner.canRun(executor.getId(), snapshot.getConfiguration())) { checkConfiguration(runner, snapshot); break; } } } } } catch (RuntimeConfigurationException exception) { myLastValidationResult = exception != null ? new ValidationResult( exception.getLocalizedMessage(), exception.getTitle(), exception.getQuickFix()) : null; } catch (ConfigurationException e) { myLastValidationResult = new ValidationResult( e.getLocalizedMessage(), ExecutionBundle.message("invalid.data.dialog.title"), null); } myValidationResultValid = true; } return myLastValidationResult; }
@Nullable public static ProgramRunner getRunner( @NotNull final String executorId, final RunnerAndConfigurationSettings configuration) { return configuration == null ? null : RunnerRegistry.getInstance().getRunner(executorId, configuration.getConfiguration()); }
@Override protected RunnerAndConfigurationSettings findExistingByElement( Location location, @NotNull RunnerAndConfigurationSettings[] existingConfigurations, ConfigurationContext context) { final PsiClass aClass = ApplicationConfigurationType.getMainClass(location.getPsiElement()); if (aClass == null) { return null; } final Module predefinedModule = ((ApplicationConfiguration) ((RunManagerImpl) RunManagerEx.getInstanceEx(location.getProject())) .getConfigurationTemplate(getConfigurationFactory()) .getConfiguration()) .getConfigurationModule() .getModule(); for (RunnerAndConfigurationSettings existingConfiguration : existingConfigurations) { final ApplicationConfiguration appConfiguration = (ApplicationConfiguration) existingConfiguration.getConfiguration(); if (Comparing.equal( JavaExecutionUtil.getRuntimeQualifiedName(aClass), appConfiguration.MAIN_CLASS_NAME)) { if (Comparing.equal( location.getModule(), appConfiguration.getConfigurationModule().getModule())) { return existingConfiguration; } final Module configurationModule = appConfiguration.getConfigurationModule().getModule(); if (Comparing.equal(location.getModule(), configurationModule)) return existingConfiguration; if (Comparing.equal(predefinedModule, configurationModule)) { return existingConfiguration; } } } return null; }
private SelectionDialog( RunnerAndConfigurationSettings selectedSettings, @NotNull List<RunnerAndConfigurationSettings> settings) { super(myProject); setTitle(ExecutionBundle.message("before.launch.run.another.configuration.choose")); mySelectedSettings = selectedSettings; mySettings = settings; init(); myJBList.setSelectedValue(mySelectedSettings, true); myJBList.addMouseListener( new MouseAdapter() { @Override public void mouseClicked(MouseEvent e) { if (SwingUtilities.isLeftMouseButton(e) && e.getClickCount() == 2) { doOKAction(); } } }); FontMetrics fontMetrics = myJBList.getFontMetrics(myJBList.getFont()); int maxWidth = fontMetrics.stringWidth("m") * 30; for (RunnerAndConfigurationSettings setting : settings) { maxWidth = Math.max(fontMetrics.stringWidth(setting.getConfiguration().getName()), maxWidth); } maxWidth += 24; // icon and gap myJBList.setMinimumSize(new Dimension(maxWidth, myJBList.getPreferredSize().height)); }
public static void runConfiguration( @NotNull RunnerAndConfigurationSettings configuration, @NotNull Executor executor) { ExecutionEnvironmentBuilder builder = createEnvironment(executor, configuration); if (builder != null) { ExecutionManager.getInstance(configuration.getConfiguration().getProject()) .restartRunProfile(builder.activeTarget().build()); } }
@NotNull public static Icon getRawIcon(RunnerAndConfigurationSettings settings) { RunConfiguration configuration = settings.getConfiguration(); ConfigurationFactory factory = settings.getFactory(); Icon icon = factory != null ? factory.getIcon(configuration) : null; if (icon == null) icon = AllIcons.RunConfigurations.Unknown; return icon; }
@Override public boolean canExecuteTask(RunConfiguration configuration, RunConfigurableBeforeRunTask task) { RunnerAndConfigurationSettings settings = task.getSettings(); if (settings == null) { return false; } String executorId = DefaultRunExecutor.getRunExecutorInstance().getId(); final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings); return runner != null && runner.canRun(executorId, settings.getConfiguration()); }
private RunnerAndConfigurationSettings createConfiguration( final PsiClass aClass, final ConfigurationContext context, Location location) { final Project project = aClass.getProject(); RunnerAndConfigurationSettings settings = cloneTemplateConfiguration(project, context); final ApplicationConfiguration configuration = (ApplicationConfiguration) settings.getConfiguration(); configuration.MAIN_CLASS_NAME = JavaExecutionUtil.getRuntimeQualifiedName(aClass); configuration.setName(configuration.getGeneratedName()); setupConfigurationModule(context, configuration); JavaRunConfigurationExtensionManager.getInstance() .extendCreatedConfiguration(configuration, location); return settings; }
private boolean checkRunConfiguration( Executor executor, Project project, RunnerAndConfigurationSettings configuration) { ExecutionTarget target = ExecutionTargetManager.getActiveTarget(project); if (!ExecutionTargetManager.canRun(configuration, target)) { ExecutionUtil.handleExecutionError( project, executor.getToolWindowId(), configuration.getConfiguration(), new ExecutionException( StringUtil.escapeXml( "Cannot run '" + configuration.getName() + "' on '" + target.getDisplayName() + "'"))); return false; } if (!RunManagerImpl.canRunConfiguration(configuration, executor) || configuration.isEditBeforeRun()) { if (!RunDialog.editConfiguration(project, configuration, "Edit configuration", executor)) { return false; } while (!RunManagerImpl.canRunConfiguration(configuration, executor)) { if (0 == Messages.showYesNoDialog( project, "Configuration is still incorrect. Do you want to edit it again?", "Change Configuration Settings", "Edit", "Continue Anyway", Messages.getErrorIcon())) { if (!RunDialog.editConfiguration( project, configuration, "Edit configuration", executor)) { break; } } else { break; } } } return true; }
@NotNull private static List<RunnerAndConfigurationSettings> getAvailableConfigurations( RunConfiguration runConfiguration) { Project project = runConfiguration.getProject(); if (project == null || !project.isInitialized()) return Collections.emptyList(); final RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(project); final ArrayList<RunnerAndConfigurationSettings> configurations = new ArrayList<RunnerAndConfigurationSettings>(runManager.getSortedConfigurations()); String executorId = DefaultRunExecutor.getRunExecutorInstance().getId(); for (Iterator<RunnerAndConfigurationSettings> iterator = configurations.iterator(); iterator.hasNext(); ) { RunnerAndConfigurationSettings settings = iterator.next(); final ProgramRunner runner = ProgramRunnerUtil.getRunner(executorId, settings); if (runner == null || settings.getConfiguration() == runConfiguration) iterator.remove(); } return configurations; }
@NotNull private static ExecutionEnvironmentBuilder createEnvironmentBuilder( @NotNull Project project, @NotNull Executor executor, @Nullable RunnerAndConfigurationSettings configuration) { ExecutionEnvironmentBuilder builder = new ExecutionEnvironmentBuilder(project, executor); ProgramRunner runner = RunnerRegistry.getInstance() .getRunner( executor.getId(), configuration != null ? configuration.getConfiguration() : null); if (runner == null && configuration != null) { LOG.error("Cannot find runner for " + configuration.getName()); } else if (runner != null) { assert configuration != null; builder.runnerAndSettings(runner, configuration); } return builder; }
@NotNull private List<RunContentDescriptor> getIncompatibleRunningDescriptors( @NotNull RunnerAndConfigurationSettings configurationAndSettings) { final RunConfiguration configurationToCheckCompatibility = configurationAndSettings.getConfiguration(); return getRunningDescriptors( runningConfigurationAndSettings -> { RunConfiguration runningConfiguration = runningConfigurationAndSettings == null ? null : runningConfigurationAndSettings.getConfiguration(); if (runningConfiguration == null || !(runningConfiguration instanceof CompatibilityAwareRunProfile)) { return false; } return ((CompatibilityAwareRunProfile) runningConfiguration) .mustBeStoppedToRun(configurationToCheckCompatibility); }); }
@Nullable public static Pair<ProgramRunner, ExecutionEnvironment> createRunner( @NotNull ExternalSystemTaskExecutionSettings taskSettings, @NotNull String executorId, @NotNull Project project, @NotNull ProjectSystemId externalSystemId) { Executor executor = ExecutorRegistry.getInstance().getExecutorById(executorId); if (executor == null) return null; String runnerId = getRunnerId(executorId); if (runnerId == null) return null; ProgramRunner runner = RunnerRegistry.getInstance().findRunnerById(runnerId); if (runner == null) return null; AbstractExternalSystemTaskConfigurationType configurationType = findConfigurationType(externalSystemId); if (configurationType == null) return null; String name = AbstractExternalSystemTaskConfigurationType.generateName(project, taskSettings); RunnerAndConfigurationSettings settings = RunManager.getInstance(project) .createRunConfiguration(name, configurationType.getFactory()); ExternalSystemRunConfiguration runConfiguration = (ExternalSystemRunConfiguration) settings.getConfiguration(); runConfiguration.getSettings().setExternalProjectPath(taskSettings.getExternalProjectPath()); runConfiguration .getSettings() .setTaskNames(ContainerUtil.newArrayList(taskSettings.getTaskNames())); runConfiguration .getSettings() .setTaskDescriptions(ContainerUtil.newArrayList(taskSettings.getTaskDescriptions())); runConfiguration.getSettings().setVmOptions(taskSettings.getVmOptions()); runConfiguration.getSettings().setScriptParameters(taskSettings.getScriptParameters()); runConfiguration.getSettings().setExecutionName(taskSettings.getExecutionName()); return Pair.create(runner, new ExecutionEnvironment(executor, runner, settings, project)); }
private void runConfigurations( final Executor executor, final List<RunConfiguration> runConfigurations, final int index) { if (index >= runConfigurations.size()) { stopRunningMultirunConfiguration.doneStaringConfigurations(); return; } if (!stopRunningMultirunConfiguration.canContinueStartingConfigurations()) { stopRunningMultirunConfiguration.doneStaringConfigurations(); // don't start more configurations if user stopped the plugin work. return; } final RunConfiguration runConfiguration = runConfigurations.get(index); final Project project = runConfiguration.getProject(); final RunnerAndConfigurationSettings configuration = new RunnerAndConfigurationSettingsImpl( RunManagerImpl.getInstanceImpl(project), runConfiguration, false); boolean started = false; try { ProgramRunner runner = RunnerRegistry.getInstance().getRunner(executor.getId(), runConfiguration); if (runner == null) return; if (!checkRunConfiguration(executor, project, configuration)) return; runTriggers(executor, configuration); RunContentDescriptor runContentDescriptor = getRunContentDescriptor(runConfiguration, project); ExecutionEnvironment executionEnvironment = new ExecutionEnvironment( runner, DefaultExecutionTarget.INSTANCE, configuration, runContentDescriptor, project); runner.execute( executor, executionEnvironment, new ProgramRunner.Callback() { @SuppressWarnings("ConstantConditions") @Override public void processStarted(final RunContentDescriptor descriptor) { if (descriptor == null) { if (startOneByOne) { // start next configuration.. runConfigurations(executor, runConfigurations, index + 1); } return; } final ProcessHandler processHandler = descriptor.getProcessHandler(); if (processHandler != null) { processHandler.addProcessListener( new ProcessAdapter() { @SuppressWarnings("ConstantConditions") @Override public void startNotified(ProcessEvent processEvent) { Content content = descriptor.getAttachedContent(); if (content != null) { content.setIcon(descriptor.getIcon()); if (!stopRunningMultirunConfiguration .canContinueStartingConfigurations()) { // Multirun was stopped - destroy processes that are still starting up processHandler.destroyProcess(); if (!content.isPinned() && !startOneByOne) { // checks if not pinned, to avoid destroying already existed tab // checks if start one by one - no need to close the console tab, as // it's won't be shown // as other checks disallow starting it // content.getManager() can be null, if content is removed already as // part of destroy above if (content.getManager() != null) { content.getManager().removeContent(content, false); } } } else { // mark all current console tab as pinned content.setPinned(true); // mark running process tab with * content.setDisplayName(descriptor.getDisplayName() + "*"); } } } @Override public void processTerminated(final ProcessEvent processEvent) { onTermination(processEvent, true); } @Override public void processWillTerminate( ProcessEvent processEvent, boolean willBeDestroyed) { onTermination(processEvent, false); } private void onTermination( final ProcessEvent processEvent, final boolean terminated) { if (descriptor.getAttachedContent() == null) { return; } LaterInvocator.invokeLater( new Runnable() { @Override public void run() { final Content content = descriptor.getAttachedContent(); if (content == null) return; // exit code is 0 if the process completed successfully final boolean completedSuccessfully = (terminated && processEvent.getExitCode() == 0); if (hideSuccessProcess && completedSuccessfully) { // close the tab for the success process and exit - nothing else // could be done if (content.getManager() != null) { content.getManager().removeContent(content, false); return; } } if (!separateTabs && completedSuccessfully) { // un-pin the console tab if re-use is allowed and process // completed successfully, // so the tab could be re-used for other processes content.setPinned(false); } // remove the * used to identify running process content.setDisplayName(descriptor.getDisplayName()); // add the alert icon in case if process existed with non-0 status if (markFailedProcess && processEvent.getExitCode() != 0) { LaterInvocator.invokeLater( new Runnable() { @Override public void run() { content.setIcon( LayeredIcon.create( content.getIcon(), AllIcons.Nodes.TabAlert)); } }); } } }); } }); } stopRunningMultirunConfiguration.addProcess(project, processHandler); if (startOneByOne) { // start next configuration.. runConfigurations(executor, runConfigurations, index + 1); } } }); started = true; } catch (ExecutionException e) { ExecutionUtil.handleExecutionError( project, executor.getToolWindowId(), configuration.getConfiguration(), e); } finally { // start the next one if (!startOneByOne) { runConfigurations(executor, runConfigurations, index + 1); } else if (!started) { // failed to start current, means the chain is broken runConfigurations(executor, runConfigurations, index + 1); } } }