Jak ustawić limit czasu dla żądań http.Get () w języku Golang?

Robię narzędzie do pobierania adresów URL w Go i mam listę adresów URL do pobrania. Wysyłam http.Get()zapytania na każdy adres URL i otrzymuję odpowiedź.

resp,fetch_err := http.Get(url)

Jak mogę ustawić niestandardowy limit czasu dla każdego żądania Get? (Domyślny czas jest bardzo długi, co powoduje, że mój moduł pobierania jest naprawdę wolny). Chcę, aby mój moduł pobierania miał limit czasu wynoszący około 40-45 sekund, po którym powinien zwrócić komunikat „przekroczono limit czasu żądania” i przejść do następnego adresu URL.

Jak mogę to osiągnąć?

Najwyraźniej w Go 1.3 http Klient ma pole Timeout

client := http.Client{
    Timeout: 5 * time.Second,
}
client.Get(url)

To mi wystarczyło.

Musisz skonfigurować własnego klienta z własnym transportem, który wykorzystuje niestandardową funkcję wybierania, która otacza DialTimeout .

Coś takiego (całkowicie niesprawdzone ) to :

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
    return net.DialTimeout(network, addr, timeout)
}

func main() {
    transport := http.Transport{
        Dial: dialTimeout,
    }

    client := http.Client{
        Transport: &transport,
    }

    resp, err := client.Get("http://some.url")
}

Aby dodać do odpowiedzi Volkera, jeśli chcesz również ustawić limit czasu odczytu / zapisu oprócz limitu czasu połączenia, możesz zrobić coś takiego

package httpclient

import (
    "net"
    "net/http"
    "time"
)

func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, addr string) (c net.Conn, err error) {
    return func(netw, addr string) (net.Conn, error) {
        conn, err := net.DialTimeout(netw, addr, cTimeout)
        if err != nil {
            return nil, err
        }
        conn.SetDeadline(time.Now().Add(rwTimeout))
        return conn, nil
    }
}

func NewTimeoutClient(connectTimeout time.Duration, readWriteTimeout time.Duration) *http.Client {

    return &http.Client{
        Transport: &http.Transport{
            Dial: TimeoutDialer(connectTimeout, readWriteTimeout),
        },
    }
}

Ten kod jest testowany i działa w produkcji. Pełna treść testów dostępna jest tutaj https://gist.github.com/dmichael/5710968

Należy pamiętać, że dla każdego żądania konieczne będzie utworzenie nowego klienta ze względu na conn.SetDeadlineodwołanie do punktu w przyszłościtime.Now()

Jeśli chcesz to zrobić na żądanie, obsługa błędów została zignorowana ze względu na zwięzłość:

ctx, cncl := context.WithTimeout(context.Background(), time.Second*3)
defer cncl()

req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "https://google.com", nil)

resp, _ := http.DefaultClient.Do(req)

Szybki i brudny sposób:

http.DefaultTransport.(*http.Transport).ResponseHeaderTimeout = time.Second * 45

To jest mutacja stanu globalnego bez jakiejkolwiek koordynacji. Jednak może to być w porządku dla twojego modułu pobierania adresów URL. W przeciwnym razie utwórz prywatną instancję http.RoundTripper:

var myTransport http.RoundTripper = &http.Transport{
        Proxy:                 http.ProxyFromEnvironment,
        ResponseHeaderTimeout: time.Second * 45,
}

var myClient = &http.Client{Transport: myTransport}

resp, err := myClient.Get(url)
...

Nic powyżej nie zostało przetestowane.

Możesz użyć https://github.com/franela/goreq, który obsługuje limity czasu w modny i prosty sposób.

timeout := time.Duration(5 * time.Second)
transport := &http.Transport{Proxy: http.ProxyURL(proxyUrl), ResponseHeaderTimeout:timeout}

Może to pomóc, ale zauważ, że ResponseHeaderTimeoutzaczyna się dopiero po ustanowieniu połączenia.