Address review: consolidate ping(), handle timeout, dedup reconnect dialogs

- Merge connection_ping() into the existing ping(): adds the
  transaction_status guard and close-on-failure recovery, returns
  bool. Removes the redundant abstract method and updates callers.
- Treat axios ECONNABORTED (client-side timeout, no error.response) as
  a connection-lost signal so the reconnect dialog still triggers when
  the server hangs on a recently-dead socket.
- Add a per-server _reconnectPending guard so concurrent failed
  child-load requests do not stack multiple reconnect dialogs; the
  flag is cleared on both OK and Cancel.

Author: ZoroXL

web/pgadmin/browser/utils.py

@@ -433,12 +433,12 @@ def children(self, **kwargs):
 
         try:
             conn = manager.connection(did=did)
-            # Use connection_ping() instead of connected() to detect
-            # stale / half-open TCP connections that were silently
-            # dropped while pgAdmin was idle.  connected() only checks
-            # local state and would miss these, causing the subsequent
-            # SQL queries to hang indefinitely.
-            if not conn.connection_ping():
+            # Use ping() instead of connected() to detect stale /
+            # half-open TCP connections that were silently dropped while
+            # pgAdmin was idle.  connected() only checks local state and
+            # would miss these, causing the subsequent SQL queries to
+            # hang indefinitely.
+            if not conn.ping():
                 status, msg = conn.connect()
                 if not status:
                     return service_unavailable(

web/pgadmin/static/js/tree/tree_nodes.ts

@@ -126,8 +126,15 @@ export class ManageTreeNodes {
       } catch (error) {
         /* react-aspen does not handle reject case */
         console.error(error);
-        if (error.response?.status === 503 &&
-            error.response?.data?.info === 'CONNECTION_LOST') {
+        const isConnectionLost =
+          (error.response?.status === 503 &&
+            error.response?.data?.info === 'CONNECTION_LOST') ||
+          // Axios client-side timeout has no error.response — treat it
+          // as a likely connection loss so the reconnect dialog still
+          // triggers when the server hangs on a recently-dead socket
+          // (before TCP keepalives detect it).
+          error.code === 'ECONNABORTED';
+        if (isConnectionLost) {
           // Connection dropped while idle.  Walk up to the server node
           // and mark it disconnected, then show a reconnect prompt so
           // the user can re-establish instead of seeing a silent
@@ -138,24 +145,38 @@ export class ManageTreeNodes {
             if (d?._type === 'server') break;
             serverNode = serverNode.parentNode ?? null;
           }
+          const sData = serverNode
+            ? (serverNode.metadata?.data ?? serverNode.data)
+            : null;
+          // When a server has multiple expanded children, every in-flight
+          // child-load request will fail independently.  Guard with a
+          // per-server flag so we only show one reconnect dialog at a
+          // time instead of stacking them.
+          if (sData?._reconnectPending) return [];
           if (serverNode) {
-            const sData = serverNode.metadata?.data ?? serverNode.data;
-            if (sData) sData.connected = false;
+            if (sData) {
+              sData.connected = false;
+              sData._reconnectPending = true;
+            }
             pgAdmin.Browser.tree?.addIcon(serverNode, {icon: 'icon-server-not-connected'});
             pgAdmin.Browser.tree?.close(serverNode);
           }
+          const clearPending = () => {
+            if (sData) sData._reconnectPending = false;
+          };
           pgAdmin.Browser.notifier.confirm(
             gettext('Connection lost'),
             gettext('The connection to the server has been lost. Would you like to reconnect?'),
             function() {
+              clearPending();
               // Re-open (connect) the server node in the tree which
               // will trigger the standard connect-to-server flow
               // including any password prompts.
               if (serverNode && pgAdmin.Browser.tree) {
                 pgAdmin.Browser.tree.toggle(serverNode);
               }
             },
-            function() { /* cancelled */ }
+            clearPending,
           );
         } else {
           pgAdmin.Browser.notifier.error(parseApiError(error)||'Node Load Error...');

web/pgadmin/utils/driver/abstract.py

@@ -116,14 +116,8 @@ class BaseConnection()
       - Implement this method to get the status of the connection. It should
         return True for connected, otherwise False.  This is a local check
         only (e.g. inspecting driver-level state) and may not detect
-        server-side disconnects.  Use connection_ping() when a network-level
-        check is required.
-
-    * connection_ping()
-      - Implement this method to verify the connection is alive by sending a
-        lightweight query (e.g. SELECT 1) to the server.  Returns True if the
-        server responds, False otherwise.  Unlike connected(), this detects
-        stale or half-open TCP connections that were silently dropped.
+        server-side disconnects.  Use ping() when a network-level check is
+        required.
 
     * reset()
       - Implement this method to reconnect the database server (if possible)
@@ -133,9 +127,13 @@ class BaseConnection()
         connection. Range of return values different for each driver type.
 
     * ping()
-      - Implement this method to ping the server. There are times, a connection
-        has been lost, but - the connection driver does not know about it. This
-        can be helpful to figure out the actual reason for query failure.
+      - Implement this method to verify the connection is alive by sending a
+        lightweight query (e.g. SELECT 1) to the server.  Returns True if the
+        server responds, False otherwise.  Unlike connected(), this detects
+        stale or half-open TCP connections that were silently dropped.  When
+        a query is already in progress or the connection is inside a
+        transaction block, the probe is skipped and True is returned (the
+        connection is evidently alive).
 
     * _release()
       - Implement this method to release the connection object. This should not
@@ -216,14 +214,6 @@ def async_fetchmany_2darray(self, records=-1,
     def connected(self):
         pass
 
-    @abstractmethod
-    def connection_ping(self):
-        """
-        Check if the connection is actually alive by sending a lightweight
-        query to the server.  Returns True if alive, False otherwise.
-        """
-        pass
-
     @abstractmethod
     def reset(self):
         pass
@@ -234,6 +224,10 @@ def transaction_status(self):
 
     @abstractmethod
     def ping(self):
+        """
+        Check if the connection is actually alive by sending a lightweight
+        query to the server.  Returns True if alive, False otherwise.
+        """
         pass
 
     @abstractmethod

web/pgadmin/utils/driver/psycopg3/connection.py

@@ -1413,46 +1413,6 @@ def connected(self):
             self.conn = None
         return False
 
-    def connection_ping(self):
-        """
-        Check if the connection is actually alive by executing a lightweight
-        query.  Unlike connected(), which only inspects local state, this
-        sends traffic to the server and will detect stale / half-open TCP
-        connections that were silently dropped by firewalls or the OS while
-        pgAdmin was idle.
-
-        Returns True if alive, False otherwise.
-        """
-        if not self.connected():
-            return False
-
-        try:
-            # Check the transaction status before executing the ping
-            # query.  If a query is already in progress (ACTIVE) or we
-            # are inside a transaction block (INTRANS / INERROR), running
-            # SELECT 1 would fail or disrupt the ongoing operation.  In
-            # those states the connection is evidently alive, so just
-            # return True.
-            txn_status = self.conn.info.transaction_status
-            if txn_status != 0:
-                # 0 = IDLE — safe to send a query
-                # 1 = ACTIVE — command in progress, connection is alive
-                # 2 = INTRANS — in transaction block, connection is alive
-                # 3 = INERROR — in failed transaction, connection is alive
-                return True
-
-            cur = self.conn.cursor()
-            cur.execute("SELECT 1")
-            cur.close()
-            return True
-        except Exception:
-            try:
-                self.conn.close()
-            except Exception:
-                pass
-            self.conn = None
-            return False
-
     def _decrypt_password(self, manager):
         """
         Decrypt password
@@ -1526,7 +1486,43 @@ def async_query_error(self):
         return self.__async_query_error
 
     def ping(self):
-        return self.execute_scalar('SELECT 1')
+        """
+        Check if the connection is actually alive by executing a lightweight
+        query.  Unlike connected(), which only inspects local state, this
+        sends traffic to the server and will detect stale / half-open TCP
+        connections that were silently dropped by firewalls or the OS while
+        pgAdmin was idle.
+
+        Returns True if alive, False otherwise.
+        """
+        if not self.connected():
+            return False
+
+        try:
+            # Check the transaction status before executing the ping
+            # query.  If a query is already in progress (ACTIVE) or we
+            # are inside a transaction block (INTRANS / INERROR), running
+            # SELECT 1 would fail or disrupt the ongoing operation.  In
+            # those states the connection is evidently alive, so just
+            # return True.
+            #   0 = IDLE     — safe to send a query
+            #   1 = ACTIVE   — command in progress, connection is alive
+            #   2 = INTRANS  — in transaction block, connection is alive
+            #   3 = INERROR  — in failed transaction, connection is alive
+            if self.conn.info.transaction_status != 0:
+                return True
+
+            cur = self.conn.cursor()
+            cur.execute("SELECT 1")
+            cur.close()
+            return True
+        except Exception:
+            try:
+                self.conn.close()
+            except Exception:
+                pass
+            self.conn = None
+            return False
 
     def _release(self):
         if self.wasConnected: