Separate the sync client in a single file

Signed-off-by: xuhui-lu <[email protected]>

Author: xuhui-lu

src/lib.rs

@@ -122,7 +122,7 @@ pub use crate::backoff::Backoff;
 #[doc(inline)]
 pub use crate::kv::{BoundRange, IntoOwnedRange, Key, KvPair, Value};
 #[doc(inline)]
-pub use crate::raw::{lowering as raw_lowering, Client as RawClient, SyncClient, ColumnFamily};
+pub use crate::raw::{lowering as raw_lowering, Client as RawClient, SyncClient as SyncRawClient, ColumnFamily};
 #[doc(inline)]
 pub use crate::request::RetryOptions;
 #[doc(inline)]

src/raw/client.rs

@@ -628,117 +628,3 @@ impl Client {
         self.atomic.then(|| ()).ok_or(Error::UnsupportedMode)
     }
 }
-
-#[derive(Clone)]
-pub struct SyncClient {
-    client: Client,
-}
-
-impl SyncClient {
-    /// The Sync version of Client
-    ///
-    /// # Examples
-    ///
-    /// ```rust,no_run
-    /// # use tikv_client::SyncClient;
-    /// let client = SyncClient::new(vec!["192.168.0.100"]).await.unwrap();
-    /// ```
-    pub async fn new<S: Into<String>>(pd_endpoints: Vec<S>) -> Result<Client> {
-        Self::new_with_config(pd_endpoints, Config::default()).await
-    }
-
-    pub async fn new_with_config<S: Into<String>>(
-        pd_endpoints: Vec<S>,
-        config: Config,
-    ) -> Result<Client> {
-        let client = Client::new_with_config(pd_endpoints, config)
-        Ok(SyncClient {
-            client: client
-        })
-    }
-
-    pub fn with_cf(&self, cf: ColumnFamily) -> SyncClient {
-        SyncClient {
-            client: self.clietn.with_cf(cf),
-        }
-    }
-
-    pub fn with_atomic_for_cas(&self) -> SyncClient {
-        SyncClient {
-            client: self.client.with_atomic_for_cas()
-        }
-    }
-
-    pub fn get(&self, key: impl Into<Key>) -> Result<Option<Value>> {
-        block_on(self.client.get(key))
-    }
-
-    pub fn batch_get(
-        &self,
-        keys: impl IntoIterator<Item = impl Into<Key>>,
-    ) -> Result<Vec<KvPair>> {
-        block_on(self.client.batch_get(keys))
-    }
-
-    pub fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
-        block_on(self.client.put(key, value))
-    }
-
-    pub fn batch_put(&self, pairs: impl IntoIterator<Item = impl Into<KvPair>>) -> Result<()> {
-        block_on(self.client.batch_put(pairs))
-    }
-
-    pub fn delete(&self, key: impl Into<Key>) -> Result<()> {
-        block_on(self.client.delete(key))
-    }
-
-    pub fn batch_delete(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> Result<()> {
-        block_on(self.client.batch_delete(keys))
-    }
-
-    pub fn delete_range(&self, range: impl Into<BoundRange>) -> Result<()> {
-        block_on(self.client.delete_range(range))
-    }
-
-    pub fn scan(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<KvPair>> {
-        block_on(self.client.scan(range, limit))
-    }
-
-    pub fn scan_keys(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<Key>> {
-        block_on(self.client.scan_keys(range, limit))
-    }
-
-    pub fn batch_scan(
-        &self,
-        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
-        each_limit: u32,
-    ) -> Result<Vec<KvPair>> {
-        block_on(self.client.batch_scan(ranges, each_limit))
-    }
-
-    pub fn batch_scan_keys(
-        &self,
-        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
-        each_limit: u32,
-    ) -> Result<Vec<Key>> {
-        block_on(self.client.batch_scan_keys(ranges, each_limit))
-    }
-
-    pub fn compare_and_swap(
-        &self,
-        key: impl Into<Key>,
-        previous_value: impl Into<Option<Value>>,
-        new_value: impl Into<Value>,
-    ) -> Result<(Option<Value>, bool)> {
-        block_on(self.client.compare_and_swap(key, previous_value, new_value))
-    }
-
-
-    fn assert_non_atomic(&self) -> Result<()> {
-        (!self.atomic).then(|| ()).ok_or(Error::UnsupportedMode)
-    }
-
-    fn assert_atomic(&self) -> Result<()> {
-        self.atomic.then(|| ()).ok_or(Error::UnsupportedMode)
-    }
-}

src/raw/mod.rs

@@ -10,10 +10,12 @@
 //! **Warning:** It is not advisable to use both raw and transactional functionality in the same keyspace.
 
 pub use self::client::Client;
+pub use self::sync_client::SyncClient;
 use crate::Error;
 use std::{convert::TryFrom, fmt};
 
 mod client;
+mod sync_client;
 pub mod lowering;
 mod requests;
 

src/raw/sync_client.rs

@@ -0,0 +1,114 @@
+// Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
+
+use crate::{
+    config::Config,
+    raw::client::Client,
+    BoundRange, ColumnFamily, Key, KvPair, Result, Value,
+};
+use futures::executor::block_on;
+use std::{u32};
+
+#[derive(Clone)]
+pub struct SyncClient {
+    client: Client,
+}
+
+impl SyncClient {
+    /// The synchronous version of RawClient
+    ///
+    /// # Examples
+    ///
+    /// ```rust,no_run
+    /// # use tikv_client::SyncRawClient;
+    /// let client = SyncRawClient::new(vec!["192.168.0.100"]).await.unwrap();
+    /// ```
+    pub async fn new<S: Into<String>>(pd_endpoints: Vec<S>) -> Result<SyncClient> {
+        Self::new_with_config(pd_endpoints, Config::default()).await
+    }
+
+    pub async fn new_with_config<S: Into<String>>(
+        pd_endpoints: Vec<S>,
+        config: Config,
+    ) -> Result<SyncClient> {
+        let client = Client::new_with_config(pd_endpoints, config).await.unwrap();
+        Ok(SyncClient {
+            client: client
+        })
+    }
+
+    pub fn with_cf(&self, cf: ColumnFamily) -> SyncClient {
+        SyncClient {
+            client: self.client.with_cf(cf),
+        }
+    }
+
+    pub fn with_atomic_for_cas(&self) -> SyncClient {
+        SyncClient {
+            client: self.client.with_atomic_for_cas()
+        }
+    }
+
+    pub fn get(&self, key: impl Into<Key>) -> Result<Option<Value>> {
+        block_on(self.client.get(key))
+    }
+
+    pub fn batch_get(
+        &self,
+        keys: impl IntoIterator<Item = impl Into<Key>>,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.client.batch_get(keys))
+    }
+
+    pub fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
+        block_on(self.client.put(key, value))
+    }
+
+    pub fn batch_put(&self, pairs: impl IntoIterator<Item = impl Into<KvPair>>) -> Result<()> {
+        block_on(self.client.batch_put(pairs))
+    }
+
+    pub fn delete(&self, key: impl Into<Key>) -> Result<()> {
+        block_on(self.client.delete(key))
+    }
+
+    pub fn batch_delete(&self, keys: impl IntoIterator<Item = impl Into<Key>>) -> Result<()> {
+        block_on(self.client.batch_delete(keys))
+    }
+
+    pub fn delete_range(&self, range: impl Into<BoundRange>) -> Result<()> {
+        block_on(self.client.delete_range(range))
+    }
+
+    pub fn scan(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<KvPair>> {
+        block_on(self.client.scan(range, limit))
+    }
+
+    pub fn scan_keys(&self, range: impl Into<BoundRange>, limit: u32) -> Result<Vec<Key>> {
+        block_on(self.client.scan_keys(range, limit))
+    }
+
+    pub fn batch_scan(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<KvPair>> {
+        block_on(self.client.batch_scan(ranges, each_limit))
+    }
+
+    pub fn batch_scan_keys(
+        &self,
+        ranges: impl IntoIterator<Item = impl Into<BoundRange>>,
+        each_limit: u32,
+    ) -> Result<Vec<Key>> {
+        block_on(self.client.batch_scan_keys(ranges, each_limit))
+    }
+
+    pub fn compare_and_swap(
+        &self,
+        key: impl Into<Key>,
+        previous_value: impl Into<Option<Value>>,
+        new_value: impl Into<Value>,
+    ) -> Result<(Option<Value>, bool)> {
+        block_on(self.client.compare_and_swap(key, previous_value, new_value))
+    }
+}