Merge remote-tracking branch 'origin/master'

java/compiler/impl/src/com/intellij/packaging/impl/artifacts/ArtifactUtil.java

@@ -26,10 +26,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VfsUtilCore;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.packaging.artifacts.Artifact;
-import com.intellij.packaging.artifacts.ArtifactManager;
-import com.intellij.packaging.artifacts.ArtifactProperties;
-import com.intellij.packaging.artifacts.ArtifactType;
+import com.intellij.packaging.artifacts.*;
 import com.intellij.packaging.elements.*;
 import com.intellij.packaging.impl.elements.*;
 import com.intellij.util.PathUtil;
@@ -599,5 +596,31 @@ public class ArtifactUtil {
   public static String suggestArtifactFileName(String artifactName) {
     return PathUtil.suggestFileName(artifactName, true, true);
   }
+
+  @Nullable
+  public static Artifact addArtifact(@NotNull ModifiableArtifactModel artifactModel,
+                                     @NotNull ArtifactType type,
+                                     @NotNull ArtifactTemplate artifactTemplate) {
+    final ArtifactTemplate.NewArtifactConfiguration configuration = artifactTemplate.createArtifact();
+    if (configuration == null) {
+      return null;
+    }
+
+    final String baseName = configuration.getArtifactName();
+    String name = baseName;
+    int i = 2;
+    while (artifactModel.findArtifact(name) != null) {
+      name = baseName + i;
+      i++;
+    }
+
+    ArtifactType actualType = configuration.getArtifactType();
+    if (actualType == null) {
+      actualType = type;
+    }
+    final ModifiableArtifact artifact = artifactModel.addArtifact(name, actualType, configuration.getRootElement());
+    artifactTemplate.setUpArtifact(artifact, configuration);
+    return artifact;
+  }
 }
 

java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/artifacts/ArtifactsStructureConfigurable.java

@@ -286,25 +286,7 @@ public class ArtifactsStructureConfigurable extends BaseStructureConfigurable {
   }
 
   private void addArtifact(@NotNull ArtifactType type, @NotNull ArtifactTemplate artifactTemplate) {
-    final ArtifactTemplate.NewArtifactConfiguration configuration = artifactTemplate.createArtifact();
-    if (configuration == null) {
-      return;
-    }
-
-    final String baseName = configuration.getArtifactName();
-    String name = baseName;
-    int i = 2;
-    while (myPackagingEditorContext.getArtifactModel().findArtifact(name) != null) {
-      name = baseName + i;
-      i++;
-    }
-
-    ArtifactType actualType = configuration.getArtifactType();
-    if (actualType == null) {
-      actualType = type;
-    }
-    final ModifiableArtifact artifact = myPackagingEditorContext.getOrCreateModifiableArtifactModel().addArtifact(name, actualType, configuration.getRootElement());
-    artifactTemplate.setUpArtifact(artifact, configuration);
+    Artifact artifact = ArtifactUtil.addArtifact(myPackagingEditorContext.getOrCreateModifiableArtifactModel(), type, artifactTemplate);
     selectNodeInTree(findNodeByObject(myRoot, artifact));
   }
 

java/remote-servers/impl/src/META-INF/RemoteServersJava.xml

@@ -2,7 +2,7 @@
 
   <extensionPoints>
     <extensionPoint qualifiedName="com.intellij.remoteServer.moduleBuilderContribution"
-                    interface="com.intellij.remoteServer.impl.module.CloudModuleBuilderContribution"/>
+                    interface="com.intellij.remoteServer.impl.module.CloudModuleBuilderContributionFactory"/>
   </extensionPoints>
 
   <extensions defaultExtensionNs="com.intellij">

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfigurable.java

@@ -15,152 +15,20 @@
  */
 package com.intellij.remoteServer.impl.module;
 
-import com.intellij.openapi.Disposable;
 import com.intellij.openapi.options.ConfigurationException;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
 import com.intellij.remoteServer.configuration.RemoteServer;
