Specifically check for timeout error

I use the following to check for timeouts when calling a webservice, but I would like to check specifically if there is a timeout error returned. How do I do that :S

I have this:

// Timeout
type Timeout struct {
	Connect   time.Duration
	ReadWrite time.Duration
}

// TimeoutDialer
func TimeoutDialer(timeout *Timeout) func(net, addr string) (c net.Conn, err error) {
	return func(netw, addr string) (net.Conn, error) {    
		conn, err := net.DialTimeout(netw, addr, timeout.Connect)
		if err != nil {
			return nil, err
		}
		conn.SetDeadline(time.Now().Add(timeout.ReadWrite))
		return conn, nil
	}
}

// HttpClient
func HttpClient(config Config) *http.Client {
	to := &Timeout{
		Connect:   time.Duration(config.MaxWait) * time.Second,
		ReadWrite: time.Duration(config.MaxWait) * time.Second,
	}

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

If you are specifically looking for i/o timeouts, you can use errors.Is to detect an os.ErrDeadlineExceeded error as documented in the net package:

// If the deadline is exceeded a call to Read or Write or to other
// I/O methods will return an error that wraps os.ErrDeadlineExceeded.
// This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
// The error's Timeout method will return true, but note that there
// are other possible errors for which the Timeout method will
// return true even if the deadline has not been exceeded.

if errors.Is(err, os.ErrDeadlineExceeded) {
...

All possible timeouts will still conform to the net.Error with Timeout() set properly. All you need to check for is:

if err, ok := err.(net.Error); ok && err.Timeout() {

You can simply pass an error to os.IsTimeout() and if it's a timeout returned by net/http then it will return true.

> func IsTimeout(err error) bool
>
> IsTimeout returns a boolean indicating whether the error is known to report that a timeout occurred.

You want the net.Error interface. http://golang.org/pkg/net/#Error

if e,ok := err.(net.Error); ok && e.Timeout() {
    // This was a timeout
} else if err != nil {
    // This was an error, but not a timeout
}

Note that the type assertion err.(net.Error) will correctly handle the nil case and return false for the ok value if nil is returned as the error, short-circuiting the Timeout check.

It's also possible by doing something like this:

var timeoutError net.Error
if errors.As(err, &timeoutError); timeoutError.Timeout() {
    fmt.Println("timeout")
}