Only acquire write while test starts

Signed-off-by: Xuanwo <github@xuanwo.io>

Author: Xuanwo

src/common/base/src/base/singleton_instance.rs

@@ -45,7 +45,7 @@ impl Singleton {
                     Some(name) => name,
                     None => panic!("thread doesn't have name"),
                 };
-                let guard = c.read_recursive();
+                let guard = c.read();
                 let v: &T = guard
                     .get(thread_name)
                     .unwrap_or_else(|| panic!("thread {thread_name} is not initiated"))
@@ -65,15 +65,11 @@ impl Singleton {
                     Some(name) => name,
                     None => panic!("thread doesn't have name"),
                 };
-                let guard = c.upgradable_read();
-                match guard.get(thread_name) {
-                    Some(c) => c.set(value),
-                    None => {
-                        let mut guard = parking_lot::RwLockUpgradableReadGuard::upgrade(guard);
-                        let c = guard.entry(thread_name.to_string()).or_default();
-                        c.set(value)
-                    }
-                }
+                let guard = c.read();
+                guard
+                    .get(thread_name)
+                    .unwrap_or_else(|| panic!("thread {thread_name} is not initiated"))
+                    .set(value)
             }
         }
     }
@@ -109,8 +105,12 @@ impl GlobalInstance {
     ///
     /// Should only be initiated once and only used in testing.
     #[cfg(debug_assertions)]
-    pub fn init_testing() {
+    pub fn init_testing(thread_name: &str) {
         let _ = GLOBAL.set(Singleton::Testing(parking_lot::RwLock::default()));
+        if let Singleton::Testing(v) = GLOBAL.wait() {
+            let mut guard = v.write();
+            guard.insert(thread_name.to_string(), <Container![Send + Sync]>::new());
+        }
     }
 
     /// drop testing global data by thread name.

src/query/service/src/global_services.rs

@@ -36,23 +36,11 @@ pub struct GlobalServices;
 
 impl GlobalServices {
     pub async fn init(config: Config) -> Result<()> {
-        GlobalServices::init_with(config, true).await
+        GlobalInstance::init_production();
+        GlobalServices::init_with(config).await
     }
 
-    pub async fn init_with(config: Config, prodcution: bool) -> Result<()> {
-        #[cfg(debug_assertions)]
-        if prodcution {
-            GlobalInstance::init_production();
-        } else {
-            GlobalInstance::init_testing();
-        }
-        #[cfg(not(debug_assertions))]
-        if prodcution {
-            GlobalInstance::init_production();
-        } else {
-            unreachable!("release build must init with production global")
-        }
-
+    pub async fn init_with(config: Config) -> Result<()> {
         // The order of initialization is very important
         GlobalConfig::init(config.clone())?;
 

src/query/service/tests/it/tests/sessions.rs

@@ -33,7 +33,13 @@ impl TestGlobalServices {
         set_panic_hook();
         std::env::set_var("UNIT_TEST", "TRUE");
 
-        GlobalServices::init_with(config.clone(), false).await?;
+        let thread_name = match std::thread::current().name() {
+            None => panic!("thread name is none"),
+            Some(thread_name) => thread_name.to_string(),
+        };
+
+        GlobalInstance::init_testing(&thread_name);
+        GlobalServices::init_with(config.clone()).await?;
 
         // Cluster register.
         {
@@ -46,12 +52,9 @@ impl TestGlobalServices {
             );
         }
 
-        match std::thread::current().name() {
-            None => panic!("thread name is none"),
-            Some(thread_name) => Ok(TestGuard {
-                thread_name: thread_name.to_string(),
-            }),
-        }
+        Ok(TestGuard {
+            thread_name: thread_name.to_string(),
+        })
     }
 }
 
@@ -61,11 +64,6 @@ pub struct TestGuard {
 
 impl Drop for TestGuard {
     fn drop(&mut self) {
-        debug!(
-            "test {} is finished, starting dropping all resources",
-            &self.thread_name
-        );
-
         // Check if session manager sill have active sessions.
         {
             let session_mgr = SessionManager::instance();
@@ -79,8 +77,6 @@ impl Drop for TestGuard {
             }
         }
 
-        GlobalInstance::drop_testing(&self.thread_name);
-
-        debug!("test {} resources have been dropped", &self.thread_name);
+        // GlobalInstance::drop_testing(&self.thread_name);
     }
 }