diff --git a/java/compiler/impl/src/com/intellij/packaging/impl/artifacts/ArtifactUtil.java b/java/compiler/impl/src/com/intellij/packaging/impl/artifacts/ArtifactUtil.java index 5752c3f5f77b..3fcfc8df5529 100644 --- a/java/compiler/impl/src/com/intellij/packaging/impl/artifacts/ArtifactUtil.java +++ b/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; + } } diff --git a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/artifacts/ArtifactsStructureConfigurable.java b/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/artifacts/ArtifactsStructureConfigurable.java index 52b601e4d9fe..5deea9c75f74 100644 --- a/java/idea-ui/src/com/intellij/openapi/roots/ui/configuration/artifacts/ArtifactsStructureConfigurable.java +++ b/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)); } diff --git a/java/remote-servers/impl/src/META-INF/RemoteServersJava.xml b/java/remote-servers/impl/src/META-INF/RemoteServersJava.xml index 24a0776ccd29..692199e3bb2c 100644 --- a/java/remote-servers/impl/src/META-INF/RemoteServersJava.xml +++ b/java/remote-servers/impl/src/META-INF/RemoteServersJava.xml @@ -2,7 +2,7 @@ + interface="com.intellij.remoteServer.impl.module.CloudModuleBuilderContributionFactory"/> diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfigurable.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfigurable.java index 14bd043a7f23..e235eeeb55aa 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfigurable.java +++ b/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, - 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 getAccount() { - return (RemoteServer)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>("Loading existing applications list") { - - @Override - protected void run(final ServerConnection connection, - final Semaphore semaphore, - final AtomicReference> result) { - connection.connectIfNeeded(new ServerConnector.ConnectionCallback() { - - @Override - public void connected(@NotNull ServerRuntimeInstance 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 run(SR serverRuntimeInstance) throws ServerRuntimeException { - return null; - } - }.performAsync(); - } - - private void setupExistingApplications(Collection 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 extends CloudConnectionTask { - - public ConnectionTask(String title) { - super(myProject, title, CloudApplicationConfigurable.this.getAccount()); - } - } } diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfiguration.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfiguration.java index 9af0f1ad472b..af9fa723e82a 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudApplicationConfiguration.java +++ b/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; - } } diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java index 25b60523a0b3..62e256c14c8e 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilder.java +++ b/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, CloudModuleBuilderContribution> myCloudType2Contribution; + private Project myProject; public CloudModuleBuilder() { + myCloudType2Contribution = new HashMap, 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; } } diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContribution.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContribution.java index 945812ae05e0..dd2d9d9af563 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContribution.java +++ b/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 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); } } diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionFactory.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionFactory.java new file mode 100644 index 000000000000..20ebc29fe148 --- /dev/null +++ b/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 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; + } +} diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionBase.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderSourceContribution.java similarity index 85% rename from java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionBase.java rename to java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderSourceContribution.java index 3652e4e757db..b5fdcc3995c8 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleBuilderContributionBase.java +++ b/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> extends CloudModuleBuilderContribution { private CloudNotifier myNotifier; - private CloudNotifier getNotifier() { - if (myNotifier == null) { - myNotifier = new CloudNotifier(getCloudType().getPresentableName()); - } - return myNotifier; + public CloudModuleBuilderSourceContribution(CloudModuleBuilder moduleBuilder, ServerType cloudType) { + super(moduleBuilder, cloudType); } @Override - public void configureModule(final Module module, - RemoteServer account, - CloudApplicationConfiguration applicationConfiguration, - final String contentPath) { - RemoteServer castedAccount = (RemoteServer)account; - final AC castedApplicationConfiguration = (AC)applicationConfiguration; + public void configureModule(final Module module) { + final CloudModuleBuilder moduleBuilder = getModuleBuilder(); + RemoteServer account = (RemoteServer)moduleBuilder.getAccount(); + final AC applicationConfiguration = (AC)moduleBuilder.getApplicationConfiguration(); DC deploymentConfiguration = createDeploymentConfiguration(); @@ -73,19 +68,19 @@ public abstract class CloudModuleBuilderContributionBase< } final DeployToServerRunConfiguration runConfiguration - = CloudAccountSelectionEditor.createRunConfiguration(castedAccount, module, deploymentConfiguration); + = CloudRunConfigurationUtil.createRunConfiguration(account, module, deploymentConfiguration); final ServerType cloudType = account.getType(); final Project project = module.getProject(); new CloudConnectionTask(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 getCloudType(); - - @Override - public abstract CloudApplicationConfigurable createApplicationConfigurable(@Nullable Project project, - Disposable parentDisposable); + protected abstract CloudSourceApplicationConfigurable createApplicationConfigurable(@Nullable Project project, + Disposable parentDisposable); protected abstract DC createDeploymentConfiguration(); diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleWizardStep.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleWizardStep.java index cf0e283616b2..79b307b0658e 100644 --- a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudModuleWizardStep.java +++ b/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, CloudApplicationConfigurable> myCloudType2ApplicationConfigurable; + private Set> myApplicationConfigurableTypes; public CloudModuleWizardStep(CloudModuleBuilder moduleBuilder, Project project, Disposable parentDisposable) { myModuleBuilder = moduleBuilder; myProject = project; myParentDisposable = parentDisposable; - myCloudType2ApplicationConfigurable = new HashMap, CloudApplicationConfigurable>(); + myApplicationConfigurableTypes = new HashSet>(); List> cloudTypes = new ArrayList>(); - 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(); } diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfigurable.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfigurable.java new file mode 100644 index 000000000000..b6e0dfc857b0 --- /dev/null +++ b/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, + 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 getAccount() { + return (RemoteServer)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>("Loading existing applications list") { + + @Override + protected void run(final ServerConnection connection, + final Semaphore semaphore, + final AtomicReference> result) { + connection.connectIfNeeded(new ServerConnector.ConnectionCallback() { + + @Override + public void connected(@NotNull ServerRuntimeInstance 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 run(SR serverRuntimeInstance) throws ServerRuntimeException { + return null; + } + }.performAsync(); + } + + private void setupExistingApplications(Collection 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 extends CloudConnectionTask { + + public ConnectionTask(String title) { + super(myProject, title, CloudSourceApplicationConfigurable.this.getAccount()); + } + } +} diff --git a/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfiguration.java b/java/remote-servers/impl/src/com/intellij/remoteServer/impl/module/CloudSourceApplicationConfiguration.java new file mode 100644 index 000000000000..b1a3df6099ab --- /dev/null +++ b/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; + } +} diff --git a/platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudAccountSelectionEditor.java b/platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudAccountSelectionEditor.java index fa4355eb356c..5a3d150daf57 100644 --- a/platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudAccountSelectionEditor.java +++ b/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 - DeployToServerRunConfiguration createRunConfiguration(RemoteServer 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 result = (DeployToServerRunConfiguration)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 { diff --git a/platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudRunConfigurationUtil.java b/platform/remote-servers/impl/src/com/intellij/remoteServer/util/CloudRunConfigurationUtil.java new file mode 100644 index 000000000000..a717571a7ca6 --- /dev/null +++ b/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 + DeployToServerRunConfiguration createRunConfiguration(RemoteServer 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 + DeployToServerRunConfiguration createRunConfiguration(RemoteServer 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 result = (DeployToServerRunConfiguration)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); + } +}