Comment définir le délai d'expiration des requêtes http.Get () dans Golang?

Je crée un récupérateur d'URL dans Go et j'ai une liste d'URL à récupérer. J'envoie des http.Get()requêtes à chaque URL et j'obtiens leur réponse.

resp,fetch_err := http.Get(url)

Comment puis-je définir un délai d'expiration personnalisé pour chaque demande Get? (Le temps par défaut est très long et cela rend mon récupérateur vraiment lent.) Je veux que mon récupérateur ait un délai d'attente d'environ 40 à 45 secondes après quoi il devrait renvoyer "requête expirée" et passer à l'URL suivante.

Comment puis-je atteindre cet objectif?

Apparemment, dans Go 1.3, http.Client a un champ Timeout

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

Cela a fait l'affaire pour moi.

Vous devez configurer votre propre client avec votre propre transport qui utilise une fonction de numérotation personnalisée qui entoure DialTimeout .

Quelque chose comme (complètement non testé ) ceci :

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

Pour ajouter à la réponse de Volker, si vous souhaitez également définir le délai de lecture / écriture en plus du délai de connexion, vous pouvez faire quelque chose comme ce qui suit

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

Ce code est testé et fonctionne en production. L'essentiel avec les tests est disponible ici https://gist.github.com/dmichael/5710968

Sachez que vous devrez créer un nouveau client pour chaque demande en raison du conn.SetDeadlinequi fait référence à un point dans le futur à partir detime.Now()

Si vous voulez le faire par requête, la gestion des erreurs est ignorée par souci de concision:

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)

Une manière rapide et sale:

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

C'est un état mondial en mutation sans aucune coordination. Pourtant, cela peut convenir à votre récupérateur d'URL. Sinon, créez une instance privée de 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)
...

Rien ci-dessus n'a été testé.

Vous pouvez utiliser https://github.com/franela/goreq qui gère les délais d'expiration de manière simple et simple.

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

Cela peut aider, mais remarquez que cela ResponseHeaderTimeoutne démarre qu'après l'établissement de la connexion.