engine_tirocks: port util (tikv#13462)

close tikv#13058

Some useless methods are not ported.

Signed-off-by: Jay Lee <BusyJayLee@gmail.com>

Co-authored-by: Ti Chi Robot <ti-community-prow-bot@tidb.io>

components/engine_panic/src/cf_options.rs

@@ -18,18 +18,18 @@ impl CfOptionsExt for PanicEngine {
 pub struct PanicCfOptions;
 
 impl CfOptions for PanicCfOptions {
-    type TitanDbOptions = PanicTitanDbOptions;
+    type TitanCfOptions = PanicTitanDbOptions;
 
     fn new() -> Self {
         panic!()
     }
     fn get_max_write_buffer_number(&self) -> u32 {
         panic!()
     }
-    fn get_level_zero_slowdown_writes_trigger(&self) -> u32 {
+    fn get_level_zero_slowdown_writes_trigger(&self) -> i32 {
         panic!()
     }
-    fn get_level_zero_stop_writes_trigger(&self) -> u32 {
+    fn get_level_zero_stop_writes_trigger(&self) -> i32 {
         panic!()
     }
     fn set_level_zero_file_num_compaction_trigger(&mut self, v: i32) {
@@ -47,7 +47,7 @@ impl CfOptions for PanicCfOptions {
     fn set_block_cache_capacity(&self, capacity: u64) -> Result<()> {
         panic!()
     }
-    fn set_titandb_options(&mut self, opts: &Self::TitanDbOptions) {
+    fn set_titan_cf_options(&mut self, opts: &Self::TitanCfOptions) {
         panic!()
     }
     fn get_target_file_size_base(&self) -> u64 {

components/engine_panic/src/db_options.rs

@@ -1,6 +1,6 @@
 // Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0.
 
-use engine_traits::{DbOptions, DbOptionsExt, Result, TitanDbOptions};
+use engine_traits::{DbOptions, DbOptionsExt, Result, TitanCfOptions};
 
 use crate::engine::PanicEngine;
 
@@ -51,7 +51,7 @@ impl DbOptions for PanicDbOptions {
 
 pub struct PanicTitanDbOptions;
 
-impl TitanDbOptions for PanicTitanDbOptions {
+impl TitanCfOptions for PanicTitanDbOptions {
     fn new() -> Self {
         panic!()
     }

components/engine_rocks/src/cf_options.rs

@@ -59,7 +59,7 @@ impl DerefMut for RocksCfOptions {
 }
 
 impl CfOptions for RocksCfOptions {
-    type TitanDbOptions = RocksTitanDbOptions;
+    type TitanCfOptions = RocksTitanDbOptions;
 
     fn new() -> Self {
         RocksCfOptions::from_raw(RawCfOptions::default())
@@ -69,12 +69,12 @@ impl CfOptions for RocksCfOptions {
         self.0.get_max_write_buffer_number()
     }
 
-    fn get_level_zero_slowdown_writes_trigger(&self) -> u32 {
-        self.0.get_level_zero_slowdown_writes_trigger()
+    fn get_level_zero_slowdown_writes_trigger(&self) -> i32 {
+        self.0.get_level_zero_slowdown_writes_trigger() as i32
     }
 
-    fn get_level_zero_stop_writes_trigger(&self) -> u32 {
-        self.0.get_level_zero_stop_writes_trigger()
+    fn get_level_zero_stop_writes_trigger(&self) -> i32 {
+        self.0.get_level_zero_stop_writes_trigger() as i32
     }
 
     fn set_level_zero_file_num_compaction_trigger(&mut self, v: i32) {
@@ -97,7 +97,7 @@ impl CfOptions for RocksCfOptions {
         self.0.set_block_cache_capacity(capacity).map_err(r2e)
     }
 
-    fn set_titandb_options(&mut self, opts: &Self::TitanDbOptions) {
+    fn set_titan_cf_options(&mut self, opts: &Self::TitanCfOptions) {
         self.0.set_titandb_options(opts.as_raw())
     }
 

components/engine_rocks/src/db_options.rs

@@ -2,7 +2,7 @@
 
 use std::ops::{Deref, DerefMut};
 
-use engine_traits::{DbOptions, DbOptionsExt, Result, TitanDbOptions};
+use engine_traits::{DbOptions, DbOptionsExt, Result, TitanCfOptions};
 use rocksdb::{DBOptions as RawDBOptions, TitanDBOptions as RawTitanDBOptions};
 use tikv_util::box_err;
 
@@ -118,7 +118,7 @@ impl DerefMut for RocksTitanDbOptions {
     }
 }
 
-impl TitanDbOptions for RocksTitanDbOptions {
+impl TitanCfOptions for RocksTitanDbOptions {
     fn new() -> Self {
         RocksTitanDbOptions::from_raw(RawTitanDBOptions::new())
     }

components/engine_tirocks/Cargo.toml

@@ -5,5 +5,10 @@ edition = "2021"
 
 [dependencies]
 engine_traits = { path = "../engine_traits" }
+slog = { version = "2.3", features = ["max_level_trace", "release_max_level_debug"] }
+slog-global = { version = "0.1", git = "https://github.com/breeswish/slog-global.git", rev = "d592f88e4dbba5eb439998463054f1a44fbf17b9" }
 tikv_alloc = { path = "../tikv_alloc" }
 tirocks = { git = "https://github.com/busyjay/tirocks.git", branch = "dev" }
+
+[dev-dependencies]
+tempfile = "3.0"

components/engine_tirocks/src/cf_options.rs

@@ -0,0 +1,170 @@
+// Copyright 2022 TiKV Project Authors. Licensed under Apache-2.0.
+
+use std::{
+    mem,
+    ops::{Deref, DerefMut},
+};
+
+use tirocks::{
+    option::{RawCfOptions, TitanCfOptions},
+    CfOptions,
+};
+
+enum Options {
+    Rocks(CfOptions),
+    Titan(TitanCfOptions),
+    // Only used for replace.
+    None,
+}
+
+pub struct RocksCfOptions(Options);
+
+impl RocksCfOptions {
+    #[inline]
+    pub fn is_titan(&self) -> bool {
+        matches!(self.0, Options::Titan(_))
+    }
+
+    #[inline]
+    pub fn default_titan() -> Self {
+        RocksCfOptions(Options::Titan(Default::default()))
+    }
+
+    #[inline]
+    pub(crate) fn into_rocks(self) -> CfOptions {
+        match self.0 {
+            Options::Rocks(opt) => opt,
+            _ => panic!("it's a titan cf option"),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn into_titan(self) -> TitanCfOptions {
+        match self.0 {
+            Options::Titan(opt) => opt,
+            _ => panic!("it's not a titan cf option"),
+        }
+    }
+}
+
+impl Default for RocksCfOptions {
+    #[inline]
+    fn default() -> Self {
+        RocksCfOptions(Options::Rocks(Default::default()))
+    }
+}
+
+impl Deref for RocksCfOptions {
+    type Target = RawCfOptions;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match &self.0 {
+            Options::Rocks(opt) => opt,
+            Options::Titan(opt) => opt,
+            Options::None => unreachable!(),
+        }
+    }
+}
+
+impl DerefMut for RocksCfOptions {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match &mut self.0 {
+            Options::Rocks(opt) => opt,
+            Options::Titan(opt) => opt,
+            Options::None => unreachable!(),
+        }
+    }
+}
+
+impl engine_traits::TitanCfOptions for RocksCfOptions {
+    fn new() -> Self {
+        // TODO: should use accessor of CfOptions instead.
+        panic!()
+    }
+
+    fn set_min_blob_size(&mut self, size: u64) {
+        if let Options::Titan(opt) = &mut self.0 {
+            opt.set_min_blob_size(size);
+            return;
+        }
+        if let Options::Rocks(r) = mem::replace(&mut self.0, Options::None) {
+            let mut opt: TitanCfOptions = r.into();
+            opt.set_min_blob_size(size);
+            self.0 = Options::Titan(opt);
+            return;
+        }
+        unreachable!()
+    }
+}
+
+impl engine_traits::CfOptions for RocksCfOptions {
+    type TitanCfOptions = Self;
+
+    #[inline]
+    fn new() -> Self {
+        Self::default()
+    }
+
+    #[inline]
+    fn get_max_write_buffer_number(&self) -> u32 {
+        self.max_write_buffer_number() as u32
+    }
+
+    fn get_level_zero_slowdown_writes_trigger(&self) -> i32 {
+        self.level0_slowdown_writes_trigger()
+    }
+
+    fn get_level_zero_stop_writes_trigger(&self) -> i32 {
+        self.level0_stop_writes_trigger()
+    }
+
+    fn set_level_zero_file_num_compaction_trigger(&mut self, v: i32) {
+        self.set_level0_file_num_compaction_trigger(v);
+    }
+
+    fn get_soft_pending_compaction_bytes_limit(&self) -> u64 {
+        self.soft_pending_compaction_bytes_limit()
+    }
+
+    fn get_hard_pending_compaction_bytes_limit(&self) -> u64 {
+        self.hard_pending_compaction_bytes_limit()
+    }
+
+    fn get_block_cache_capacity(&self) -> u64 {
+        // TODO: block cache should be managed by global shared resource.
+        panic!()
+    }
+
+    fn set_block_cache_capacity(&self, _: u64) -> engine_traits::Result<()> {
+        // TODO: block cache should be managed by global shared resource.
+        panic!()
+    }
+
+    fn set_titan_cf_options(&mut self, _: &Self::TitanCfOptions) {
+        // TODO: change to use mut accessor instead of setter.
+        panic!()
+    }
+
+    fn get_target_file_size_base(&self) -> u64 {
+        self.target_file_size_base()
+    }
+
+    fn set_disable_auto_compactions(&mut self, v: bool) {
+        (**self).set_disable_auto_compactions(v);
+    }
+
+    fn get_disable_auto_compactions(&self) -> bool {
+        self.disable_auto_compactions()
+    }
+
+    fn get_disable_write_stall(&self) -> bool {
+        self.disable_write_stall()
+    }
+
+    fn set_sst_partitioner_factory<F: engine_traits::SstPartitionerFactory>(&mut self, _: F) {
+        // TODO: It should be shared.
+        panic!()
+    }
+}

components/engine_tirocks/src/db_options.rs

@@ -0,0 +1,79 @@
+// Copyright 2022 TiKV Project Authors. Licensed under Apache-2.0.
+
+use std::{
+    ops::{Deref, DerefMut},
+    sync::Arc,
+};
+
+use tirocks::{
+    env::Env,
+    option::{RawDbOptions, TitanDbOptions},
+    DbOptions,
+};
+
+enum Options {
+    Rocks(DbOptions),
+    Titan(TitanDbOptions),
+}
+
+pub struct RocksDbOptions(Options);
+
+impl RocksDbOptions {
+    #[inline]
+    pub fn env(&self) -> Option<&Arc<Env>> {
+        match &self.0 {
+            Options::Rocks(opt) => opt.env(),
+            Options::Titan(opt) => opt.env(),
+        }
+    }
+
+    #[inline]
+    pub fn is_titan(&self) -> bool {
+        matches!(self.0, Options::Titan(_))
+    }
+
+    #[inline]
+    pub(crate) fn into_rocks(self) -> DbOptions {
+        match self.0 {
+            Options::Rocks(opt) => opt,
+            _ => panic!("it's a titan option"),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn into_titan(self) -> TitanDbOptions {
+        match self.0 {
+            Options::Titan(opt) => opt,
+            _ => panic!("it's not a titan option"),
+        }
+    }
+}
+
+impl Default for RocksDbOptions {
+    #[inline]
+    fn default() -> Self {
+        RocksDbOptions(Options::Rocks(Default::default()))
+    }
+}
+
+impl Deref for RocksDbOptions {
+    type Target = RawDbOptions;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        match &self.0 {
+            Options::Rocks(opt) => opt,
+            Options::Titan(opt) => opt,
+        }
+    }
+}
+
+impl DerefMut for RocksDbOptions {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        match &mut self.0 {
+            Options::Rocks(opt) => opt,
+            Options::Titan(opt) => opt,
+        }
+    }
+}