¿Cómo configurar el tiempo de espera para las solicitudes http.Get () en Golang?

Estoy creando un buscador de URL en Go y tengo una lista de URL para buscar. Envío http.Get()solicitudes a cada URL y obtengo su respuesta.

resp,fetch_err := http.Get(url)

¿Cómo puedo establecer un tiempo de espera personalizado para cada solicitud de obtención? (El tiempo predeterminado es muy largo y eso hace que mi buscador sea muy lento.) Quiero que mi buscador tenga un tiempo de espera de alrededor de 40-45 segundos, después de lo cual debería devolver "solicitud agotada" y pasar a la siguiente URL.

¿Cómo puedo conseguir esto?

Aparentemente, en Go 1.3 http.El cliente tiene un campo de tiempo de espera

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

Eso me ha funcionado.

Debe configurar su propio cliente con su propio transporte, que utiliza una función de marcado personalizada que envuelve DialTimeout .

Algo como (completamente no probado ) esto :

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 agregar a la respuesta de Volker, si también desea establecer el tiempo de espera de lectura / escritura además del tiempo de espera de conexión, puede hacer algo como lo siguiente

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 está probado y está funcionando en producción. La esencia completa con las pruebas está disponible aquí https://gist.github.com/dmichael/5710968

Tenga en cuenta que deberá crear un nuevo cliente para cada solicitud debido a conn.SetDeadlineque hace referencia a un punto en el futuro desdetime.Now()

Si desea hacerlo por solicitud, se ignora el manejo de errores por brevedad:

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)

Una forma rápida y sucia:

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

Este es un estado global mutante sin ninguna coordinación. Sin embargo, posiblemente esté bien para su buscador de URL. De lo contrario, cree una instancia 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 de lo anterior fue probado.

Puede utilizar https://github.com/franela/goreq, que gestiona los tiempos de espera de forma sencilla y moderna.

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

Esto puede ayudar, pero tenga en cuenta que ResponseHeaderTimeoutcomienza solo después de que se establece la conexión.