Como definir o tempo limite para solicitações http.Get () no Golang?

Estou fazendo um buscador de URL no Go e tenho uma lista de URLs para buscar. Eu envio http.Get()solicitações para cada URL e obtenho sua resposta.

resp,fetch_err := http.Get(url)

Como posso definir um tempo limite personalizado para cada solicitação Get? (O tempo padrão é muito longo e isso torna meu buscador muito lento.) Eu quero que meu buscador tenha um tempo limite de cerca de 40-45 segundos, após o qual ele deve retornar "tempo limite da solicitação esgotado" e seguir para a próxima URL.

Como posso conseguir isso?

Aparentemente no Go 1.3 http.Client tem o campo Timeout

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

Isso fez o truque para mim.

Você precisa configurar seu próprio Cliente com seu próprio Transporte, que usa uma função de discagem personalizada que envolve DialTimeout .

Algo como (completamente não testado ) isto :

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

Para adicionar à resposta de Volker, se você também gostaria de definir o tempo limite de leitura / gravação além do tempo limite de conexão, você pode fazer algo como o seguinte

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

Este código foi testado e está funcionando em produção. A essência completa com testes está disponível aqui https://gist.github.com/dmichael/5710968

Esteja ciente de que você precisará criar um novo cliente para cada solicitação por causa do conn.SetDeadlinequal faz referência a um ponto no futuro detime.Now()

Se você quiser fazer isso por solicitação, tratamento de erros ignorado por questões de brevidade:

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)

Uma maneira rápida e suja:

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

Este é um estado global mutante sem qualquer coordenação. No entanto, pode ser adequado para seu coletor de urls. Caso contrário, crie uma instância privada 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)
...

Nada acima foi testado.

Você pode usar https://github.com/franela/goreq, que lida com os tempos limite de uma maneira simples.

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

Isso pode ajudar, mas observe que ResponseHeaderTimeoutcomeça somente depois que a conexão é estabelecida.