Configurazione proxy Gradle

Ho bisogno dell'accesso web da Gradle tramite un server proxy per utilizzare l'integrazione Gradle / Artifactory per Jenkins. Per ridurre le possibili cause dei problemi, aggiungo manualmente il plug-in Artifactory in build.gradle ed eseguo dalla riga di comando:

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

Seguendo questa descrizione ho specificato quanto segue in .gradle / gradle.properties nella mia directory home:

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

Con la configurazione proxy sopra (che altrimenti è nota per funzionare), non riesce:

11: 33: 17.699 [ERRORE] [org.gradle.BuildExceptionReporter] Causato da: java.io.IOException: il server ha restituito il codice di risposta HTTP: 407 per l'URL: http://gradle.artifactoryonline.com/gradle/plugins/org/ JFrog / buildinfo / buildinfo-estrattore-Gradle / 1.0.1 / artifactoryplugin-1.0.1.gradle

Ho due server proxy tra cui scegliere e uno risponde sempre con 407( Autenticazione proxy richiesta ), l'altro con 502( Bad gateway ), quindi ovviamente vengono utilizzate le opzioni proxyHost e proxyPort.

Poiché il nome utente (basato su un utente di Active Directory) contiene una barra rovesciata, ho provato entrambi \\e \, ma nessuno dei due ha funzionato. L'utente specificato è diverso dall'utente che ha effettuato l'accesso alla macchina e ad Active Directory. Le credenziali di questo utente non sono valide per il proxy, quindi devo essere in grado di specificare un altro utente.

L'impostazione delle stesse opzioni nella GUI di Jenkins o Artifactory ha funzionato.

Affinamento sulla risposta di Daniel:

Configurazione solo proxy HTTP

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

HTTPS Solo configurazione proxy

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

Configurazione proxy HTTP e 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"

Configurazione proxy con utente e password

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

ha funzionato per me (con gradle.propertieshomedir o dir del progetto, la build non andava ancora bene). Grazie per aver segnalato il problema a Gradle che ha dato questa soluzione alternativa. Consulta il documento di riferimento su https://docs.gradle.org/current/userguide/build_environment.html#sec:accessing_the_web_via_a_proxy

Aggiornamento È inoltre possibile inserire queste proprietà in gradle-wrapper.properties(consultare: https://stackoverflow.com/a/50492027/474034 ).

Questa è la mia gradle.properties, si prega di notare quelle parti HTTPS

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

Nel mio build.gradleho il seguente compito, che utilizza le solite impostazioni del proxy Linux HTTP_PROXYe HTTPS_PROXY, dalla 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

Per me, funziona aggiungendo questa configurazione nel file gradle.properties del progetto, dove il file build.gradle è:

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

Dove: proxyUrl è l'URL del server proxy ( http: // ..... )

proxyPort è la porta (di solito 8080)

USER è il mio utente di dominio

PASSWORD, la mia password

In questo caso, il proxy per http e https è lo stesso

Prova quanto segue:

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

Utilizzando un molto semplice "Richiedi un'URL" programma Java, sono stato in grado di replicare il problema.

http.proxyUsere http.proxyPasswordsembrano essere opzioni non standard, sebbene popolari, in quanto non sono descritte nella pagina di riferimento Java collegata dal tutorial Gradle ; anche se il manuale Gradle li menziona.

Sembra che i programmi Java che desiderano supportare l'autenticazione proxy debbano farlo manualmente (e sono stato in grado di farlo usando il codice sulla pagina collegata).

Ho inviato questo problema (e una correzione) al tracker del problema Gradle . Problema risolto GRADLE-1556 è stato risolto in 1.0-milestone-8 (febbraio 2012)

Dai un'occhiata a c: \ Users \ nome utente \ .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 | >

Creare un file chiamato gradle.propertiesall'interno della cartella del progetto in cui build.gradleè presente il file. Aggiungi la seguente voce

     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

Se si utilizza DNS per proxy, aggiungerlo come systemProp.https.proxyHost=www.proxysite.com

Per l'IP basta specificare l'IP con out http://o https://
Controlla il docle ufficiale per maggiori dettagli e impostare il proxy a livello globale

Esistono 2 modi per utilizzare Gradle dietro un proxy:

Aggiungi argomenti nella riga di comando

(Dal post di Guillaume Berche)

Aggiungi questi argomenti nel tuo comando gradle:

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

o questi argomenti se si utilizza https:

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

Aggiungi righe nel file di configurazione gradle

in gradle.properties aggiungere le seguenti righe:

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

(per l' gradle.propertiesubicazione del file, consultare la documentazione ufficiale https://docs.gradle.org/current/userguide/build_environment.html

EDIT: come detto da @Joost: un piccolo ma importante dettaglio che inizialmente ho trascurato: nota che il nome host effettivo NON contiene http:// parte del protocollo dell'URL ...

Basato sulla risposta di SourceSimian; questo ha funzionato su account utente di dominio Windows. Tieni presente che il nome utente non ha un dominio incluso,

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

Nel caso in cui provo a configurare il proxy da Android Studio Aspetto e comportamento => Impostazioni di sistema => Proxy HTTP. Ma il proxy non ha funzionato, quindi faccio clic su nessun proxy.

Selezionando NO PROXY non si rimuoveranno le impostazioni del proxy da gradle.properties (globale). È necessario rimuoverlo manualmente.

Quindi rimuovo tutte le proprietà che iniziano con systemProp, ad esempio - systemProp.http.nonProxyHosts = *. Local, localhost

Un aggiornamento alla risposta di @sourcesimian e @ kunal-b che imposta dinamicamente nome utente e password se configurato nelle proprietà del sistema.

Quanto segue imposta il nome utente e la password se forniti o aggiunge semplicemente l'host e la porta se non sono impostati nome utente e password.

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())
        }
    }
}

Se sei dietro al proxy e stai usando eclipse, vai a Window Menu --> Preferences --> General --> Network Connections. Selezionare i provider attivi come "Manuale".

Nella sezione Voci proxy, fai clic su HTTPS, fai clic su Modifica e aggiungi host e porta proxy. Se sono richiesti nome utente e password, fornire anche quello. Ha funzionato per me!

Se questo problema con l'errore HTTP 407 si è verificato solo per i pacchetti selezionati, il problema non riguarda l'impostazione proxy e la connessione Internet. Puoi persino esporre il tuo PC a Internet tramite NAT e dovrai ancora affrontare questo problema. In genere allo stesso tempo è possibile scaricare i pacchetti desiderati nel browser. L'unica soluzione che trovo: elimina la cartella .gradle nel tuo profilo (non nel progetto). Dopo aver sincronizzato il progetto, ci vorrà molto tempo ma ripristinerà tutto.