Clear lastErr on reconnect success

nats.go

@@ -1453,6 +1453,7 @@ func (nc *Conn) connect() error {
 			if err == nil {
 				nc.srvPool[i].didConnect = true
 				nc.srvPool[i].reconnects = 0
+				nc.current.lastErr = nil
 				returnedErr = nil
 				break
 			} else {
@@ -1622,7 +1623,6 @@ func normalizeErr(line string) string {
 // applicable. Will wait for a flush to return from the server for error
 // processing.
 func (nc *Conn) sendConnect() error {
-
 	// Construct the CONNECT protocol string
 	cProto, err := nc.connectProto()
 	if err != nil {
@@ -1849,6 +1849,18 @@ func (nc *Conn) doReconnect(err error) {
 
 		// Process connect logic
 		if nc.err = nc.processConnectInit(); nc.err != nil {
+			// If we have a lastErr recorded for this server
+			// do the normal processing here. We might get closed.
+			if nc.current.lastErr != nil {
+				err := nc.err
+				nc.mu.Unlock()
+				nc.processErr(err.Error())
+				nc.mu.Lock()
+				if nc.isClosed() {
+					break
+				}
+			}
+
 			nc.status = RECONNECTING
 			// Reset the buffered writer to the pending buffer
 			// (was set to a buffered writer on nc.conn in createConn)
@@ -1891,12 +1903,19 @@ func (nc *Conn) doReconnect(err error) {
 		if nc.Opts.ReconnectedCB != nil {
 			nc.ach.push(func() { nc.Opts.ReconnectedCB(nc) })
 		}
+
+		lastErr := nc.current.lastErr
+
 		// Release lock here, we will return below.
 		nc.mu.Unlock()
 
 		// Make sure to flush everything
 		nc.Flush()
 
+		if lastErr != nil && !nc.IsClosed() {
+			nc.clearCurrentLastErr()
+		}
+
 		return
 	}
 
@@ -2278,6 +2297,14 @@ func (nc *Conn) processAuthError(err error) {
 	nc.mu.Unlock()
 }
 
+// clearCurrentLastErr will clear the last error when we know we have
+// successfully connected after a flush.
+func (nc *Conn) clearCurrentLastErr() {
+	nc.mu.Lock()
+	nc.current.lastErr = nil
+	nc.mu.Unlock()
+}
+
 // flusher is a separate Go routine that will process flush requests for the write
 // bufio. This allows coalescing of writes to the underlying socket.
 func (nc *Conn) flusher() {

nats_test.go

@@ -1454,6 +1454,9 @@ func TestExpiredUserCredentials(t *testing.T) {
 	if err := WaitTime(ch, 2*time.Second); err != nil {
 		t.Fatal("Should have closed after multiple failed attempts.")
 	}
+	if stats := nc.Stats(); stats.Reconnects > 2 {
+		t.Fatalf("Expected at most 2 reconnects, got %d", stats.Reconnects)
+	}
 }
 
 func TestExpiredUserCredentialsRenewal(t *testing.T) {
@@ -1514,9 +1517,19 @@ func TestExpiredUserCredentialsRenewal(t *testing.T) {
 		t.Fatal("Should have reconnected.")
 	}
 
+	// We should not have been closed.
 	if nc.IsClosed() {
 		t.Fatal("Got disconnected when we should have reconnected.")
 	}
+
+	// Check that we clear the lastErr that can cause the disconnect.
+	// Our reconnect CB will happen before the clear. So check after a bit.
+	time.Sleep(50 * time.Millisecond)
+	nc.mu.Lock()
+	defer nc.mu.Unlock()
+	if nc.current.lastErr != nil {
+		t.Fatalf("Expected lastErr to be cleared, got %q", nc.current.lastErr)
+	}
 }
 
 // If we are using TLS and have multiple servers we try to match the IP