platform/lang-impl/src/com/intellij/execution/impl/RunManagerImpl.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.intellij.execution.impl;
  18
  19 import com.intellij.execution.*;
  20 import com.intellij.execution.configurations.*;
  21 import com.intellij.ide.util.PropertiesComponent;
  22 import com.intellij.openapi.components.ProjectComponent;
  23 import com.intellij.openapi.extensions.Extensions;
  24 import com.intellij.openapi.project.Project;
  25 import com.intellij.openapi.util.*;
  26 import com.intellij.util.NullableFunction;
  27 import com.intellij.util.containers.ContainerUtil;
  28 import com.intellij.util.containers.WeakHashMap;
  29 import org.jdom.Element;
  30 import org.jetbrains.annotations.NonNls;
  31 import org.jetbrains.annotations.NotNull;
  32 import org.jetbrains.annotations.Nullable;
  33
  34 import java.util.*;
  35
  36
  37 public class RunManagerImpl extends RunManagerEx implements JDOMExternalizable, ProjectComponent {
  38   private final Project myProject;
  39
  40   private final Map<String, ConfigurationType> myTypesByName = new LinkedHashMap<String, ConfigurationType>();
  41
  42   private final Map<String, RunnerAndConfigurationSettingsImpl> myConfigurations =
  43       new LinkedHashMap<String, RunnerAndConfigurationSettingsImpl>(); // template configurations are not included here
  44   private final Map<Integer, Boolean> mySharedConfigurations = new TreeMap<Integer, Boolean>();
  45   /**
  46    * configurationID -> [BeforeTaskProviderName->BeforeRunTask]
  47    */
  48   private final Map<RunConfiguration, Map<Key<? extends BeforeRunTask>, BeforeRunTask>> myConfigurationToBeforeTasksMap =
  49     new WeakHashMap<RunConfiguration, Map<Key<? extends BeforeRunTask>, BeforeRunTask>>();
  50
  51   private final Map<String, RunnerAndConfigurationSettingsImpl> myTemplateConfigurationsMap =
  52       new HashMap<String, RunnerAndConfigurationSettingsImpl>();
  53   private RunnerAndConfigurationSettingsImpl mySelectedConfiguration = null;
  54   private String mySelectedConfig = null;
  55
  56   @NonNls
  57   protected static final String CONFIGURATION = "configuration";
  58   private ConfigurationType[] myTypes;
  59   private final RunManagerConfig myConfig;
  60   @NonNls
  61   protected static final String NAME_ATTR = "name";
  62   @NonNls
  63   protected static final String SELECTED_ATTR = "selected";
  64   @NonNls private static final String METHOD = "method";
  65   @NonNls private static final String OPTION = "option";
  66   @NonNls private static final String VALUE = "value";
  67
  68   private List<Element> myUnloadedElements = null;
  69   private JDOMExternalizableStringList myOrder = new JDOMExternalizableStringList();
  70
  71   public RunManagerImpl(final Project project,
  72                         PropertiesComponent propertiesComponent) {
  73     myConfig = new RunManagerConfig(propertiesComponent, this);
  74     myProject = project;
  75
  76     initConfigurationTypes();
  77   }
  78
  79   // separate method needed for tests
  80   public final void initializeConfigurationTypes(@NotNull final ConfigurationType[] factories) {
  81     Arrays.sort(factories, new Comparator<ConfigurationType>() {
  82       public int compare(final ConfigurationType o1, final ConfigurationType o2) {
  83         return o1.getDisplayName().compareTo(o2.getDisplayName());
  84       }
  85     });
  86
  87     final ArrayList<ConfigurationType> types = new ArrayList<ConfigurationType>(Arrays.asList(factories));
  88     types.add(UnknownConfigurationType.INSTANCE);
  89     myTypes = types.toArray(new ConfigurationType[types.size()]);
  90
  91     for (final ConfigurationType type : factories) {
  92       myTypesByName.put(type.getId(), type);
  93     }
  94
  95     final UnknownConfigurationType broken = UnknownConfigurationType.INSTANCE;
  96     myTypesByName.put(broken.getId(), broken);
  97   }
  98
  99   private void initConfigurationTypes() {
 100     final ConfigurationType[] configurationTypes = Extensions.getExtensions(ConfigurationType.CONFIGURATION_TYPE_EP);
 101     initializeConfigurationTypes(configurationTypes);
 102   }
 103
 104   public void disposeComponent() {
 105   }
 106
 107   public void initComponent() {
 108   }
 109
 110   public void projectOpened() {
 111   }
 112
 113   @NotNull
 114   public RunnerAndConfigurationSettingsImpl createConfiguration(final String name, final ConfigurationFactory factory) {
 115     return createConfiguration(doCreateConfiguration(name, factory), factory);
 116   }
 117
 118   protected RunConfiguration doCreateConfiguration(String name, ConfigurationFactory factory) {
 119     return factory.createConfiguration(name, getConfigurationTemplate(factory).getConfiguration());
 120   }
 121
 122   @NotNull
 123   public RunnerAndConfigurationSettingsImpl createConfiguration(final RunConfiguration runConfiguration,
 124                                                                 final ConfigurationFactory factory) {
 125     RunnerAndConfigurationSettingsImpl template = getConfigurationTemplate(factory);
 126     myConfigurationToBeforeTasksMap.put(runConfiguration, getBeforeRunTasks(template.getConfiguration()));
 127     shareConfiguration(runConfiguration, isConfigurationShared(template));
 128     RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(this, runConfiguration, false);
 129     settings.importRunnerAndConfigurationSettings(template);
 130     return settings;
 131   }
 132
 133   public void projectClosed() {
 134     myTemplateConfigurationsMap.clear();
 135   }
 136
 137   public RunManagerConfig getConfig() {
 138     return myConfig;
 139   }
 140
 141   public ConfigurationType[] getConfigurationFactories() {
 142     return myTypes.clone();
 143   }
 144
 145   public ConfigurationType[] getConfigurationFactories(final boolean includeUnknown) {
 146     final ConfigurationType[] configurationTypes = myTypes.clone();
 147     if (!includeUnknown) {
 148       final List<ConfigurationType> types = new ArrayList<ConfigurationType>();
 149       for (ConfigurationType configurationType : configurationTypes) {
 150         if (!(configurationType instanceof UnknownConfigurationType)) {
 151           types.add(configurationType);
 152         }
 153       }
 154
 155       return types.toArray(new ConfigurationType[types.size()]);
 156     }
 157
 158     return configurationTypes;
 159   }
 160
 161   /**
 162    * Template configuration is not included
 163    */
 164   public RunConfiguration[] getConfigurations(@NotNull final ConfigurationType type) {
 165
 166     final List<RunConfiguration> array = new ArrayList<RunConfiguration>();
 167     for (RunnerAndConfigurationSettingsImpl myConfiguration : getSortedConfigurations()) {
 168       final RunConfiguration configuration = myConfiguration.getConfiguration();
 169       final ConfigurationType configurationType = configuration.getType();
 170       if (type.getId().equals(configurationType.getId())) {
 171         array.add(configuration);
 172       }
 173     }
 174     return array.toArray(new RunConfiguration[array.size()]);
 175   }
 176
 177   public RunConfiguration[] getAllConfigurations() {
 178     RunConfiguration[] result = new RunConfiguration[myConfigurations.size()];
 179     int i = 0;
 180     for (Iterator<RunnerAndConfigurationSettingsImpl> iterator = getSortedConfigurations().iterator(); iterator.hasNext(); i++) {
 181       RunnerAndConfigurationSettings settings = iterator.next();
 182       result[i] = settings.getConfiguration();
 183     }
 184
 185     return result;
 186   }
 187
 188   @Nullable
 189   public RunnerAndConfigurationSettingsImpl getSettings(RunConfiguration configuration) {
 190     for (RunnerAndConfigurationSettingsImpl settings : getSortedConfigurations()) {
 191       if (settings.getConfiguration() == configuration) return settings;
 192     }
 193     return null;
 194   }
 195
 196   /**
 197    * Template configuration is not included
 198    */
 199   public RunnerAndConfigurationSettingsImpl[] getConfigurationSettings(@NotNull final ConfigurationType type) {
 200
 201     final LinkedHashSet<RunnerAndConfigurationSettingsImpl> array = new LinkedHashSet<RunnerAndConfigurationSettingsImpl>();
 202     for (RunnerAndConfigurationSettingsImpl configuration : getSortedConfigurations()) {
 203       final ConfigurationType configurationType = configuration.getType();
 204       if (configurationType != null && type.getId().equals(configurationType.getId())) {
 205         array.add(configuration);
 206       }
 207     }
 208     return array.toArray(new RunnerAndConfigurationSettingsImpl[array.size()]);
 209   }
 210
 211   public RunnerAndConfigurationSettingsImpl getConfigurationTemplate(final ConfigurationFactory factory) {
 212     RunnerAndConfigurationSettingsImpl template = myTemplateConfigurationsMap.get(factory.getType().getId() + "." + factory.getName());
 213     if (template == null) {
 214       template = new RunnerAndConfigurationSettingsImpl(this, factory.createTemplateConfiguration(myProject, this), true);
 215       if (template.getConfiguration() instanceof UnknownRunConfiguration) {
 216         ((UnknownRunConfiguration) template.getConfiguration()).setDoNotStore(true);
 217       }
 218       myTemplateConfigurationsMap.put(factory.getType().getId() + "." + factory.getName(), template);
 219     }
 220     return template;
 221   }
 222
 223   public void addConfiguration(RunnerAndConfigurationSettingsImpl settings, boolean shared, Map<Key<? extends BeforeRunTask>, BeforeRunTask> tasks) {
 224     final RunConfiguration configuration = settings.getConfiguration();
 225     final String configName = getUniqueName(configuration);
 226
 227     myConfigurations.put(configName, settings);
 228     checkRecentsLimit();
 229
 230     mySharedConfigurations.put(configuration.getUniqueID(), shared);
 231     setBeforeRunTasks(configuration, tasks);
 232   }
 233
 234   void checkRecentsLimit() {
 235     while (getTempConfigurations().length > getConfig().getRecentsLimit()) {
 236       for (Iterator<Map.Entry<String, RunnerAndConfigurationSettingsImpl>> it = myConfigurations.entrySet().iterator(); it.hasNext();) {
 237         Map.Entry<String, RunnerAndConfigurationSettingsImpl> entry = it.next();
 238         if (entry.getValue().isTemporary()) {
 239           it.remove();
 240           break;
 241         }
 242       }
 243     }
 244   }
 245
 246   public static String getUniqueName(final RunConfiguration settings) {
 247     return settings.getType().getDisplayName() + "." + settings.getName();
 248   }
 249
 250   public RunConfiguration getConfigurationByUniqueID(int id) {
 251     for (RunConfiguration each : getAllConfigurations()) {
 252       if (each.getUniqueID() == id) {
 253         return each;
 254       }
 255     }
 256     return null;
 257   }
 258
 259   public RunConfiguration getConfigurationByUniqueName(String name) {
 260     for (RunConfiguration each : getAllConfigurations()) {
 261       if (getUniqueName(each).equals(name)) {
 262         return each;
 263       }
 264     }
 265     return null;
 266   }
 267
 268   public void removeConfigurations(@NotNull final ConfigurationType type) {
 269
 270     //for (Iterator<Pair<RunConfiguration, JavaProgramRunner>> it = myRunnerPerConfigurationSettings.keySet().iterator(); it.hasNext();) {
 271     //  final Pair<RunConfiguration, JavaProgramRunner> pair = it.next();
 272     //  if (type.equals(pair.getFirst().getType())) {
 273     //    it.remove();
 274     //  }
 275     //}
 276     for (Iterator<RunnerAndConfigurationSettingsImpl> it = getSortedConfigurations().iterator(); it.hasNext();) {
 277       final RunnerAndConfigurationSettings configuration = it.next();
 278       final ConfigurationType configurationType = configuration.getType();
 279       if (configurationType != null && type.getId().equals(configurationType.getId())) {
 280         it.remove();
 281       }
 282     }
 283   }
 284
 285   @Override
 286   public Collection<RunnerAndConfigurationSettingsImpl> getSortedConfigurations() {
 287     if (myOrder != null && !myOrder.isEmpty()) { //compatibility
 288       final HashMap<String, RunnerAndConfigurationSettingsImpl> settings =
 289           new HashMap<String, RunnerAndConfigurationSettingsImpl>(myConfigurations); //sort shared and local configurations
 290       myConfigurations.clear();
 291       final List<String> order = new ArrayList<String>(settings.keySet());
 292       Collections.sort(order, new Comparator<String>() {
 293         public int compare(final String o1, final String o2) {
 294           return myOrder.indexOf(o1) - myOrder.indexOf(o2);
 295         }
 296       });
 297       for (String configName : order) {
 298         myConfigurations.put(configName, settings.get(configName));
 299       }
 300       myOrder = null;
 301     }
 302     return myConfigurations.values();
 303   }
 304
 305   @Override
 306   public void removeConfiguration(RunnerAndConfigurationSettingsImpl settings) {
 307     for (Iterator<RunnerAndConfigurationSettingsImpl> it = getSortedConfigurations().iterator(); it.hasNext();) {
 308       final RunnerAndConfigurationSettings configuration = it.next();
 309       if (configuration.equals(settings)) {
 310         if (mySelectedConfiguration != null && settings.equals(mySelectedConfiguration)) {
 311           setSelectedConfiguration(null);
 312         }
 313
 314         it.remove();
 315         break;
 316       }
 317     }
 318   }
 319
 320   public RunnerAndConfigurationSettingsImpl getSelectedConfiguration() {
 321     if (mySelectedConfiguration == null && mySelectedConfig != null) {
 322       mySelectedConfiguration = myConfigurations.get(mySelectedConfig);
 323       mySelectedConfig = null;
 324     }
 325     return mySelectedConfiguration;
 326   }
 327
 328   public void setSelectedConfiguration(final RunnerAndConfigurationSettingsImpl configuration) {
 329     mySelectedConfiguration = configuration;
 330   }
 331
 332   public static boolean canRunConfiguration(@NotNull final RunnerAndConfigurationSettingsImpl configuration, @NotNull final Executor executor) {
 333     try {
 334       configuration.checkSettings(executor);
 335     }
 336     catch (RuntimeConfigurationError er) {
 337       return false;
 338     }
 339     catch (RuntimeConfigurationException e) {
 340       return true;
 341     }
 342     return true;
 343   }
 344
 345   public void writeExternal(@NotNull final Element parentNode) throws WriteExternalException {
 346
 347     writeContext(parentNode);
 348     for (final RunnerAndConfigurationSettingsImpl runnerAndConfigurationSettings : myTemplateConfigurationsMap.values()) {
 349       if (runnerAndConfigurationSettings.getConfiguration() instanceof UnknownRunConfiguration) {
 350         if (((UnknownRunConfiguration) runnerAndConfigurationSettings.getConfiguration()).isDoNotStore()) {
 351           continue;
 352         }
 353       }
 354
 355       addConfigurationElement(parentNode, runnerAndConfigurationSettings);
 356     }
 357
 358     final Collection<RunnerAndConfigurationSettingsImpl> configurations = getStableConfigurations().values();
 359     for (RunnerAndConfigurationSettingsImpl configuration : configurations) {
 360       if (!isConfigurationShared(configuration)) {
 361         addConfigurationElement(parentNode, configuration);
 362       }
 363     }
 364
 365     final JDOMExternalizableStringList order = new JDOMExternalizableStringList();
 366
 367     //temp && stable configurations, !unknown
 368     order.addAll(ContainerUtil.findAll(myConfigurations.keySet(), new Condition<String>() {
 369       public boolean value(final String s) {
 370         return !s.startsWith(UnknownConfigurationType.NAME);
 371       }
 372     }));
 373
 374     order.writeExternal(parentNode);
 375
 376     if (myUnloadedElements != null) {
 377       for (Element unloadedElement : myUnloadedElements) {
 378         parentNode.addContent((Element)unloadedElement.clone());
 379       }
 380     }
 381   }
 382
 383   public void writeContext(Element parentNode) throws WriteExternalException {
 384     for (RunnerAndConfigurationSettingsImpl configurationSettings : myConfigurations.values()) {
 385       if (configurationSettings.isTemporary()) {
 386         addConfigurationElement(parentNode, configurationSettings, CONFIGURATION);
 387       }
 388     }
 389     if (mySelectedConfiguration != null) {
 390       parentNode.setAttribute(SELECTED_ATTR, getUniqueName(mySelectedConfiguration.getConfiguration()));
 391     }
 392   }
 393
 394   public void addConfigurationElement(final Element parentNode, RunnerAndConfigurationSettingsImpl template) throws WriteExternalException {
 395     addConfigurationElement(parentNode, template, CONFIGURATION);
 396   }
 397
 398   private void addConfigurationElement(final Element parentNode, RunnerAndConfigurationSettingsImpl settings, String elementType)
 399       throws WriteExternalException {
 400     final Element configurationElement = new Element(elementType);
 401     parentNode.addContent(configurationElement);
 402     settings.writeExternal(configurationElement);
 403
 404     if (!(settings.getConfiguration() instanceof UnknownRunConfiguration)) {
 405       final Map<Key<? extends BeforeRunTask>, BeforeRunTask> tasks = getBeforeRunTasks(settings.getConfiguration());
 406       Map<Key<? extends BeforeRunTask>, BeforeRunTask> templateTasks;
 407       if (!settings.isTemplate()) {
 408         final RunnerAndConfigurationSettingsImpl templateSettings = getConfigurationTemplate(settings.getFactory());
 409         templateTasks = getBeforeRunTasks(templateSettings.getConfiguration());
 410       }
 411       else {
 412         templateTasks = null;
 413       }
 414       final List<Key<? extends BeforeRunTask>> order = new ArrayList<Key<? extends BeforeRunTask>>(tasks.keySet());
 415       Collections.sort(order, new Comparator<Key<? extends BeforeRunTask>>() {
 416         public int compare(Key<? extends BeforeRunTask> o1, Key<? extends BeforeRunTask> o2) {
 417           return o1.toString().compareToIgnoreCase(o2.toString());
 418         }
 419       });
 420       final Element methodsElement = new Element(METHOD);
 421       for (Key<? extends BeforeRunTask> providerID : order) {
 422         final BeforeRunTask beforeRunTask = tasks.get(providerID);
 423
 424         if (templateTasks != null) {
 425           final BeforeRunTask templateTask = templateTasks.get(providerID);
 426           if (beforeRunTask.equals(templateTask)) {
 427             continue; // not neccesary saving if the task is the same as template
 428           }
 429         }
 430
 431         final Element child = new Element(OPTION);
 432         child.setAttribute(NAME_ATTR, providerID.toString());
 433         beforeRunTask.writeExternal(child);
 434         methodsElement.addContent(child);
 435       }
 436       configurationElement.addContent(methodsElement);
 437     }
 438   }
 439
 440   public void readExternal(final Element parentNode) throws InvalidDataException {
 441     clear();
 442
 443     final List children = parentNode.getChildren();
 444     for (final Object aChildren : children) {
 445       final Element element = (Element)aChildren;
 446       if (loadConfiguration(element, false) == null && Comparing.strEqual(element.getName(), CONFIGURATION)) {
 447         if (myUnloadedElements == null) myUnloadedElements = new ArrayList<Element>(2);
 448         myUnloadedElements.add(element);
 449       }
 450     }
 451
 452     myOrder.readExternal(parentNode);
 453
 454     mySelectedConfig = parentNode.getAttributeValue(SELECTED_ATTR);
 455   }
 456
 457   public void readContext(Element parentNode) throws InvalidDataException {
 458     final List children = parentNode.getChildren();
 459     mySelectedConfig = parentNode.getAttributeValue(SELECTED_ATTR);
 460     for (final Object aChildren : children) {
 461       final Element element = (Element)aChildren;
 462       if (mySelectedConfig == null && Boolean.valueOf(element.getAttributeValue(SELECTED_ATTR)).booleanValue()) {
 463         mySelectedConfig = element.getAttributeValue(RunnerAndConfigurationSettingsImpl.NAME_ATTR);
 464       }
 465       loadConfiguration(element, false);
 466     }
 467     if (mySelectedConfig != null) {
 468       RunnerAndConfigurationSettingsImpl configurationSettings = myConfigurations.get(mySelectedConfig);
 469       if (configurationSettings != null) {
 470         mySelectedConfiguration = null;
 471       }
 472     }
 473   }
 474
 475   private void clear() {
 476     myConfigurations.clear();
 477     myUnloadedElements = null;
 478     myConfigurationToBeforeTasksMap.clear();
 479     mySharedConfigurations.clear();
 480   }
 481
 482   @Nullable
 483   public RunnerAndConfigurationSettingsImpl loadConfiguration(final Element element, boolean isShared) throws InvalidDataException {
 484     RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(this);
 485     settings.readExternal(element);
 486     ConfigurationFactory factory = settings.getFactory();
 487     if (factory == null) {
 488       return null;
 489     }
 490
 491     final Element methodsElement = element.getChild(METHOD);
 492     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> map = readStepsBeforeRun(methodsElement, settings);
 493     if (settings.isTemplate()) {
 494       myTemplateConfigurationsMap.put(factory.getType().getId() + "." + factory.getName(), settings);
 495       setBeforeRunTasks(settings.getConfiguration(), map);
 496     }
 497     else {
 498       if (Boolean.valueOf(element.getAttributeValue(SELECTED_ATTR)).booleanValue()) { //to support old style
 499         mySelectedConfiguration = settings;
 500       }
 501       addConfiguration(settings, isShared, map);
 502     }
 503     return settings;
 504   }
 505
 506   @NotNull
 507   private Map<Key<? extends BeforeRunTask>, BeforeRunTask> readStepsBeforeRun(final Element child, RunnerAndConfigurationSettingsImpl settings) {
 508     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> map = new HashMap<Key<? extends BeforeRunTask>, BeforeRunTask>();
 509     if (child != null) {
 510       for (Object o : child.getChildren(OPTION)) {
 511         final Element methodElement = (Element)o;
 512         final String providerName = methodElement.getAttributeValue(NAME_ATTR);
 513         final Key<? extends BeforeRunTask> id = getProviderKey(providerName);
 514         final BeforeRunTaskProvider provider = getProvider(id);
 515         final BeforeRunTask beforeRunTask = provider.createTask(settings.getConfiguration());
 516         if (beforeRunTask != null) {
 517           beforeRunTask.readExternal(methodElement);
 518           map.put(id, beforeRunTask);
 519         }
 520       }
 521     }
 522     return map;
 523   }
 524
 525
 526   @Nullable
 527   public ConfigurationType getConfigurationType(final String typeName) {
 528     return myTypesByName.get(typeName);
 529   }
 530
 531   @Nullable
 532   public ConfigurationFactory getFactory(final String typeName, String factoryName) {
 533     final ConfigurationType type = myTypesByName.get(typeName);
 534     if (factoryName == null) {
 535       factoryName = type != null ? type.getConfigurationFactories()[0].getName() : null;
 536     }
 537     return findFactoryOfTypeNameByName(typeName, factoryName);
 538   }
 539
 540
 541   @Nullable
 542   private ConfigurationFactory findFactoryOfTypeNameByName(final String typeName, final String factoryName) {
 543     ConfigurationType type = myTypesByName.get(typeName);
 544     if (type == null) {
 545       type = myTypesByName.get(UnknownConfigurationType.NAME);
 546     }
 547
 548     return findFactoryOfTypeByName(type, factoryName);
 549   }
 550
 551   @Nullable
 552   private static ConfigurationFactory findFactoryOfTypeByName(final ConfigurationType type, final String factoryName) {
 553     if (factoryName == null) return null;
 554
 555     if (type instanceof UnknownConfigurationType) {
 556       return type.getConfigurationFactories()[0];
 557     }
 558
 559     final ConfigurationFactory[] factories = type.getConfigurationFactories();
 560     for (final ConfigurationFactory factory : factories) {
 561       if (factoryName.equals(factory.getName())) return factory;
 562     }
 563
 564     return null;
 565   }
 566
 567   @NotNull
 568   public String getComponentName() {
 569     return "RunManager";
 570   }
 571
 572   public void setTemporaryConfiguration(@NotNull final RunnerAndConfigurationSettingsImpl tempConfiguration) {
 573     tempConfiguration.setTemporary(true);
 574
 575     addConfiguration(tempConfiguration, isConfigurationShared(tempConfiguration),
 576                      getBeforeRunTasks(tempConfiguration.getConfiguration()));
 577     setActiveConfiguration(tempConfiguration);
 578   }
 579
 580   public void setActiveConfiguration(final RunnerAndConfigurationSettingsImpl configuration) {
 581     setSelectedConfiguration(configuration);
 582   }
 583
 584   public Map<String, RunnerAndConfigurationSettingsImpl> getStableConfigurations() {
 585     final Map<String, RunnerAndConfigurationSettingsImpl> result =
 586         new LinkedHashMap<String, RunnerAndConfigurationSettingsImpl>(myConfigurations);
 587     for (Iterator<Map.Entry<String, RunnerAndConfigurationSettingsImpl>> it = result.entrySet().iterator(); it.hasNext();) {
 588       Map.Entry<String, RunnerAndConfigurationSettingsImpl> entry = it.next();
 589       if (entry.getValue().isTemporary()) {
 590         it.remove();
 591       }
 592     }
 593     return result;
 594   }
 595
 596   public boolean isTemporary(final RunConfiguration configuration) {
 597     return Arrays.asList(getTempConfigurations()).contains(configuration);
 598   }
 599
 600   public boolean isTemporary(RunnerAndConfigurationSettingsImpl settings) {
 601     return settings.isTemporary();
 602   }
 603
 604   public RunConfiguration[] getTempConfigurations() {
 605     List<RunConfiguration> configurations = ContainerUtil.mapNotNull(myConfigurations.values(), new NullableFunction<RunnerAndConfigurationSettingsImpl, RunConfiguration>() {
 606       public RunConfiguration fun(RunnerAndConfigurationSettingsImpl settings) {
 607         return settings.isTemporary() ? settings.getConfiguration() : null;
 608       }
 609     });
 610     return configurations.toArray(new RunConfiguration[configurations.size()]);
 611   }
 612
 613   public void makeStable(final RunConfiguration configuration) {
 614     RunnerAndConfigurationSettingsImpl settings = getSettings(configuration);
 615     if (settings != null) {
 616       settings.setTemporary(false);
 617     }
 618   }
 619
 620   public RunnerAndConfigurationSettings createRunConfiguration(String name, ConfigurationFactory type) {
 621     return createConfiguration(name, type);
 622   }
 623
 624   public boolean isConfigurationShared(final RunnerAndConfigurationSettingsImpl settings) {
 625     Boolean shared = mySharedConfigurations.get(settings.getConfiguration().getUniqueID());
 626     if (shared == null) {
 627       final RunnerAndConfigurationSettingsImpl template = getConfigurationTemplate(settings.getFactory());
 628       shared = mySharedConfigurations.get(template.getConfiguration().getUniqueID());
 629     }
 630     return shared != null && shared.booleanValue();
 631   }
 632
 633   public <T extends BeforeRunTask> Collection<T> getBeforeRunTasks(Key<T> taskProviderID, boolean includeOnlyActiveTasks) {
 634     final Collection<T> tasks = new ArrayList<T>();
 635     if (includeOnlyActiveTasks) {
 636       final Set<RunnerAndConfigurationSettingsImpl> checkedTemplates = new HashSet<RunnerAndConfigurationSettingsImpl>();
 637       for (RunnerAndConfigurationSettingsImpl settings : myConfigurations.values()) {
 638         final BeforeRunTask runTask = getBeforeRunTask(settings.getConfiguration(), taskProviderID);
 639         if (runTask != null && runTask.isEnabled()) {
 640           tasks.add((T)runTask);
 641         }
 642         else {
 643           final RunnerAndConfigurationSettingsImpl template = getConfigurationTemplate(settings.getFactory());
 644           if (!checkedTemplates.contains(template)) {
 645             checkedTemplates.add(template);
 646             final BeforeRunTask templateTask = getBeforeRunTask(template.getConfiguration(), taskProviderID);
 647             if (templateTask != null && templateTask.isEnabled()) {
 648               tasks.add((T)templateTask);
 649             }
 650           }
 651         }
 652       }
 653     }
 654     else {
 655       for (RunnerAndConfigurationSettingsImpl settings : myTemplateConfigurationsMap.values()) {
 656         final T task = getBeforeRunTask(settings.getConfiguration(), taskProviderID);
 657         if (task != null) {
 658           tasks.add(task);
 659         }
 660       }
 661       for (RunnerAndConfigurationSettingsImpl settings : myConfigurations.values()) {
 662         final T task = getBeforeRunTask(settings.getConfiguration(), taskProviderID);
 663         if (task != null) {
 664           tasks.add(task);
 665         }
 666       }
 667     }
 668     return tasks;
 669   }
 670
 671   @Override
 672   @Nullable
 673   public RunnerAndConfigurationSettingsImpl findConfigurationByName(@NotNull String name) {
 674     return null;
 675   }
 676
 677   @Nullable
 678   public <T extends BeforeRunTask> T getBeforeRunTask(RunConfiguration settings, Key<T> taskProviderID) {
 679     Map<Key<? extends BeforeRunTask>, BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings);
 680     if (tasks == null) {
 681       tasks = getBeforeRunTasks(settings);
 682       myConfigurationToBeforeTasksMap.put(settings, tasks);
 683     }
 684     return (T)tasks.get(taskProviderID);
 685   }
 686
 687   public Map<Key<? extends BeforeRunTask>, BeforeRunTask> getBeforeRunTasks(final RunConfiguration settings) {
 688     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> tasks = myConfigurationToBeforeTasksMap.get(settings);
 689     if (tasks != null) {
 690       final Map<Key<? extends BeforeRunTask>, BeforeRunTask> _tasks = new HashMap<Key<? extends BeforeRunTask>, BeforeRunTask>();
 691       for (Map.Entry<Key<? extends BeforeRunTask>, BeforeRunTask> entry : tasks.entrySet()) {
 692         _tasks.put(entry.getKey(), entry.getValue().clone());
 693       }
 694       return _tasks;
 695     }
 696
 697     final RunnerAndConfigurationSettingsImpl template = getConfigurationTemplate(settings.getFactory());
 698     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> templateTasks = myConfigurationToBeforeTasksMap.get(template.getConfiguration());
 699     if (templateTasks != null) {
 700       final Map<Key<? extends BeforeRunTask>, BeforeRunTask> _tasks = new HashMap<Key<? extends BeforeRunTask>, BeforeRunTask>();
 701       for (Map.Entry<Key<? extends BeforeRunTask>, BeforeRunTask> entry : templateTasks.entrySet()) {
 702         _tasks.put(entry.getKey(), entry.getValue().clone());
 703       }
 704       return _tasks;
 705     }
 706
 707     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> _tasks = new HashMap<Key<? extends BeforeRunTask>, BeforeRunTask>();
 708     for (BeforeRunTaskProvider<? extends BeforeRunTask> provider : Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) {
 709       BeforeRunTask task = provider.createTask(settings);
 710       if (task != null) {
 711         Key<? extends BeforeRunTask> providerID = provider.getId();
 712         _tasks.put(providerID, task);
 713         settings.getFactory().configureBeforeRunTaskDefaults(providerID, task);
 714       }
 715     }
 716     return _tasks;
 717   }
 718
 719   public void shareConfiguration(final RunConfiguration runConfiguration, final boolean shareConfiguration) {
 720     mySharedConfigurations.put(runConfiguration.getUniqueID(), shareConfiguration);
 721   }
 722
 723   public final void setBeforeRunTasks(final RunConfiguration runConfiguration, Map<Key<? extends BeforeRunTask>, BeforeRunTask> tasks) {
 724     final Map<Key<? extends BeforeRunTask>, BeforeRunTask> taskMap = getBeforeRunTasks(runConfiguration);
 725     for (Map.Entry<Key<? extends BeforeRunTask>, BeforeRunTask> entry : tasks.entrySet()) {
 726       //if (taskMap.containsKey(entry.getKey())) {
 727         taskMap.put(entry.getKey(), entry.getValue());
 728       //}
 729     }
 730     myConfigurationToBeforeTasksMap.put(runConfiguration, taskMap);
 731   }
 732
 733   public final void resetBeforeRunTasks(final RunConfiguration runConfiguration) {
 734     myConfigurationToBeforeTasksMap.remove(runConfiguration);
 735   }
 736
 737   public void addConfiguration(final RunnerAndConfigurationSettingsImpl settings, final boolean isShared) {
 738     addConfiguration(settings, isShared, Collections.<Key<? extends BeforeRunTask>, BeforeRunTask>emptyMap());
 739   }
 740
 741   public static RunManagerImpl getInstanceImpl(final Project project) {
 742     return (RunManagerImpl)RunManager.getInstance(project);
 743   }
 744
 745   public void removeNotExistingSharedConfigurations(final Set<String> existing) {
 746     for (Iterator<Map.Entry<String, RunnerAndConfigurationSettingsImpl>> it = myConfigurations.entrySet().iterator(); it.hasNext();) {
 747       Map.Entry<String, RunnerAndConfigurationSettingsImpl> c = it.next();
 748       final RunnerAndConfigurationSettingsImpl o = c.getValue();
 749       if (!o.isTemplate() && isConfigurationShared(o) && !existing.contains(getUniqueName(o.getConfiguration()))) {
 750         it.remove();
 751       }
 752     }
 753   }
 754
 755   private Map<Key<? extends BeforeRunTask>, BeforeRunTaskProvider> myBeforeStepsMap;
 756   private Map<String, Key<? extends BeforeRunTask>> myProviderKeysMap;
 757
 758   @NotNull
 759   private synchronized BeforeRunTaskProvider getProvider(Key<? extends BeforeRunTask> providerId) {
 760     if (myBeforeStepsMap == null) {
 761       initProviderMaps();
 762     }
 763     return myBeforeStepsMap.get(providerId);
 764   }
 765
 766   @NotNull
 767   private synchronized Key<? extends BeforeRunTask> getProviderKey(String keyString) {
 768     if (myProviderKeysMap == null) {
 769       initProviderMaps();
 770     }
 771     Key<? extends BeforeRunTask> id = myProviderKeysMap.get(keyString);
 772     if (id == null) {
 773       final UnknownBeforeRunTaskProvider provider = new UnknownBeforeRunTaskProvider(keyString);
 774       id = provider.getId();
 775       myProviderKeysMap.put(keyString, id);
 776       myBeforeStepsMap.put(id, provider);
 777     }
 778     return id;
 779   }
 780
 781   private void initProviderMaps() {
 782     myBeforeStepsMap = new HashMap<Key<? extends BeforeRunTask>, BeforeRunTaskProvider>();
 783     myProviderKeysMap = new HashMap<String, Key<? extends BeforeRunTask>>();
 784     for (BeforeRunTaskProvider<? extends BeforeRunTask> provider : Extensions.getExtensions(BeforeRunTaskProvider.EXTENSION_POINT_NAME, myProject)) {
 785       final Key<? extends BeforeRunTask> id = provider.getId();
 786       myBeforeStepsMap.put(id, provider);
 787       myProviderKeysMap.put(id.toString(), id);
 788     }
 789   }
 790
 791
 792 }