Handle context cancellation and improve comment correctness.

Author: matthewdale

x/mongo/driver/topology/connection_options.go

@@ -55,7 +55,7 @@ type connectionConfig struct {
 	zstdLevel                *int
 	ocspCache                ocsp.Cache
 	disableOCSPEndpointCheck bool
-	errorHandlingCallback    func(error, error, uint64, *primitive.ObjectID)
+	errorHandlingCallback    func(err, ctxErr error, startGenNum uint64, svcID *primitive.ObjectID)
 	tlsConnectionSource      tlsConnectionSource
 	loadBalanced             bool
 	getGenerationFn          generationNumberFn
@@ -92,7 +92,7 @@ func withTLSConnectionSource(fn func(tlsConnectionSource) tlsConnectionSource) C
 	}
 }
 
-func withErrorHandlingCallback(fn func(error, error, uint64, *primitive.ObjectID)) ConnectionOption {
+func withErrorHandlingCallback(fn func(err, ctxErr error, startGenNum uint64, svcID *primitive.ObjectID)) ConnectionOption {
 	return func(c *connectionConfig) error {
 		c.errorHandlingCallback = fn
 		return nil

x/mongo/driver/topology/connection_test.go

@@ -129,7 +129,7 @@ func TestConnection(t *testing.T) {
 							return &net.TCPConn{}, nil
 						})
 					}),
-					withErrorHandlingCallback(func(err, ctxErr error, _ uint64, _ *primitive.ObjectID) {
+					withErrorHandlingCallback(func(err, _ error, _ uint64, _ *primitive.ObjectID) {
 						got = err
 					}),
 				)

x/mongo/driver/topology/server.go

@@ -273,7 +273,7 @@ func (s *Server) Connection(ctx context.Context) (driver.Connection, error) {
 }
 
 // ProcessHandshakeError implements SDAM error handling for errors that occur before a connection finishes handshaking.
-// ctxErr is any error caused by the context passed to Server#Connection() and is used to determine whether or not an
+// ctxErr is any error caused by the context passed to Server.Connection() and is used to determine whether or not an
 // operation-scoped context deadline or cancellation was the cause of the handshake error.
 func (s *Server) ProcessHandshakeError(err, ctxErr error, startingGenerationNumber uint64, serviceID *primitive.ObjectID) {
 	// Ignore the error if the server is behind a load balancer but the service ID is unknown. This indicates that the
@@ -292,29 +292,37 @@ func (s *Server) ProcessHandshakeError(err, ctxErr error, startingGenerationNumb
 		return
 	}
 
-	isTimeout := func(err error) bool {
+	isTimeoutOrCanceled := func(err error) bool {
 		for err != nil {
+			// Check for errors that implement the "net.Error" interface and self-report as timeout
+			// errors. Includes some "*net.OpError" errors and "context.DeadlineExceeded".
 			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
 				return true
 			}
-			// Handle the case where an error has been replaced by "net.errCanceled", which isn't
-			// exported and can't be compared directly. In this case, just compare the error message.
-			if err.Error() == "operation was canceled" {
+			// Check for context cancellation. Also handle the case where the cancellation error has
+			// been replaced by "net.errCanceled" (which isn't exported and can't be compared
+			// directly) by checking the error message.
+			if err == context.Canceled || err.Error() == "operation was canceled" {
 				return true
 			}
-			if wrapper, ok := err.(interface{ Unwrap() error }); ok {
-				err = wrapper.Unwrap()
-			} else {
+
+			wrapper, ok := err.(interface{ Unwrap() error })
+			if !ok {
 				break
 			}
+			err = wrapper.Unwrap()
 		}
 
 		return false
 	}
 
-	// Ignore errors that indicate a client-side timeout occurred when using an operation-scoped
-	// deadline (i.e. not using connectTimeoutMS as the connection timeout).
-	if (ctxErr == context.DeadlineExceeded || ctxErr == context.Canceled) && isTimeout(wrappedConnErr) {
+	// Ignore errors that indicate a client-side timeout occurred when the context passed into an
+	// operation timed out or was canceled (i.e. errors caused by an operation-scoped timeout).
+	// Timeouts caused by reaching connectTimeoutMS or other non-operation-scoped timeouts should
+	// still clear the pool.
+	// TODO(GODRIVER-2038): Remove this condition when connections are no longer created with an
+	// operation-scoped timeout.
+	if ctxErr != nil && isTimeoutOrCanceled(wrappedConnErr) {
 		return
 	}