Credentials added as environment variables in Run Command Tool (#2693)

* Credentials added as environment variables in Run Command Tool

* duplication removed

* Custom Run Profile added

* Tests changed, tool deleted

* Extension function for connection settings, mock region and credential identifier added

* test changed, deleted unwanted code from run profile

* windows test changed

* unit test changed for windows

* test changed

Author: manodnyab

jetbrains-core/src/software/aws/toolkits/jetbrains/core/credentials/ConnectionSettings.kt

@@ -3,9 +3,19 @@
 
 package software.aws.toolkits.jetbrains.core.credentials
 
+import com.intellij.openapi.project.Project
 import software.aws.toolkits.core.credentials.ToolkitCredentialsProvider
 import software.aws.toolkits.core.region.AwsRegion
 
 data class ConnectionSettings(val credentials: ToolkitCredentialsProvider, val region: AwsRegion)
 
 val ConnectionSettings.shortName get() = "${credentials.shortName}@${region.id}"
+
+fun ConnectionSettings.toEnvironmentVariables(): Map<String, String> = region.toEnvironmentVariables() +
+    credentials.resolveCredentials().toEnvironmentVariables()
+
+fun <T> Project.withAwsConnection(block: (ConnectionSettings) -> T): T {
+    val connectionSettings = AwsConnectionManager.getInstance(this).connectionSettings()
+        ?: throw IllegalStateException("Connection settings are not configured")
+    return block(connectionSettings)
+}

jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/ContainerActions.kt

@@ -18,8 +18,7 @@ import software.amazon.awssdk.services.ecs.model.LogDriver
 import software.amazon.awssdk.services.ecs.model.Service
 import software.aws.toolkits.jetbrains.AwsToolkit
 import software.aws.toolkits.jetbrains.core.awsClient
-import software.aws.toolkits.jetbrains.core.credentials.AwsConnectionManager
-import software.aws.toolkits.jetbrains.core.credentials.toEnvironmentVariables
+import software.aws.toolkits.jetbrains.core.credentials.withAwsConnection
 import software.aws.toolkits.jetbrains.core.explorer.actions.SingleExplorerNodeActionGroup
 import software.aws.toolkits.jetbrains.core.getResource
 import software.aws.toolkits.jetbrains.core.getResourceNow
@@ -143,7 +142,9 @@ class ExecuteCommandAction(
             if (EcsExecUtils.ensureServiceIsInStableState(project, container.service)) {
                 SessionManagerPluginInstallationVerification.requiresSessionManager(project) {
                     runInEdt {
-                        RunCommandDialog(project, container).show()
+                        project.withAwsConnection {
+                            RunCommandDialog(project, container, it).show()
+                        }
                     }
                 }
             } else {
@@ -166,12 +167,9 @@ class ExecuteCommandInShellAction(
         coroutineScope.launch {
             if (EcsExecUtils.ensureServiceIsInStableState(project, container.service)) {
                 SessionManagerPluginInstallationVerification.requiresSessionManager(project) {
-                    val connectionSettings = AwsConnectionManager.getInstance(project).connectionSettings()
-                    if (connectionSettings != null) {
-                        val environmentVariables = connectionSettings.region.toEnvironmentVariables() +
-                            connectionSettings.credentials.resolveCredentials().toEnvironmentVariables()
-                        runInEdt {
-                            OpenShellInContainerDialog(project, container, environmentVariables).show()
+                    runInEdt {
+                        project.withAwsConnection {
+                            OpenShellInContainerDialog(project, container, it).show()
                         }
                     }
                 }

jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/exec/OpenShellInContainerDialog.kt

@@ -17,6 +17,8 @@ import org.jetbrains.plugins.terminal.TerminalTabState
 import org.jetbrains.plugins.terminal.TerminalView
 import org.jetbrains.plugins.terminal.cloud.CloudTerminalProcess
 import org.jetbrains.plugins.terminal.cloud.CloudTerminalRunner
+import software.aws.toolkits.jetbrains.core.credentials.ConnectionSettings
+import software.aws.toolkits.jetbrains.core.credentials.toEnvironmentVariables
 import software.aws.toolkits.jetbrains.core.executables.ExecutableInstance
 import software.aws.toolkits.jetbrains.core.executables.ExecutableManager
 import software.aws.toolkits.jetbrains.core.executables.getExecutable
@@ -35,7 +37,7 @@ import javax.swing.JComponent
 class OpenShellInContainerDialog(
     private val project: Project,
     private val container: ContainerDetails,
-    private val environmentVariables: Map<String, String>
+    private val connectionSettings: ConnectionSettings
 ) : DialogWrapper(project) {
     private val coroutineScope = ApplicationThreadPoolScope("OpenShellInContainerDialog")
     private val tasks = ResourceSelector
@@ -126,7 +128,7 @@ class OpenShellInContainerDialog(
     private fun constructExecCommand(executable: ExecutableInstance.Executable): PtyProcess {
         val task = tasks.selected() ?: throw IllegalStateException("No tasks selected")
         val commandLine = executable.getCommandLine().execCommand(
-            environmentVariables,
+            connectionSettings.toEnvironmentVariables(),
             container.service.clusterArn(),
             task,
             ('"' + shell + '"'),

jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/exec/RunCommandDialog.kt

@@ -5,19 +5,18 @@ package software.aws.toolkits.jetbrains.services.ecs.exec
 
 import com.intellij.execution.executors.DefaultRunExecutor
 import com.intellij.execution.runners.ExecutionEnvironmentBuilder
-import com.intellij.openapi.actionSystem.impl.SimpleDataContext
 import com.intellij.openapi.application.ModalityState
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.DialogWrapper
-import com.intellij.tools.Tool
-import com.intellij.tools.ToolRunProfile
 import com.intellij.ui.CollectionComboBoxModel
 import com.intellij.ui.components.JBTextField
 import com.intellij.ui.layout.GrowPolicy
 import com.intellij.ui.layout.applyToComponent
 import com.intellij.ui.layout.panel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import software.aws.toolkits.jetbrains.core.credentials.ConnectionSettings
+import software.aws.toolkits.jetbrains.core.credentials.toEnvironmentVariables
 import software.aws.toolkits.jetbrains.services.ecs.ContainerDetails
 import software.aws.toolkits.jetbrains.services.ecs.resources.EcsResources
 import software.aws.toolkits.jetbrains.ui.ResourceSelector
@@ -27,12 +26,11 @@ import software.aws.toolkits.resources.message
 import software.aws.toolkits.telemetry.EcsExecuteCommandType
 import software.aws.toolkits.telemetry.EcsTelemetry
 import software.aws.toolkits.telemetry.Result
-import java.nio.file.Path
 import javax.swing.JComponent
 import javax.swing.JTextField
 import javax.swing.plaf.basic.BasicComboBoxEditor
 
-class RunCommandDialog(private val project: Project, private val container: ContainerDetails) :
+class RunCommandDialog(private val project: Project, private val container: ContainerDetails, private val connectionSettings: ConnectionSettings) :
     DialogWrapper(project) {
     private val coroutineScope = ApplicationThreadPoolScope("RunCommandDialog")
     private val tasks = ResourceSelector
@@ -122,14 +120,15 @@ class RunCommandDialog(private val project: Project, private val container: Cont
     private suspend fun runCommand() {
         try {
             val awsCliPath = AwsCliExecutable().resolve() ?: throw IllegalStateException(message("executableCommon.missing_executable", "AWS CLI"))
-            val execCommand = buildExecCommandConfiguration(('"' + command + '"'), awsCliPath)
             val environment = ExecutionEnvironmentBuilder
                 .create(
                     project,
                     DefaultRunExecutor.getRunExecutorInstance(),
-                    ToolRunProfile(
-                        execCommand,
-                        SimpleDataContext.getProjectContext(project)
+                    RunCommandRunProfile(
+                        connectionSettings.toEnvironmentVariables(),
+                        constructExecCommandParameters(('"' + command + '"')),
+                        container.containerDefinition.name(),
+                        awsCliPath.toAbsolutePath().toString()
                     )
                 )
                 .build()
@@ -144,16 +143,6 @@ class RunCommandDialog(private val project: Project, private val container: Cont
         }
     }
 
-    fun buildExecCommandConfiguration(commandToExecute: String, path: Path): Tool {
-        val execCommand = Tool()
-        execCommand.isShowConsoleOnStdOut = true
-        execCommand.isUseConsole = true
-        execCommand.parameters = constructExecCommandParameters(commandToExecute)
-        execCommand.name = container.containerDefinition.name()
-        execCommand.program = path.toAbsolutePath().toString()
-        return execCommand
-    }
-
     companion object {
         val commandsEnteredPreviously = mutableSetOf<String>()
     }

jetbrains-core/src/software/aws/toolkits/jetbrains/services/ecs/exec/RunCommandRunProfile.kt

@@ -0,0 +1,82 @@
+// Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package software.aws.toolkits.jetbrains.services.ecs.exec
+
+import com.intellij.execution.ExecutionResult
+import com.intellij.execution.Executor
+import com.intellij.execution.configurations.CommandLineState
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.execution.configurations.RunProfile
+import com.intellij.execution.configurations.RunProfileState
+import com.intellij.execution.filters.TextConsoleBuilderFactory
+import com.intellij.execution.process.ColoredProcessHandler
+import com.intellij.execution.process.ProcessAdapter
+import com.intellij.execution.process.ProcessEvent
+import com.intellij.execution.process.ProcessHandler
+import com.intellij.execution.process.ProcessOutputTypes
+import com.intellij.execution.process.ProcessTerminatedListener
+import com.intellij.execution.runners.ExecutionEnvironment
+import com.intellij.execution.runners.ProgramRunner
+import com.intellij.execution.ui.RunContentManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Key
+import javax.swing.Icon
+
+class RunCommandRunProfile(
+    private val credentials: Map<String, String>,
+    private val parameters: String?,
+    private val containerName: String,
+    private val path: String
+) : RunProfile {
+    override fun getState(executor: Executor, environment: ExecutionEnvironment): RunProfileState? {
+        val cmdLine = getCommandLine()
+        val project = environment.project
+        if (cmdLine == null) {
+            return null
+        }
+        val commandLineState = CmdLineState(environment, cmdLine, project)
+        val builder = TextConsoleBuilderFactory.getInstance().createBuilder(project)
+        commandLineState.consoleBuilder = builder
+        return commandLineState
+    }
+
+    override fun getName(): String = containerName
+
+    override fun getIcon(): Icon? = null
+
+    fun getCommandLine(): GeneralCommandLine? {
+        val commandLine = GeneralCommandLine()
+        commandLine.parametersList.addParametersString(parameters)
+        commandLine.exePath = path
+        commandLine.withEnvironment(credentials)
+        return commandLine
+    }
+}
+
+class CmdLineState(
+    environment: ExecutionEnvironment,
+    private val cmdLine: GeneralCommandLine,
+    private val project: Project,
+) : CommandLineState(environment) {
+    override fun startProcess(): ProcessHandler {
+        val processHandler = ColoredProcessHandler(cmdLine)
+        ProcessTerminatedListener.attach(processHandler)
+        return processHandler
+    }
+
+    override fun execute(executor: Executor, runner: ProgramRunner<*>): ExecutionResult {
+        val result = super.execute(executor, runner)
+        val processHandler = result.processHandler
+        processHandler?.addProcessListener(object : ProcessAdapter() {
+            override fun onTextAvailable(event: ProcessEvent, outputType: Key<*>) {
+                if (outputType === ProcessOutputTypes.STDOUT ||
+                    outputType === ProcessOutputTypes.STDERR
+                ) {
+                    RunContentManager.getInstance(project).toFrontRunContent(executor, processHandler)
+                }
+            }
+        })
+        return result
+    }
+}