| /* |
| * 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.ide.util.newProjectWizard.StepSequence; |
| import com.intellij.ide.util.newProjectWizard.modes.CreateFromSourcesMode; |
| import com.intellij.ide.util.projectWizard.AbstractStepWithProgress; |
| import com.intellij.ide.util.projectWizard.ModuleWizardStep; |
| import com.intellij.ide.util.projectWizard.ProjectBuilder; |
| import com.intellij.ide.util.projectWizard.WizardContext; |
| import com.intellij.openapi.Disposable; |
| import com.intellij.openapi.module.Module; |
| import com.intellij.openapi.progress.ProgressIndicator; |
| import com.intellij.openapi.progress.ProgressManager; |
| import com.intellij.openapi.progress.Task; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.roots.ui.configuration.DefaultModulesProvider; |
| import com.intellij.openapi.roots.ui.configuration.ModulesProvider; |
| import com.intellij.openapi.ui.MessageType; |
| import com.intellij.openapi.util.Disposer; |
| import com.intellij.remoteServer.ServerType; |
| import com.intellij.remoteServer.configuration.RemoteServer; |
| import com.intellij.remoteServer.impl.configuration.deployment.DeployToServerRunConfiguration; |
| import com.intellij.remoteServer.util.*; |
| import com.intellij.remoteServer.util.ssh.SshKeyChecker; |
| import com.intellij.util.containers.ContainerUtil; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| |
| public abstract class CloudModuleBuilderSourceContribution< |
| SC extends CloudConfigurationBase, |
| DC extends CloudDeploymentNameConfiguration, |
| AC extends CloudSourceApplicationConfiguration, |
| SR extends CloudMultiSourceServerRuntimeInstance<DC, ?, ?, ?>> |
| extends CloudModuleBuilderContribution { |
| |
| private CloudNotifier myNotifier; |
| |
| public CloudModuleBuilderSourceContribution(CloudModuleBuilder moduleBuilder, ServerType<SC> cloudType) { |
| super(moduleBuilder, cloudType); |
| } |
| |
| @Override |
| 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(); |
| |
| if (applicationConfiguration.isExisting()) { |
| deploymentConfiguration.setDefaultDeploymentName(false); |
| deploymentConfiguration.setDeploymentName(applicationConfiguration.getExistingAppName()); |
| } |
| |
| final DeployToServerRunConfiguration<SC, DC> runConfiguration |
| = 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()), |
| account) { |
| |
| boolean myFirstAttempt = true; |
| |
| @Override |
| protected Object run(SR serverRuntime) throws ServerRuntimeException { |
| doConfigureModule(applicationConfiguration, runConfiguration, myFirstAttempt, serverRuntime); |
| return null; |
| } |
| |
| @Override |
| protected void runtimeErrorOccurred(@NotNull String errorMessage) { |
| myFirstAttempt = false; |
| new SshKeyChecker().checkServerError(errorMessage, getNotifier(), project, this); |
| } |
| |
| @Override |
| protected void postPerform(Object result) { |
| detectModuleStructure(module, moduleBuilder.getContentEntryPath()); |
| } |
| |
| @Override |
| protected boolean shouldStartInBackground() { |
| return false; |
| } |
| }.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(); |
| |
| final CreateFromSourcesMode mode = new CreateFromSourcesMode() { |
| |
| @Override |
| public boolean isAvailable(WizardContext context) { |
| return true; |
| } |
| |
| @Override |
| public void addSteps(WizardContext context, ModulesProvider modulesProvider, StepSequence sequence, String specific) { |
| super.addSteps(context, modulesProvider, sequence, specific); |
| myProjectBuilder.setFileToImport(contentPath); |
| } |
| }; |
| |
| final WizardContext context = new WizardContext(project); |
| |
| final StepSequence stepSequence = mode.getSteps(context, DefaultModulesProvider.createForProject(context.getProject())); |
| if (stepSequence == null) { |
| return; |
| } |
| |
| Disposer.register(project, new Disposable() { |
| |
| @Override |
| public void dispose() { |
| for (ModuleWizardStep step : stepSequence.getAllSteps()) { |
| step.disposeUIResources(); |
| } |
| } |
| }); |
| |
| ProgressManager.getInstance() |
| .run(new Task.Backgroundable(project, CloudBundle.getText("detect.module.structure", getCloudType().getPresentableName()), false) { |
| |
| @Override |
| public void run(@NotNull ProgressIndicator indicator) { |
| for (ModuleWizardStep step = ContainerUtil.getFirstItem(stepSequence.getSelectedSteps()); |
| step != null; |
| step = stepSequence.getNextStep(step)) { |
| if (step instanceof AbstractStepWithProgress<?>) { |
| ((AbstractStepWithProgress)step).performStep(); |
| } |
| else { |
| step.updateDataModel(); |
| } |
| } |
| CloudAccountSelectionEditor.unsetAccountOnContext(context, getCloudType()); |
| } |
| |
| @Override |
| public boolean shouldStartInBackground() { |
| return false; |
| } |
| |
| @Override |
| public void onSuccess() { |
| ProjectBuilder moduleBuilder = mode.getModuleBuilder(); |
| if (moduleBuilder == null) { |
| return; |
| } |
| moduleBuilder.commit(project); |
| getNotifier().showMessage(CloudBundle.getText("cloud.support.added", getCloudType().getPresentableName()), MessageType.INFO); |
| } |
| }); |
| } |
| |
| @Override |
| protected abstract CloudSourceApplicationConfigurable<SC, DC, SR, AC> createApplicationConfigurable(@Nullable Project project, |
| Disposable parentDisposable); |
| |
| protected abstract DC createDeploymentConfiguration(); |
| |
| protected abstract void doConfigureModule(AC applicationConfiguration, |
| DeployToServerRunConfiguration<SC, DC> runConfiguration, |
| boolean firstAttempt, |
| SR serverRuntime) throws ServerRuntimeException; |
| } |