cargo fmt

Signed-off-by: iosmanthus <myosmanthustree@gmail.com>

Author: iosmanthus

src/pd/client.rs

@@ -1,7 +1,6 @@
 // Copyright 2018 TiKV Project Authors. Licensed under Apache-2.0.
 
-use std::{collections::HashMap, sync::Arc, thread};
-use std::marker::PhantomData;
+use std::{collections::HashMap, marker::PhantomData, sync::Arc, thread};
 
 use async_trait::async_trait;
 use futures::{prelude::*, stream::BoxStream};
@@ -14,15 +13,15 @@ use tikv_client_proto::{kvrpcpb, metapb};
 use tikv_client_store::{KvClient, KvConnect, TikvConnect};
 
 use crate::{
-    BoundRange,
     compat::stream_fn,
-    Config,
-    Key,
     kv::codec,
     pd::{retry::RetryClientTrait, RetryClient},
-    region::{RegionId, RegionVerId, RegionWithLeader}, region_cache::RegionCache, Result, SecurityManager, store::RegionStore, Timestamp,
+    region::{RegionId, RegionVerId, RegionWithLeader},
+    region_cache::RegionCache,
+    request::request_codec::RequestCodec,
+    store::RegionStore,
+    BoundRange, Config, Key, Result, SecurityManager, Timestamp,
 };
-use crate::request::request_codec::RequestCodec;
 
 const CQ_COUNT: usize = 1;
 const CLIENT_PREFIX: &str = "tikv-client";
@@ -75,11 +74,11 @@ pub trait PdClient: Send + Sync + 'static {
 
     fn group_keys_by_region<K, K2>(
         self: Arc<Self>,
-        keys: impl Iterator<Item=K> + Send + Sync + 'static,
+        keys: impl Iterator<Item = K> + Send + Sync + 'static,
     ) -> BoxStream<'static, Result<(RegionId, Vec<K2>)>>
-        where
-            K: AsRef<Key> + Into<K2> + Send + Sync + 'static,
-            K2: Send + Sync + 'static,
+    where
+        K: AsRef<Key> + Into<K2> + Send + Sync + 'static,
+        K2: Send + Sync + 'static,
     {
         let keys = keys.peekable();
         stream_fn(keys, move |mut keys| {
@@ -101,7 +100,7 @@ pub trait PdClient: Send + Sync + 'static {
                 }
             }
         })
-            .boxed()
+        .boxed()
     }
 
     /// Returns a Stream which iterates over the contexts for each region covered by range.
@@ -132,7 +131,7 @@ pub trait PdClient: Send + Sync + 'static {
                 Ok(Some((Some(region_end), store)))
             }
         })
-            .boxed()
+        .boxed()
     }
 
     /// Returns a Stream which iterates over the contexts for ranges in the same region.
@@ -196,7 +195,7 @@ pub trait PdClient: Send + Sync + 'static {
                 }
             }
         })
-            .boxed()
+        .boxed()
     }
 
     fn decode_region(mut region: RegionWithLeader, enable_codec: bool) -> Result<RegionWithLeader> {
@@ -293,7 +292,7 @@ impl<C> PdRpcClient<C, TikvConnect, Cluster> {
             enable_codec,
             logger,
         )
-            .await
+        .await
     }
 }
 
@@ -314,10 +313,10 @@ impl<C, KvC: KvConnect + Send + Sync + 'static, Cl> PdRpcClient<C, KvC, Cl> {
         enable_codec: bool,
         logger: Logger,
     ) -> Result<PdRpcClient<C, KvC, Cl>>
