impl: support for using proxies to access Coder REST API

fioan89 · fioan89 · commit cd068a117f4b · 2025-04-15T23:50:45.000+03:00
- proxy credentials are not yet supported as they were not exposed in Toolbox settings - system and manual proxy configuration supported. - manual tests included system wide settings and manual http settings. - resolves #39
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Added
+
+- support for using proxies. Proxy authentication is not yet supported.
+
 ## 0.1.5 - 2025-04-14
 
 ### Fixed
diff --git a/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt b/src/main/kotlin/com/coder/toolbox/CoderToolboxContext.kt
@@ -7,6 +7,7 @@ import com.coder.toolbox.util.toURL
 import com.jetbrains.toolbox.api.core.diagnostics.Logger
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
+import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
 import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette
 import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager
 import com.jetbrains.toolbox.api.ui.ToolboxUi
@@ -21,7 +22,8 @@ data class CoderToolboxContext(
     val logger: Logger,
     val i18n: LocalizableStringFactory,
     val settingsStore: CoderSettingsStore,
-    val secrets: CoderSecretsStore
+    val secrets: CoderSecretsStore,
+    val proxySettings: ToolboxProxySettings,
 ) {
     /**
      * Try to find a URL.
diff --git a/src/main/kotlin/com/coder/toolbox/CoderToolboxExtension.kt b/src/main/kotlin/com/coder/toolbox/CoderToolboxExtension.kt
@@ -7,10 +7,12 @@ import com.jetbrains.toolbox.api.core.PluginSecretStore
 import com.jetbrains.toolbox.api.core.PluginSettingsStore
 import com.jetbrains.toolbox.api.core.ServiceLocator
 import com.jetbrains.toolbox.api.core.diagnostics.Logger
+import com.jetbrains.toolbox.api.core.getService
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
 import com.jetbrains.toolbox.api.remoteDev.RemoteDevExtension
 import com.jetbrains.toolbox.api.remoteDev.RemoteProvider
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
+import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
 import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette
 import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager
 import com.jetbrains.toolbox.api.ui.ToolboxUi
@@ -25,15 +27,16 @@ class CoderToolboxExtension : RemoteDevExtension {
         val logger = serviceLocator.getService(Logger::class.java)
         return CoderRemoteProvider(
             CoderToolboxContext(
-                serviceLocator.getService(ToolboxUi::class.java),
-                serviceLocator.getService(EnvironmentUiPageManager::class.java),
-                serviceLocator.getService(EnvironmentStateColorPalette::class.java),
-                serviceLocator.getService(ClientHelper::class.java),
-                serviceLocator.getService(CoroutineScope::class.java),
-                serviceLocator.getService(Logger::class.java),
-                serviceLocator.getService(LocalizableStringFactory::class.java),
-                CoderSettingsStore(serviceLocator.getService(PluginSettingsStore::class.java), Environment(), logger),
-                CoderSecretsStore(serviceLocator.getService(PluginSecretStore::class.java)),
+                serviceLocator.getService<ToolboxUi>(),
+                serviceLocator.getService<EnvironmentUiPageManager>(),
+                serviceLocator.getService<EnvironmentStateColorPalette>(),
+                serviceLocator.getService<ClientHelper>(),
+                serviceLocator.getService<CoroutineScope>(),
+                serviceLocator.getService<Logger>(),
+                serviceLocator.getService<LocalizableStringFactory>(),
+                CoderSettingsStore(serviceLocator.getService<PluginSettingsStore>(), Environment(), logger),
+                CoderSecretsStore(serviceLocator.getService<PluginSecretStore>()),
+                serviceLocator.getService<ToolboxProxySettings>()
             )
         )
     }
diff --git a/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt b/src/main/kotlin/com/coder/toolbox/sdk/CoderRestClient.kt
@@ -23,37 +23,24 @@ import com.coder.toolbox.util.getArch
 import com.coder.toolbox.util.getHeaders
 import com.coder.toolbox.util.getOS
 import com.squareup.moshi.Moshi
-import okhttp3.Credentials
 import okhttp3.OkHttpClient
 import retrofit2.Response
 import retrofit2.Retrofit
 import retrofit2.converter.moshi.MoshiConverterFactory
 import java.net.HttpURLConnection
-import java.net.ProxySelector
 import java.net.URL
 import java.util.UUID
 import javax.net.ssl.X509TrustManager
 
-/**
- * Holds proxy information.
- */
-data class ProxyValues(
-    val username: String?,
-    val password: String?,
-    val useAuth: Boolean,
-    val selector: ProxySelector,
-)
-
 /**
  * An HTTP client that can make requests to the Coder API.
  *
  * The token can be omitted if some other authentication mechanism is in use.
  */
 open class CoderRestClient(
-    context: CoderToolboxContext,
+    private val context: CoderToolboxContext,
     val url: URL,
     val token: String?,
-    private val proxyValues: ProxyValues? = null,
     private val pluginVersion: String = "development",
 ) {
     private val settings = context.settingsStore.readOnly()
@@ -81,22 +68,27 @@ open class CoderRestClient(
         val trustManagers = coderTrustManagers(settings.tls.caPath)
         var builder = OkHttpClient.Builder()
 
-        if (proxyValues != null) {
-            builder =
-                builder
-                    .proxySelector(proxyValues.selector)
-                    .proxyAuthenticator { _, response ->
-                        if (proxyValues.useAuth && proxyValues.username != null && proxyValues.password != null) {
-                            val credentials = Credentials.basic(proxyValues.username, proxyValues.password)
-                            response.request.newBuilder()
-                                .header("Proxy-Authorization", credentials)
-                                .build()
-                        } else {
-                            null
-                        }
-                    }
+        if (context.proxySettings.getProxy() != null) {
+            context.logger.debug("proxy: ${context.proxySettings.getProxy()}")
+            builder.proxy(context.proxySettings.getProxy())
+        } else if (context.proxySettings.getProxySelector() != null) {
+            context.logger.debug("proxy selector: ${context.proxySettings.getProxySelector()}")
+            builder.proxySelector(context.proxySettings.getProxySelector()!!)
         }
 
+        //TODO - add support for proxy auth. when Toolbox exposes them
+//                    builder.proxyAuthenticator { _, response ->
+//                        if (proxyValues.useAuth && proxyValues.username != null && proxyValues.password != null) {
+//                            val credentials = Credentials.basic(proxyValues.username, proxyValues.password)
+//                            response.request.newBuilder()
+//                                .header("Proxy-Authorization", credentials)
+//                                .build()
+//                        } else {
+//                            null
+//                        }
+//                    }
+//        }
+
         if (token != null) {
             builder = builder.addInterceptor {
                 it.proceed(
diff --git a/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt b/src/main/kotlin/com/coder/toolbox/util/CoderProtocolHandler.kt
@@ -238,13 +238,10 @@ open class CoderProtocolHandler(
         if (settings.requireTokenAuth && token == null) { // User aborted.
             throw MissingArgumentException("Token is required")
         }
-        // The http client Toolbox gives us is already set up with the
-        // proxy config, so we do net need to explicitly add it.
         val client = CoderRestClient(
             context,
             deploymentURL.toURL(),
             token,
-            proxyValues = null, // TODO - not sure the above comment applies as we are creating our own http client
             PluginManager.pluginInfo.version
         )
         client.authenticate()
diff --git a/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt b/src/main/kotlin/com/coder/toolbox/views/ConnectStep.kt
@@ -74,13 +74,10 @@ class ConnectStep(
         signInJob = context.cs.launch {
             try {
                 statusField.textState.update { (context.i18n.ptrl("Authenticating to ${url.host}...")) }
-                // The http client Toolbox gives us is already set up with the
-                // proxy config, so we do net need to explicitly add it.
                 val client = CoderRestClient(
                     context,
                     url,
                     token,
-                    proxyValues = null,
                     PluginManager.pluginInfo.version,
                 )
                 // allows interleaving with the back/cancel action
diff --git a/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt b/src/test/kotlin/com/coder/toolbox/cli/CoderCLIManagerTest.kt
@@ -30,6 +30,7 @@ import com.coder.toolbox.util.toURL
 import com.jetbrains.toolbox.api.core.diagnostics.Logger
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
+import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
 import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette
 import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager
 import com.jetbrains.toolbox.api.ui.ToolboxUi
@@ -68,7 +69,8 @@ internal class CoderCLIManagerTest {
             Environment(),
             mockk<Logger>(relaxed = true)
         ),
-        mockk<CoderSecretsStore>()
+        mockk<CoderSecretsStore>(),
+        mockk<ToolboxProxySettings>()
     )
 
     /**
diff --git a/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt b/src/test/kotlin/com/coder/toolbox/sdk/CoderRestClientTest.kt
@@ -23,6 +23,7 @@ import com.coder.toolbox.util.sslContextFromPEMs
 import com.jetbrains.toolbox.api.core.diagnostics.Logger
 import com.jetbrains.toolbox.api.localization.LocalizableStringFactory
 import com.jetbrains.toolbox.api.remoteDev.connection.ClientHelper
+import com.jetbrains.toolbox.api.remoteDev.connection.ToolboxProxySettings
 import com.jetbrains.toolbox.api.remoteDev.states.EnvironmentStateColorPalette
 import com.jetbrains.toolbox.api.remoteDev.ui.EnvironmentUiPageManager
 import com.jetbrains.toolbox.api.ui.ToolboxUi
@@ -51,6 +52,7 @@ import java.nio.file.Path
 import java.util.UUID
 import javax.net.ssl.SSLHandshakeException
 import javax.net.ssl.SSLPeerUnverifiedException
+import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
@@ -104,8 +106,17 @@ class CoderRestClientTest {
         mockk<Logger>(relaxed = true),
         mockk<LocalizableStringFactory>(),
         CoderSettingsStore(pluginTestSettingsStore(), Environment(), mockk<Logger>(relaxed = true)),
-        mockk<CoderSecretsStore>()
-    )
+        mockk<CoderSecretsStore>(),
+        object : ToolboxProxySettings {
+            override fun getProxy(): Proxy? = null
+            override fun getProxySelector(): ProxySelector? = null
+            override fun addProxyChangeListener(listener: Runnable) {
+            }
+
+            override fun removeProxyChangeListener(listener: Runnable) {
+            }
+        })
+
 
     data class TestWorkspace(var workspace: Workspace, var resources: List<WorkspaceResource>? = emptyList())
 
@@ -529,6 +540,7 @@ class CoderRestClientTest {
     }
 
     @Test
+    @Ignore("Until proxy authentication is supported")
     fun usesProxy() {
         val settings = CoderSettingsStore(pluginTestSettingsStore(), Environment(), context.logger)
         val workspaces = listOf(DataGen.workspace("ws1"))
@@ -545,26 +557,33 @@ class CoderRestClientTest {
         val srv2 = mockProxy()
         val client =
             CoderRestClient(
-                context.copy(settingsStore = settings),
+                context.copy(settingsStore = settings, proxySettings = object : ToolboxProxySettings {
+                    override fun getProxy(): Proxy? = null
+
+                    override fun getProxySelector(): ProxySelector? {
+                        return object : ProxySelector() {
+                            override fun select(uri: URI): List<Proxy> =
+                                listOf(Proxy(Proxy.Type.HTTP, InetSocketAddress("localhost", srv2.address.port)))
+
+                            override fun connectFailed(
+                                uri: URI,
+                                sa: SocketAddress,
+                                ioe: IOException,
+                            ) {
+                                getDefault().connectFailed(uri, sa, ioe)
+                            }
+                        }
+                    }
+
+                    override fun addProxyChangeListener(listener: Runnable) {
+                    }
+
+                    override fun removeProxyChangeListener(listener: Runnable) {
+                    }
+
+                }),
                 URL(url1),
                 "token",
-                ProxyValues(
-                    "foo",
-                    "bar",
-                    true,
-                    object : ProxySelector() {
-                        override fun select(uri: URI): List<Proxy> =
-                            listOf(Proxy(Proxy.Type.HTTP, InetSocketAddress("localhost", srv2.address.port)))
-
-                        override fun connectFailed(
-                            uri: URI,
-                            sa: SocketAddress,
-                            ioe: IOException,
-                        ) {
-                            getDefault().connectFailed(uri, sa, ioe)
-                        }
-                    },
-                ),
             )
 
         assertEquals(workspaces.map { ws -> ws.name }, runBlocking { client.workspaces() }.map { ws -> ws.name })

Original file line number	Diff line number	Diff line change
`@@ -238,13 +238,10 @@ open class CoderProtocolHandler(`
`238`	`238`	`if (settings.requireTokenAuth && token == null) { // User aborted.`
`239`	`239`	`throw MissingArgumentException("Token is required")`
`240`	`240`	`}`
`241`		`- // The http client Toolbox gives us is already set up with the`
`242`		`- // proxy config, so we do net need to explicitly add it.`
`243`	`241`	`val client = CoderRestClient(`
`244`	`242`	`context,`
`245`	`243`	`deploymentURL.toURL(),`
`246`	`244`	`token,`
`247`		`- proxyValues = null, // TODO - not sure the above comment applies as we are creating our own http client`
`248`	`245`	`PluginManager.pluginInfo.version`
`249`	`246`	`)`
`250`	`247`	`client.authenticate()`