rpc: send clean close frame on websocket disconnect (#20788)

Currently, when a WebSocket connection is closed by the RPC server, the
underlying TCP connection gets torn down immediately without sending a
final WebSocket Close frame. Because of this abrupt teardown, clients
connected to the node experience an abnormal closure (error code 1006)
instead of a clean, normal disconnect (error code 1000).

This PR fixes that behavior by explicitly sending a clean 1000 normal
closure frame right before terminating the connection. It uses the
`Close()` method from the `coder/websocket` library to safely transmit
this control frame.

Author: Sahil-4555

rpc/websocket.go

@@ -257,7 +257,28 @@ type wsConnAdapter struct {
 }
 
 func (a *wsConnAdapter) Close() error {
-	return a.conn.CloseNow()
+	// Attempt a graceful WebSocket close handshake first, so the peer sees a clean
+	// 1000 (normal closure) instead of 1006 (abnormal). Keep the handshake fully async
+	// so server shutdown doesn't block per connection, and force-close after a bounded
+	// grace period if the peer doesn't complete the close promptly.
+	closeDone := make(chan struct{})
+	go func() {
+		defer close(closeDone)
+		_ = a.conn.Close(websocket.StatusNormalClosure, "")
+	}()
+
+	go func() {
+		timer := time.NewTimer(time.Second)
+		defer timer.Stop()
+
+		select {
+		case <-closeDone:
+		case <-timer.C:
+			_ = a.conn.CloseNow()
+		}
+	}()
+
+	return nil
 }
 
 func (a *wsConnAdapter) SetWriteDeadline(t time.Time) error {

rpc/websocket_test.go

@@ -367,3 +367,44 @@ func TestWebsocketNonBlockingAcquire(t *testing.T) {
 		t.Errorf("expected error code %d (server overloaded), got %d", ErrCodeServerOverloaded, rpcErr.ErrorCode())
 	}
 }
+
+// TestWebsocketServerGracefulClose verifies that when the server initiates a
+// websocket closure, it explicitly sends a clean StatusNormalClosure (1000)
+// rather than an abnormal closure.
+func TestWebsocketServerGracefulClose(t *testing.T) {
+	t.Parallel()
+	logger := log.New()
+
+	srv := newTestServer(logger)
+	httpsrv := httptest.NewServer(srv.WebsocketHandler([]string{"*"}, nil, false, logger))
+	wsURL := "ws:" + strings.TrimPrefix(httpsrv.URL, "http:")
+	defer srv.Stop()
+	defer httpsrv.Close()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	conn, resp, err := websocket.Dial(ctx, wsURL, nil)
+	if err != nil {
+		if resp != nil && resp.Body != nil {
+			resp.Body.Close()
+		}
+		t.Fatalf("failed to dial: %v", err)
+	}
+	defer conn.CloseNow()
+
+	if err := conn.Write(ctx, websocket.MessageText, []byte("invalid json")); err != nil {
+		t.Fatalf("failed to write: %v", err)
+	}
+
+	for {
+		_, _, err := conn.Read(ctx)
+		if err != nil {
+			status := websocket.CloseStatus(err)
+			if status != websocket.StatusNormalClosure {
+				t.Errorf("expected close status %v, got %v (err: %v)", websocket.StatusNormalClosure, status, err)
+			}
+			break
+		}
+	}
+}