IJPL-157834 No way to start two run configurations at once

GitOrigin-RevId: 93a70bd8fc53164a9e4863559d5f901c50f0085b

platform/execution-impl/api-dump-unreviewed.txt

@@ -197,25 +197,6 @@ f:com.intellij.execution.ExecutionTargetManagerImpl
 - setActiveTarget(com.intellij.execution.ExecutionTarget):V
 - setRunManager(com.intellij.execution.impl.RunManagerImpl):V
 - update():V
-f:com.intellij.execution.ExecutorRegistryImpl
-- com.intellij.execution.ExecutorRegistry
-- sf:RUNNERS_GROUP:java.lang.String
-- sf:RUN_CONTEXT_EXECUTORS_GROUP:java.lang.String
-- sf:RUN_CONTEXT_GROUP:java.lang.String
-- sf:RUN_CONTEXT_GROUP_MORE:java.lang.String
-- <init>():V
-- getExecutorById(java.lang.String):com.intellij.execution.Executor
-- initExecutorActions(com.intellij.execution.Executor,com.intellij.openapi.actionSystem.ex.ActionRuntimeRegistrar):V
-c:com.intellij.execution.ExecutorRegistryImpl$ExecutorAction
-- com.intellij.openapi.actionSystem.AnAction
-- com.intellij.openapi.project.DumbAware
-- <init>(com.intellij.execution.Executor):V
-f:com.intellij.execution.ExecutorRegistryImpl$RunnerHelper
-- <init>():V
-- s:canRun(com.intellij.openapi.project.Project,com.intellij.execution.Executor,com.intellij.execution.configurations.RunConfiguration):Z
-- s:canRun(com.intellij.openapi.project.Project,com.intellij.execution.Executor,com.intellij.execution.configurations.RunConfiguration,com.intellij.openapi.util.Ref):Z
-- s:run(com.intellij.openapi.project.Project,com.intellij.execution.configurations.RunConfiguration,com.intellij.execution.RunnerAndConfigurationSettings,com.intellij.openapi.actionSystem.DataContext,com.intellij.execution.Executor):V
-- s:runSubProcess(com.intellij.openapi.project.Project,com.intellij.execution.configurations.RunConfiguration,com.intellij.execution.RunnerAndConfigurationSettings,com.intellij.openapi.actionSystem.DataContext,com.intellij.execution.Executor,java.util.function.Consumer):V
 f:com.intellij.execution.ExternalizablePath
 - com.intellij.openapi.util.JDOMExternalizable
 - <init>():V
@@ -924,7 +905,7 @@ c:com.intellij.execution.impl.ExecutionManagerImpl
 - getRunningDescriptors(com.intellij.openapi.util.Condition):java.util.List
 - getRunningProcesses():com.intellij.execution.process.ProcessHandler[]
 - sf:isProcessRunning(com.intellij.execution.ui.RunContentDescriptor):Z
-- isStarting(java.lang.String,java.lang.String):Z
+- isStarting(java.lang.String,java.lang.String,java.lang.String):Z
 - restartRunProfile(com.intellij.execution.runners.ExecutionEnvironment):V
 - restartRunProfile(com.intellij.openapi.project.Project,com.intellij.execution.Executor,com.intellij.execution.ExecutionTarget,com.intellij.execution.RunnerAndConfigurationSettings,com.intellij.execution.process.ProcessHandler,java.util.function.Consumer):V
 - f:setForceCompilationInTests(Z):V

platform/execution-impl/exposed-private-api.txt

@@ -8,5 +8,4 @@ com/intellij/internal/statistic/eventLog/events/ObjectEventData
 com/intellij/internal/statistic/eventLog/events/ObjectListEventField
 com/intellij/internal/statistic/eventLog/events/StringEventField
 com/intellij/internal/statistic/eventLog/events/VarargEventId
-com/intellij/openapi/actionSystem/ex/ActionRuntimeRegistrar
 com/intellij/openapi/actionSystem/remoting/ActionRemoteBehavior