-import com.intellij.remoteServer.runtime.Deployment;
-import com.intellij.remoteServer.runtime.ServerConnection;
-import com.intellij.remoteServer.runtime.ServerConnector;
-import com.intellij.remoteServer.runtime.deployment.ServerRuntimeInstance;
-import com.intellij.remoteServer.util.*;
-import com.intellij.util.concurrency.Semaphore;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
-import javax.swing.*;
-import java.util.Collection;
-import java.util.concurrent.atomic.AtomicReference;
+import java.awt.*;
 
 
-public abstract class CloudApplicationConfigurable<
-  SC extends CloudConfigurationBase,
-  DC extends CloudDeploymentNameConfiguration,
-  SR extends CloudMultiSourceServerRuntimeInstance<DC, ?, ?, ?>,
-  AC extends CloudApplicationConfiguration> {
+public abstract class CloudApplicationConfigurable {
 
-  private final Project myProject;
-  private final Disposable myParentDisposable;
+  public abstract Component getComponent();
 
-  private DelayedRunner myRunner;
+  public abstract void setAccount(RemoteServer<?> account);
 
-  private RemoteServer<?> myAccount;
-
-  public CloudApplicationConfigurable(@Nullable Project project, Disposable parentDisposable) {
-    myProject = project;
-    myParentDisposable = parentDisposable;
-  }
-
-  public void setAccount(RemoteServer<?> account) {
-    myAccount = account;
-    clearCloudData();
-  }
-
-  protected RemoteServer<SC> getAccount() {
-    return (RemoteServer<SC>)myAccount;
-  }
-
-  public JComponent getComponent() {
-    JComponent result = getMainPanel();
-    if (myRunner == null) {
-      myRunner = new DelayedRunner(result) {
-
-        private RemoteServer<?> myPreviousAccount;
-
-        @Override
-        protected boolean wasChanged() {
-          boolean result = myPreviousAccount != myAccount;
-          if (result) {
-            myPreviousAccount = myAccount;
-          }
-          return result;
-        }
-
-        @Override
-        protected void run() {
-          loadCloudData();
-        }
-      };
-      Disposer.register(myParentDisposable, myRunner);
-    }
-    return result;
-  }
-
-  protected void clearCloudData() {
-    getExistingComboBox().removeAllItems();
-  }
-
-  protected void loadCloudData() {
-    new ConnectionTask<Collection<Deployment>>("Loading existing applications list") {
-
-      @Override
-      protected void run(final ServerConnection<DC> connection,
-                         final Semaphore semaphore,
-                         final AtomicReference<Collection<Deployment>> result) {
-        connection.connectIfNeeded(new ServerConnector.ConnectionCallback<DC>() {
-
-          @Override
-          public void connected(@NotNull ServerRuntimeInstance<DC> serverRuntimeInstance) {
-            connection.computeDeployments(new Runnable() {
-
-              @Override
-              public void run() {
-                result.set(connection.getDeployments());
-                semaphore.up();
-                UIUtil.invokeLaterIfNeeded(new Runnable() {
-                  @Override
-                  public void run() {
-                    if (!Disposer.isDisposed(myParentDisposable)) {
-                      setupExistingApplications(result.get());
-                    }
-                  }
-                });
-              }
-            });
-          }
-
-          @Override
-          public void errorOccurred(@NotNull String errorMessage) {
-            runtimeErrorOccurred(errorMessage);
-            semaphore.up();
-          }
-        });
-      }
-
-      @Override
-      protected Collection<Deployment> run(SR serverRuntimeInstance) throws ServerRuntimeException {
-        return null;
-      }
-    }.performAsync();
-  }
-
-  private void setupExistingApplications(Collection<Deployment> deployments) {
-    JComboBox existingComboBox = getExistingComboBox();
-    existingComboBox.removeAllItems();
-    for (Deployment deployment : deployments) {
-      existingComboBox.addItem(deployment.getName());
-    }
-  }
-
-  protected Project getProject() {
-    return myProject;
-  }
-
-  protected abstract JComboBox getExistingComboBox();
-
-  protected abstract JComponent getMainPanel();
-
-  public abstract AC createConfiguration();
+  public abstract CloudApplicationConfiguration createConfiguration();
 
   public abstract void validate() throws ConfigurationException;
-
-  protected abstract class ConnectionTask<T> extends CloudConnectionTask<T, SC, DC, SR> {
-
-    public ConnectionTask(String title) {
-      super(myProject, title, CloudApplicationConfigurable.this.getAccount());
-    }
-  }
 }
 

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfiguration.java

@@ -18,19 +18,4 @@ package com.intellij.remoteServer.impl.module;
 
 public abstract class CloudApplicationConfiguration {
 
-  private boolean myExisting;
-  private final String myExistingAppName;
-
-  protected CloudApplicationConfiguration(boolean existing, String existingAppName) {
-    myExisting = existing;
-    myExistingAppName = existingAppName;
-  }
-
-  public boolean isExisting() {
-    return myExisting;
-  }
-
-  public String getExistingAppName() {
-    return myExistingAppName;
-  }
 }

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java

@@ -16,6 +16,7 @@
 package com.intellij.remoteServer.impl.module;
 
 import com.intellij.icons.AllIcons;
+import com.intellij.ide.util.newProjectWizard.impl.FrameworkSupportModelBase;
 import com.intellij.ide.util.projectWizard.JavaModuleBuilder;
 import com.intellij.ide.util.projectWizard.ModuleBuilderListener;
 import com.intellij.ide.util.projectWizard.ModuleWizardStep;
@@ -23,20 +24,42 @@ import com.intellij.ide.util.projectWizard.WizardContext;
 import com.intellij.openapi.Disposable;
 import com.intellij.openapi.module.JavaModuleType;
 import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.openapi.roots.ui.configuration.ModulesProvider;
+import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainer;
+import com.intellij.openapi.roots.ui.configuration.projectRoot.LibrariesContainerFactory;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.remoteServer.ServerType;
 import com.intellij.remoteServer.configuration.RemoteServer;
+import com.intellij.util.containers.hash.HashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
+import java.util.Map;
 
 
 public class CloudModuleBuilder extends JavaModuleBuilder {
 
   private RemoteServer<?> myAccount;
   private CloudApplicationConfiguration myApplicationConfiguration;
+  private FrameworkSupportModelBase myFrameworkSupportModel;
+
+  private Map<ServerType<?>, CloudModuleBuilderContribution> myCloudType2Contribution;
+  private Project myProject;
 
   public CloudModuleBuilder() {
+    myCloudType2Contribution = new HashMap<ServerType<?>, CloudModuleBuilderContribution>();
+
+    ModuleConfigurationUpdater configurationUpdater = new ModuleConfigurationUpdater() {
+
+      public void update(@NotNull final Module module, @NotNull final ModifiableRootModel rootModel) {
+        preConfigureModule(module, rootModel);
+      }
+    };
+    addModuleConfigurationUpdater(configurationUpdater);
+
     addListener(new ModuleBuilderListener() {
 
       @Override
@@ -93,19 +116,59 @@ public class CloudModuleBuilder extends JavaModuleBuilder {
   @Nullable
   @Override
   public ModuleWizardStep getCustomOptionsStep(WizardContext context, Disposable parentDisposable) {
-    return new CloudModuleWizardStep(this, context.getProject(), parentDisposable);
+    myProject = context.getProject();
+    return new CloudModuleWizardStep(this, myProject, parentDisposable);
   }
 
   public void setAccount(RemoteServer<?> account) {
     myAccount = account;
   }
 
+  public RemoteServer<?> getAccount() {
+    return myAccount;
+  }
+
   public void setApplicationConfiguration(CloudApplicationConfiguration applicationConfiguration) {
     myApplicationConfiguration = applicationConfiguration;
   }
 
+  public CloudApplicationConfiguration getApplicationConfiguration() {
+    return myApplicationConfiguration;
+  }
+
+  public CloudModuleBuilderContribution getContribution(ServerType<?> cloudType) {
+    CloudModuleBuilderContribution result = myCloudType2Contribution.get(cloudType);
+    if (result == null) {
+      result = CloudModuleBuilderContributionFactory.getInstanceByType(cloudType).createContribution(this);
+      myCloudType2Contribution.put(cloudType, result);
+    }
+    return result;
+  }
+
+  private CloudModuleBuilderContribution getContribution() {
+    return getContribution(myAccount.getType());
+  }
+
+  private void preConfigureModule(Module module, ModifiableRootModel model) {
+    getContribution().preConfigureModule(module, model);
+  }
+
   private void configureModule(final Module module) {
-    CloudModuleBuilderContribution
-      .getInstanceByType(myAccount.getType()).configureModule(module, myAccount, myApplicationConfiguration, getContentEntryPath());
+    getContribution().configureModule(module);
+  }
+
+  public FrameworkSupportModelBase getFrameworkSupportModel() {
+    if (myFrameworkSupportModel == null) {
+      final LibrariesContainer librariesContainer = LibrariesContainerFactory.createContainer(myProject);
+      myFrameworkSupportModel = new FrameworkSupportModelBase(myProject, this, librariesContainer) {
+
+        @NotNull
+        @Override
+        public String getBaseDirectoryForLibrariesPath() {
+          return StringUtil.notNullize(getContentEntryPath());
+        }
+      };
+    }
+    return myFrameworkSupportModel;
   }
 }

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContribution.java

@@ -16,34 +16,51 @@
 package com.intellij.remoteServer.impl.module;
 
 import com.intellij.openapi.Disposable;
-import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.module.Module;
 import com.intellij.openapi.project.Project;
+import com.intellij.openapi.roots.ModifiableRootModel;
 import com.intellij.remoteServer.ServerType;
-import com.intellij.remoteServer.configuration.RemoteServer;
+import com.intellij.remoteServer.configuration.deployment.DeploymentConfiguration;
+import com.intellij.remoteServer.configuration.deployment.DeploymentSource;
 import org.jetbrains.annotations.Nullable;
 
 
 public abstract class CloudModuleBuilderContribution {
 
-  public static final ExtensionPointName<CloudModuleBuilderContribution> EP_NAME
-    = ExtensionPointName.create("com.intellij.remoteServer.moduleBuilderContribution");
+  private final CloudModuleBuilder myModuleBuilder;
 
-  public abstract ServerType<?> getCloudType();
+  private final ServerType<?> myCloudType;
+  private CloudApplicationConfigurable myApplicationConfigurable;
 
-  public abstract CloudApplicationConfigurable createApplicationConfigurable(@Nullable Project project, Disposable parentDisposable);
+  public CloudModuleBuilderContribution(CloudModuleBuilder moduleBuilder, ServerType<?> cloudType) {
+    myModuleBuilder = moduleBuilder;
+    myCloudType = cloudType;
+  }
 
-  public abstract void configureModule(Module module,
-                                       RemoteServer<?> account,
-                                       CloudApplicationConfiguration configuration,
-                                       String contentPath);
+  protected CloudModuleBuilder getModuleBuilder() {
+    return myModuleBuilder;
+  }
 
-  public static CloudModuleBuilderContribution getInstanceByType(ServerType<?> cloudType) {
-    for (CloudModuleBuilderContribution contribution : EP_NAME.getExtensions()) {
-      if (contribution.getCloudType() == cloudType) {
-        return contribution;
-      }
+  protected ServerType<?> getCloudType() {
+    return myCloudType;
+  }
+
+  public CloudApplicationConfigurable getApplicationConfigurable(@Nullable Project project, Disposable parentDisposable) {
+    if (myApplicationConfigurable == null) {
+      myApplicationConfigurable = createApplicationConfigurable(project, parentDisposable);
     }
-    return null;
+    return myApplicationConfigurable;
+  }
+
+  public void preConfigureModule(Module module, ModifiableRootModel model) {
+
+  }
+
+  public abstract void configureModule(Module module);
+
+  protected abstract CloudApplicationConfigurable createApplicationConfigurable(@Nullable Project project, Disposable parentDisposable);
+
+  protected DeploymentConfiguration createDeploymentConfiguration(DeploymentSource deploymentSource) {
+    return myCloudType.createDeploymentConfigurator(null).createDefaultConfiguration(deploymentSource);
   }
 }

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionFactory.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.remoteServer.impl.module;
+
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.remoteServer.ServerType;
+
+
+public abstract class CloudModuleBuilderContributionFactory {
+
+  public static final ExtensionPointName<CloudModuleBuilderContributionFactory> EP_NAME
+    = ExtensionPointName.create("com.intellij.remoteServer.moduleBuilderContribution");
+
+  public abstract ServerType<?> getCloudType();
+
+  public abstract CloudModuleBuilderContribution createContribution(CloudModuleBuilder moduleBuilder);
+
+  public static CloudModuleBuilderContributionFactory getInstanceByType(ServerType<?> cloudType) {
+    for (CloudModuleBuilderContributionFactory contribution : EP_NAME.getExtensions()) {
+      if (contribution.getCloudType() == cloudType) {
+        return contribution;
+      }
+    }
+    return null;
+  }
+}

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderSourceContribution.java

@@ -41,29 +41,24 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 
-public abstract class CloudModuleBuilderContributionBase<
+public abstract class CloudModuleBuilderSourceContribution<
   SC extends CloudConfigurationBase,
   DC extends CloudDeploymentNameConfiguration,
-  AC extends CloudApplicationConfiguration,
+  AC extends CloudSourceApplicationConfiguration,
   SR extends CloudMultiSourceServerRuntimeInstance<DC, ?, ?, ?>>
   extends CloudModuleBuilderContribution {
 
   private CloudNotifier myNotifier;
 
-  private CloudNotifier getNotifier() {
-    if (myNotifier == null) {
-      myNotifier = new CloudNotifier(getCloudType().getPresentableName());
-    }
-    return myNotifier;
+  public CloudModuleBuilderSourceContribution(CloudModuleBuilder moduleBuilder, ServerType<SC> cloudType) {
+    super(moduleBuilder, cloudType);
   }
 
   @Override
-  public void configureModule(final Module module,
-                              RemoteServer<?> account,
-                              CloudApplicationConfiguration applicationConfiguration,
-                              final String contentPath) {
-    RemoteServer<SC> castedAccount = (RemoteServer<SC>)account;
-    final AC castedApplicationConfiguration = (AC)applicationConfiguration;
+  public void configureModule(final Module module) {
+    final CloudModuleBuilder moduleBuilder = getModuleBuilder();
+    RemoteServer<SC> account = (RemoteServer<SC>)moduleBuilder.getAccount();
+    final AC applicationConfiguration = (AC)moduleBuilder.getApplicationConfiguration();
 
     DC deploymentConfiguration = createDeploymentConfiguration();
 
@@ -73,19 +68,19 @@ public abstract class CloudModuleBuilderContributionBase<
     }
 
     final DeployToServerRunConfiguration<SC, DC> runConfiguration
-      = CloudAccountSelectionEditor.createRunConfiguration(castedAccount, module, deploymentConfiguration);
+      = CloudRunConfigurationUtil.createRunConfiguration(account, module, deploymentConfiguration);
 
     final ServerType<?> cloudType = account.getType();
     final Project project = module.getProject();
     new CloudConnectionTask<Object, SC, DC, SR>(project,
                                                 CloudBundle.getText("cloud.support", cloudType.getPresentableName()),
-                                                castedAccount) {
+                                                account) {
 
       boolean myFirstAttempt = true;
 
       @Override
       protected Object run(SR serverRuntime) throws ServerRuntimeException {
-        doConfigureModule(castedApplicationConfiguration, runConfiguration, myFirstAttempt, serverRuntime);
+        doConfigureModule(applicationConfiguration, runConfiguration, myFirstAttempt, serverRuntime);
         return null;
       }
 
@@ -97,7 +92,7 @@ public abstract class CloudModuleBuilderContributionBase<
 
       @Override
       protected void postPerform(Object result) {
-        detectModuleStructure(module, contentPath);
+        detectModuleStructure(module, moduleBuilder.getContentEntryPath());
       }
 
       @Override
@@ -107,6 +102,13 @@ public abstract class CloudModuleBuilderContributionBase<
     }.performAsync();
   }
 
+  private CloudNotifier getNotifier() {
+    if (myNotifier == null) {
+      myNotifier = new CloudNotifier(getCloudType().getPresentableName());
+    }
+    return myNotifier;
+  }
+
   private void detectModuleStructure(Module module, final String contentPath) {
     final Project project = module.getProject();
 
@@ -177,11 +179,8 @@ public abstract class CloudModuleBuilderContributionBase<
   }
 
   @Override
-  public abstract ServerType<SC> getCloudType();
-
-  @Override
-  public abstract CloudApplicationConfigurable<SC, DC, SR, AC> createApplicationConfigurable(@Nullable Project project,
-                                                                                             Disposable parentDisposable);
+  protected abstract CloudSourceApplicationConfigurable<SC, DC, SR, AC> createApplicationConfigurable(@Nullable Project project,
+                                                                                                      Disposable parentDisposable);
 
   protected abstract DC createDeploymentConfiguration();
 

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleWizardStep.java

@@ -22,13 +22,13 @@ import com.intellij.openapi.project.Project;
 import com.intellij.remoteServer.ServerType;
 import com.intellij.remoteServer.configuration.RemoteServer;
 import com.intellij.remoteServer.util.CloudAccountSelectionEditor;
-import com.intellij.util.containers.hash.HashMap;
+import com.intellij.util.containers.HashSet;
 
 import javax.swing.*;
 import java.awt.*;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
+import java.util.Set;
 
 
 public class CloudModuleWizardStep extends ModuleWizardStep {
@@ -43,17 +43,17 @@ public class CloudModuleWizardStep extends ModuleWizardStep {
 
   private CloudAccountSelectionEditor myAccountSelectionPanel;
 
-  private Map<ServerType<?>, CloudApplicationConfigurable> myCloudType2ApplicationConfigurable;
+  private Set<ServerType<?>> myApplicationConfigurableTypes;
 
   public CloudModuleWizardStep(CloudModuleBuilder moduleBuilder, Project project, Disposable parentDisposable) {
     myModuleBuilder = moduleBuilder;
     myProject = project;
     myParentDisposable = parentDisposable;
 
-    myCloudType2ApplicationConfigurable = new HashMap<ServerType<?>, CloudApplicationConfigurable>();
+    myApplicationConfigurableTypes = new HashSet<ServerType<?>>();
 
     List<ServerType<?>> cloudTypes = new ArrayList<ServerType<?>>();
-    for (CloudModuleBuilderContribution contribution : CloudModuleBuilderContribution.EP_NAME.getExtensions()) {
+    for (CloudModuleBuilderContributionFactory contribution : CloudModuleBuilderContributionFactory.EP_NAME.getExtensions()) {
       cloudTypes.add(contribution.getCloudType());
     }
 
@@ -86,11 +86,8 @@ public class CloudModuleWizardStep extends ModuleWizardStep {
 
     ServerType<?> cloudType = account.getType();
     String cardName = cloudType.getId();
-    CloudApplicationConfigurable<?, ?, ?, ?> applicationConfigurable = getApplicationConfigurable();
-    if (applicationConfigurable == null) {
-      applicationConfigurable
-        = CloudModuleBuilderContribution.getInstanceByType(cloudType).createApplicationConfigurable(myProject, myParentDisposable);
-      myCloudType2ApplicationConfigurable.put(cloudType, applicationConfigurable);
+    CloudApplicationConfigurable applicationConfigurable = getApplicationConfigurable();
+    if (myApplicationConfigurableTypes.add(cloudType)) {
       myApplicationPanelPlaceHolder.add(applicationConfigurable.getComponent(), cardName);
     }
     applicationPlaceHolderLayout.show(myApplicationPanelPlaceHolder, cardName);
@@ -103,25 +100,25 @@ public class CloudModuleWizardStep extends ModuleWizardStep {
     return myMainPanel;
   }
 
-  private CloudApplicationConfigurable<?, ?, ?, ?> getApplicationConfigurable() {
+  private CloudApplicationConfigurable getApplicationConfigurable() {
     RemoteServer<?> account = getSelectedAccount();
     if (account == null) {
       return null;
     }
-    return myCloudType2ApplicationConfigurable.get(account.getType());
+    return myModuleBuilder.getContribution(account.getType()).getApplicationConfigurable(myProject, myParentDisposable);
   }
 
   @Override
   public void updateDataModel() {
     myModuleBuilder.setAccount(myAccountSelectionPanel.getSelectedAccount());
-    CloudApplicationConfigurable<?, ?, ?, ?> configurable = getApplicationConfigurable();
+    CloudApplicationConfigurable configurable = getApplicationConfigurable();
     myModuleBuilder.setApplicationConfiguration(configurable == null ? null : configurable.createConfiguration());
   }
 
   @Override
   public boolean validate() throws ConfigurationException {
     myAccountSelectionPanel.validate();
-    CloudApplicationConfigurable<?, ?, ?, ?> configurable = getApplicationConfigurable();
+    CloudApplicationConfigurable configurable = getApplicationConfigurable();
     if (configurable != null) {
       configurable.validate();
     }

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfigurable.java

@@ -0,0 +1,165 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.remoteServer.impl.module;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.remoteServer.configuration.RemoteServer;
+import com.intellij.remoteServer.runtime.Deployment;
+import com.intellij.remoteServer.runtime.ServerConnection;
+import com.intellij.remoteServer.runtime.ServerConnector;
+import com.intellij.remoteServer.runtime.deployment.ServerRuntimeInstance;
+import com.intellij.remoteServer.util.*;
+import com.intellij.util.concurrency.Semaphore;
+import com.intellij.util.ui.UIUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.swing.*;
+import java.util.Collection;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+public abstract class CloudSourceApplicationConfigurable<
+  SC extends CloudConfigurationBase,
+  DC extends CloudDeploymentNameConfiguration,
+  SR extends CloudMultiSourceServerRuntimeInstance<DC, ?, ?, ?>,
+  AC extends CloudApplicationConfiguration> extends CloudApplicationConfigurable {
+
+  private final Project myProject;
+  private final Disposable myParentDisposable;
+
+  private DelayedRunner myRunner;
+
+  private RemoteServer<?> myAccount;
+
+  public CloudSourceApplicationConfigurable(@Nullable Project project, Disposable parentDisposable) {
+    myProject = project;
+    myParentDisposable = parentDisposable;
+  }
+
+  @Override
+  public void setAccount(RemoteServer<?> account) {
+    myAccount = account;
+    clearCloudData();
+  }
+
+  protected RemoteServer<SC> getAccount() {
+    return (RemoteServer<SC>)myAccount;
+  }
+
+  @Override
+  public JComponent getComponent() {
+    JComponent result = getMainPanel();
+    if (myRunner == null) {
+      myRunner = new DelayedRunner(result) {
+
+        private RemoteServer<?> myPreviousAccount;
+
+        @Override
+        protected boolean wasChanged() {
+          boolean result = myPreviousAccount != myAccount;
+          if (result) {
+            myPreviousAccount = myAccount;
+          }
+          return result;
+        }
+
+        @Override
+        protected void run() {
+          loadCloudData();
+        }
+      };
+      Disposer.register(myParentDisposable, myRunner);
+    }
+    return result;
+  }
+
+  protected void clearCloudData() {
+    getExistingComboBox().removeAllItems();
+  }
+
+  protected void loadCloudData() {
+    new ConnectionTask<Collection<Deployment>>("Loading existing applications list") {
+
+      @Override
+      protected void run(final ServerConnection<DC> connection,
+                         final Semaphore semaphore,
+                         final AtomicReference<Collection<Deployment>> result) {
+        connection.connectIfNeeded(new ServerConnector.ConnectionCallback<DC>() {
+
+          @Override
+          public void connected(@NotNull ServerRuntimeInstance<DC> serverRuntimeInstance) {
+            connection.computeDeployments(new Runnable() {
+
+              @Override
+              public void run() {
+                result.set(connection.getDeployments());
+                semaphore.up();
+                UIUtil.invokeLaterIfNeeded(new Runnable() {
+                  @Override
+                  public void run() {
+                    if (!Disposer.isDisposed(myParentDisposable)) {
+                      setupExistingApplications(result.get());
+                    }
+                  }
+                });
+              }
+            });
+          }
+
+          @Override
+          public void errorOccurred(@NotNull String errorMessage) {
+            runtimeErrorOccurred(errorMessage);
+            semaphore.up();
+          }
+        });
+      }
+
+      @Override
+      protected Collection<Deployment> run(SR serverRuntimeInstance) throws ServerRuntimeException {
+        return null;
+      }
+    }.performAsync();
+  }
+
+  private void setupExistingApplications(Collection<Deployment> deployments) {
+    JComboBox existingComboBox = getExistingComboBox();
+    existingComboBox.removeAllItems();
+    for (Deployment deployment : deployments) {
+      existingComboBox.addItem(deployment.getName());
+    }
+  }
+
+  protected Project getProject() {
+    return myProject;
+  }
+
+  protected abstract JComboBox getExistingComboBox();
+
+  protected abstract JComponent getMainPanel();
+
+  @Override
+  public abstract AC createConfiguration();
+
+  protected abstract class ConnectionTask<T> extends CloudConnectionTask<T, SC, DC, SR> {
+
+    public ConnectionTask(String title) {
+      super(myProject, title, CloudSourceApplicationConfigurable.this.getAccount());
+    }
+  }
+}

java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfiguration.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.remoteServer.impl.module;
+
+
+public abstract class CloudSourceApplicationConfiguration extends CloudApplicationConfiguration {
+
+  private boolean myExisting;
+  private final String myExistingAppName;
+
+  protected CloudSourceApplicationConfiguration(boolean existing, String existingAppName) {
+    myExisting = existing;
+    myExistingAppName = existingAppName;
+  }
+
+  public boolean isExisting() {
+    return myExisting;
+  }
+
+  public String getExistingAppName() {
+    return myExistingAppName;
+  }
+}

platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudAccountSelectionEditor.java

@@ -15,9 +15,6 @@
  */
 package com.intellij.remoteServer.util;
 
-import com.intellij.execution.RunManagerEx;
-import com.intellij.execution.RunnerAndConfigurationSettings;
-import com.intellij.execution.configurations.ConfigurationType;
 import com.intellij.ide.DataManager;
 import com.intellij.ide.actions.ShowSettingsUtilImpl;
 import com.intellij.ide.util.projectWizard.WizardContext;
@@ -25,11 +22,8 @@ import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.DefaultActionGroup;
 import com.intellij.openapi.module.Module;
-import com.intellij.openapi.module.ModulePointer;
-import com.intellij.openapi.module.ModulePointerManager;
 import com.intellij.openapi.options.ConfigurationException;
 import com.intellij.openapi.options.ex.SingleConfigurableEditor;
-import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.ComboBox;
 import com.intellij.openapi.ui.popup.JBPopupFactory;
 import com.intellij.openapi.util.Condition;
@@ -38,12 +32,7 @@ import com.intellij.openapi.util.Ref;
 import com.intellij.remoteServer.ServerType;
 import com.intellij.remoteServer.configuration.RemoteServer;
 import com.intellij.remoteServer.configuration.RemoteServersManager;
-import com.intellij.remoteServer.configuration.ServerConfiguration;
-import com.intellij.remoteServer.configuration.deployment.DeploymentConfiguration;
 import com.intellij.remoteServer.impl.configuration.RemoteServerConfigurable;
-import com.intellij.remoteServer.impl.configuration.deployment.DeployToServerConfigurationType;
-import com.intellij.remoteServer.impl.configuration.deployment.DeployToServerRunConfiguration;
-import com.intellij.remoteServer.impl.configuration.deployment.ModuleDeploymentSourceImpl;
 import com.intellij.util.Consumer;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.hash.HashMap;
@@ -224,52 +213,7 @@ public class CloudAccountSelectionEditor {
     if (account == null) {
       return;
     }
-    createRunConfiguration(account, module, configuration);
-  }
-
-  public static <SC extends ServerConfiguration, DC extends DeploymentConfiguration>
-  DeployToServerRunConfiguration<SC, DC> createRunConfiguration(RemoteServer<SC> account, Module module, DC deploymentConfiguration) {
-
-    Project project = module.getProject();
-
-    String accountName = account.getName();
-
-    String name = generateRunConfigurationName(accountName, module.getName());
-
-    final RunManagerEx runManager = RunManagerEx.getInstanceEx(project);
-    final RunnerAndConfigurationSettings runSettings
-      = runManager.createRunConfiguration(name, getRunConfigurationType(account.getType()).getConfigurationFactories()[0]);
-
-    final DeployToServerRunConfiguration<SC, DC> result = (DeployToServerRunConfiguration<SC, DC>)runSettings.getConfiguration();
-
-    result.setServerName(accountName);
-
-    final ModulePointer modulePointer = ModulePointerManager.getInstance(project).create(module);
-    result.setDeploymentSource(new ModuleDeploymentSourceImpl(modulePointer));
-
-    result.setDeploymentConfiguration(deploymentConfiguration);
-
-    runManager.addConfiguration(runSettings, false);
-    runManager.setSelectedConfiguration(runSettings);
-
-    return result;
-  }
-
-  private static DeployToServerConfigurationType getRunConfigurationType(ServerType<?> cloudType) {
-    String id = DeployToServerConfigurationType.getId(cloudType);
-    for (ConfigurationType configurationType : ConfigurationType.CONFIGURATION_TYPE_EP.getExtensions()) {
-      if (configurationType instanceof DeployToServerConfigurationType) {
-        DeployToServerConfigurationType deployConfigurationType = (DeployToServerConfigurationType)configurationType;
-        if (deployConfigurationType.getId().equals(id)) {
-          return deployConfigurationType;
-        }
-      }
-    }
-    return null;
-  }
-
-  private static String generateRunConfigurationName(String serverName, String moduleName) {
-    return CloudBundle.getText("run.configuration.name", serverName, moduleName);
+    CloudRunConfigurationUtil.createRunConfiguration(account, module, configuration);
   }
 
   private static class AccountItem {

platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudRunConfigurationUtil.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2000-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.remoteServer.util;
+
+import com.intellij.execution.RunManagerEx;
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.configuration.ConfigurationFactoryEx;
+import com.intellij.execution.configurations.ConfigurationFactory;
+import com.intellij.execution.configurations.ConfigurationType;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModulePointer;
+import com.intellij.openapi.module.ModulePointerManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.remoteServer.ServerType;
+import com.intellij.remoteServer.configuration.RemoteServer;
+import com.intellij.remoteServer.configuration.ServerConfiguration;
+import com.intellij.remoteServer.configuration.deployment.DeploymentConfiguration;
+import com.intellij.remoteServer.configuration.deployment.DeploymentSource;
+import com.intellij.remoteServer.impl.configuration.deployment.DeployToServerConfigurationType;
+import com.intellij.remoteServer.impl.configuration.deployment.DeployToServerRunConfiguration;
+import com.intellij.remoteServer.impl.configuration.deployment.ModuleDeploymentSourceImpl;
+
+
+public class CloudRunConfigurationUtil {
+
+  public static <SC extends ServerConfiguration, DC extends DeploymentConfiguration>
+  DeployToServerRunConfiguration<SC, DC> createRunConfiguration(RemoteServer<SC> account, Module module, DC deploymentConfiguration) {
+    final ModulePointer modulePointer = ModulePointerManager.getInstance(module.getProject()).create(module);
+    DeploymentSource deploymentSource = new ModuleDeploymentSourceImpl(modulePointer);
+    return createRunConfiguration(account, module, deploymentSource, deploymentConfiguration);
+  }
+
+  public static <SC extends ServerConfiguration, DC extends DeploymentConfiguration>
+  DeployToServerRunConfiguration<SC, DC> createRunConfiguration(RemoteServer<SC> account,
+                                                                Module module,
+                                                                DeploymentSource deploymentSource,
+                                                                DC deploymentConfiguration) {
+    Project project = module.getProject();
+
+    String accountName = account.getName();
+
+    String name = generateRunConfigurationName(accountName, module.getName());
+
+    final RunManagerEx runManager = RunManagerEx.getInstanceEx(project);
+    ConfigurationFactory configurationFactory = getRunConfigurationType(account.getType()).getConfigurationFactories()[0];
+    final RunnerAndConfigurationSettings runSettings = runManager.createRunConfiguration(name, configurationFactory);
+
+    final DeployToServerRunConfiguration<SC, DC> result = (DeployToServerRunConfiguration<SC, DC>)runSettings.getConfiguration();
+
+    result.setServerName(accountName);
+
+    result.setDeploymentSource(deploymentSource);
+
+    result.setDeploymentConfiguration(deploymentConfiguration);
+
+    ((ConfigurationFactoryEx)configurationFactory).onNewConfigurationCreated(runSettings.getConfiguration());
+
+    runManager.addConfiguration(runSettings, false);
+    runManager.setSelectedConfiguration(runSettings);
+
+    return result;
+  }
+
+  private static DeployToServerConfigurationType getRunConfigurationType(ServerType<?> cloudType) {
+    String id = DeployToServerConfigurationType.getId(cloudType);
+    for (ConfigurationType configurationType : ConfigurationType.CONFIGURATION_TYPE_EP.getExtensions()) {
+      if (configurationType instanceof DeployToServerConfigurationType) {
+        DeployToServerConfigurationType deployConfigurationType = (DeployToServerConfigurationType)configurationType;
+        if (deployConfigurationType.getId().equals(id)) {
+          return deployConfigurationType;
+        }
+      }
+    }
+    return null;
+  }
+
+  private static String generateRunConfigurationName(String serverName, String moduleName) {
+    return CloudBundle.getText("run.configuration.name", serverName, moduleName);
+  }
+}