Come impostare il timeout per le richieste http.Get () in Golang?

Sto creando un URL fetcher in Go e ho un elenco di URL da recuperare. Invio http.Get()richieste a ciascun URL e ottengo la loro risposta.

resp,fetch_err := http.Get(url)

Come posso impostare un timeout personalizzato per ogni richiesta Get? (Il tempo predefinito è molto lungo e questo rende il mio fetcher molto lento.) Voglio che il mio fetcher abbia un timeout di circa 40-45 secondi dopo di che dovrebbe restituire "richiesta scaduta" e passare all'URL successivo.

Come posso raggiungere questo obiettivo?

Apparentemente in Go 1.3 http.Client ha il campo Timeout

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

Questo ha fatto il trucco per me.

È necessario impostare il proprio client con il proprio trasporto che utilizza una funzione di composizione personalizzata che avvolge DialTimeout .

Qualcosa di simile (completamente non testato ) questo :

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

Per aggiungere alla risposta di Volker, se desideri impostare anche il timeout di lettura / scrittura oltre al timeout di connessione, puoi fare qualcosa di simile al seguente

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

Questo codice è testato e funziona in produzione. L'essenza completa con i test è disponibile qui https://gist.github.com/dmichael/5710968

Tieni presente che dovrai creare un nuovo client per ogni richiesta a causa del conn.SetDeadlinequale fa riferimento a un punto in futurotime.Now()

Se vuoi farlo per richiesta, la gestione degli errori ignorata per brevità:

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)

Un modo veloce e sporco:

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

Questo sta mutando lo stato globale senza alcun coordinamento. Eppure potrebbe essere ok per il tuo fetcher di URL. Altrimenti crea un'istanza privata di 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)
...

Niente di cui sopra è stato testato.

Puoi utilizzare https://github.com/franela/goreq che gestisce i timeout in modo semplice e alla moda.

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

Questo può essere d'aiuto, ma nota che si ResponseHeaderTimeoutavvia solo dopo aver stabilito la connessione.