-        where
-            PdFut: Future<Output=Result<RetryClient<Cl>>>,
-            MakeKvC: FnOnce(Arc<Environment>, Arc<SecurityManager>) -> KvC,
-            MakePd: FnOnce(Arc<Environment>, Arc<SecurityManager>) -> PdFut,
+    where
+        PdFut: Future<Output = Result<RetryClient<Cl>>>,
+        MakeKvC: FnOnce(Arc<Environment>, Arc<SecurityManager>) -> KvC,
+        MakePd: FnOnce(Arc<Environment>, Arc<SecurityManager>) -> PdFut,
     {
         let env = Arc::new(
             EnvBuilder::new()
@@ -327,7 +326,7 @@ impl<C, KvC: KvConnect + Send + Sync + 'static, Cl> PdRpcClient<C, KvC, Cl> {
         );
         let security_mgr = Arc::new(
             if let (Some(ca_path), Some(cert_path), Some(key_path)) =
-            (&config.ca_path, &config.cert_path, &config.key_path)
+                (&config.ca_path, &config.cert_path, &config.key_path)
             {
                 SecurityManager::load(ca_path, cert_path, key_path)?
             } else {

src/raw/client.rs

@@ -1,8 +1,7 @@
 // Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
 
 use core::ops::Range;
-use std::{str::FromStr, sync::Arc, u32};
-use std::marker::PhantomData;
+use std::{marker::PhantomData, str::FromStr, sync::Arc, u32};
 
 use slog::{Drain, Logger};
 use tikv_client_common::Error;
@@ -13,10 +12,9 @@ use crate::{
     config::Config,
     pd::{PdClient, PdRpcClient},
     raw::lowering::*,
-    request::{Collect, CollectSingle, Plan},
+    request::{request_codec::RequestCodec, Collect, CollectSingle, Plan},
     Backoff, BoundRange, ColumnFamily, Key, KvPair, Result, Value,
 };
-use crate::request::request_codec::RequestCodec;
 
 const MAX_RAW_KV_SCAN_LIMIT: u32 = 10240;
 
@@ -106,7 +104,7 @@ impl<C: RequestCodec> Client<C, PdRpcClient<C>> {
             cf: None,
             atomic: false,
             logger,
-            _phantom: PhantomData
+            _phantom: PhantomData,
         })
     }
 
@@ -141,7 +139,7 @@ impl<C: RequestCodec> Client<C, PdRpcClient<C>> {
             cf: Some(cf),
             atomic: self.atomic,
             logger: self.logger.clone(),
-            _phantom: PhantomData
+            _phantom: PhantomData,
         }
     }
 
@@ -159,12 +157,12 @@ impl<C: RequestCodec> Client<C, PdRpcClient<C>> {
             cf: self.cf.clone(),
             atomic: true,
             logger: self.logger.clone(),
-            _phantom: PhantomData
+            _phantom: PhantomData,
         }
     }
 }
 
