Configuration du proxy Gradle

J'ai besoin d'un accès Web depuis Gradle via un serveur proxy pour utiliser l'intégration Gradle / Artifactory pour Jenkins. Pour réduire les causes possibles des problèmes, j'ajoute manuellement le plugin Artifactory dans build.gradle et je l'exécute à partir de la ligne de commande:

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

Suite à cette description, j'ai spécifié ce qui suit dans .gradle / gradle.properties dans mon répertoire personnel:

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

Avec la configuration de proxy ci-dessus (qui est autrement connue pour fonctionner), elle échoue:

11: 33: 17.699 [ERROR] [org.gradle.BuildExceptionReporter] Causé par: java.io.IOException: le serveur a renvoyé le code de réponse HTTP: 407 pour l'URL: http://gradle.artifactoryonline.com/gradle/plugins/org/ jfrog / buildinfo / build-info-extractor-gradle / 1.0.1 / artifactoryplugin-1.0.1.gradle

J'ai le choix entre deux serveurs proxy et l'un répond toujours avec 407( authentification proxy requise ), l'autre avec 502( mauvaise passerelle ), donc évidemment, les options proxyHost et proxyPort sont utilisées.

Comme le nom d'utilisateur (basé sur un utilisateur Active Directory) contient une barre oblique inverse, j'ai essayé les deux \\et \, mais aucun n'a fonctionné. L'utilisateur spécifié est différent de l'utilisateur connecté à la machine et à Active Directory. Les informations d'identification de cet utilisateur ne sont pas valides pour le proxy, je dois donc être en mesure de spécifier un utilisateur différent.

Définir les mêmes options dans l'interface graphique de Jenkins ou d'Artifactory a fonctionné.

Raffinement de la réponse de Daniel:

Configuration du proxy HTTP uniquement

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

Configuration proxy HTTPS uniquement

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

Configuration du proxy HTTP et 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"

Configuration du proxy avec utilisateur et mot de passe

gradlew -Dhttp.proxyHost = 127.0.0.1 -Dhttp.proxyPort = 3128 - Dhttps.proxyHost = 127.0.0.1 -Dhttps.proxyPort = 3129 -Dhttps.proxyUser = utilisateur -Dhttps.proxyPassword = pass -Dhttp.proxyDUserword = pass -Dhttp.proxyDUserword = pass -Dhttp.proxyDUserhttp. proxyPassword = pass -Dhttp.nonProxyHosts = host1.com | host2.com

a fonctionné pour moi (avec gradle.propertiessoit dans homedir soit dans le répertoire du projet, la construction échouait toujours). Merci d'avoir signalé le problème à gradle qui a donné cette solution de contournement. Voir le document de référence sur https://docs.gradle.org/current/userguide/build_environment.html#sec:accessing_the_web_via_a_proxy

Mise à jour Vous pouvez également insérer ces propriétés dans gradle-wrapper.properties(voir: https://stackoverflow.com/a/50492027/474034 ).

Ceci est mon gradle.properties, veuillez noter la partie HTTPS

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

Dans mon, build.gradlej'ai la tâche suivante, qui utilise les paramètres de proxy Linux habituels, HTTP_PROXYet HTTPS_PROXY, à partir du shell env:

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

Pour moi, cela fonctionne en ajoutant cette configuration dans le fichier gradle.properties du projet, où le fichier build.gradle est:

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

Où: proxyUrl est l'url du serveur proxy ( http: // ..... )

proxyPort est le port (généralement 8080)

USER est mon utilisateur de domaine

MOT DE PASSE, mon mot de passe

Dans ce cas, le proxy pour http et https est le même

Essayez ce qui suit:

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

En utilisant un programme Java très simple «Demander une URL», j'ai pu répliquer le problème.

http.proxyUseret http.proxyPasswordsemblent être des options non standard, bien que populaires, car elles ne sont pas décrites dans la page de référence Java liée au didacticiel Gradle ; même si le manuel Gradle les mentionne.

Il semble que les programmes Java qui souhaitent prendre en charge l'authentification proxy doivent le faire manuellement (et j'ai pu le faire en utilisant le code sur la page liée).

J'ai soumis ce problème (et un correctif) à l'outil de suivi des problèmes Gradle . Le problème GRADLE-1556 a été résolu dans 1.0-milestone-8 (février 2012)

Vérifiez sur c: \ Users \ votre nom d'utilisateur \ .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 | >

Créez un fichier appelé gradle.propertiesdans le dossier du projet où le build.gradlefichier est présent. Ajoutez l'entrée suivante

     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 vous utilisez DNS pour proxy, ajoutez-le comme systemProp.https.proxyHost=www.proxysite.com

Pour IP, spécifiez simplement l'IP sur http://ou https://
Check doc officiel gradle pour plus de détails et la mise en place proxy au niveau mondial

Il existe 2 façons d'utiliser Gradle derrière un proxy:

Ajouter des arguments en ligne de commande

(D'après le post de Guillaume Berche)

Ajoutez ces arguments dans votre commande gradle:

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

ou ces arguments si vous utilisez https:

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

Ajouter des lignes dans le fichier de configuration gradle

en gradle.properties ajouter les lignes suivantes:

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

(pour l' gradle.propertiesemplacement du fichier, veuillez vous référer à la documentation officielle https://docs.gradle.org/current/userguide/build_environment.html

EDIT: comme dit par @Joost: Un petit mais important détail que j'ai initialement négligé: notez que le nom d'hôte réel ne contient PAS la http:// partie protocole de l'URL ...

Basé sur la réponse de SourceSimian; cela a fonctionné sur les comptes d'utilisateurs de domaine Windows. Notez que le nom d' utilisateur n'a pas de domaine inclus,

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

Dans le cas où j'essaye de configurer un proxy à partir d'Android Studio Apparence et comportement => Paramètres système => Proxy HTTP. Mais le proxy n'a pas fonctionné, je clique donc sur aucun proxy.

Cocher NO PROXY ne supprimera pas le paramètre de proxy de gradle.properties (Global). Vous devez le supprimer manuellement.

Je supprime donc toutes les propriétés commençant par systemProp par exemple - systemProp.http.nonProxyHosts = *. Local, localhost

Une mise à jour de @sourcesimian et de @ kunal-b qui définit dynamiquement le nom d'utilisateur et le mot de passe s'ils sont configurés dans les propriétés du système.

Ce qui suit définit le nom d'utilisateur et le mot de passe s'ils sont fournis ou ajoute simplement l'hôte et le port si aucun nom d'utilisateur et mot de passe n'est défini.

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 vous êtes derrière proxy et que vous utilisez eclipse, accédez à Window Menu --> Preferences --> General --> Network Connections . Sélectionnez les fournisseurs actifs comme «Manuel».

Dans la section Entrées proxy, cliquez sur HTTPS, cliquez sur Modifier et ajoutez l'hôte et le port proxy. Si un nom d'utilisateur et un mot de passe sont requis, indiquez-le également. Cela a fonctionné pour moi!

Si ce problème avec l'erreur HTTP 407 s'est produit uniquement avec les packages sélectionnés, le problème ne se situe pas dans le paramètre proxy et la connexion Internet. Vous pouvez même exposer votre PC à Internet via NAT et faire face à ce problème. Généralement, en même temps, vous pouvez télécharger les packages souhaités dans le navigateur. La seule solution que je trouve: supprimez le dossier .gradle dans votre profil (pas dans le projet). Après cela, synchronisez le projet, cela prendra beaucoup de temps mais restaurez tout.