GODRIVER-1581 Implement Unwrap for all wrapping error types (#394)

Author: Divjot Arora

mongo/errors.go

@@ -37,7 +37,13 @@ func replaceErrors(err error) error {
 		return ErrClientDisconnected
 	}
 	if de, ok := err.(driver.Error); ok {
-		return CommandError{Code: de.Code, Message: de.Message, Labels: de.Labels, Name: de.Name}
+		return CommandError{
+			Code:    de.Code,
+			Message: de.Message,
+			Labels:  de.Labels,
+			Name:    de.Name,
+			Wrapped: de.Wrapped,
+		}
 	}
 	if qe, ok := err.(driver.QueryFailureError); ok {
 		// qe.Message is "command failure"
@@ -83,6 +89,11 @@ func (ekve EncryptionKeyVaultError) Error() string {
 	return fmt.Sprintf("key vault communication error: %v", ekve.Wrapped)
 }
 
+// Unwrap returns the underlying error.
+func (ekve EncryptionKeyVaultError) Unwrap() error {
+	return ekve.Wrapped
+}
+
 // MongocryptdError represents an error while communicating with mongocryptd during client-side encryption.
 type MongocryptdError struct {
 	Wrapped error
@@ -93,12 +104,18 @@ func (e MongocryptdError) Error() string {
 	return fmt.Sprintf("mongocryptd communication error: %v", e.Wrapped)
 }
 
+// Unwrap returns the underlying error.
+func (e MongocryptdError) Unwrap() error {
+	return e.Wrapped
+}
+
 // CommandError represents a server error during execution of a command. This can be returned by any operation.
 type CommandError struct {
 	Code    int32
 	Message string
 	Labels  []string // Categories to which the error belongs
 	Name    string   // A human-readable name corresponding to the error code
+	Wrapped error    // The underlying error, if one exists.
 }
 
 // Error implements the error interface.
@@ -109,6 +126,11 @@ func (e CommandError) Error() string {
 	return e.Message
 }
 
+// Unwrap returns the underlying error.
+func (e CommandError) Unwrap() error {
+	return e.Wrapped
+}
+
 // HasErrorLabel returns true if the error contains the specified label.
 func (e CommandError) HasErrorLabel(label string) bool {
 	if e.Labels != nil {

mongo/integration/errors_test.go

@@ -0,0 +1,60 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+// +build go1.13
+
+package integration
+
+import (
+	"context"
+	"errors"
+	"io"
+	"testing"
+
+	"go.mongodb.org/mongo-driver/internal/testutil/assert"
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/integration/mtest"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+func TestErrors(t *testing.T) {
+	mt := mtest.New(t, noClientOpts)
+	defer mt.Close()
+
+	mt.RunOpts("errors are wrapped", noClientOpts, func(mt *mtest.T) {
+		mt.Run("network error during application operation", func(mt *mtest.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+
+			err := mt.Client.Ping(ctx, mtest.PrimaryRp)
+			assert.True(mt, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err)
+		})
+
+		authOpts := mtest.NewOptions().Auth(true).Topologies(mtest.ReplicaSet, mtest.Single).MinServerVersion("4.0")
+		mt.RunOpts("network error during auth", authOpts, func(mt *mtest.T) {
+			mt.SetFailPoint(mtest.FailPoint{
+				ConfigureFailPoint: "failCommand",
+				Mode: mtest.FailPointMode{
+					Times: 1,
+				},
+				Data: mtest.FailPointData{
+					// Set the fail point for saslContinue rather than saslStart because the driver will use speculative
+					// auth on 4.4+ so there won't be an explicit saslStart command.
+					FailCommands:    []string{"saslContinue"},
+					CloseConnection: true,
+				},
+			})
+
+			client, err := mongo.Connect(mtest.Background, options.Client().ApplyURI(mt.ConnString()))
+			assert.Nil(mt, err, "Connect error: %v", err)
+			defer client.Disconnect(mtest.Background)
+
+			// A connection getting closed should manifest as an io.EOF error.
+			err = client.Ping(mtest.Background, mtest.PrimaryRp)
+			assert.True(mt, errors.Is(err, io.EOF), "expected error %v, got %v", io.EOF, err)
+		})
+	})
+}

x/mongo/driver/auth/auth.go

@@ -201,6 +201,11 @@ func (e *Error) Inner() error {
 	return e.inner
 }
 
+// Unwrap returns the underlying error.
+func (e *Error) Unwrap() error {
+	return e.inner
+}
+
 // Message returns the message.
 func (e *Error) Message() string {
 	return e.message

x/mongo/driver/errors.go

@@ -220,6 +220,11 @@ func (e Error) Error() string {
 	return e.Message
 }
 
+// Unwrap returns the underlying error.
+func (e Error) Unwrap() error {
+	return e.Wrapped
+}
+
 // HasErrorLabel returns true if the error contains the specified label.
 func (e Error) HasErrorLabel(label string) bool {
 	if e.Labels != nil {

x/mongo/driver/ocsp/ocsp.go

@@ -271,8 +271,9 @@ func contactResponders(ctx context.Context, cfg config) (*ResponseDetails, error
 
 				timeout := urlErr.Timeout()
 				cancelled := urlErr.Err == context.Canceled // Timeout() does not return true for context.Cancelled.
-				if userContextUsed && (timeout || cancelled) {
-					// Handle the original context expiring or being cancelled.
+				if cancelled || (userContextUsed && timeout) {
+					// Handle the original context expiring or being cancelled. The url.Error type supports Unwrap, so
+					// users can use errors.Is to check for context errors.
 					return err
 				}
 				return nil // Ignore all other errors.

x/mongo/driver/ocsp/ocsp_test.go

@@ -0,0 +1,39 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+// +build go1.13
+
+package ocsp
+
+import (
+	"context"
+	"crypto/x509"
+	"errors"
+	"testing"
+
+	"go.mongodb.org/mongo-driver/internal/testutil/assert"
+)
+
+func TestOCSP(t *testing.T) {
+	t.Run("contactResponders", func(t *testing.T) {
+		t.Run("cancelled context is propagated", func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+
+			serverCert := &x509.Certificate{
+				OCSPServer: []string{"https://localhost:5000"},
+			}
+			cfg := config{
+				serverCert: serverCert,
+				issuer:     &x509.Certificate{},
+				cache:      NewCache(),
+			}
+
+			_, err := contactResponders(ctx, cfg)
+			assert.True(t, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err)
+		})
+	})
+}

x/mongo/driver/topology/connection.go

@@ -541,7 +541,7 @@ func configureTLS(ctx context.Context, nc net.Conn, addr address.Address, config
 			return nil, ocspErr
 		}
 	case <-ctx.Done():
-		return nil, errors.New("server connection cancelled/timeout during TLS handshake")
+		return nil, ctx.Err()
 	}
 	return client, nil
 }

x/mongo/driver/topology/connection_errors_test.go

@@ -0,0 +1,72 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+// +build go1.13
+
+package topology
+
+import (
+	"context"
+	"errors"
+	"net"
+	"testing"
+
+	"go.mongodb.org/mongo-driver/internal/testutil/assert"
+	"go.mongodb.org/mongo-driver/x/mongo/driver/address"
+	"go.mongodb.org/mongo-driver/x/mongo/driver/auth"
+)
+
+func TestConnectionErrors(t *testing.T) {
+	t.Run("errors are wrapped", func(t *testing.T) {
+		t.Run("dial error", func(t *testing.T) {
+			dialError := errors.New("foo")
+
+			conn, err := newConnection(context.Background(), address.Address(""), WithDialer(func(Dialer) Dialer {
+				return DialerFunc(func(context.Context, string, string) (net.Conn, error) { return nil, dialError })
+			}))
+			assert.Nil(t, err, "newConnection error: %v", err)
+
+			conn.connect(context.Background())
+			err = conn.wait()
+			assert.True(t, errors.Is(err, dialError), "expected error %v, got %v", dialError, err)
+		})
+		t.Run("handshake error", func(t *testing.T) {
+			conn, err := newConnection(context.Background(), address.Address(""),
+				WithHandshaker(func(Handshaker) Handshaker {
+					return auth.Handshaker(nil, &auth.HandshakeOptions{})
+				}),
+				WithDialer(func(Dialer) Dialer {
+					return DialerFunc(func(context.Context, string, string) (net.Conn, error) {
+						return &net.TCPConn{}, nil
+					})
+				}),
+			)
+			assert.Nil(t, err, "newConnection error: %v", err)
+			defer conn.close()
+
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+			conn.connect(ctx)
+			err = conn.wait()
+
+			assert.True(t, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err)
+		})
+		t.Run("write error", func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+			conn := &connection{id: "foobar", nc: &net.TCPConn{}, connected: connected}
+			err := conn.writeWireMessage(ctx, []byte{})
+			assert.True(t, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err)
+		})
+		t.Run("read error", func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+			cancel()
+			conn := &connection{id: "foobar", nc: &net.TCPConn{}, connected: connected}
+			_, err := conn.readWireMessage(ctx, []byte{})
+			assert.True(t, errors.Is(err, context.Canceled), "expected error %v, got %v", context.Canceled, err)
+		})
+	})
+}

x/mongo/driver/topology/errors.go

@@ -20,3 +20,8 @@ func (e ConnectionError) Error() string {
 	}
 	return fmt.Sprintf("connection(%s) %s", e.ConnectionID, e.message)
 }
+
+// Unwrap returns the underlying error.
+func (e ConnectionError) Unwrap() error {
+	return e.Wrapped
+}

x/mongo/driver/topology/topology.go

@@ -325,7 +325,7 @@ func (t *Topology) SelectServer(ctx context.Context, ss description.ServerSelect
 		if !doneOnce {
 			// for the first pass, select a server from the current description.
 			// this improves selection speed for up-to-date topology descriptions.
-			suitable, selectErr = t.selectServerFromDescription(ctx, t.Description(), selectionState)
+			suitable, selectErr = t.selectServerFromDescription(t.Description(), selectionState)
 			doneOnce = true
 		} else {
 			// if the first pass didn't select a server, the previous description did not contain a suitable server, so
@@ -450,7 +450,7 @@ func (t *Topology) selectServerFromSubscription(ctx context.Context, subscriptio
 		case current = <-subscriptionCh:
 		}
 
-		suitable, err := t.selectServerFromDescription(ctx, current, selectionState)
+		suitable, err := t.selectServerFromDescription(current, selectionState)
 		if err != nil {
 			return nil, err
 		}
@@ -463,7 +463,7 @@ func (t *Topology) selectServerFromSubscription(ctx context.Context, subscriptio
 }
 
 // selectServerFromDescription process the given topology description and returns a slice of suitable servers.
-func (t *Topology) selectServerFromDescription(ctx context.Context, desc description.Topology,
+func (t *Topology) selectServerFromDescription(desc description.Topology,
 	selectionState serverSelectionState) ([]description.Server, error) {
 
 	// Unlike selectServerFromSubscription, this code path does not check ctx.Done or selectionState.timeoutChan because