Konfiguracja proxy Gradle

Aby skorzystać z integracji Gradle / Artifactory dla Jenkins, potrzebuję dostępu do sieci Web z Gradle przez serwer proxy. Aby zmniejszyć możliwe przyczyny problemów, ręcznie dodaję wtyczkę Artifactory do pliku build.gradle i uruchamiam ją z wiersza poleceń:

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

Zgodnie z tym opisem w .gradle / gradle.properties w moim katalogu domowym umieściłem:

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

Przy powyższej konfiguracji proxy (o której wiadomo, że działa), kończy się niepowodzeniem:

11: 33: 17.699 [ERROR] [org.gradle.BuildExceptionReporter] Przyczyna: java.io.IOException: serwer zwrócił kod odpowiedzi HTTP: 407 dla adresu URL: http://gradle.artifactoryonline.com/gradle/plugins/org/ jfrog / buildinfo / build-info-extractor-gradle / 1.0.1 / artifactoryplugin-1.0.1.gradle

Mam do wyboru dwa serwery proxy, a jeden zawsze odpowiada 407( Wymagane uwierzytelnianie proxy ), a drugi 502( Zła brama ), więc oczywiście używane są opcje proxyHost i proxyPort.

Ponieważ nazwa użytkownika (oparta na użytkowniku Active Directory) zawiera odwrotny ukośnik, próbowałem obu \\i \, ale żaden z nich nie działał. Określony użytkownik różni się od użytkownika zalogowanego na komputerze i w usłudze Active Directory. Poświadczenia tego użytkownika nie są prawidłowe dla serwera proxy, więc muszę mieć możliwość określenia innego użytkownika.

Ustawienie tych samych opcji w GUI Jenkinsa lub Artifactory działało.

Udoskonalenie odpowiedzi Daniela:

Konfiguracja proxy tylko HTTP

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

Konfiguracja proxy HTTPS

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

Konfiguracja serwera proxy HTTP i 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"

Konfiguracja proxy z użytkownikiem i hasłem

gradlew -Dhttp.proxyHost = 127.0.0.1 -Dhttp.proxyPort = 3128 - Dhttps.proxyHost = 127.0.0.1 -Dhttps.proxyPort = 3129 -Dhttps.proxyUser = użytkownik -Dhttps.proxyPassword = hasło -Dhttp.proxyhttp = użytkownik. proxyPassword = pass -Dhttp.nonProxyHosts = host1.com | host2.com

pracował dla mnie ( gradle.propertiesw domu lub w reżimie projektu, kompilacja wciąż się nie udała). Dziękujemy za wskazanie w firmie Gradle problemu, który umożliwił obejście tego problemu. Zobacz dokument referencyjny pod adresem https://docs.gradle.org/current/userguide/build_environment.html#sec:accessing_the_web_via_a_proxy

