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