Improve port forwarding in JetBrains EAP IDEs

Author: felladrin

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

@@ -18,6 +18,7 @@ import com.intellij.util.withFragment
 import com.intellij.util.withPath
 import com.intellij.util.withQuery
 import com.jetbrains.rd.util.URI
+import io.gitpod.jetbrains.remote.utils.LocalHostUri
 import io.netty.buffer.Unpooled
 import io.netty.channel.ChannelHandlerContext
 import io.netty.handler.codec.http.FullHttpRequest
@@ -29,12 +30,12 @@ import org.jetbrains.io.response
 import java.io.OutputStreamWriter
 import java.nio.file.InvalidPathException
 import java.nio.file.Path
+import java.util.*
 
 @Suppress("UnstableApiUsage", "OPT_IN_USAGE")
 class GitpodCLIService : RestService() {
 
     private val manager = service<GitpodManager>()
-    private val portsService = service<GitpodPortsService>()
     private val cliHelperService = service<GitpodCLIHelper>()
 
     override fun getServiceName() = SERVICE_NAME
@@ -74,29 +75,35 @@ class GitpodCLIService : RestService() {
                 return "url is missing"
             }
 
-            val resolvedUrl = resolveExternalUrl(url)
-
             return withClient(request, context) { project ->
+                var resolvedUrl = url
+                val uri = URI.create(url)
+                val localHostUriMetadata = LocalHostUri.extractLocalHostUriMetaDataForPortMapping(uri)
+
+                if (localHostUriMetadata.isPresent) {
+                    val gitpodPortForwardingService = service<GitpodPortForwardingService>()
+                    var localHostUriFromPort = Optional.empty<URI>()
+
+                    application.invokeAndWait {
+                        localHostUriFromPort = gitpodPortForwardingService
+                                .getLocalHostUriFromHostPort(localHostUriMetadata.get().port)
+                    }
+
+                    if (localHostUriFromPort.isPresent) {
+                        resolvedUrl =  localHostUriFromPort.get()
+                                .withPath(uri.path)
+                                .withQuery(uri.query)
+                                .withFragment(uri.fragment)
+                                .toString()
+                    }
+                }
+
                 BrowserUtil.browse(resolvedUrl, project)
             }
         }
         return "invalid operation"
     }
 
