fix: http proxy wasn't used by git commands

Author: slisson

workspace-manager/src/main/kotlin/org/modelix/services/gitconnector/GitFetchTask.kt

@@ -22,6 +22,7 @@ class GitFetchTask(scope: CoroutineScope, val repo: GitRepositoryConfig) : TaskI
             if (password.isNotEmpty()) {
                 cmd.applyCredentials(username, password)
             }
+            cmd.configureHttpProxy()
 
             val refs = withContext(Dispatchers.IO) {
                 cmd.call()

workspace-manager/src/main/kotlin/org/modelix/services/gitconnector/GitImportTask.kt

@@ -1,6 +1,7 @@
 package org.modelix.services.gitconnector
 
 import io.kubernetes.client.openapi.models.V1Container
+import io.kubernetes.client.openapi.models.V1EnvVar
 import io.kubernetes.client.openapi.models.V1Job
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
@@ -71,6 +72,9 @@ class GitImportTaskUsingKubernetesJob(
                         addContainersItem(V1Container().apply {
                             name = "importer"
                             image = System.getenv("GIT_IMPORT_IMAGE")
+                            System.getenv("MODELIX_HTTP_PROXY")?.let {
+                                addEnvItem(V1EnvVar().name("MODELIX_HTTP_PROXY").value(it))
+                            }
                             args = listOf(
                                 "git-import-remote",
                                 remote.url,

workspace-manager/src/main/kotlin/org/modelix/services/gitconnector/JGitExtensions.kt

@@ -16,7 +16,7 @@ import java.net.PasswordAuthentication
 import java.net.Proxy
 import java.net.URL
 
-fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> E.applyCredentials(username: String, password: String): E {
+fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> E.applyCredentials(username: String?, password: String): E {
     val cmd = this
     cmd.setCredentialsProvider(UsernamePasswordCredentialsProvider(username, password))
     cmd.setTransportConfigCallback { transport ->
@@ -37,6 +37,15 @@ fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> E.applyCredentials(userna
     return cmd
 }
 
+fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> E.configureHttpProxy(): E {
+    val proxy = System.getenv("MODELIX_HTTP_PROXY") ?: return this
+    // see https://github.com/openjdk/jdk/blob/e783c524c17e1d1a3fff4b6370e222134e66edc8/src/java.base/share/classes/sun/net/spi/DefaultProxySelector.java#L80
+    // and https://github.com/eclipse-jgit/jgit/blob/a762badfcecd3c200bb29b8ad5806546c7db8eaa/org.eclipse.jgit/src/org/eclipse/jgit/transport/TransportHttp.java#L292
+    System.setProperty("http.proxy", proxy)
+    System.setProperty("https.proxy", proxy)
+    return this
+}
+
 /**
  * The credentialsProvider only works with WWW-Authenticate: Basic, but not with WWW-Authenticate: Negotiate.
  * This is handled by the JDK.

workspace-manager/src/main/kotlin/org/modelix/workspace/manager/GitRepositoryManager.kt

@@ -17,20 +17,10 @@ import org.eclipse.jgit.api.Git
 import org.eclipse.jgit.api.GitCommand
 import org.eclipse.jgit.api.TransportCommand
 import org.eclipse.jgit.errors.RepositoryNotFoundException
-import org.eclipse.jgit.transport.Transport
-import org.eclipse.jgit.transport.TransportHttp
-import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider
-import org.eclipse.jgit.transport.http.HttpConnection
-import org.eclipse.jgit.transport.http.HttpConnectionFactory
-import org.eclipse.jgit.transport.http.JDKHttpConnection
-import org.eclipse.jgit.transport.http.JDKHttpConnectionFactory
+import org.modelix.services.gitconnector.applyCredentials
+import org.modelix.services.gitconnector.configureHttpProxy
 import org.modelix.workspaces.GitRepository
 import java.io.File
-import java.net.Authenticator
-import java.net.HttpURLConnection
-import java.net.PasswordAuthentication
-import java.net.Proxy
-import java.net.URL
 import java.util.zip.ZipOutputStream
 
 class GitRepositoryManager(val config: GitRepository, val workspaceDirectory: File) {
@@ -45,7 +35,7 @@ class GitRepositoryManager(val config: GitRepository, val workspaceDirectory: Fi
         val existed = repoDirectory.exists()
         val git = openRepo()
         if (existed) {
-            applyCredentials(git.fetch()).call()
+            git.fetch().applyCredentials().configureHttpProxy().call()
             git.checkout().setName(config.commitHash ?: ("origin/" + config.branch)).call()
 //            if (config.commitHash == null) {
 //                applyCredentials(git.pull()).call()
@@ -66,51 +56,18 @@ class GitRepositoryManager(val config: GitRepository, val workspaceDirectory: Fi
         }
     }
 
-    private fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> applyCredentials(cmd: E): E {
+    private fun <C : GitCommand<T>, T, E : TransportCommand<C, T>> E.applyCredentials(): E {
         val credentials = config.credentials
         if (credentials != null) {
-            cmd.setCredentialsProvider(UsernamePasswordCredentialsProvider(credentials.user, credentials.password))
-            cmd.setTransportConfigCallback { transport ->
-                transport?.setAuthenticator(object : Authenticator() {
-                    override fun getPasswordAuthentication(): PasswordAuthentication {
-                        return PasswordAuthentication(credentials.user, credentials.password.toCharArray())
-                    }
-                })
-            }
-        }
-        return cmd
-    }
-
-    /**
-     * The credentialsProvider only works with WWW-Authenticate: Basic, but not with WWW-Authenticate: Negotiate.
-     * This is handled by the JDK.
-     */
-    private fun Transport.setAuthenticator(authenticator: Authenticator) {
-        val transport = this as TransportHttp
-        val originalFactory = transport.httpConnectionFactory as JDKHttpConnectionFactory
-        transport.httpConnectionFactory = object : HttpConnectionFactory {
-            override fun create(url: URL?): HttpConnection {
-                return modify(originalFactory.create(url))
-            }
-
-            override fun create(url: URL?, proxy: Proxy?): HttpConnection {
-                return modify(originalFactory.create(url, proxy))
-            }
-
-            fun modify(conn: HttpConnection): HttpConnection {
-                val jdkConn = conn as JDKHttpConnection
-                val field = jdkConn.javaClass.getDeclaredField("wrappedUrlConnection")
-                field.isAccessible = true
-                val wrapped = field.get(jdkConn) as HttpURLConnection
-                wrapped.setAuthenticator(authenticator)
-                return conn
-            }
+            applyCredentials(credentials.user, credentials.password)
         }
+        return this
     }
 
     private fun cloneRepo(): Git {
         val cmd = Git.cloneRepository()
-        applyCredentials(cmd)
+        cmd.applyCredentials()
+        cmd.configureHttpProxy()
         cmd.setURI(config.url)
         cmd.setBranch(config.branch)
         val directory = repoDirectory