Configuración del proxy Gradle

Necesito acceso web desde Gradle a través de un servidor proxy para usar la integración Gradle / Artifactory para Jenkins. Para reducir las posibles causas de problemas, agrego manualmente el complemento Artifactory en build.gradle y lo ejecuto desde la línea de comandos:

apply {
    apply from: "http://gradle.artifactoryonline.com/gradle/plugins/org/jfrog/buildinfo/build-info-extractor-gradle/1.0.1/artifactoryplugin-1.0.1.gradle"
}

Siguiendo esta descripción, especifiqué lo siguiente en .gradle / gradle.properties en mi directorio de inicio:

systemProp.http.proxyHost=hostname
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=de\\username
systemProp.http.proxyPassword=xxx

Con la configuración de proxy anterior (que se sabe que funciona), falla:

11: 33: 17.699 [ERROR] [org.gradle.BuildExceptionReporter] Causado por: java.io.IOException: el servidor devolvió el código de respuesta HTTP: 407 para URL: http://gradle.artifactoryonline.com/gradle/plugins/org/ jfrog / buildinfo / build-info-extractor-gradle / 1.0.1 / artifactoryplugin-1.0.1.gradle

Tengo dos servidores proxy para elegir, y uno siempre responde con 407(se requiere autenticación de proxy ), el otro con 502( Puerta de enlace incorrecta ), por lo que, obviamente, se utilizan las opciones proxyHost y proxyPort.

Como el nombre de usuario (basado en un usuario de Active Directory) contiene una barra diagonal inversa, probé ambos \\y \, pero ninguno funcionó. El usuario especificado es diferente del usuario que inició sesión en la máquina y en Active Directory. Las credenciales de este usuario no son válidas para el proxy, por lo que necesito poder especificar un usuario diferente.

Establecer las mismas opciones en la GUI de Jenkins o Artifactory funcionó.

Refinamiento sobre la respuesta de Daniel:

Configuración de proxy solo HTTP

gradlew -Dhttp.proxyHost=127.0.0.1 -Dhttp.proxyPort=3128 "-Dhttp.nonProxyHosts=*.nonproxyrepos.com|localhost"

Configuración de proxy solo HTTPS

gradlew -Dhttps.proxyHost=127.0.0.1 -Dhttps.proxyPort=3129 "-Dhttp.nonProxyHosts=*.nonproxyrepos.com|localhost"

Configuración de proxy HTTP y HTTPS

gradlew -Dhttp.proxyHost=127.0.0.1 -Dhttp.proxyPort=3128 -Dhttps.proxyHost=127.0.0.1 -Dhttps.proxyPort=3129 "-Dhttp.nonProxyHosts=*.nonproxyrepos.com|localhost"

Configuración de proxy con usuario y contraseña

gradlew -Dhttp.proxyHost = 127.0.0.1 -Dhttp.proxyPort = 3128 - Dhttps.proxyHost = 127.0.0.1 -Dhttps.proxyPort = 3129 -Dhttps.proxyUser = user -Dhttps.proxyPassword = pass -Dhttp.proxyUser = user-dhttp.proxyHser = user proxyPassword = pasar -Dhttp.nonProxyHosts = host1.com | host2.com

funcionó para mí ( gradle.propertiesya sea en homedir o dir del proyecto, la compilación seguía fallando). Gracias por señalar el problema en Gradle que dio esta solución. Consulte el documento de referencia en https://docs.gradle.org/current/userguide/build_environment.html#sec:accessing_the_web_via_a_proxy