-    private fun resolveExternalUrl(url: String): String {
-        val uri = URI.create(url)
-        val optionalLocalHostUriMetadata = portsService.extractLocalHostUriMetaDataForPortMapping(uri)
-
-        return when {
-            optionalLocalHostUriMetadata.isEmpty -> url
-            else -> portsService.getLocalHostUriFromHostPort(optionalLocalHostUriMetadata.get().port)
-                    .withPath(uri.path)
-                    .withQuery(uri.query)
-                    .withFragment(uri.fragment)
-                    .toString()
-        }
-    }
-
     private fun withClient(request: FullHttpRequest, context: ChannelHandlerContext, action: suspend (project: Project?) -> Unit): String? {
         GlobalScope.launch {
             getClientSessionAndProjectAsync().let { (session, project) ->

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

@@ -36,7 +36,7 @@ import java.util.concurrent.CompletableFuture
 class GitpodClientProjectSessionTracker(private val project: Project) : Disposable {
 
     private val manager = service<GitpodManager>()
-    private val portsService = service<GitpodPortsService>()
+    private val gitpodPortForwardingService = service<GitpodPortForwardingService>()
     private val session = ClientSessionsManager.getProjectSession(project)
 
     private lateinit var info: Info.WorkspaceInfoResponse
@@ -64,8 +64,9 @@ class GitpodClientProjectSessionTracker(private val project: Project) : Disposab
     }
 
     private fun getForwardedPortUrl(port: PortsStatus): String {
+        val localHostUri = gitpodPortForwardingService.getLocalHostUriFromHostPort(port.localPort)
         return when {
-            portsService.isForwarded(port.localPort) -> portsService.getLocalHostUriFromHostPort(port.localPort).toString()
+            localHostUri.isPresent -> localHostUri.get().toString()
             else -> port.exposed.url
         }
     }

components/ide/jetbrains/backend-plugin/src/main/kotlin/io/gitpod/jetbrains/remote/GitpodGlobalPortForwardingService.kt renamed to components/ide/jetbrains/backend-plugin/src/main/kotlin/io/gitpod/jetbrains/remote/GitpodPortForwardingService.kt

@@ -5,7 +5,10 @@
 package io.gitpod.jetbrains.remote
 
 import com.intellij.openapi.Disposable
+import java.util.Optional
+import com.jetbrains.rd.util.URI
 
-interface GitpodGlobalPortForwardingService {
-    fun monitorPortsOfPid(disposable: Disposable, pid: Long)
+interface GitpodPortForwardingService : Disposable {
+    /** Returns the localhost URI if the given port is forwarded on client. */
+    fun getLocalHostUriFromHostPort(hostPort: Int): Optional<URI>
 }

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

@@ -4,7 +4,6 @@
 
 package io.gitpod.jetbrains.remote
 
-// import com.intellij.openapi.components.service
 import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.project.Project
 import com.intellij.util.application
@@ -35,7 +34,6 @@ class GitpodTerminalService(project: Project) {
     private val terminalServiceFutureStub = TerminalServiceGrpc.newFutureStub(GitpodManager.supervisorChannel)
     private val terminalServiceStub = TerminalServiceGrpc.newStub(GitpodManager.supervisorChannel)
     private val statusServiceStub = StatusServiceGrpc.newStub(GitpodManager.supervisorChannel)
-    // private val portForwardingService = service<GitpodGlobalPortForwardingService>()
 
     init {
         start()
@@ -187,10 +185,6 @@ class GitpodTerminalService(project: Project) {
         exitTaskWhenTerminalWidgetGetsClosed(supervisorTerminal, shellTerminalWidget)
 
         listenForTaskTerminationAndTitleChanges(supervisorTerminal, shellTerminalWidget)
-
-        // This works for auto-forwarding ports opened in Gitpod Terminals, but it's currently not useful as we
-        // have the GitpodPortForwardingService already auto-forwarding all the ports from the workspace.
-        // portForwardingService.monitorPortsOfPid(shellTerminalWidget, supervisorTerminal.pid)
     }
 
     private fun listenForTaskTerminationAndTitleChanges(

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

@@ -8,20 +8,30 @@ import com.intellij.openapi.actionSystem.ActionPlaces
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
-import com.intellij.openapi.components.service
 import com.intellij.openapi.ide.CopyPasteManager
+import com.jetbrains.rd.platform.codeWithMe.portForwarding.ClientPortState
+import com.jetbrains.rd.platform.codeWithMe.portForwarding.PortConfiguration
 import com.jetbrains.rd.platform.codeWithMe.portForwarding.PortForwardingDataKeys
-import io.gitpod.jetbrains.remote.GitpodPortsService
+import org.apache.http.client.utils.URIBuilder
 import java.awt.datatransfer.StringSelection
 
 @Suppress("ComponentNotRegistered", "UnstableApiUsage")
 class GitpodCopyUrlAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
-        e.dataContext.getData(PortForwardingDataKeys.SUGGESTION)?.getSuggestedHostPort()?.let { hostPort ->
-            service<GitpodPortsService>().getLocalHostUriFromHostPort(hostPort).let { localHostUri ->
-                CopyPasteManager.getInstance().setContents(StringSelection(localHostUri.toString()))
-            }
-        }
+        (e.dataContext.getData(PortForwardingDataKeys.PORT)
+                ?.configuration as PortConfiguration.PerClientTcpForwarding?)
+                ?.clientPortState?.let {
+                    if (it is ClientPortState.Assigned) {
+                        CopyPasteManager.getInstance().setContents(StringSelection(
+                                URIBuilder()
+                                        .setScheme("http")
+                                        .setHost(it.clientInterface)
+                                        .setPort(it.clientPort)
+                                        .build()
+                                        .toString())
+                        )
+                    }
+                }
     }
 
     override fun update(e: AnActionEvent) {

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

@@ -8,23 +8,21 @@ import com.intellij.openapi.actionSystem.ActionPlaces
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
+import com.intellij.openapi.components.service
 import com.intellij.openapi.ide.CopyPasteManager
-import com.intellij.util.application
+import com.jetbrains.rd.platform.codeWithMe.portForwarding.PerClientPortForwardingManager
+import com.jetbrains.rd.platform.codeWithMe.portForwarding.PortConfiguration
 import com.jetbrains.rd.platform.codeWithMe.portForwarding.PortForwardingDataKeys
-import io.gitpod.jetbrains.remote.GitpodManager
-import io.gitpod.supervisor.api.Status.PortsStatusRequest
-import io.gitpod.supervisor.api.StatusServiceGrpc
-import kotlinx.coroutines.launch
 import java.awt.datatransfer.StringSelection
 
 @Suppress("ComponentNotRegistered", "UnstableApiUsage")
 class GitpodCopyWebUrlAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
         e.dataContext.getData(PortForwardingDataKeys.SUGGESTION)?.getSuggestedHostPort()?.let { hostPort ->
-            application.coroutineScope.launch {
-                getUrlFromPort(hostPort)?.let {
-                    CopyPasteManager.getInstance().setContents(StringSelection(it))
-                }
+            (service<PerClientPortForwardingManager>().getPorts(hostPort).firstOrNull {
+                it.labels.contains(GitpodPortForwardingServiceImpl.EXPOSED_PORT_LABEL)
+            }?.configuration as PortConfiguration.UrlExposure?)?.exposedUrl?.let {
+                CopyPasteManager.getInstance().setContents(StringSelection(it))
             }
         }
     }
@@ -34,17 +32,4 @@ class GitpodCopyWebUrlAction : AnAction() {
     }
 
     override fun getActionUpdateThread() = ActionUpdateThread.BGT
-
-    private fun getUrlFromPort(port: Number): String? {
-        val blockingStub = StatusServiceGrpc.newBlockingStub(GitpodManager.supervisorChannel)
-        val request = PortsStatusRequest.newBuilder().setObserve(false).build()
-        val response = blockingStub.portsStatus(request)
-        while (response.hasNext()) {
-            val portStatusResponse = response.next()
-            for (portStatus in portStatusResponse.portsList) {
-                if (portStatus.localPort == port) return portStatus.exposed.url
-            }
-        }
-        return null
-    }
 }