-impl<C:RequestCodec, PdC: PdClient> Client<C, PdC> {
+impl<C: RequestCodec, PdC: PdClient> Client<C, PdC> {
     /// Create a new 'get' request.
     ///
     /// Once resolved this request will result in the fetching of the value associated with the
@@ -217,7 +215,8 @@ impl<C:RequestCodec, PdC: PdClient> Client<C, PdC> {
         keys: impl IntoIterator<Item = impl Into<Key>>,
     ) -> Result<Vec<KvPair>> {
         debug!(self.logger, "invoking raw batch_get request");
-        let request = new_raw_batch_get_request::<C>(keys.into_iter().map(Into::into), self.cf.clone());
+        let request =
+            new_raw_batch_get_request::<C>(keys.into_iter().map(Into::into), self.cf.clone());
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(DEFAULT_REGION_BACKOFF)
             .merge(Collect)
@@ -245,7 +244,8 @@ impl<C:RequestCodec, PdC: PdClient> Client<C, PdC> {
     /// ```
     pub async fn put(&self, key: impl Into<Key>, value: impl Into<Value>) -> Result<()> {
         debug!(self.logger, "invoking raw put request");
-        let request = new_raw_put_request::<C>(key.into(), value.into(), self.cf.clone(), self.atomic);
+        let request =
+            new_raw_put_request::<C>(key.into(), value.into(), self.cf.clone(), self.atomic);
         let plan = crate::request::PlanBuilder::new(self.rpc.clone(), request)
             .retry_multi_region(DEFAULT_REGION_BACKOFF)
             .merge(CollectSingle)

src/raw/lowering.rs

@@ -4,27 +4,31 @@
 //! types (i.e., the types from the client crate) and converts these to the types used in the
 //! generated protobuf code, then calls the low-level ctor functions in the requests module.
 
-use std::{iter::Iterator, ops::Range, sync::Arc};
-use std::marker::PhantomData;
+use std::{iter::Iterator, marker::PhantomData, ops::Range, sync::Arc};
 
 use tikv_client_proto::{kvrpcpb, metapb};
 
-use crate::{BoundRange, ColumnFamily, Key, KvPair, raw::requests, Value};
-use crate::request::KvRequest;
-use crate::request::request_codec::RequestCodec;
+use crate::{
+    raw::requests,
+    request::{request_codec::RequestCodec, KvRequest},
+    BoundRange, ColumnFamily, Key, KvPair, Value,
+};
 
-pub fn new_raw_get_request<C:RequestCodec>(key: Key, cf: Option<ColumnFamily>) -> kvrpcpb::RawGetRequest {
+pub fn new_raw_get_request<C: RequestCodec>(
+    key: Key,
+    cf: Option<ColumnFamily>,
+) -> kvrpcpb::RawGetRequest {
     requests::new_raw_get_request::<C>(key.into(), cf)
 }
 
-pub fn new_raw_batch_get_request<C:RequestCodec>(
-    keys: impl Iterator<Item=Key>,
+pub fn new_raw_batch_get_request<C: RequestCodec>(
+    keys: impl Iterator<Item = Key>,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchGetRequest {
     requests::new_raw_batch_get_request::<C>(keys.map(Into::into).collect(), cf)
 }
 
-pub fn new_raw_put_request<C:RequestCodec>(
+pub fn new_raw_put_request<C: RequestCodec>(
     key: Key,
     value: Value,
     cf: Option<ColumnFamily>,
@@ -33,43 +37,47 @@ pub fn new_raw_put_request<C:RequestCodec>(
     requests::new_raw_put_request::<C>(key.into(), value, cf, atomic)
 }
 
-pub fn new_raw_batch_put_request<C:RequestCodec>(
-    pairs: impl Iterator<Item=KvPair>,
+pub fn new_raw_batch_put_request<C: RequestCodec>(
+    pairs: impl Iterator<Item = KvPair>,
     cf: Option<ColumnFamily>,
     atomic: bool,
 ) -> kvrpcpb::RawBatchPutRequest {
     requests::new_raw_batch_put_request::<C>(pairs.map(Into::into).collect(), cf, atomic)
 }
 
-pub fn new_raw_delete_request<C:RequestCodec>(
+pub fn new_raw_delete_request<C: RequestCodec>(
     key: Key,
     cf: Option<ColumnFamily>,
     atomic: bool,
 ) -> kvrpcpb::RawDeleteRequest {
     requests::new_raw_delete_request::<C>(key.into(), cf, atomic)
 }
 
-pub fn new_raw_batch_delete_request<C:RequestCodec>(
-    keys: impl Iterator<Item=Key>,
+pub fn new_raw_batch_delete_request<C: RequestCodec>(
+    keys: impl Iterator<Item = Key>,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchDeleteRequest {
     requests::new_raw_batch_delete_request::<C>(keys.map(Into::into).collect(), cf)
 }
 
-pub fn new_raw_delete_range_request<C:RequestCodec>(
+pub fn new_raw_delete_range_request<C: RequestCodec>(
     range: BoundRange,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawDeleteRangeRequest {
     let (start_key, end_key) = range.into_keys();
-    requests::new_raw_delete_range_request::<C>(start_key.into(), end_key.unwrap_or_default().into(), cf)
+    requests::new_raw_delete_range_request::<C>(
+        start_key.into(),
+        end_key.unwrap_or_default().into(),
+        cf,
+    )
 }
 
-pub fn new_raw_scan_request<C:RequestCodec>(
+pub fn new_raw_scan_request<C: RequestCodec>(
     range: BoundRange,
     limit: u32,
     key_only: bool,
     cf: Option<ColumnFamily>,
-) -> kvrpcpb::RawScanRequest  {
+) -> kvrpcpb::RawScanRequest {
     let (start_key, end_key) = range.into_keys();
     requests::new_raw_scan_request::<C>(
         start_key.into(),
@@ -80,16 +88,21 @@ pub fn new_raw_scan_request<C:RequestCodec>(
     )
 }
 
-pub fn new_raw_batch_scan_request<C:RequestCodec>(
-    ranges: impl Iterator<Item=BoundRange>,
+pub fn new_raw_batch_scan_request<C: RequestCodec>(
+    ranges: impl Iterator<Item = BoundRange>,
     each_limit: u32,
     key_only: bool,
     cf: Option<ColumnFamily>,
 ) -> kvrpcpb::RawBatchScanRequest {
-    requests::new_raw_batch_scan_request::<C>(ranges.map(Into::into).collect(), each_limit, key_only, cf)
+    requests::new_raw_batch_scan_request::<C>(
+        ranges.map(Into::into).collect(),
+        each_limit,
+        key_only,
+        cf,
+    )
 }
 
-pub fn new_cas_request<C:RequestCodec>(
+pub fn new_cas_request<C: RequestCodec>(
     key: Key,
     value: Value,
     previous_value: Option<Value>,
@@ -98,10 +111,10 @@ pub fn new_cas_request<C:RequestCodec>(
     requests::new_cas_request::<C>(key.into(), value, previous_value, cf)
 }
 
-pub fn new_raw_coprocessor_request<C:RequestCodec>(
+pub fn new_raw_coprocessor_request<C: RequestCodec>(
     copr_name: String,
     copr_version_req: String,
-    ranges: impl Iterator<Item=BoundRange>,
+    ranges: impl Iterator<Item = BoundRange>,
     request_builder: impl Fn(metapb::Region, Vec<Range<Key>>) -> Vec<u8> + Send + Sync + 'static,
 ) -> requests::RawCoprocessorRequest {
     requests::new_raw_coprocessor_request::<C>(