Actualización También puede poner estas propiedades en gradle-wrapper.properties(consulte: https://stackoverflow.com/a/50492027/474034 ).

Esta es mi gradle.properties, tenga en cuenta esas porciones HTTPS

systemProp.http.proxyHost=127.0.0.1
systemProp.http.proxyPort=8118
systemProp.https.proxyHost=127.0.0.1
systemProp.https.proxyPort=8118

En mi build.gradletengo la siguiente tarea, que utiliza la configuración habitual de proxy de Linux HTTP_PROXYy HTTPS_PROXY, desde el entorno de shell:

task setHttpProxyFromEnv {
    def map = ['HTTP_PROXY': 'http', 'HTTPS_PROXY': 'https']
    for (e in System.getenv()) {
        def key = e.key.toUpperCase()
        if (key in map) {
            def base = map[key]
            def url = e.value.toURL()
            println " - systemProp.${base}.proxy=${url.host}:${url.port}"
            System.setProperty("${base}.proxyHost", url.host.toString())
            System.setProperty("${base}.proxyPort", url.port.toString())
        }
    }
}

build.dependsOn setHttpProxyFromEnv

Para mí, funciona agregando esta configuración en el archivo gradle.properties del proyecto, donde el archivo build.gradle es:

systemProp.http.proxyHost=proxyURL
systemProp.http.proxyPort=proxyPort
systemProp.http.proxyUser=USER
systemProp.http.proxyPassword=PASSWORD
systemProp.https.proxyHost=proxyUrl 
systemProp.https.proxyPort=proxyPort
systemProp.https.proxyUser=USER
systemProp.https.proxyPassword=PASSWORD

Donde: proxyUrl es la url del servidor proxy ( http: // ..... )

proxyPort es el puerto (generalmente 8080)

USER es mi usuario de dominio

CONTRASEÑA, mi contraseña

En este caso, el proxy para http y https es el mismo

Intenta lo siguiente:

gradle -Dhttp.proxyHost=yourProxy -Dhttp.proxyPort=yourPort -Dhttp.proxyUser=usernameProxy -Dhttp.proxyPassword=yourPassoword

Utilizando un programa Java muy simple "Solicitar una URL", pude replicar el problema.

http.proxyUsery http.proxyPasswordparecen ser opciones no estándar, aunque populares, ya que no se describen en la página de referencia de Java vinculada desde el tutorial de Gradle ; a pesar de que el manual de Gradle los menciona.

Parece que los programas Java que desean admitir la autenticación proxy necesitan hacer esto manualmente (y pude hacerlo usando el código en la página vinculada).

Envié este problema (y una solución) al rastreador de problemas de Gradle . El problema planteado GRADLE-1556 se resolvió en 1.0-hito-8 (febrero de 2012)

Echa un vistazo a c: \ Users \ your username \ .gradle \ gradle.properties:

systemProp.http.proxyHost=<proxy host>
systemProp.http.proxyPort=<proxy port>
systemProp.http.proxyUser=<proxy user>
systemProp.http.proxyPassword=<proxy password>
systemProp.http.nonProxyHosts=<csv of exceptions>
systemProp.https.proxyHost=<proxy host>
systemProp.https.proxyPort=<proxy port>
systemProp.https.proxyUser=<proxy user>
systemProp.https.proxyPassword=<proxy password>
systemProp.https.nonProxyHosts=<csv of exceptions seperated by | >

Cree un archivo llamado gradle.propertiesdentro de la carpeta del proyecto donde build.gradleestá presente el archivo. Agregue la siguiente entrada

     systemProp.http.proxyHost=proxy_url
     systemProp.http.proxyPort=proxy_port
     systemProp.http.proxyUser=USER
     systemProp.http.proxyPassword=PWD
     systemProp.https.proxyHost=proxy_url 
     systemProp.https.proxyPort=proxy_port
     systemProp.https.proxyUser=USER
     systemProp.https.proxyPassword=PWD

Si está utilizando DNS para proxy, agréguelo como systemProp.https.proxyHost=www.proxysite.com

Para IP, solo especifique la IP sin http://o https://
Compruebe el documento oficial de Gradle para obtener más detalles y configurar el proxy a nivel global

Hay 2 formas de usar Gradle detrás de un proxy:

Agregar argumentos en la línea de comando

(Del post de Guillaume Berche)

Agregue estos argumentos en su comando gradle:

-Dhttp.proxyHost=your_proxy_http_host -Dhttp.proxyPort=your_proxy_http_port

o estos argumentos si está utilizando https:

-Dhttps.proxyHost=your_proxy_https_host -Dhttps.proxyPort=your_proxy_https_port

Agregar líneas en el archivo de configuración de gradle

en gradle.properties agregar las siguientes líneas:

systemProp.http.proxyHost=your_proxy_http_host
systemProp.http.proxyPort=your_proxy_http_port
systemProp.https.proxyHost=your_proxy_https_host
systemProp.https.proxyPort=your_proxy_https_port

(para gradle.propertiesla ubicación del archivo, consulte la documentación oficial https://docs.gradle.org/current/userguide/build_environment.html

EDITAR: como dijo @Joost: Un pequeño pero importante detalle que inicialmente pasé por alto: observe que el nombre de host real NO contiene http:// parte del protocolo de la URL ...

Basado en la respuesta de SourceSimian; esto funcionó en cuentas de usuario de dominio de Windows. Tenga en cuenta que el nombre de usuario no tiene dominio incluido,

task setHttpProxyFromEnv {
    def map = ['HTTP_PROXY': 'http', 'HTTPS_PROXY': 'https']
    for (e in System.getenv()) {
        def key = e.key.toUpperCase()
        if (key in map) {
            def base = map[key]
            def url = e.value.toURL()
            println " - systemProp.${base}.proxy=${url.host}:${url.port}"
            System.setProperty("${base}.proxyHost", url.host.toString())
            System.setProperty("${base}.proxyPort", url.port.toString())
            System.setProperty("${base}.proxyUser", "Username")
            System.setProperty("${base}.proxyPassword", "Password")
        }
    }
}
build.dependsOn setHttpProxyFromEnv

En caso de que intente configurar el proxy desde el estudio de Android Apariencia y comportamiento => Configuración del sistema => Proxy HTTP. Pero el proxy no funcionó, así que no hago clic en proxy.

Si marca NO PROXY no se eliminará la configuración del proxy de gradle.properties (Global). Necesita eliminarlo manualmente.

Así que elimino todas las propiedades que comienzan con systemProp, por ejemplo: systemProp.http.nonProxyHosts = *. Local, localhost

Una actualización de la respuesta de @sourcesimian y @kunal-b que establece dinámicamente el nombre de usuario y la contraseña si se configura en las propiedades del sistema.

Lo siguiente establece el nombre de usuario y la contraseña si se proporcionan o simplemente agrega el host y el puerto si no se establece ningún nombre de usuario y contraseña.

task setHttpProxyFromEnv {
    def map = ['HTTP_PROXY': 'http', 'HTTPS_PROXY': 'https']
    for (e in System.getenv()) {
        def key = e.key.toUpperCase()
        if (key in map) {
            def base = map[key]
            //Get proxyHost,port, username, and password from http system properties 
            // in the format http://username:password@proxyhost:proxyport
            def (val1,val2) = e.value.tokenize( '@' )
            def (val3,val4) = val1.tokenize( '//' )
            def(userName, password) = val4.tokenize(':')
            def url = e.value.toURL()
            //println " - systemProp.${base}.proxy=${url.host}:${url.port}"
            System.setProperty("${base}.proxyHost", url.host.toString())
            System.setProperty("${base}.proxyPort", url.port.toString())
            System.setProperty("${base}.proxyUser", userName.toString())
            System.setProperty("${base}.proxyPassword", password.toString())
        }
    }
}

Si está detrás del proxy y usa eclipse, vaya a Window Menu --> Preferences --> General --> Network Connections. Seleccione los proveedores activos como 'Manual'.

En la sección Entradas de proxy, haga clic en HTTPS, haga clic en Editar y agregue host y puerto proxy. Si se requiere un nombre de usuario y una contraseña, indíquelo también. ¡Funcionó para mí!

Si este problema con el error HTTP 407 ocurrió con los paquetes seleccionados solo entonces el problema no está en la configuración del proxy y la conexión a Internet. Incluso puede exponer su PC a Internet a través de NAT y aún enfrentará este problema. Por lo general, al mismo tiempo, puede descargar los paquetes deseados en el navegador. La única solución que encuentro: eliminar la carpeta .gradle en su perfil (no en el proyecto). Después de sincronizar el proyecto, llevará mucho tiempo pero restaurará todo.