Added delay for checking whether an IDE Backend is running on small instance sizes (#3465)

* added delay

* added changelog

Author: manodnyab

.changes/next-release/bugfix-f207aac3-4371-4320-b744-c487f7f93625.json

@@ -0,0 +1,4 @@
+{
+  "type" : "bugfix",
+  "description" : "Fix Small Dev Environment instance sizes not connecting to the thin clients"
+}

jetbrains-gateway/src/software/aws/toolkits/jetbrains/gateway/CawsConnectionProvider.kt

@@ -37,6 +37,7 @@ import org.jetbrains.concurrency.AsyncPromise
 import org.jetbrains.concurrency.await
 import software.amazon.awssdk.services.codecatalyst.CodeCatalystClient
 import software.amazon.awssdk.services.codecatalyst.model.DevEnvironmentStatus
+import software.amazon.awssdk.services.codecatalyst.model.InstanceType
 import software.aws.toolkits.core.utils.AttributeBagKey
 import software.aws.toolkits.core.utils.debug
 import software.aws.toolkits.core.utils.error
@@ -144,6 +145,12 @@ class CawsConnectionProvider : GatewayConnectionProvider {
                             isIndeterminate = true,
                         ) {
                             validateEnvironmentIsRunning(indicator, environmentActions)
+                            val isSmallInstance = cawsClient.getDevEnvironment {
+                                it.id(envId)
+                                it.projectName(projectName)
+                                it.spaceName(spaceName)
+                            }.instanceType().equals(InstanceType.DEV_STANDARD1_SMALL)
+
                             lifetime.launchIOBackground {
                                 ApplicationManager.getApplication().messageBus.syncPublisher(WorkspaceNotifications.TOPIC)
                                     .environmentStarted(
@@ -237,7 +244,8 @@ class CawsConnectionProvider : GatewayConnectionProvider {
                                 handle,
                                 envId,
                                 connectionParams.gitSettings,
-                                toolkitInstallSettings
+                                toolkitInstallSettings,
+                                isSmallInstance
                             ).await()
                         }.invokeOnCompletion { e ->
                             if (e == null) {
@@ -355,6 +363,7 @@ class CawsConnectionProvider : GatewayConnectionProvider {
         envId: String,
         gitSettings: GitSettings,
         toolkitInstallSettings: ToolkitInstallSettings,
+        isSmallInstance: Boolean
     ): AsyncPromise<Unit> {
         val remoteScriptPath = "/tmp/${UUID.randomUUID()}"
         val remoteProjectName = (gitSettings as? GitSettings.GitRepoSettings)?.repoName
@@ -392,7 +401,7 @@ class CawsConnectionProvider : GatewayConnectionProvider {
             if (AwsToolkit.isDeveloperMode()) {
                 add(PatchBackend(gatewayHandle, executor, lifetime))
             }
-            add(StartBackend(gatewayHandle, remoteScriptPath, remoteProjectName, executor, lifetime, envId))
+            add(StartBackend(gatewayHandle, remoteScriptPath, remoteProjectName, executor, lifetime, envId, isSmallInstance))
         }
 
         val promise = AsyncPromise<Unit>()

jetbrains-gateway/src/software/aws/toolkits/jetbrains/gateway/connection/workflow/StartBackend.kt

@@ -8,6 +8,8 @@ import com.jetbrains.gateway.thinClientLink.LinkedClientManager
 import com.jetbrains.rd.util.lifetime.LifetimeDefinition
 import com.jetbrains.rd.util.lifetime.onTermination
 import com.jetbrains.rd.util.reactive.adviseEternal
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
 import software.aws.toolkits.core.utils.getLogger
 import software.aws.toolkits.core.utils.info
 import software.aws.toolkits.jetbrains.core.credentials.sono.lazilyGetUserId
@@ -32,7 +34,8 @@ class StartBackend(
     private val remoteProjectName: String?,
     private val executor: CawsCommandExecutor,
     private val lifetime: LifetimeDefinition,
-    private val envId: String
+    private val envId: String,
+    private val isSmallInstance: Boolean
 ) : Step() {
     override val stepName: String = message("gateway.connection.workflow.start_ide")
 
@@ -91,14 +94,27 @@ class StartBackend(
         if (initialConnectLink != null) {
             stepEmitter.emitMessageLine("Reusing existing backend instance at: $initialConnectLink", isError = false)
         }
+        if (isSmallInstance) {
+            runBlocking {
+                delay(5000)
+            }
+        }
+
         val remoteLink = initialConnectLink ?: let {
             val backend = ideActions.startBackend()
             stepEmitter.attachProcess(backend)
             lifetime.onTermination {
                 backend.destroyProcess()
             }
 
+            if (isSmallInstance) {
+                runBlocking {
+                    delay(5000)
+                }
+            }
+
             val start = System.currentTimeMillis()
+
             val duration = Duration.ofMinutes(3)
             return@let try {
                 spinUntilValue(duration = duration, interval = Duration.ofSeconds(5)) {