From 2d38816d150f4adfa2940b59ba29552a6abb5cb5 Mon Sep 17 00:00:00 2001 From: Vladimir Krivosheev Date: Mon, 10 Apr 2017 13:25:22 +0200 Subject: [PATCH] ensute that RC level is set correctly on load (cherry picked from commit a4d3f0947eba37fab477464e20d48dbb1588406d) --- .../src/com/intellij/execution/RunManager.kt | 7 +- .../RunnerAndConfigurationSettings.java | 7 +- .../com/intellij/execution/RunManagerEx.java | 31 ++-- .../execution/actions/CreateAction.java | 16 +- .../impl/BaseRCSettingsConfigurable.java | 11 +- .../impl/ModuleRunConfigurationManager.java | 6 +- .../impl/ProjectRunConfigurationManager.java | 6 +- .../intellij/execution/impl/RunManagerImpl.kt | 175 ++++++++---------- .../RunnerAndConfigurationSettingsImpl.kt | 14 +- .../impl/SingleConfigurationConfigurable.java | 2 +- .../src/com/intellij/mock/MockRunManager.kt | 7 +- .../lang/ant/config/explorer/AntExplorer.java | 4 +- 12 files changed, 137 insertions(+), 149 deletions(-) diff --git a/platform/lang-api/src/com/intellij/execution/RunManager.kt b/platform/lang-api/src/com/intellij/execution/RunManager.kt index bd7930ec4fde..f9405c136545 100644 --- a/platform/lang-api/src/com/intellij/execution/RunManager.kt +++ b/platform/lang-api/src/com/intellij/execution/RunManager.kt @@ -155,13 +155,18 @@ abstract class RunManager { */ abstract fun getConfigurationTemplate(factory: ConfigurationFactory): RunnerAndConfigurationSettings + /** + * Adds the specified run configuration to the list of run configurations. + */ + abstract fun addConfiguration(settings: RunnerAndConfigurationSettings) + /** * Adds the specified run configuration to the list of run configurations stored in the project. * @param settings the run configuration settings. * @param isShared true if the configuration is marked as shared (stored in the versioned part of the project files), false if it's local * * (stored in the workspace file). */ - abstract fun addConfiguration(settings: RunnerAndConfigurationSettings, isShared: Boolean) + abstract fun addConfiguration(settings: RunnerAndConfigurationSettings, isShawred: Boolean) /** * Marks the specified run configuration as recently used (the temporary run configurations are deleted in LRU order). diff --git a/platform/lang-api/src/com/intellij/execution/RunnerAndConfigurationSettings.java b/platform/lang-api/src/com/intellij/execution/RunnerAndConfigurationSettings.java index 025cffbbad5c..8864b58aa612 100644 --- a/platform/lang-api/src/com/intellij/execution/RunnerAndConfigurationSettings.java +++ b/platform/lang-api/src/com/intellij/execution/RunnerAndConfigurationSettings.java @@ -41,10 +41,9 @@ public interface RunnerAndConfigurationSettings { /** * Returns the factory used to create the run configuration. * - * @return the factory, or null if the settings object was loaded from disk and no plugin corresponding to the stored type of the run - * configuration is loaded. + * @return the factory */ - @Nullable + @NotNull ConfigurationFactory getFactory(); /** @@ -209,4 +208,6 @@ public interface RunnerAndConfigurationSettings { * @return the folder name, or null if the configuration is displayed on the top level. */ @Nullable String getFolderName(); + + } diff --git a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java index 4e7131723c45..5f68fe926169 100644 --- a/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java +++ b/platform/lang-impl/src/com/intellij/execution/RunManagerEx.java @@ -17,6 +17,7 @@ package com.intellij.execution; import com.intellij.execution.configurations.ConfigurationType; import com.intellij.execution.configurations.RunConfiguration; +import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Key; import org.jetbrains.annotations.NotNull; @@ -34,10 +35,10 @@ public abstract class RunManagerEx extends RunManager { } /** - * @deprecated use {@link #setSelectedConfiguration(RunnerAndConfigurationSettings)} instead + * @deprecated Use {@link #setSelectedConfiguration(RunnerAndConfigurationSettings)} instead */ @Deprecated - public void setActiveConfiguration(@Nullable RunnerAndConfigurationSettings configuration) { + public final void setActiveConfiguration(@Nullable RunnerAndConfigurationSettings configuration) { setSelectedConfiguration(configuration); } @@ -46,18 +47,26 @@ public abstract class RunManagerEx extends RunManager { @NotNull public abstract RunManagerConfig getConfig(); - public void addConfiguration(@NotNull RunnerAndConfigurationSettings settings) { - addConfiguration(settings, settings.isShared(), null, false); - } - public void addConfiguration(@NotNull RunnerAndConfigurationSettings settings, boolean isShared) { - addConfiguration(settings, isShared, null, false); + if (isShared) { + ((RunnerAndConfigurationSettingsImpl)settings).setLevel(RunnerAndConfigurationSettingsImpl.Level.PROJECT); + } + addConfiguration(settings); } - public abstract void addConfiguration(RunnerAndConfigurationSettings settings, - boolean isShared, - List tasks, - boolean addTemplateTasksIfAbsent); + @Deprecated + public final void addConfiguration(RunnerAndConfigurationSettings settings, boolean isShared, List tasks, boolean addTemplateTasksIfAbsent) { + if (isShared) { + ((RunnerAndConfigurationSettingsImpl)settings).setLevel(RunnerAndConfigurationSettingsImpl.Level.PROJECT); + } + addConfiguration(settings, tasks, addTemplateTasksIfAbsent); + } + + @Deprecated + public void addConfiguration(@NotNull RunnerAndConfigurationSettings settings, @NotNull List tasks, boolean addTemplateTasksIfAbsent) { + setBeforeRunTasks(settings.getConfiguration(), tasks, addTemplateTasksIfAbsent); + addConfiguration(settings); + } @SuppressWarnings("MethodMayBeStatic") @Deprecated diff --git a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java index e4a2baaeef3d..8af49fa43374 100644 --- a/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java +++ b/platform/lang-impl/src/com/intellij/execution/actions/CreateAction.java @@ -19,7 +19,6 @@ package com.intellij.execution.actions; import com.intellij.execution.ExecutionBundle; import com.intellij.execution.RunManager; import com.intellij.execution.RunnerAndConfigurationSettings; -import com.intellij.execution.configurations.RunConfiguration; import com.intellij.execution.impl.RunDialog; import com.intellij.execution.impl.RunManagerImpl; import com.intellij.openapi.actionSystem.Presentation; @@ -122,14 +121,9 @@ public class CreateAction extends BaseRunConfigurationAction { @Override public void perform(final ConfigurationContext context) { - final RunManagerImpl runManager = (RunManagerImpl)context.getRunManager(); - final RunnerAndConfigurationSettings configuration = context.getConfiguration(); - final RunnerAndConfigurationSettings template = runManager.getConfigurationTemplate(configuration.getFactory()); - final RunConfiguration templateConfiguration = template.getConfiguration(); - runManager.addConfiguration(configuration, - template.isShared(), - runManager.getBeforeRunTasks(templateConfiguration), - false); + RunManagerImpl runManager = (RunManagerImpl)context.getRunManager(); + RunnerAndConfigurationSettings configuration = context.getConfiguration(); + runManager.addConfiguration(configuration, runManager.getConfigurationTemplate(configuration.getFactory()).isShared()); runManager.setSelectedConfiguration(configuration); } } @@ -146,9 +140,7 @@ public class CreateAction extends BaseRunConfigurationAction { final RunnerAndConfigurationSettings configuration = context.getConfiguration(); if (RunDialog.editConfiguration(context.getProject(), configuration, ExecutionBundle.message("create.run.configuration.for.item.dialog.title", configuration.getName()))) { final RunManagerImpl runManager = (RunManagerImpl)context.getRunManager(); - runManager.addConfiguration(configuration, - configuration.isShared(), - runManager.getBeforeRunTasks(configuration.getConfiguration()), false); + runManager.addConfiguration(configuration); runManager.setSelectedConfiguration(configuration); } } diff --git a/platform/lang-impl/src/com/intellij/execution/impl/BaseRCSettingsConfigurable.java b/platform/lang-impl/src/com/intellij/execution/impl/BaseRCSettingsConfigurable.java index f1ffbbc534a8..d9f138ec595d 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/BaseRCSettingsConfigurable.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/BaseRCSettingsConfigurable.java @@ -38,15 +38,14 @@ abstract class BaseRCSettingsConfigurable extends SettingsEditorConfigurable>?, addEnabledTemplateTasksIfAbsent: Boolean) { - val existingId = findExistingConfigurationId(settings) + override fun addConfiguration(settings: RunnerAndConfigurationSettings) { val newId = settings.uniqueID var existingSettings: RunnerAndConfigurationSettings? = null + var existingId: String? = null + lock.write { + existingId = findExistingConfigurationId(settings) + existingId?.let { + existingSettings = idToSettings.remove(it) + } - if (existingId != null) { - existingSettings = idToSettings.remove(existingId) + if (selectedConfigurationId != null && selectedConfigurationId == existingId) { + setSelectedConfigurationId(newId) + } + idToSettings.put(newId, settings) + + if (existingId == null) { + refreshUsagesList(settings.configuration) + } + + if (!settings.isShared && existingSettings !== settings) { + schemeManager.addScheme(settings as RunConfigurationScheme) + } } - if (selectedConfigurationId != null && selectedConfigurationId == existingId) { - setSelectedConfigurationId(newId) - } - idToSettings.put(newId, settings) - - val configuration = settings.configuration - if (existingId == null) { - refreshUsagesList(configuration) - } checkRecentsLimit() - if (shared) { - settings.isTemporary = false - } - - if (tasks != null) { - setBeforeRunTasks(configuration, tasks, addEnabledTemplateTasksIfAbsent) - } - if (existingSettings === settings) { myDispatcher.multicaster.runConfigurationChanged(settings, existingId) } else { - runConfigurationAdded(settings, shared) + myDispatcher.multicaster.runConfigurationAdded(settings) } } - private fun runConfigurationAdded(settings: RunnerAndConfigurationSettings, shared: Boolean) { - if (!shared) { - schemeManager.addScheme(settings as RunConfigurationScheme) - } - - myDispatcher.multicaster.runConfigurationAdded(settings) - } - override fun refreshUsagesList(profile: RunProfile) { if (profile !is RunConfiguration) return val settings = getSettings(profile) @@ -331,14 +323,16 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent fun checkRecentsLimit() { trimUsagesListToLimit() val removed = SmartList() - while (tempConfigurationsList.size > config.recentsLimit) { - val it = idToSettings.values.iterator() - while (it.hasNext()) { - val configuration = it.next() - if (configuration.isTemporary && !recentlyUsedTemporaries.contains(configuration.configuration)) { - removed.add(configuration) - it.remove() - break + lock.write { + while (tempConfigurationsList.size > config.recentsLimit) { + val it = idToSettings.values.iterator() + while (it.hasNext()) { + val settings = it.next() + if (settings.isTemporary && !recentlyUsedTemporaries.contains(settings.configuration)) { + removed.add(settings) + it.remove() + break + } } } } @@ -508,32 +502,21 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent } fun writeContext(element: Element) { - val values = ArrayList(idToSettings.values) - for (configurationSettings in values) { - if (configurationSettings.isTemporary) { - addConfigurationElement(element, configurationSettings) - } - } + writeConfigurations(element, lock.read { idToSettings.values.filterSmart { it.isTemporary } }) selectedConfiguration?.let { element.setAttribute(SELECTED_ATTR, it.uniqueID) } } - fun addConfigurationElement(parentNode: Element, settings: RunnerAndConfigurationSettings) { - val configurationElement = Element(CONFIGURATION) - parentNode.addContent(configurationElement) - (settings as RunnerAndConfigurationSettingsImpl).writeExternal(configurationElement) - writeBeforeRunTasks(settings.configuration, settings.isTemplate, configurationElement) + fun writeConfigurations(parentNode: Element, settings: Collection) { + settings.forEach { parentNode.addContent((it as RunnerAndConfigurationSettingsImpl).writeScheme()) } } - internal fun writeBeforeRunTasks(configuration: RunConfiguration, isTemplate: Boolean, configurationElement: Element) { - if (configuration is UnknownRunConfiguration) { - return - } - - val tasks = if (isTemplate) configuration.beforeRunTasks else getEffectiveBeforeRunTasks(configuration, ownIsOnlyEnabled = false, isDisableTemplateTasks = true) - if (tasks.isEmpty()) { + internal fun writeBeforeRunTasks(settings: RunnerAndConfigurationSettings, configurationElement: Element) { + val configuration = settings.configuration + val tasks = if (settings.isTemplate) configuration.beforeRunTasks else getEffectiveBeforeRunTasks(configuration, ownIsOnlyEnabled = false, isDisableTemplateTasks = true) + if (tasks.isEmpty() && settings.isNewSerializationAllowed) { return } @@ -624,8 +607,8 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent fireRunConfigurationSelected() } - fun findExistingConfigurationId(settings: RunnerAndConfigurationSettings?): String? { - if (settings != null) { + fun findExistingConfigurationId(settings: RunnerAndConfigurationSettings): String? { + lock.read { for ((key, value) in idToSettings) { if (value === settings) { return key @@ -681,21 +664,25 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent settings.readExternal(element, isShared) } - val factory = settings.factory ?: return null - doLoadConfiguration(element, isShared, settings, factory) + if (isShared) { + settings.level = RunnerAndConfigurationSettingsImpl.Level.PROJECT + } + + doLoadConfiguration(element, settings) return settings } - private fun doLoadConfiguration(element: Element, isShared: Boolean, settings: RunnerAndConfigurationSettingsImpl, factory: ConfigurationFactory) { + private fun doLoadConfiguration(element: Element, settings: RunnerAndConfigurationSettingsImpl) { val tasks = element.getChild(METHOD)?.let { readStepsBeforeRun(it, settings) } ?: emptyList() settings.configuration.beforeRunTasks = tasks if (settings.isTemplate) { + val factory = settings.factory lock.write { templateIdToConfiguration.put("${factory.type.id}.${factory.name}", settings) } } else { - addConfiguration(settings, isShared, null, false) + addConfiguration(settings) if (element.getAttributeValue(SELECTED_ATTR).toBoolean()) { // to support old style selectedConfiguration = settings @@ -754,17 +741,19 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent } } - fun getStableConfigurations(shared: Boolean): Collection { - var result: MutableList? = null - for (configuration in idToSettings.values) { - if (!configuration.isTemporary && configuration.isShared == shared) { - if (result == null) { - result = SmartList() + fun getSharedConfigurations(): List { + lock.read { + var result: MutableList? = null + for (configuration in idToSettings.values) { + if (configuration.isShared) { + if (result == null) { + result = ArrayList() + } + result.add(configuration) } - result.add(configuration) } + return result ?: emptyList() } - return ContainerUtil.notNullize(result) } internal val configurationSettings: Collection @@ -1012,16 +1001,18 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent fun removeNotExistingSharedConfigurations(existing: Set) { var removed: MutableList? = null - val it = idToSettings.entries.iterator() - while (it.hasNext()) { - val entry = it.next() - val settings = entry.value - if (!settings.isTemplate && settings.isShared && !existing.contains(settings.uniqueID)) { - if (removed == null) { - removed = SmartList() + lock.write { + val it = idToSettings.entries.iterator() + while (it.hasNext()) { + val entry = it.next() + val settings = entry.value + if (!settings.isTemplate && settings.isShared && !existing.contains(settings.uniqueID)) { + if (removed == null) { + removed = SmartList() + } + removed!!.add(settings) + it.remove() } - removed.add(settings) - it.remove() } } fireRunConfigurationsRemoved(removed) @@ -1042,9 +1033,7 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent private fun fireRunConfigurationsRemoved(removed: List?) { if (removed != null && !removed.isEmpty()) { recentlyUsedTemporaries.removeAll(removed.map { it.configuration }) - for (settings in removed) { - myDispatcher.multicaster.runConfigurationRemoved(settings) - } + removed.forEach { myDispatcher.multicaster.runConfigurationRemoved(it) } } } @@ -1106,10 +1095,10 @@ class RunManagerImpl(internal val project: Project) : RunManagerEx(), Persistent internal interface RunConfigurationScheme : Scheme -private class UnknownRunConfigurationScheme(private val name: String) : RunConfigurationScheme, SerializableScheme { - override fun getSchemeState() = SchemeState.UNCHANGED - - override fun writeScheme() = throw AssertionError("Must be not called") - - override fun getName() = name -} \ No newline at end of file +//private class UnknownRunConfigurationScheme(private val name: String) : RunConfigurationScheme, SerializableScheme { +// override fun getSchemeState() = SchemeState.UNCHANGED +// +// override fun writeScheme() = throw AssertionError("Must be not called") +// +// override fun getName() = name +//} \ No newline at end of file diff --git a/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.kt b/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.kt index ccb622196514..79beaa71044a 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.kt +++ b/platform/lang-impl/src/com/intellij/execution/impl/RunnerAndConfigurationSettingsImpl.kt @@ -67,13 +67,13 @@ class RunnerAndConfigurationSettingsImpl @JvmOverloads constructor(private val m override fun createSettings(runner: ProgramRunner<*>) = configuration!!.createRunnerSettings(InfoProvider(runner)) } - internal var level = Level.WORKSPACE + var level = Level.WORKSPACE private var isEditBeforeRun = false private var isActivateToolWindowBeforeRun = true private var wasSingletonSpecifiedExplicitly = false private var folderName: String? = null - override fun getFactory() = configuration?.factory + override fun getFactory(): ConfigurationFactory = configuration?.factory ?: UnknownConfigurationType.FACTORY override fun isTemplate() = isTemplate @@ -197,8 +197,8 @@ class RunnerAndConfigurationSettingsImpl @JvmOverloads constructor(private val m } fun writeExternal(element: Element) { - val configuration = configuration - val factory = configuration!!.factory + val configuration = getConfiguration() + val factory = configuration.factory if (configuration !is UnknownRunConfiguration) { if (isTemplate) { element.setAttribute(TEMPLATE_FLAG_ATTRIBUTE, "true") @@ -249,7 +249,7 @@ class RunnerAndConfigurationSettingsImpl @JvmOverloads constructor(private val m writeExternal(element) configuration?.let { - manager.writeBeforeRunTasks(it, isTemplate, element) + manager.writeBeforeRunTasks(this, element) } return element @@ -473,3 +473,7 @@ class RunnerAndConfigurationSettingsImpl @JvmOverloads constructor(private val m } } } + +// always write method element for shared settings for now due to preserve backward compatibility +val RunnerAndConfigurationSettings.isNewSerializationAllowed: Boolean + get() = !isShared \ No newline at end of file diff --git a/platform/lang-impl/src/com/intellij/execution/impl/SingleConfigurationConfigurable.java b/platform/lang-impl/src/com/intellij/execution/impl/SingleConfigurationConfigurable.java index 4a6b2420ad2e..ac171cf7ce01 100644 --- a/platform/lang-impl/src/com/intellij/execution/impl/SingleConfigurationConfigurable.java +++ b/platform/lang-impl/src/com/intellij/execution/impl/SingleConfigurationConfigurable.java @@ -125,7 +125,7 @@ public final class SingleConfigurationConfigurable() - fun isTemporary(configuration: RunConfiguration) = false - override fun makeStable(configuration: RunConfiguration) {} override fun makeStable(settings: RunnerAndConfigurationSettings) {} @@ -77,10 +75,7 @@ class MockRunManager : RunManagerEx() { throw UnsupportedOperationException() } - override fun addConfiguration(settings: RunnerAndConfigurationSettings, - isShared: Boolean, - tasks: List>, - addTemplateTasksIfAbsent: Boolean) { + override fun addConfiguration(settings: RunnerAndConfigurationSettings) { } override fun getBeforeRunTasks(configuration: RunConfiguration): List> { diff --git a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntExplorer.java b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntExplorer.java index 4374ad125ed5..6eeb3dd80dc6 100644 --- a/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntExplorer.java +++ b/plugins/ant/src/com/intellij/lang/ant/config/explorer/AntExplorer.java @@ -637,9 +637,7 @@ public class AntExplorer extends SimpleToolWindowPanel implements DataProvider, configuration.acceptSettings(target); if (RunDialog.editConfiguration(e.getProject(), settings, ExecutionBundle .message("create.run.configuration.for.item.dialog.title", configuration.getName()))) { - runManager.addConfiguration(settings, - settings.isShared(), - runManager.getBeforeRunTasks(settings.getConfiguration()), false); + runManager.addConfiguration(settings); runManager.setSelectedConfiguration(settings); } }