Aktualizacja Możesz również umieścić te właściwości w gradle-wrapper.properties(patrz: https://stackoverflow.com/a/50492027/474034 ).

To jest moja gradle.properties, zwróć uwagę na część dotyczącą HTTPS

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

W moim build.gradlemam następujące zadanie, które używa zwykłych ustawień proxy Linuksa HTTP_PROXYoraz HTTPS_PROXYz powłoki 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

U mnie działa dodanie tej konfiguracji w pliku gradle.properties projektu, gdzie plik build.gradle to:

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

Gdzie: proxyUrl to adres URL serwera proxy ( http: // ..... )

proxyPort to port (zwykle 8080)

USER jest użytkownikiem mojej domeny

PASSWORD, moje hasło

W tym przypadku serwer proxy dla http i https jest taki sam

Spróbuj wykonać następujące czynności:

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

Używając bardzo prostego programu Java „Zażądaj adresu URL”, udało mi się odtworzyć problem.

http.proxyUseri http.proxyPasswordwydają się być niestandardowymi, aczkolwiek popularnymi opcjami, ponieważ nie są opisane na stronie referencyjnej Java, do której link znajduje się w samouczku Gradle ; mimo że wspomina o nich podręcznik Gradle.

Wygląda na to, że programy Java, które chcą obsługiwać uwierzytelnianie proxy, muszą to robić ręcznie (a udało mi się to zrobić za pomocą kodu na połączonej stronie).

Przesłałem ten problem (i poprawkę) do narzędzia do śledzenia problemów w Gradle . Zgłoszony problem GRADLE-1556 został rozwiązany w 1.0-kamień milowy-8 (luty 2012)

Sprawdź na c: \ Users \ twoja nazwa użytkownika \ .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 | >

Utwórz plik o nazwie gradle.propertieswewnątrz folderu projektu, w którym build.gradleznajduje się plik. Dodaj następujący wpis

     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

Jeśli używasz DNS dla proxy, dodaj go jak systemProp.https.proxyHost=www.proxysite.com

W przypadku adresu IP wystarczy podać adres IP bez http://lub https://
sprawdzić oficjalny dokument gradle, aby uzyskać więcej informacji i skonfigurować proxy na poziomie globalnym

Istnieją dwa sposoby korzystania z Gradle za proxy:

Dodaj argumenty w linii poleceń

(Z postu Guillaume Berche)

Dodaj te argumenty do polecenia gradle:

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

lub te argumenty, jeśli używasz https:

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

Dodaj linie w pliku konfiguracyjnym gradle

w gradle.properties dodaj następujące linie:

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

( gradle.propertieslokalizację pliku można znaleźć w oficjalnej dokumentacji https://docs.gradle.org/current/userguide/build_environment.html

EDYCJA: jak powiedział @Joost: Mały, ale ważny szczegół, który początkowo przeoczyłem: zauważ, że rzeczywista nazwa hosta NIE zawiera http:// części protokołu w adresie URL ...

Na podstawie odpowiedzi SourceSimian; działało to na kontach użytkowników domeny Windows. Pamiętaj, że nazwa użytkownika nie zawiera domeny,

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

W przypadku, gdy próbuję skonfigurować serwer proxy z Android Studio Wygląd i zachowanie => Ustawienia systemowe => Serwer proxy HTTP. Ale proxy nie zadziałało, więc nie klikam proxy.

Zaznaczenie opcji NO PROXY nie spowoduje usunięcia ustawienia proxy z gradle.properties (Global). Musisz go ręcznie usunąć.

Usuwam więc wszystkie właściwości zaczynające się na przykład od systemProp - systemProp.http.nonProxyHosts = *. Local, localhost

Aktualizacja odpowiedzi @sourcesimian i @ kunal-b, która dynamicznie ustawia nazwę użytkownika i hasło, jeśli są skonfigurowane we właściwościach systemu.

Poniżej ustawia się nazwę użytkownika i hasło, jeśli są podane, lub po prostu dodaje hosta i port, jeśli nie ustawiono nazwy użytkownika i hasł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())
        }
    }
}

Jeśli jesteś za proxy i używasz eclipse, przejdź do Window Menu --> Preferences --> General --> Network Connections. Wybierz aktywnych dostawców jako „Ręcznie”.

W sekcji Wpisy proxy kliknij HTTPS, kliknij Edytuj i dodaj hosta i port proxy. Jeśli wymagana jest nazwa użytkownika i hasło, również je podaj. U mnie zadziałało!

Jeśli ten problem z błędem HTTP 407 wystąpił tylko w wybranych pakietach, problem nie dotyczy ustawień serwera proxy i połączenia internetowego. Możesz nawet wystawić swój komputer na połączenie z Internetem za pośrednictwem NAT i nadal napotkasz ten problem. Zwykle w tym samym czasie możesz pobrać żądane pakiety w przeglądarce. Jedyne rozwiązanie, które znalazłem: usuń folder .gradle w swoim profilu (nie w projekcie). Po tej zsynchronizowaniu projektu zajmie to dużo czasu, ale przywrócenie wszystkiego.