delay + batch to avoid too many threads

Tool: gitpod/catfood.gitpod.cloud

Author: mustard-mh

components/ide/jetbrains/backend-plugin/src/main/kotlin/io/gitpod/jetbrains/remote/AbstractGitpodPortForwardingService.kt

@@ -26,6 +26,7 @@ import java.util.*
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicReference
+import java.util.concurrent.Semaphore
 
 @Suppress("UnstableApiUsage")
 abstract class AbstractGitpodPortForwardingService : GitpodPortForwardingService {
@@ -50,6 +51,13 @@ abstract class AbstractGitpodPortForwardingService : GitpodPortForwardingService
     // Debounce job for port updates
     private var debounceJob: Job? = null
 
+    // Batch size for port operations
+    private val BATCH_SIZE = 10
+    private val BATCH_DELAY = 100
+
+    // Semaphore to limit concurrent operations
+    private val operationSemaphore = Semaphore(10)
+
     init { start() }
 
     private fun start() {
@@ -106,7 +114,7 @@ abstract class AbstractGitpodPortForwardingService : GitpodPortForwardingService
 
                 // Create new debounce job
                 debounceJob = runJob(lifetime) {
-                    delay(300) // 300ms debounce delay
+                    delay(500)
                     try {
                         if (syncInProgress.compareAndSet(false, true)) {
                             try {
@@ -175,30 +183,56 @@ abstract class AbstractGitpodPortForwardingService : GitpodPortForwardingService
             .map { it.hostPortNumber }
             .filter { portsNumbersFromNonServedPorts.contains(it) || !portsNumbersFromPortsList.contains(it) }
 
-        // Process port changes in background
+        // Process port changes in background with batching
         runJob(lifetime) {
             try {
-                // Stop unnecessary ports first
-                forwardedPortsToStopForwarding.forEach { stopForwarding(it) }
-                exposedPortsToStopExposingOnClient.forEach { stopExposingOnClient(it) }
-
-                // Start necessary ports
-                servedPortsToStartForwarding.forEach {
-                    startForwarding(it)
-                    allPortsToKeep.add(it.localPort)
+                forwardedPortsToStopForwarding.chunked(BATCH_SIZE).forEach { batch ->
+                    batch.forEach { port ->
+                        operationSemaphore.withPermit {
+                            stopForwarding(port)
+                        }
+                    }
+                    delay(100) // Add delay between batches
                 }
 
-                exposedPortsToStartExposingOnClient.forEach {
-                    startExposingOnClient(it)
-                    allPortsToKeep.add(it.localPort)
+                exposedPortsToStopExposingOnClient.chunked(BATCH_SIZE).forEach { batch ->
+                    batch.forEach { port ->
+                        operationSemaphore.withPermit {
+                            stopExposingOnClient(port)
+                        }
+                    }
+                    delay(BATCH_DELAY)
                 }
 
-                // Update presentation for all ports
-                application.invokeLater {
-                    portsList.forEach {
-                        updatePortsPresentation(it)
-                        allPortsToKeep.add(it.localPort)
+                servedPortsToStartForwarding.chunked(BATCH_SIZE).forEach { batch ->
+                    batch.forEach { port ->
+                        operationSemaphore.withPermit {
+                            startForwarding(port)
+                            allPortsToKeep.add(port.localPort)
+                        }
+                    }
+                    delay(BATCH_DELAY)
+                }
+
+                exposedPortsToStartExposingOnClient.chunked(BATCH_SIZE).forEach { batch ->
+                    batch.forEach { port ->
+                        operationSemaphore.withPermit {
+                            startExposingOnClient(port)
+                            allPortsToKeep.add(port.localPort)
+                        }
+                    }
+                    delay(BATCH_DELAY)
+                }
+
+                // Update presentation for all ports in batches
+                portsList.chunked(BATCH_SIZE).forEach { batch ->
+                    application.invokeLater {
+                        batch.forEach {
+                            updatePortsPresentation(it)
+                            allPortsToKeep.add(it.localPort)
+                        }
                     }
+                    delay(BATCH_DELAY)
                 }
 
                 cleanupUnusedLifetimes(allPortsToKeep)