git fire!: wip api v2

Signed-off-by: iosmanthus <[email protected]>

Author: iosmanthus

src/kv/key.rs

@@ -8,6 +8,7 @@ use proptest::{arbitrary::any_with, collection::size_range};
 #[cfg(test)]
 use proptest_derive::Arbitrary;
 use std::{fmt, ops::Bound, u8};
+use std::ops::{Deref, DerefMut};
 use tikv_client_proto::kvrpcpb;
 
 const _PROPTEST_KEY_MAX: usize = 1024 * 2; // 2 KB
@@ -179,3 +180,17 @@ impl fmt::Debug for Key {
         write!(f, "Key({})", HexRepr(&self.0))
     }
 }
+
+impl Deref for Key {
+    type Target = Vec<u8>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Key {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}

src/raw/client.rs

@@ -19,6 +19,7 @@ use crate::{
     },
     Backoff, BoundRange, ColumnFamily, Key, KvPair, Result, Value,
 };
+use crate::request::request_codec::RawApiV1;
 
 const MAX_RAW_KV_SCAN_LIMIT: u32 = 10240;
 
@@ -50,6 +51,16 @@ impl<C: RequestCodec> Clone for Client<C> {
     }
 }
 
+impl Client<RawApiV1> {
+    pub async fn new<S: Into<String>>(
+        pd_endpoints: Vec<S>,
+        logger: Option<Logger>,
+    ) -> Result<Self> {
+        Self::new_with_config(pd_endpoints, Config::default(), RawApiV1, logger).await
+    }
+}
+
+
 impl<C: RawCodec> Client<C> {
     /// Create a raw [`Client`] and connect to the TiKV cluster.
     ///
@@ -69,7 +80,7 @@ impl<C: RawCodec> Client<C> {
     ///     .unwrap();
     /// # });
     /// ```
-    pub async fn new<S: Into<String>>(
+    pub async fn new_with_codec<S: Into<String>>(
         pd_endpoints: Vec<S>,
         codec: C,
         logger: Option<Logger>,

src/request/request_codec.rs

@@ -1,6 +1,15 @@
+use tikv_client_common::Error;
 use tikv_client_proto::metapb::Region;
+use tikv_client_store::Request;
 
-use crate::{kv::codec::decode_bytes_in_place, Key, Result};
+use crate::{Key, kv::codec::decode_bytes_in_place, Result};
+
+const KEYSPACE_PREFIX_LEN: usize = 4;
+const RAW_MODE_PREFIX: u8 = b'r';
+const TXN_MODE_PREFIX: u8 = b'x';
+const RAW_MODE_MAX_KEY: Prefix = [RAW_MODE_PREFIX + 1, 0, 0, 0];
+const TXN_MODE_MAX_KEY: Prefix = [TXN_MODE_PREFIX + 1, 0, 0, 0];
+const MAX_KEYSPACE_ID: KeySpaceId = [0xff, 0xff, 0xff];
 
 #[macro_export]
 macro_rules! plain_request {
@@ -41,14 +50,90 @@ pub trait RequestCodec: Sized + Clone + Sync + Send + 'static {
     }
 }
 
-#[derive(Clone)]
-pub struct RawApiV1;
+#[derive(Copy, Clone)]
+enum KeyMode {
+    Raw,
+    Txn,
+}
 
-impl RequestCodec for RawApiV1 {}
+impl From<KeyMode> for u8 {
+    fn from(mode: KeyMode) -> u8 {
+        match mode {
+            KeyMode::Raw => b'r',
+            KeyMode::Txn => b'x',
+        }
+    }
+}
+
+type Prefix = [u8; KEYSPACE_PREFIX_LEN];
+
+type KeySpaceId = [u8; 3];
+
+#[derive(Copy, Clone)]
+struct KeySpaceCodec {
+    mode: KeyMode,
+    id: KeySpaceId,
+}
+
+impl From<KeySpaceCodec> for Prefix {
+    fn from(codec: KeySpaceCodec) -> Self {
+        [codec.mode.into(), codec.id[0], codec.id[1], codec.id[2]]
+    }
+}
+
+impl RequestCodec for KeySpaceCodec {
+    fn encode_key(&self, mut key: Key) -> Key {
+        let this = self.clone();
+        let mut encoded = Vec::with_capacity(key.len() + KEYSPACE_PREFIX_LEN);
+        let prefix: Prefix = this.into();
+        encoded.extend_from_slice(&prefix);
+        encoded.append(&mut key);
+        encoded.into()
+    }
+
+    fn decode_key(&self, mut key: Key) -> Result<Key> {
+        let prefix: Prefix = self.clone().into();
+
+        if !key.starts_with(&prefix) {
+            return Err(Error::CorruptedKeyspace {
+                expected: prefix.to_vec(),
+                actual: key[..KEYSPACE_PREFIX_LEN].to_vec(),
+                key: key.into(),
+            });
+        }
+
+        Ok(key.split_off(KEYSPACE_PREFIX_LEN).into())
+    }
+
+    fn encode_range(&self, start: Key, end: Key) -> (Key, Key) {
+        (self.encode_key(start), self.encode_key(end))
+    }
+
+    fn encode_pd_query(&self, key: Key) -> Key {
+        todo!()
+    }
+
+    fn decode_region(&self, region: Region) -> Result<Region> {
+        todo!()
+    }
+
+    fn is_plain(&self) -> bool {
+        todo!()
+    }
+}
 
 #[derive(Clone)]
 pub struct TxnApiV1;
 
+#[derive(Clone)]
+pub struct RawApiV1;
+
+pub trait RawCodec: RequestCodec {}
+
+pub trait TxnCodec: RequestCodec {}
+
+impl RequestCodec for RawApiV1 {}
+
 impl RequestCodec for TxnApiV1 {
     fn encode_pd_query(&self, key: Key) -> Key {
         key.to_encoded()
@@ -62,8 +147,6 @@ impl RequestCodec for TxnApiV1 {
     }
 }
 
-pub trait RawCodec: RequestCodec {}
-pub trait TxnCodec: RequestCodec {}
-
 impl RawCodec for RawApiV1 {}
-impl TxnCodec for TxnApiV1 {}
+
+impl TxnCodec for TxnApiV1 {}

tikv-client-common/src/errors.rs

@@ -93,6 +93,12 @@ pub enum Error {
         inner: Box<Error>,
         success_keys: Vec<Vec<u8>>,
     },
+    #[error("Corrupted keyspace: expected: {:?}, actual: {:?}, key: {:?}" , expected, actual, key)]
+    CorruptedKeyspace {
+        expected: Vec<u8>,
+        actual: Vec<u8>,
+        key: Vec<u8>
+    },
 }
 
 impl From<tikv_client_proto::errorpb::Error> for Error {