fix: deadlock in session destruction

Author: dantengsky

src/query/service/src/sessions/session_mgr.rs

@@ -213,16 +213,27 @@ impl SessionManager {
     }
 
     pub fn processes_info(&self) -> Vec<ProcessInfo> {
-        let sessions = self.active_sessions.read();
+        let active_sessions = {
+            // Here the situation is the same of method `graceful_shutdown`:
+            //
+            // We should drop the read lock before
+            // - acquiring upgraded session reference: the Arc<Session>,
+            // - extracting the ProcessInfo from it
+            // - and then drop the Arc<Session>
+            // Since there are chances that we are the last one that holding the reference, and the
+            // destruction of session need to acquire the write lock of `active_sessions`, which leads
+            // to dead lock.
+            //
+            // Although online expression can also do this, to make this clearer, we wrap it in a block
+
+            let active_sessions_guard = self.active_sessions.read();
+            active_sessions_guard.values().cloned().collect::<Vec<_>>()
+        };
 
-        let mut processes_info = Vec::with_capacity(sessions.len());
-        for weak_ptr in sessions.values() {
-            if let Some(active_session) = weak_ptr.upgrade() {
-                processes_info.push(active_session.process_info());
-            }
-        }
-
-        processes_info
+        active_sessions
+            .into_iter()
+            .filter_map(|weak_ptr| weak_ptr.upgrade().map(|session| session.process_info()))
+            .collect::<Vec<_>>()
     }
 
     fn destroy_idle_sessions(sessions: &Arc<RwLock<HashMap<String, Weak<Session>>>>) -> bool {