platform/execution-impl/src/com/intellij/execution/ExecutorRegistryImpl.java

@@ -34,6 +34,7 @@ import org.jetbrains.annotations.*;
 import java.util.*;
 import java.util.function.Consumer;
 
+@ApiStatus.Internal
 public final class ExecutorRegistryImpl extends ExecutorRegistry {
   private static final Logger LOG = Logger.getInstance(ExecutorRegistryImpl.class);
 
@@ -336,7 +337,9 @@ public final class ExecutorRegistryImpl extends ExecutorRegistry {
       }
     }
 
-    public static boolean canRun(@NotNull Project project, @NotNull Executor executor, RunConfiguration configuration) {
+    public static boolean canRun(@NotNull Project project,
+                                 @NotNull Executor executor,
+                                 @NotNull RunConfiguration configuration) {
       return canRun(project, executor, configuration, null);
     }
 
@@ -366,8 +369,8 @@ public final class ExecutorRegistryImpl extends ExecutorRegistry {
 
       for (SettingsAndEffectiveTarget pair : pairs) {
         RunConfiguration configuration = pair.getConfiguration();
-        if (configuration instanceof CompoundRunConfiguration) {
+        if (configuration instanceof CompoundRunConfiguration o) {
-          if (!canRun(project, ((CompoundRunConfiguration)configuration).getConfigurationsWithEffectiveRunTargets(), executor, isStartingTracker)) {
+          if (!canRun(project, o.getConfigurationsWithEffectiveRunTargets(), executor, isStartingTracker)) {
             return false;
           }
           continue;
@@ -377,7 +380,9 @@ public final class ExecutorRegistryImpl extends ExecutorRegistry {
         if (runner == null || !ExecutionTargetManager.canRun(configuration, pair.getTarget())) {
           return false;
         }
-        else if (ExecutionManager.getInstance(project).isStarting(executor.getId(), runner.getRunnerId())) {
+        else if (ExecutionManager.getInstance(project).isStarting(
+          RunnerAndConfigurationSettingsImpl.getUniqueIdFor(configuration),
+          executor.getId(), runner.getRunnerId())) {
           if (isStartingTracker != null) isStartingTracker.set(true);
           else return false;
         }

platform/execution-impl/src/com/intellij/execution/actions/RunContextAction.java

@@ -98,7 +98,7 @@ public class RunContextAction extends BaseRunConfigurationAction {
     presentation.setVisible(b.second);
   }
 
-  private Pair<Boolean, Boolean> isEnabledAndVisible(ConfigurationContext context) {
+  private Pair<Boolean, Boolean> isEnabledAndVisible(@NotNull ConfigurationContext context) {
     RunnerAndConfigurationSettings configuration = findExisting(context);
     if (configuration == null) {
       configuration = context.getConfiguration();
@@ -110,7 +110,8 @@ public class RunContextAction extends BaseRunConfigurationAction {
     }
 
     Project project = context.getProject();
-    return Pair.create(!ExecutionManager.getInstance(project).isStarting(myExecutor.getId(), runner.getRunnerId()), true);
+    return Pair.create(!ExecutionManager.getInstance(project).isStarting(
+      configuration.getUniqueID(), myExecutor.getId(), runner.getRunnerId()), true);
   }
 
   @Override

platform/execution-impl/src/com/intellij/execution/impl/ExecutionManagerImpl.kt

@@ -208,7 +208,10 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
   private fun processNotStarted(environment: ExecutionEnvironment, activity: StructuredIdeActivity?, e : Throwable? = null) {
     RunConfigurationUsageTriggerCollector.logProcessFinished(activity, RunConfigurationFinishType.FAILED_TO_START)
     val executorId = environment.executor.id
-    inProgress.remove(InProgressEntry(executorId, environment.runner.runnerId))
+    val inProgressEntry = InProgressEntry(
+      environment.runnerAndConfigurationSettings?.uniqueID ?: "",
+      executorId, environment.runner.runnerId)
+    inProgress.remove(inProgressEntry)
     environment.callback?.processNotStarted(e)
     project.messageBus.syncPublisher(EXECUTION_TOPIC).processNotStarted(executorId, environment, e)
   }
@@ -263,7 +266,10 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
     }
 
     val executor = environment.executor
-    inProgress.add(InProgressEntry(executor.id, environment.runner.runnerId))
+    val inProgressEntry = InProgressEntry(
+      environment.runnerAndConfigurationSettings?.uniqueID ?: "",
+      executor.id, environment.runner.runnerId)
+    inProgress.add(inProgressEntry)
     project.messageBus.syncPublisher(EXECUTION_TOPIC).processStartScheduled(executor.id, environment)
     registerRecentExecutor(environment)
 
@@ -306,7 +312,7 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
                   project.messageBus.syncPublisher(EXECUTION_TOPIC).processStarting(executor.id, environment, processHandler)
                   processHandler.startNotify()
                 }
-                inProgress.remove(InProgressEntry(executor.id, environment.runner.runnerId))
+                inProgress.remove(inProgressEntry)
                 project.messageBus.syncPublisher(EXECUTION_TOPIC).processStarted(executor.id, environment, processHandler)
 
                 val listener = ProcessExecutionListener(project, executor.id, environment, descriptor, activity)
@@ -590,9 +596,9 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
           // a new rerun has been requested before starting this one, ignore this rerun
           return
         }
-
+        val inProgressEntry = InProgressEntry(configuration?.uniqueID ?: "", environment.executor.id, environment.runner.runnerId)
         if ((configuration != null && !configuration.type.isDumbAware && DumbService.getInstance(project).isDumb)
-            || inProgress.contains(InProgressEntry(environment.executor.id, environment.runner.runnerId))) {
+            || inProgress.contains(inProgressEntry)) {
           awaitTermination(this, 100)
           return
         }
@@ -738,10 +744,13 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
             editConfigurationUntilSuccess(environment, assignNewId)
           }
           else {
-            inProgress.add(InProgressEntry(environment.executor.id, environment.runner.runnerId))
+            val inProgressEntry = InProgressEntry(
+              environment.runnerAndConfigurationSettings?.uniqueID  ?: "",
+              environment.executor.id, environment.runner.runnerId)
+            inProgress.add(inProgressEntry)
             ReadAction.nonBlocking(Callable { RunManagerImpl.canRunConfiguration(environment) })
               .finishOnUiThread(ModalityState.nonModal()) { canRun ->
-                inProgress.remove(InProgressEntry(environment.executor.id, environment.runner.runnerId))
+                inProgress.remove(inProgressEntry)
                 if (canRun) {
 
                   executeConfiguration(environment, environment.runner, assignNewId, this.project,
@@ -828,8 +837,13 @@ open class ExecutionManagerImpl(private val project: Project) : ExecutionManager
     ExecutionUtil.handleExecutionError(environment, e)
   }
 
-  override fun isStarting(executorId: String, runnerId: String): Boolean {
+  override fun isStarting(configurationId: String, executorId: String, runnerId: String): Boolean {
-    return inProgress.contains(InProgressEntry(executorId, runnerId))
+    if (configurationId != "") {
+      return inProgress.contains(InProgressEntry(configurationId, executorId, runnerId))
+    }
+    else {
+      return inProgress.any { it.executorId == executorId && it.runnerId == runnerId  }
+    }
   }
 
   private fun awaitTermination(request: Runnable, delayMillis: Long) {
@@ -1088,7 +1102,7 @@ private class ProcessExecutionListener(private val project: Project,
   }
 }
 
-private data class InProgressEntry(val executorId: String, val runnerId: String)
+private data class InProgressEntry(val configId: String, val executorId: String, val runnerId: String)
 
 private data class RunningConfigurationEntry(
   val descriptor: RunContentDescriptor,

platform/execution/src/com/intellij/execution/ExecutionManager.kt

@@ -109,11 +109,12 @@ abstract class ExecutionManager {
   abstract fun restartRunProfile(environment: ExecutionEnvironment)
 
   fun isStarting(environment: ExecutionEnvironment): Boolean {
-    return isStarting(environment.executor.id, environment.runner.runnerId)
+    return isStarting(environment.runnerAndConfigurationSettings?.uniqueID ?: "",
+                      environment.executor.id, environment.runner.runnerId)
   }
 
   @ApiStatus.Internal
-  abstract fun isStarting(executorId: String, runnerId: String): Boolean
+  abstract fun isStarting(configurationId: String, executorId: String, runnerId: String): Boolean
 
   @ApiStatus.Experimental
   abstract fun executePreparationTasks(environment: ExecutionEnvironment, currentState: RunProfileState): Promise<Any?>

platform/execution/src/com/intellij/execution/ExecutorRegistry.java

@@ -25,15 +25,16 @@ public abstract class ExecutorRegistry {
   @Nullable
   public abstract Executor getExecutorById(@NotNull String executorId);
 
-  /**
+  /** @deprecated Use {@link ExecutionManager#isStarting(ExecutionEnvironment)} */
-   * Consider to use {@link ExecutionManager#isStarting(ExecutionEnvironment)}
-   */
   @SuppressWarnings("MethodMayBeStatic")
+  @Deprecated(forRemoval = true)
   public final boolean isStarting(@NotNull Project project, @NotNull String executorId, @NotNull String runnerId) {
-    return ExecutionManager.getInstance(project).isStarting(executorId, runnerId);
+    return ExecutionManager.getInstance(project).isStarting("", executorId, runnerId);
   }
 
+  /** @deprecated Use {@link ExecutionManager#isStarting(ExecutionEnvironment)} */
   @SuppressWarnings("MethodMayBeStatic")
+  @Deprecated(forRemoval = true)
   public final boolean isStarting(@NotNull ExecutionEnvironment environment) {
     return ExecutionManager.getInstance(environment.getProject()).isStarting(environment);
   }

platform/lang-impl/src/com/intellij/execution/dashboard/actions/ExecutorAction.java

@@ -86,17 +86,18 @@ public abstract class ExecutorAction extends DumbAwareAction {
                   DumbService.isDumb(project));
   }
 
-  private boolean canRun(RunnerAndConfigurationSettings settings, ExecutionTarget target, boolean isDumb) {
+  private boolean canRun(@NotNull RunnerAndConfigurationSettings settings,
+                         @Nullable ExecutionTarget target,
+                         boolean isDumb) {
     if (isDumb && !settings.getType().isDumbAware()) return false;
 
     String executorId = getExecutor().getId();
     RunConfiguration configuration = settings.getConfiguration();
     Project project = configuration.getProject();
-    if (configuration instanceof CompoundRunConfiguration) {
+    if (configuration instanceof CompoundRunConfiguration comp) {
-      if (ExecutionTargetManager.getInstance(project).getTargetsFor(configuration).isEmpty()) return false;
+      if (ExecutionTargetManager.getInstance(project).getTargetsFor(comp).isEmpty()) return false;
 
-      List<SettingsAndEffectiveTarget> subConfigurations =
+      List<SettingsAndEffectiveTarget> subConfigurations = comp.getConfigurationsWithEffectiveRunTargets();
-        ((CompoundRunConfiguration)configuration).getConfigurationsWithEffectiveRunTargets();
       if (subConfigurations.isEmpty()) return false;
 
       RunManager runManager = RunManager.getInstance(project);
@@ -121,7 +122,8 @@ public abstract class ExecutorAction extends DumbAwareAction {
     else if (!ExecutionTargetManager.canRun(configuration, target)) {
       return false;
     }
-    return !ExecutionManager.getInstance(project).isStarting(executorId, runner.getRunnerId());
+    return !ExecutionManager.getInstance(project).isStarting(
+      settings.getUniqueID(), executorId, runner.getRunnerId());
   }
 
   private static boolean isValid(RunnerAndConfigurationSettings settings) {