chore: fix commen

Author: ZhiHanZ

src/query/sharing-endpoint/src/accessor.rs

@@ -12,13 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::Arc;
-
-use common_base::base::Singleton;
+use common_base::base::GlobalInstance;
 use common_exception::Result;
 use common_storage::init_operator;
 use common_storage::StorageParams;
-use once_cell::sync::OnceCell;
 use opendal::Operator;
 use time::Duration;
 
@@ -27,11 +24,9 @@ use crate::models;
 use crate::models::PresignFileResponse;
 use crate::models::SharedTableResponse;
 
-static SHARING_ACCESSOR: OnceCell<Singleton<Arc<SharingAccessor>>> = OnceCell::new();
-
 #[derive(Clone)]
 pub struct SharingAccessor {
-    op: Arc<Operator>,
+    op: Operator,
     config: Config,
 }
 
@@ -63,25 +58,24 @@ pub fn truncate_root(root: String, loc: String) -> String {
 }
 
 impl SharingAccessor {
-    pub async fn init(cfg: &Config, v: Singleton<Arc<SharingAccessor>>) -> Result<()> {
-        let op = init_operator(&cfg.storage.params)?;
-        v.init(Arc::new(SharingAccessor {
-            op: Arc::new(op),
-            config: cfg.clone(),
-        }))?;
+    pub async fn init(cfg: &Config) -> Result<()> {
+        GlobalInstance::set(Self::try_create(cfg).await?);
 
-        SHARING_ACCESSOR.set(v).ok();
         Ok(())
     }
 
-    // get singleton instance for Sharing Accessor
-    pub fn instance() -> Arc<SharingAccessor> {
-        match SHARING_ACCESSOR.get() {
-            None => panic!("Sharing Accessor is not init"),
-            Some(sharing_accessor) => sharing_accessor.get(),
-        }
+    pub fn instance() -> SharingAccessor {
+        GlobalInstance::get()
     }
 
+    pub async fn try_create(cfg: &Config) -> Result<SharingAccessor> {
+        let operator = init_operator(&cfg.storage.params)?;
+
+        Ok(SharingAccessor {
+            op: operator,
+            config: cfg.clone(),
+        })
+    }
     fn get_root(&self) -> String {
         match self.config.storage.params {
             StorageParams::S3(ref s3) => s3.root.trim_matches('/').to_string(),

src/query/sharing-endpoint/src/services.rs

@@ -12,73 +12,22 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::cell::UnsafeCell;
-use std::sync::Arc;
-
-use common_base::base::GlobalIORuntime;
-use common_base::base::Runtime;
-use common_base::base::SingletonImpl;
+use common_base::base::GlobalInstance;
+use common_base::runtime::GlobalIORuntime;
 use common_exception::Result;
 
 use crate::accessor::SharingAccessor;
 use crate::configs::Config;
 
 // hold singleton services.
-pub struct SharingServices {
-    // by default, operator init needs the global_runtime singleton instance
-    // thus we keep it in the sharing services, alternatively, we may consider expose no layer operator
-    global_runtime: UnsafeCell<Option<Arc<Runtime>>>,
-    // storage_accessor is the accessor for the shared tenant data.
-    storage_accessor: UnsafeCell<Option<Arc<SharingAccessor>>>,
-}
-
-unsafe impl Send for SharingServices {}
-
-unsafe impl Sync for SharingServices {}
+pub struct SharingServices {}
 
 impl SharingServices {
     pub async fn init(config: Config) -> Result<()> {
-        let sharing_services = Arc::new(SharingServices {
-            global_runtime: UnsafeCell::new(None),
-            storage_accessor: UnsafeCell::new(None),
-        });
-        GlobalIORuntime::init(config.storage.num_cpus as usize, sharing_services.clone())?;
-        SharingAccessor::init(&config, sharing_services.clone()).await
-    }
-}
-
-impl SingletonImpl<Arc<SharingAccessor>> for SharingServices {
-    fn get(&self) -> Arc<SharingAccessor> {
-        unsafe {
-            match &*self.storage_accessor.get() {
-                None => panic!("Sharing Accessor is not init"),
-                Some(storage_accessor) => storage_accessor.clone(),
-            }
-        }
-    }
-
-    fn init(&self, value: Arc<SharingAccessor>) -> Result<()> {
-        unsafe {
-            *(self.storage_accessor.get() as *mut Option<Arc<SharingAccessor>>) = Some(value);
-            Ok(())
-        }
-    }
-}
-
-impl SingletonImpl<Arc<Runtime>> for SharingServices {
-    fn get(&self) -> Arc<Runtime> {
-        unsafe {
-            match &*self.global_runtime.get() {
-                None => panic!("Global Runtime is not init"),
-                Some(runtime) => runtime.clone(),
-            }
-        }
-    }
+        // init global instance singleton
+        GlobalInstance::init_production();
 
-    fn init(&self, value: Arc<Runtime>) -> Result<()> {
-        unsafe {
-            *(self.global_runtime.get() as *mut Option<Arc<Runtime>>) = Some(value);
-            Ok(())
-        }
+        GlobalIORuntime::init(config.storage.num_cpus as usize)?;
+        SharingAccessor::init(&config).await
     }
 }