diff --git a/cmd/src/server.rs b/cmd/src/server.rs
index 012c5a72899..32800d601fb 100644
--- a/cmd/src/server.rs
+++ b/cmd/src/server.rs
@@ -123,7 +123,7 @@ struct TiKVServer {
     engines: Option<Engines>,
     servers: Option<Servers>,
     region_info_accessor: RegionInfoAccessor,
-    coprocessor_host: Option<CoprocessorHost>,
+    coprocessor_host: Option<CoprocessorHost<RocksEngine>>,
     to_stop: Vec<Box<dyn Stop>>,
     lock_files: Vec<File>,
 }
@@ -131,14 +131,14 @@ struct TiKVServer {
 struct Engines {
     engines: engine::Engines,
     store_meta: Arc<Mutex<StoreMeta>>,
-    engine: RaftKv<ServerRaftStoreRouter>,
-    raft_router: ServerRaftStoreRouter,
+    engine: RaftKv<ServerRaftStoreRouter<RocksEngine>>,
+    raft_router: ServerRaftStoreRouter<RocksEngine>,
 }
 
 struct Servers {
-    pd_sender: FutureScheduler<PdTask>,
+    pd_sender: FutureScheduler<PdTask<RocksEngine>>,
     lock_mgr: Option<LockManager>,
-    server: Server<ServerRaftStoreRouter, resolve::PdStoreAddrResolver>,
+    server: Server<ServerRaftStoreRouter<RocksEngine>, resolve::PdStoreAddrResolver>,
     node: Node<RpcClient>,
     importer: Arc<SSTImporter>,
     cdc_scheduler: tikv_util::worker::Scheduler<cdc::Task>,
@@ -436,7 +436,7 @@ impl TiKVServer {
         });
     }
 
-    fn init_gc_worker(&mut self) -> GcWorker<RaftKv<ServerRaftStoreRouter>> {
+    fn init_gc_worker(&mut self) -> GcWorker<RaftKv<ServerRaftStoreRouter<RocksEngine>>> {
         let engines = self.engines.as_ref().unwrap();
         let mut gc_worker = GcWorker::new(
             engines.engine.clone(),
@@ -457,7 +457,7 @@ impl TiKVServer {
 
     fn init_servers(
         &mut self,
-        gc_worker: &GcWorker<RaftKv<ServerRaftStoreRouter>>,
+        gc_worker: &GcWorker<RaftKv<ServerRaftStoreRouter<RocksEngine>>>,
     ) -> Arc<ServerConfig> {
         let mut cfg_controller = self.cfg_controller.take().unwrap();
         cfg_controller.register(
@@ -656,7 +656,10 @@ impl TiKVServer {
         server_config
     }
 
-    fn register_services(&mut self, gc_worker: GcWorker<RaftKv<ServerRaftStoreRouter>>) {
+    fn register_services(
+        &mut self,
+        gc_worker: GcWorker<RaftKv<ServerRaftStoreRouter<RocksEngine>>>,
+    ) {
         let servers = self.servers.as_mut().unwrap();
         let engines = self.engines.as_ref().unwrap();
 
diff --git a/components/cdc/src/endpoint.rs b/components/cdc/src/endpoint.rs
index 8b2118fd980..dc33c9d3acc 100644
--- a/components/cdc/src/endpoint.rs
+++ b/components/cdc/src/endpoint.rs
@@ -205,7 +205,7 @@ pub struct Endpoint<T> {
     min_ts_region_id: u64,
 }
 
-impl<T: 'static + RaftStoreRouter> Endpoint<T> {
+impl<T: 'static + RaftStoreRouter<RocksEngine>> Endpoint<T> {
     pub fn new(
         pd_client: Arc<dyn PdClient>,
         scheduler: Scheduler<Task>,
@@ -774,7 +774,7 @@ impl Initializer {
     }
 }
 
-impl<T: 'static + RaftStoreRouter> Runnable<Task> for Endpoint<T> {
+impl<T: 'static + RaftStoreRouter<RocksEngine>> Runnable<Task> for Endpoint<T> {
     fn run(&mut self, task: Task) {
         debug!("run cdc task"; "task" => %task);
         match task {
@@ -808,7 +808,7 @@ impl<T: 'static + RaftStoreRouter> Runnable<Task> for Endpoint<T> {
     }
 }
 
-impl<T: 'static + RaftStoreRouter> RunnableWithTimer<Task, ()> for Endpoint<T> {
+impl<T: 'static + RaftStoreRouter<RocksEngine>> RunnableWithTimer<Task, ()> for Endpoint<T> {
     fn on_timeout(&mut self, timer: &mut Timer<()>, _: ()) {
         CDC_CAPTURED_REGION_COUNT.set(self.capture_regions.len() as i64);
         if self.min_resolved_ts != TimeStamp::max() {
diff --git a/components/cdc/src/observer.rs b/components/cdc/src/observer.rs
index a0a9597b916..5fb3ff65013 100644
--- a/components/cdc/src/observer.rs
+++ b/components/cdc/src/observer.rs
@@ -3,6 +3,7 @@
 use std::cell::RefCell;
 use std::sync::{Arc, RwLock};
 
+use engine_rocks::RocksEngine;
 use raft::StateRole;
 use raftstore::coprocessor::*;
 use raftstore::store::fsm::ObserveID;
@@ -40,7 +41,7 @@ impl CdcObserver {
         }
     }
 
-    pub fn register_to(&self, coprocessor_host: &mut CoprocessorHost) {
+    pub fn register_to(&self, coprocessor_host: &mut CoprocessorHost<RocksEngine>) {
         // 100 is the priority of the observer. CDC should have a high priority.
         coprocessor_host
             .registry
diff --git a/components/cdc/tests/mod.rs b/components/cdc/tests/mod.rs
index c329d852c5a..c4cd5f37daa 100644
--- a/components/cdc/tests/mod.rs
+++ b/components/cdc/tests/mod.rs
@@ -9,6 +9,7 @@ use std::rc::Rc;
 use std::sync::*;
 use std::time::Duration;
 
+use engine_rocks::RocksEngine;
 use futures::{Future, Stream};
 use grpcio::{ChannelBuilder, Environment};
 use grpcio::{ClientDuplexReceiver, ClientDuplexSender, ClientUnaryReceiver};
@@ -113,7 +114,7 @@ impl TestSuite {
             let cdc_ob = cdc::CdcObserver::new(scheduler.clone());
             obs.insert(id, cdc_ob.clone());
             sim.coprocessor_hooks.entry(id).or_default().push(Box::new(
-                move |host: &mut CoprocessorHost| {
+                move |host: &mut CoprocessorHost<RocksEngine>| {
                     cdc_ob.register_to(host);
                 },
             ));
diff --git a/components/raftstore/src/coprocessor/dispatcher.rs b/components/raftstore/src/coprocessor/dispatcher.rs
index 809d0c604bf..0a6aeae6970 100644
--- a/components/raftstore/src/coprocessor/dispatcher.rs
+++ b/components/raftstore/src/coprocessor/dispatcher.rs
@@ -1,6 +1,5 @@
 // Copyright 2016 TiKV Project Authors. Licensed under Apache-2.0.
 
-use engine_rocks::RocksEngine;
 use engine_traits::{CfName, KvEngine};
 use kvproto::metapb::Region;
 use kvproto::pdpb::CheckPolicy;
@@ -151,7 +150,7 @@ impl_box_observer!(BoxCmdObserver, CmdObserver, WrappedCmdObserver);
 #[derive(Clone)]
 pub struct Registry<E>
 where
-    E: KvEngine,
+    E: 'static,
 {
     admin_observers: Vec<Entry<BoxAdminObserver>>,
     query_observers: Vec<Entry<BoxQueryObserver>>,
@@ -163,10 +162,7 @@ where
     // TODO: add endpoint
 }
 
-impl<E> Default for Registry<E>
-where
-    E: KvEngine,
-{
+impl<E> Default for Registry<E> {
     fn default() -> Registry<E> {
         Registry {
             admin_observers: Default::default(),
@@ -193,10 +189,7 @@ macro_rules! push {
     };
 }
 
-impl<E> Registry<E>
-where
-    E: KvEngine,
-{
+impl<E> Registry<E> {
     pub fn register_admin_observer(&mut self, priority: u32, ao: BoxAdminObserver) {
         push!(priority, ao, self.admin_observers);
     }
@@ -275,13 +268,30 @@ macro_rules! loop_ob {
 }
 
 /// Admin and invoke all coprocessors.
-#[derive(Default, Clone)]
-pub struct CoprocessorHost {
-    pub registry: Registry<RocksEngine>,
+#[derive(Clone)]
+pub struct CoprocessorHost<E>
+where
+    E: 'static,
+{
+    pub registry: Registry<E>,
 }
 
-impl CoprocessorHost {
-    pub fn new<C: CasualRouter<RocksEngine> + Clone + Send + 'static>(ch: C) -> CoprocessorHost {
+impl<E> Default for CoprocessorHost<E>
+where
+    E: 'static,
+{
+    fn default() -> Self {
+        CoprocessorHost {
+            registry: Default::default(),
+        }
+    }
+}
+
+impl<E> CoprocessorHost<E>
+where
+    E: KvEngine,
+{
+    pub fn new<C: CasualRouter<E> + Clone + Send + 'static>(ch: C) -> CoprocessorHost<E> {
         let mut registry = Registry::default();
         registry.register_split_check_observer(
             200,
@@ -396,10 +406,10 @@ impl CoprocessorHost {
         &self,
         cfg: &'a Config,
         region: &Region,
-        engine: &RocksEngine,
+        engine: &E,
         auto_split: bool,
         policy: CheckPolicy,
-    ) -> SplitCheckerHost<'a, RocksEngine> {
+    ) -> SplitCheckerHost<'a, E> {
         let mut host = SplitCheckerHost::new(auto_split, cfg);
         loop_ob!(
             region,
@@ -486,6 +496,7 @@ mod tests {
     use std::sync::atomic::*;
     use std::sync::Arc;
 
+    use engine_rocks::RocksEngine;
     use kvproto::metapb::Region;
     use kvproto::raft_cmdpb::{
         AdminRequest, AdminResponse, RaftCmdRequest, RaftCmdResponse, Request, Response,
@@ -616,7 +627,7 @@ mod tests {
 
     #[test]
     fn test_trigger_right_hook() {
-        let mut host = CoprocessorHost::default();
+        let mut host = CoprocessorHost::<RocksEngine>::default();
         let ob = TestCoprocessor::default();
         host.registry
             .register_admin_observer(1, BoxAdminObserver::new(ob.clone()));
@@ -678,7 +689,7 @@ mod tests {
 
     #[test]
     fn test_order() {
-        let mut host = CoprocessorHost::default();
+        let mut host = CoprocessorHost::<RocksEngine>::default();
 
         let ob1 = TestCoprocessor::default();
         host.registry
diff --git a/components/raftstore/src/coprocessor/region_info_accessor.rs b/components/raftstore/src/coprocessor/region_info_accessor.rs
index f0da0322b63..975141ec6b1 100644
--- a/components/raftstore/src/coprocessor/region_info_accessor.rs
+++ b/components/raftstore/src/coprocessor/region_info_accessor.rs
@@ -11,6 +11,7 @@ use super::{
     BoxRegionChangeObserver, BoxRoleObserver, Coprocessor, CoprocessorHost, ObserverContext,
     RegionChangeEvent, RegionChangeObserver, Result, RoleObserver,
 };
+use engine_rocks::RocksEngine;
 use keys::{data_end_key, data_key};
 use kvproto::metapb::Region;
 use raft::StateRole;
@@ -142,7 +143,7 @@ impl RoleObserver for RegionEventListener {
 
 /// Creates an `RegionEventListener` and register it to given coprocessor host.
 fn register_region_event_listener(
-    host: &mut CoprocessorHost,
+    host: &mut CoprocessorHost<RocksEngine>,
     scheduler: Scheduler<RegionInfoQuery>,
 ) {
     let listener = RegionEventListener { scheduler };
@@ -457,7 +458,7 @@ impl RegionInfoAccessor {
     /// Creates a new `RegionInfoAccessor` and register to `host`.
     /// `RegionInfoAccessor` doesn't need, and should not be created more than once. If it's needed
     /// in different places, just clone it, and their contents are shared.
-    pub fn new(host: &mut CoprocessorHost) -> Self {
+    pub fn new(host: &mut CoprocessorHost<RocksEngine>) -> Self {
         let worker = WorkerBuilder::new("region-collector-worker").create();
         let scheduler = worker.scheduler();
 
diff --git a/components/raftstore/src/router.rs b/components/raftstore/src/router.rs
index 28e0caa6bfa..71488f1ef1b 100644
--- a/components/raftstore/src/router.rs
+++ b/components/raftstore/src/router.rs
@@ -9,16 +9,19 @@ use crate::store::{
     Callback, CasualMessage, LocalReader, PeerMsg, RaftCommand, SignificantMsg, StoreMsg,
 };
 use crate::{DiscardReason, Error as RaftStoreError, Result as RaftStoreResult};
-use engine_rocks::RocksEngine;
+use engine_traits::KvEngine;
 use raft::SnapshotStatus;
 
 /// Routes messages to the raftstore.
-pub trait RaftStoreRouter: Send + Clone {
+pub trait RaftStoreRouter<E>: Send + Clone
+where
+    E: KvEngine,
+{
     /// Sends RaftMessage to local store.
     fn send_raft_msg(&self, msg: RaftMessage) -> RaftStoreResult<()>;
 
     /// Sends RaftCmdRequest to local store.
-    fn send_command(&self, req: RaftCmdRequest, cb: Callback<RocksEngine>) -> RaftStoreResult<()>;
+    fn send_command(&self, req: RaftCmdRequest, cb: Callback<E>) -> RaftStoreResult<()>;
 
     /// Sends a significant message. We should guarantee that the message can't be dropped.
     fn significant_send(&self, region_id: u64, msg: SignificantMsg) -> RaftStoreResult<()>;
@@ -53,20 +56,23 @@ pub trait RaftStoreRouter: Send + Clone {
         )
     }
 
-    fn casual_send(&self, region_id: u64, msg: CasualMessage<RocksEngine>) -> RaftStoreResult<()>;
+    fn casual_send(&self, region_id: u64, msg: CasualMessage<E>) -> RaftStoreResult<()>;
 }
 
 #[derive(Clone)]
 pub struct RaftStoreBlackHole;
 
-impl RaftStoreRouter for RaftStoreBlackHole {
+impl<E> RaftStoreRouter<E> for RaftStoreBlackHole
+where
+    E: KvEngine,
+{
     /// Sends RaftMessage to local store.
     fn send_raft_msg(&self, _: RaftMessage) -> RaftStoreResult<()> {
         Ok(())
     }
 
     /// Sends RaftCmdRequest to local store.
-    fn send_command(&self, _: RaftCmdRequest, _: Callback<RocksEngine>) -> RaftStoreResult<()> {
+    fn send_command(&self, _: RaftCmdRequest, _: Callback<E>) -> RaftStoreResult<()> {
         Ok(())
     }
 
@@ -77,24 +83,30 @@ impl RaftStoreRouter for RaftStoreBlackHole {
 
     fn broadcast_unreachable(&self, _: u64) {}
 
-    fn casual_send(&self, _: u64, _: CasualMessage<RocksEngine>) -> RaftStoreResult<()> {
+    fn casual_send(&self, _: u64, _: CasualMessage<E>) -> RaftStoreResult<()> {
         Ok(())
     }
 }
 
 /// A router that routes messages to the raftstore
 #[derive(Clone)]
-pub struct ServerRaftStoreRouter {
-    router: RaftRouter<RocksEngine>,
-    local_reader: LocalReader<RaftRouter<RocksEngine>, RocksEngine>,
+pub struct ServerRaftStoreRouter<E>
+where
+    E: KvEngine,
+{
+    router: RaftRouter<E>,
+    local_reader: LocalReader<RaftRouter<E>, E>,
 }
 
-impl ServerRaftStoreRouter {
+impl<E> ServerRaftStoreRouter<E>
+where
+    E: KvEngine,
+{
     /// Creates a new router.
     pub fn new(
-        router: RaftRouter<RocksEngine>,
-        local_reader: LocalReader<RaftRouter<RocksEngine>, RocksEngine>,
-    ) -> ServerRaftStoreRouter {
+        router: RaftRouter<E>,
+        local_reader: LocalReader<RaftRouter<E>, E>,
+    ) -> ServerRaftStoreRouter<E> {
         ServerRaftStoreRouter {
             router,
             local_reader,
@@ -119,7 +131,10 @@ pub fn handle_send_error<T>(region_id: u64, e: TrySendError<T>) -> RaftStoreErro
     }
 }
 
-impl RaftStoreRouter for ServerRaftStoreRouter {
+impl<E> RaftStoreRouter<E> for ServerRaftStoreRouter<E>
+where
+    E: KvEngine,
+{
     fn send_raft_msg(&self, msg: RaftMessage) -> RaftStoreResult<()> {
         let region_id = msg.get_region_id();
         self.router
@@ -127,9 +142,9 @@ impl RaftStoreRouter for ServerRaftStoreRouter {
             .map_err(|e| handle_send_error(region_id, e))
     }
 
-    fn send_command(&self, req: RaftCmdRequest, cb: Callback<RocksEngine>) -> RaftStoreResult<()> {
+    fn send_command(&self, req: RaftCmdRequest, cb: Callback<E>) -> RaftStoreResult<()> {
         let cmd = RaftCommand::new(req, cb);
-        if LocalReader::<RaftRouter<RocksEngine>, RocksEngine>::acceptable(&cmd.request) {
+        if LocalReader::<RaftRouter<E>, E>::acceptable(&cmd.request) {
             self.local_reader.execute_raft_command(cmd);
             Ok(())
         } else {
@@ -153,7 +168,7 @@ impl RaftStoreRouter for ServerRaftStoreRouter {
         Ok(())
     }
 
-    fn casual_send(&self, region_id: u64, msg: CasualMessage<RocksEngine>) -> RaftStoreResult<()> {
+    fn casual_send(&self, region_id: u64, msg: CasualMessage<E>) -> RaftStoreResult<()> {
         self.router
             .send(region_id, PeerMsg::CasualMessage(msg))
             .map_err(|e| handle_send_error(region_id, e))
diff --git a/components/raftstore/src/store/fsm/apply.rs b/components/raftstore/src/store/fsm/apply.rs
index b682f988718..e7f00f8dd12 100644
--- a/components/raftstore/src/store/fsm/apply.rs
+++ b/components/raftstore/src/store/fsm/apply.rs
@@ -15,8 +15,8 @@ use std::{cmp, usize};
 
 use batch_system::{BasicMailbox, BatchRouter, BatchSystem, Fsm, HandlerBuilder, PollHandler};
 use crossbeam::channel::{TryRecvError, TrySendError};
-use engine_rocks::{RocksEngine, RocksSnapshot};
-use engine_traits::{KvEngine, MiscExt, Peekable, Snapshot, WriteBatch, WriteBatchVecExt};
+use engine_rocks::RocksEngine;
+use engine_traits::{KvEngine, Snapshot, WriteBatch, WriteBatchVecExt};
 use engine_traits::{ALL_CFS, CF_DEFAULT, CF_LOCK, CF_RAFT, CF_WRITE};
 use kvproto::import_sstpb::SstMeta;
 use kvproto::metapb::{Peer as PeerMeta, Region, RegionEpoch};
@@ -58,14 +58,20 @@ const WRITE_BATCH_LIMIT: usize = 16;
 const APPLY_WB_SHRINK_SIZE: usize = 1024 * 1024;
 const SHRINK_PENDING_CMD_QUEUE_CAP: usize = 64;
 
-pub struct PendingCmd {
+pub struct PendingCmd<E>
+where
+    E: KvEngine,
+{
     pub index: u64,
     pub term: u64,
-    pub cb: Option<Callback<RocksEngine>>,
+    pub cb: Option<Callback<E>>,
 }
 
-impl PendingCmd {
-    fn new(index: u64, term: u64, cb: Callback<RocksEngine>) -> PendingCmd {
+impl<E> PendingCmd<E>
+where
+    E: KvEngine,
+{
+    fn new(index: u64, term: u64, cb: Callback<E>) -> PendingCmd<E> {
         PendingCmd {
             index,
             term,
@@ -74,7 +80,10 @@ impl PendingCmd {
     }
 }
 
-impl Drop for PendingCmd {
+impl<E> Drop for PendingCmd<E>
+where
+    E: KvEngine,
+{
     fn drop(&mut self) {
         if self.cb.is_some() {
             safe_panic!(
@@ -86,7 +95,10 @@ impl Drop for PendingCmd {
     }
 }
 
-impl Debug for PendingCmd {
+impl<E> Debug for PendingCmd<E>
+where
+    E: KvEngine,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
@@ -99,14 +111,27 @@ impl Debug for PendingCmd {
 }
 
 /// Commands waiting to be committed and applied.
-#[derive(Default, Debug)]
-pub struct PendingCmdQueue {
-    normals: VecDeque<PendingCmd>,
-    conf_change: Option<PendingCmd>,
+#[derive(Debug)]
+pub struct PendingCmdQueue<E>
+where
+    E: KvEngine,
+{
+    normals: VecDeque<PendingCmd<E>>,
+    conf_change: Option<PendingCmd<E>>,
 }
 
-impl PendingCmdQueue {
-    fn pop_normal(&mut self, index: u64, term: u64) -> Option<PendingCmd> {
+impl<E> PendingCmdQueue<E>
+where
+    E: KvEngine,
+{
+    fn new() -> PendingCmdQueue<E> {
+        PendingCmdQueue {
+            normals: VecDeque::new(),
+            conf_change: None,
+        }
+    }
+
+    fn pop_normal(&mut self, index: u64, term: u64) -> Option<PendingCmd<E>> {
         self.normals.pop_front().and_then(|cmd| {
             if self.normals.capacity() > SHRINK_PENDING_CMD_QUEUE_CAP
                 && self.normals.len() < SHRINK_PENDING_CMD_QUEUE_CAP
@@ -121,18 +146,18 @@ impl PendingCmdQueue {
         })
     }
 
-    fn append_normal(&mut self, cmd: PendingCmd) {
+    fn append_normal(&mut self, cmd: PendingCmd<E>) {
         self.normals.push_back(cmd);
     }
 
-    fn take_conf_change(&mut self) -> Option<PendingCmd> {
+    fn take_conf_change(&mut self) -> Option<PendingCmd<E>> {
         // conf change will not be affected when changing between follower and leader,
         // so there is no need to check term.
         self.conf_change.take()
     }
 
     // TODO: seems we don't need to separate conf change from normal entries.
-    fn set_conf_change(&mut self, cmd: PendingCmd) {
+    fn set_conf_change(&mut self, cmd: PendingCmd<E>) {
         self.conf_change = Some(cmd);
     }
 }
@@ -163,7 +188,10 @@ impl Range {
 }
 
 #[derive(Debug)]
-pub enum ExecResult {
+pub enum ExecResult<E>
+where
+    E: KvEngine,
+{
     ChangePeer(ChangePeer),
     CompactLog {
         state: RaftTruncatedState,
@@ -188,7 +216,8 @@ pub enum ExecResult {
     ComputeHash {
         region: Region,
         index: u64,
-        snap: RocksSnapshot,
+        snap: E::Snapshot,
+        _phantom: PhantomData<E>,
     },
     VerifyHash {
         index: u64,
@@ -203,11 +232,14 @@ pub enum ExecResult {
 }
 
 /// The possible returned value when applying logs.
-pub enum ApplyResult {
+pub enum ApplyResult<E>
+where
+    E: KvEngine,
+{
     None,
     Yield,
     /// Additional result that needs to be sent back to raftstore.
-    Res(ExecResult),
+    Res(ExecResult<E>),
     /// It is unable to apply the `CommitMerge` until the source peer
     /// has applied to the required position and sets the atomic boolean
     /// to true.
@@ -230,18 +262,24 @@ impl ExecContext {
     }
 }
 
-struct ApplyCallback {
+struct ApplyCallback<E>
+where
+    E: KvEngine,
+{
     region: Region,
-    cbs: Vec<(Option<Callback<RocksEngine>>, RaftCmdResponse)>,
+    cbs: Vec<(Option<Callback<E>>, RaftCmdResponse)>,
 }
 
-impl ApplyCallback {
-    fn new(region: Region) -> ApplyCallback {
+impl<E> ApplyCallback<E>
+where
+    E: KvEngine,
+{
+    fn new(region: Region) -> ApplyCallback<E> {
         let cbs = vec![];
         ApplyCallback { region, cbs }
     }
 
-    fn invoke_all(self, host: &CoprocessorHost) {
+    fn invoke_all(self, host: &CoprocessorHost<RocksEngine>) {
         for (cb, mut resp) in self.cbs {
             host.post_apply(&self.region, &mut resp);
             if let Some(cb) = cb {
@@ -250,20 +288,26 @@ impl ApplyCallback {
         }
     }
 
-    fn push(&mut self, cb: Option<Callback<RocksEngine>>, resp: RaftCmdResponse) {
+    fn push(&mut self, cb: Option<Callback<E>>, resp: RaftCmdResponse) {
         self.cbs.push((cb, resp));
     }
 }
 
 #[derive(Clone)]
-pub enum Notifier {
-    Router(RaftRouter<RocksEngine>),
+pub enum Notifier<E>
+where
+    E: KvEngine,
+{
+    Router(RaftRouter<E>),
     #[cfg(test)]
-    Sender(Sender<PeerMsg<RocksEngine>>),
+    Sender(Sender<PeerMsg<E>>),
 }
 
-impl Notifier {
-    fn notify(&self, region_id: u64, msg: PeerMsg<RocksEngine>) {
+impl<E> Notifier<E>
+where
+    E: KvEngine,
+{
+    fn notify(&self, region_id: u64, msg: PeerMsg<E>) {
         match *self {
             Notifier::Router(ref r) => {
                 r.force_send(region_id, msg).unwrap();
@@ -274,17 +318,21 @@ impl Notifier {
     }
 }
 
-struct ApplyContext<W: WriteBatch + WriteBatchVecExt<RocksEngine>> {
+struct ApplyContext<E, W>
+where
+    E: KvEngine,
+    W: WriteBatch + WriteBatchVecExt<E>,
+{
     tag: String,
     timer: Option<Instant>,
-    host: CoprocessorHost,
+    host: CoprocessorHost<RocksEngine>,
     importer: Arc<SSTImporter>,
-    region_scheduler: Scheduler<RegionTask>,
+    region_scheduler: Scheduler<RegionTask<E>>,
     router: ApplyRouter,
-    notifier: Notifier,
-    engine: RocksEngine,
-    cbs: MustConsumeVec<ApplyCallback>,
-    apply_res: Vec<ApplyRes>,
+    notifier: Notifier<E>,
+    engine: E,
+    cbs: MustConsumeVec<ApplyCallback<E>>,
+    apply_res: Vec<ApplyRes<E>>,
     exec_ctx: Option<ExecContext>,
 
     kv_wb: Option<W>,
@@ -302,18 +350,22 @@ struct ApplyContext<W: WriteBatch + WriteBatchVecExt<RocksEngine>> {
     use_delete_range: bool,
 }
 
-impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
+impl<E, W> ApplyContext<E, W>
+where
+    E: KvEngine,
+    W: WriteBatch + WriteBatchVecExt<E>,
+{
     pub fn new(
         tag: String,
-        host: CoprocessorHost,
+        host: CoprocessorHost<RocksEngine>,
         importer: Arc<SSTImporter>,
-        region_scheduler: Scheduler<RegionTask>,
-        engine: RocksEngine,
+        region_scheduler: Scheduler<RegionTask<E>>,
+        engine: E,
         router: ApplyRouter,
-        notifier: Notifier,
+        notifier: Notifier<E>,
         cfg: &Config,
-    ) -> ApplyContext<W> {
-        ApplyContext::<W> {
+    ) -> ApplyContext<E, W> {
+        ApplyContext::<E, W> {
             tag,
             timer: None,
             host,
@@ -341,7 +393,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
     /// A general apply progress for a delegate is:
     /// `prepare_for` -> `commit` [-> `commit` ...] -> `finish_for`.
     /// After all delegates are handled, `write_to_db` method should be called.
-    pub fn prepare_for(&mut self, delegate: &mut ApplyDelegate) {
+    pub fn prepare_for(&mut self, delegate: &mut ApplyDelegate<E>) {
         self.prepare_write_batch();
         self.cbs.push(ApplyCallback::new(delegate.region.clone()));
         self.last_applied_index = delegate.apply_state.get_applied_index();
@@ -375,7 +427,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
     /// write the changes into rocksdb.
     ///
     /// This call is valid only when it's between a `prepare_for` and `finish_for`.
-    pub fn commit(&mut self, delegate: &mut ApplyDelegate) {
+    pub fn commit(&mut self, delegate: &mut ApplyDelegate<E>) {
         if self.last_applied_index < delegate.apply_state.get_applied_index() {
             delegate.write_apply_state(self.kv_wb.as_mut().unwrap());
         }
@@ -384,7 +436,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
         self.commit_opt(delegate, true);
     }
 
-    fn commit_opt(&mut self, delegate: &mut ApplyDelegate, persistent: bool) {
+    fn commit_opt(&mut self, delegate: &mut ApplyDelegate<E>, persistent: bool) {
         delegate.update_metrics(self);
         if persistent {
             self.write_to_db();
@@ -430,7 +482,11 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
     }
 
     /// Finishes `Apply`s for the delegate.
-    pub fn finish_for(&mut self, delegate: &mut ApplyDelegate, results: VecDeque<ExecResult>) {
+    pub fn finish_for(
+        &mut self,
+        delegate: &mut ApplyDelegate<E>,
+        results: VecDeque<ExecResult<E>>,
+    ) {
         if !delegate.pending_remove {
             delegate.write_apply_state(self.kv_wb.as_mut().unwrap());
         }
@@ -504,7 +560,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> ApplyContext<W> {
 }
 
 /// Calls the callback of `cmd` when the Region is removed.
-fn notify_region_removed(region_id: u64, peer_id: u64, mut cmd: PendingCmd) {
+fn notify_region_removed(region_id: u64, peer_id: u64, mut cmd: PendingCmd<impl KvEngine>) {
     debug!(
         "region is removed, notify commands";
         "region_id" => region_id,
@@ -515,14 +571,19 @@ fn notify_region_removed(region_id: u64, peer_id: u64, mut cmd: PendingCmd) {
     notify_req_region_removed(region_id, cmd.cb.take().unwrap());
 }
 
-pub fn notify_req_region_removed(region_id: u64, cb: Callback<RocksEngine>) {
+pub fn notify_req_region_removed(region_id: u64, cb: Callback<impl KvEngine>) {
     let region_not_found = Error::RegionNotFound(region_id);
     let resp = cmd_resp::new_error(region_not_found);
     cb.invoke_with_response(resp);
 }
 
 /// Calls the callback of `cmd` when it can not be processed further.
-fn notify_stale_command(region_id: u64, peer_id: u64, term: u64, mut cmd: PendingCmd) {
+fn notify_stale_command(
+    region_id: u64,
+    peer_id: u64,
+    term: u64,
+    mut cmd: PendingCmd<impl KvEngine>,
+) {
     info!(
         "command is stale, skip";
         "region_id" => region_id,
@@ -533,7 +594,7 @@ fn notify_stale_command(region_id: u64, peer_id: u64, term: u64, mut cmd: Pendin
     notify_stale_req(term, cmd.cb.take().unwrap());
 }
 
-pub fn notify_stale_req(term: u64, cb: Callback<RocksEngine>) {
+pub fn notify_stale_req(term: u64, cb: Callback<impl KvEngine>) {
     let resp = cmd_resp::err_resp(Error::StaleCommand, term);
     cb.invoke_with_response(resp);
 }
@@ -599,17 +660,23 @@ struct WaitSourceMergeState {
     logs_up_to_date: Arc<AtomicU64>,
 }
 
-struct YieldState {
+struct YieldState<E>
+where
+    E: KvEngine,
+{
     /// All of the entries that need to continue to be applied after
     /// the source peer has applied its logs.
     pending_entries: Vec<Entry>,
     /// All of messages that need to continue to be handled after
     /// the source peer has applied its logs and pending entries
     /// are all handled.
-    pending_msgs: Vec<Msg>,
+    pending_msgs: Vec<Msg<E>>,
 }
 
-impl Debug for YieldState {
+impl<E> Debug for YieldState<E>
+where
+    E: KvEngine,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("YieldState")
             .field("pending_entries", &self.pending_entries.len())
@@ -640,7 +707,10 @@ impl Debug for WaitSourceMergeState {
 /// located at this store, and it will get the corresponding apply delegate to
 /// handle the apply task to make the code logic more clear.
 #[derive(Debug)]
-pub struct ApplyDelegate {
+pub struct ApplyDelegate<E>
+where
+    E: KvEngine,
+{
     /// The ID of the peer.
     id: u64,
     /// The term of the Region.
@@ -659,7 +729,7 @@ pub struct ApplyDelegate {
     pending_remove: bool,
 
     /// The commands waiting to be committed and applied
-    pending_cmds: PendingCmdQueue,
+    pending_cmds: PendingCmdQueue<E>,
     /// The counter of pending request snapshots. See more in `Peer`.
     pending_request_snapshot_count: Arc<AtomicUsize>,
 
@@ -667,7 +737,7 @@ pub struct ApplyDelegate {
     is_merging: bool,
     /// Records the epoch version after the last merge.
     last_merge_version: u64,
-    yield_state: Option<YieldState>,
+    yield_state: Option<YieldState<E>>,
     /// A temporary state that keeps track of the progress of the source peer state when
     /// CommitMerge is unable to be executed.
     wait_merge_state: Option<WaitSourceMergeState>,
@@ -692,8 +762,11 @@ pub struct ApplyDelegate {
     metrics: ApplyMetrics,
 }
 
-impl ApplyDelegate {
-    fn from_registration(reg: Registration) -> ApplyDelegate {
+impl<E> ApplyDelegate<E>
+where
+    E: KvEngine,
+{
+    fn from_registration(reg: Registration) -> ApplyDelegate<E> {
         ApplyDelegate {
             id: reg.id,
             tag: format!("[region {}] {}", reg.region.get_id(), reg.id),
@@ -709,7 +782,7 @@ impl ApplyDelegate {
             yield_state: None,
             wait_merge_state: None,
             is_merging: reg.is_merging,
-            pending_cmds: Default::default(),
+            pending_cmds: PendingCmdQueue::new(),
             metrics: Default::default(),
             last_merge_version: 0,
             pending_request_snapshot_count: reg.pending_request_snapshot_count,
@@ -726,9 +799,9 @@ impl ApplyDelegate {
     }
 
     /// Handles all the committed_entries, namely, applies the committed entries.
-    fn handle_raft_committed_entries<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_raft_committed_entries<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         mut committed_entries: Vec<Entry>,
     ) {
         if committed_entries.is_empty() {
@@ -803,15 +876,15 @@ impl ApplyDelegate {
         }
     }
 
-    fn update_metrics<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn update_metrics<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &ApplyContext<W>,
+        apply_ctx: &ApplyContext<E, W>,
     ) {
         self.metrics.written_bytes += apply_ctx.delta_bytes();
         self.metrics.written_keys += apply_ctx.delta_keys();
     }
 
-    fn write_apply_state<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(&self, wb: &mut W) {
+    fn write_apply_state<W: WriteBatch + WriteBatchVecExt<E>>(&self, wb: &mut W) {
         wb.put_msg_cf(
             CF_RAFT,
             &keys::apply_state_key(self.region.get_id()),
@@ -825,11 +898,11 @@ impl ApplyDelegate {
         });
     }
 
-    fn handle_raft_entry_normal<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_raft_entry_normal<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         entry: &Entry,
-    ) -> ApplyResult {
+    ) -> ApplyResult<E> {
         fail_point!("yield_apply_1000", self.region_id() == 1000, |_| {
             ApplyResult::Yield
         });
@@ -871,11 +944,11 @@ impl ApplyDelegate {
         ApplyResult::None
     }
 
-    fn handle_raft_entry_conf_change<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_raft_entry_conf_change<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         entry: &Entry,
-    ) -> ApplyResult {
+    ) -> ApplyResult<E> {
         // Although conf change can't yield in normal case, it is convenient to
         // simulate yield before applying a conf change log.
         fail_point!("yield_apply_conf_change_3", self.id() == 3, |_| {
@@ -905,12 +978,7 @@ impl ApplyDelegate {
         }
     }
 
-    fn find_cb(
-        &mut self,
-        index: u64,
-        term: u64,
-        is_conf_change: bool,
-    ) -> Option<Callback<RocksEngine>> {
+    fn find_cb(&mut self, index: u64, term: u64, is_conf_change: bool) -> Option<Callback<E>> {
         let (region_id, peer_id) = (self.region_id(), self.id());
         if is_conf_change {
             if let Some(mut cmd) = self.pending_cmds.take_conf_change() {
@@ -941,13 +1009,13 @@ impl ApplyDelegate {
         None
     }
 
-    fn process_raft_cmd<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn process_raft_cmd<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         index: u64,
         term: u64,
         cmd: RaftCmdRequest,
-    ) -> ApplyResult {
+    ) -> ApplyResult<E> {
         if index == 0 {
             panic!(
                 "{} processing raft command needs a none zero index",
@@ -996,13 +1064,13 @@ impl ApplyDelegate {
     ///   2. it encounters an error that may not occur on all stores, in this case
     /// we should try to apply the entry again or panic. Considering that this
     /// usually due to disk operation fail, which is rare, so just panic is ok.
-    fn apply_raft_cmd<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn apply_raft_cmd<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         index: u64,
         term: u64,
         req: &RaftCmdRequest,
-    ) -> (RaftCmdResponse, ApplyResult) {
+    ) -> (RaftCmdResponse, ApplyResult<E>) {
         // if pending remove, apply should be aborted already.
         assert!(!self.pending_remove);
 
@@ -1076,10 +1144,7 @@ impl ApplyDelegate {
         (resp, exec_result)
     }
 
-    fn destroy<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
-        &mut self,
-        apply_ctx: &mut ApplyContext<W>,
-    ) {
+    fn destroy<W: WriteBatch + WriteBatchVecExt<E>>(&mut self, apply_ctx: &mut ApplyContext<E, W>) {
         self.stopped = true;
         apply_ctx.router.close(self.region_id());
         for cmd in self.pending_cmds.normals.drain(..) {
@@ -1105,13 +1170,16 @@ impl ApplyDelegate {
     }
 }
 
-impl ApplyDelegate {
+impl<E> ApplyDelegate<E>
+where
+    E: KvEngine,
+{
     // Only errors that will also occur on all other stores should be returned.
-    fn exec_raft_cmd<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_raft_cmd<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &RaftCmdRequest,
-    ) -> Result<(RaftCmdResponse, ApplyResult)> {
+    ) -> Result<(RaftCmdResponse, ApplyResult<E>)> {
         // Include region for epoch not match after merge may cause key not in range.
         let include_region =
             req.get_header().get_region_epoch().get_version() >= self.last_merge_version;
@@ -1123,11 +1191,11 @@ impl ApplyDelegate {
         }
     }
 
-    fn exec_admin_cmd<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_admin_cmd<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &RaftCmdRequest,
-    ) -> Result<(RaftCmdResponse, ApplyResult)> {
+    ) -> Result<(RaftCmdResponse, ApplyResult<E>)> {
         let request = req.get_admin_request();
         let cmd_type = request.get_cmd_type();
         if cmd_type != AdminCmdType::CompactLog && cmd_type != AdminCmdType::CommitMerge {
@@ -1166,11 +1234,11 @@ impl ApplyDelegate {
         Ok((resp, exec_result))
     }
 
-    fn exec_write_cmd<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_write_cmd<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &RaftCmdRequest,
-    ) -> Result<(RaftCmdResponse, ApplyResult)> {
+    ) -> Result<(RaftCmdResponse, ApplyResult<E>)> {
         fail_point!(
             "on_apply_write_cmd",
             cfg!(release) || self.id() == 3,
@@ -1239,7 +1307,10 @@ impl ApplyDelegate {
 }
 
 // Write commands related.
-impl ApplyDelegate {
+impl<E> ApplyDelegate<E>
+where
+    E: KvEngine,
+{
     fn handle_put<W: WriteBatch>(&mut self, wb: &mut W, req: &Request) -> Result<Response> {
         let (key, value) = (req.get_put().get_key(), req.get_put().get_value());
         // region key range has no data prefix, so we must use origin key to check.
@@ -1325,7 +1396,7 @@ impl ApplyDelegate {
 
     fn handle_delete_range(
         &mut self,
-        engine: &RocksEngine,
+        engine: &E,
         req: &Request,
         ranges: &mut Vec<Range>,
         use_delete_range: bool,
@@ -1397,7 +1468,7 @@ impl ApplyDelegate {
     fn handle_ingest_sst(
         &mut self,
         importer: &Arc<SSTImporter>,
-        engine: &RocksEngine,
+        engine: &E,
         req: &Request,
         ssts: &mut Vec<SstMeta>,
     ) -> Result<Response> {
@@ -1429,12 +1500,15 @@ impl ApplyDelegate {
 }
 
 // Admin commands related.
-impl ApplyDelegate {
-    fn exec_change_peer<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+impl<E> ApplyDelegate<E>
+where
+    E: KvEngine,
+{
+    fn exec_change_peer<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         request: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         let request = request.get_change_peer();
         let peer = request.get_peer();
         let store_id = peer.get_store_id();
@@ -1629,11 +1703,11 @@ impl ApplyDelegate {
         ))
     }
 
-    fn exec_split<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_split<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         info!(
             "split is deprecated, redirect to use batch split";
             "region_id" => self.region_id(),
@@ -1651,11 +1725,11 @@ impl ApplyDelegate {
         self.exec_batch_split(ctx, &admin_req)
     }
 
-    fn exec_batch_split<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_batch_split<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         fail_point!(
             "apply_before_split_1_3",
             { self.id == 3 && self.region_id() == 1 },
@@ -1760,11 +1834,11 @@ impl ApplyDelegate {
         ))
     }
 
-    fn exec_prepare_merge<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_prepare_merge<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         fail_point!("apply_before_prepare_merge");
 
         PEER_ADMIN_CMD_COUNTER.prepare_merge.all.inc();
@@ -1831,11 +1905,11 @@ impl ApplyDelegate {
     // 7.   resume `exec_commit_merge` in target apply fsm
     // 8.   `on_ready_commit_merge` in target peer fsm and send `MergeResult` to source peer fsm
     // 9.   `on_merge_result` in source peer fsm (destroy itself)
-    fn exec_commit_merge<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_commit_merge<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         {
             let apply_before_commit_merge = || {
                 fail_point!(
@@ -1964,11 +2038,11 @@ impl ApplyDelegate {
         ))
     }
 
-    fn exec_rollback_merge<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_rollback_merge<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         PEER_ADMIN_CMD_COUNTER.rollback_merge.all.inc();
         let region_state_key = keys::region_state_key(self.region_id());
         let state: RegionLocalState = match ctx.engine.get_msg_cf(CF_RAFT, &region_state_key) {
@@ -2006,11 +2080,11 @@ impl ApplyDelegate {
         ))
     }
 
-    fn exec_compact_log<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_compact_log<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         PEER_ADMIN_CMD_COUNTER.compact.all.inc();
 
         let compact_index = req.get_compact_log().get_compact_index();
@@ -2066,11 +2140,11 @@ impl ApplyDelegate {
         ))
     }
 
-    fn exec_compute_hash<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_compute_hash<W: WriteBatch + WriteBatchVecExt<E>>(
         &self,
-        ctx: &ApplyContext<W>,
+        ctx: &ApplyContext<E, W>,
         _: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         let resp = AdminResponse::default();
         Ok((
             resp,
@@ -2082,15 +2156,16 @@ impl ApplyDelegate {
                 // TODO: figure out another way to do consistency check without snapshot
                 // or short life snapshot.
                 snap: ctx.engine.snapshot(),
+                _phantom: PhantomData,
             }),
         ))
     }
 
-    fn exec_verify_hash<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn exec_verify_hash<W: WriteBatch + WriteBatchVecExt<E>>(
         &self,
-        _: &ApplyContext<W>,
+        _: &ApplyContext<E, W>,
         req: &AdminRequest,
-    ) -> Result<(AdminResponse, ApplyResult)> {
+    ) -> Result<(AdminResponse, ApplyResult<E>)> {
         let verify_req = req.get_verify_hash();
         let index = verify_req.get_index();
         let hash = verify_req.get_hash().to_vec();
@@ -2229,15 +2304,21 @@ impl Registration {
     }
 }
 
-pub struct Proposal {
+pub struct Proposal<E>
+where
+    E: KvEngine,
+{
     is_conf_change: bool,
     index: u64,
     term: u64,
-    pub cb: Callback<RocksEngine>,
+    pub cb: Callback<E>,
 }
 
-impl Proposal {
-    pub fn new(is_conf_change: bool, index: u64, term: u64, cb: Callback<RocksEngine>) -> Proposal {
+impl<E> Proposal<E>
+where
+    E: KvEngine,
+{
+    pub fn new(is_conf_change: bool, index: u64, term: u64, cb: Callback<E>) -> Proposal<E> {
         Proposal {
             is_conf_change,
             index,
@@ -2247,14 +2328,20 @@ impl Proposal {
     }
 }
 
-pub struct RegionProposal {
+pub struct RegionProposal<E>
+where
+    E: KvEngine,
+{
     pub id: u64,
     pub region_id: u64,
-    pub props: Vec<Proposal>,
+    pub props: Vec<Proposal<E>>,
 }
 
-impl RegionProposal {
-    pub fn new(id: u64, region_id: u64, props: Vec<Proposal>) -> RegionProposal {
+impl<E> RegionProposal<E>
+where
+    E: KvEngine,
+{
+    pub fn new(id: u64, region_id: u64, props: Vec<Proposal<E>>) -> RegionProposal<E> {
         RegionProposal {
             id,
             region_id,
@@ -2308,13 +2395,16 @@ impl GenSnapTask {
         self.commit_index
     }
 
-    pub fn generate_and_schedule_snapshot(
+    pub fn generate_and_schedule_snapshot<E>(
         self,
-        kv_snap: RocksSnapshot,
+        kv_snap: E::Snapshot,
         last_applied_index_term: u64,
         last_applied_state: RaftApplyState,
-        region_sched: &Scheduler<RegionTask>,
-    ) -> Result<()> {
+        region_sched: &Scheduler<RegionTask<E>>,
+    ) -> Result<()>
+    where
+        E: KvEngine,
+    {
         let snapshot = RegionTask::Gen {
             region_id: self.region_id,
             notifier: self.snap_notifier,
@@ -2374,13 +2464,16 @@ pub enum ChangeCmd {
     },
 }
 
-pub enum Msg {
+pub enum Msg<E>
+where
+    E: KvEngine,
+{
     Apply {
         start: Instant,
         apply: Apply,
     },
     Registration(Registration),
-    Proposal(RegionProposal),
+    Proposal(RegionProposal<E>),
     LogsUpToDate(CatchUpLogs),
     Noop,
     Destroy(Destroy),
@@ -2388,25 +2481,29 @@ pub enum Msg {
     Change {
         cmd: ChangeCmd,
         region_epoch: RegionEpoch,
-        cb: Callback<RocksEngine>,
+        cb: Callback<E>,
     },
     #[cfg(any(test, feature = "testexport"))]
-    Validate(u64, Box<dyn FnOnce((&ApplyDelegate, bool)) + Send>),
+    #[allow(clippy::type_complexity)]
+    Validate(u64, Box<dyn FnOnce((&ApplyDelegate<E>, bool)) + Send>),
 }
 
-impl Msg {
-    pub fn apply(apply: Apply) -> Msg {
+impl<E> Msg<E>
+where
+    E: KvEngine,
+{
+    pub fn apply(apply: Apply) -> Msg<E> {
         Msg::Apply {
             start: Instant::now(),
             apply,
         }
     }
 
-    pub fn register(peer: &Peer) -> Msg {
+    pub fn register(peer: &Peer) -> Msg<E> {
         Msg::Registration(Registration::new(peer))
     }
 
-    pub fn destroy(region_id: u64, async_remove: bool) -> Msg {
+    pub fn destroy(region_id: u64, async_remove: bool) -> Msg<E> {
         Msg::Destroy(Destroy {
             region_id,
             async_remove,
@@ -2414,7 +2511,10 @@ impl Msg {
     }
 }
 
-impl Debug for Msg {
+impl<E> Debug for Msg<E>
+where
+    E: KvEngine,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             Msg::Apply { apply, .. } => write!(f, "[region {}] async apply", apply.region_id),
@@ -2455,17 +2555,23 @@ pub struct ApplyMetrics {
 }
 
 #[derive(Debug)]
-pub struct ApplyRes {
+pub struct ApplyRes<E>
+where
+    E: KvEngine,
+{
     pub region_id: u64,
     pub apply_state: RaftApplyState,
     pub applied_index_term: u64,
-    pub exec_res: VecDeque<ExecResult>,
+    pub exec_res: VecDeque<ExecResult<E>>,
     pub metrics: ApplyMetrics,
 }
 
 #[derive(Debug)]
-pub enum TaskRes {
-    Apply(ApplyRes),
+pub enum TaskRes<E>
+where
+    E: KvEngine,
+{
+    Apply(ApplyRes<E>),
     Destroy {
         // ID of region that has been destroyed.
         region_id: u64,
@@ -2474,19 +2580,25 @@ pub enum TaskRes {
     },
 }
 
-pub struct ApplyFsm {
-    delegate: ApplyDelegate,
-    receiver: Receiver<Msg>,
-    mailbox: Option<BasicMailbox<ApplyFsm>>,
+pub struct ApplyFsm<E>
+where
+    E: KvEngine,
+{
+    delegate: ApplyDelegate<E>,
+    receiver: Receiver<Msg<E>>,
+    mailbox: Option<BasicMailbox<ApplyFsm<E>>>,
 }
 
-impl ApplyFsm {
-    fn from_peer(peer: &Peer) -> (LooseBoundedSender<Msg>, Box<ApplyFsm>) {
+impl<E> ApplyFsm<E>
+where
+    E: KvEngine,
+{
+    fn from_peer(peer: &Peer) -> (LooseBoundedSender<Msg<E>>, Box<ApplyFsm<E>>) {
         let reg = Registration::new(peer);
         ApplyFsm::from_registration(reg)
     }
 
-    fn from_registration(reg: Registration) -> (LooseBoundedSender<Msg>, Box<ApplyFsm>) {
+    fn from_registration(reg: Registration) -> (LooseBoundedSender<Msg<E>>, Box<ApplyFsm<E>>) {
         let (tx, rx) = loose_bounded(usize::MAX);
         let delegate = ApplyDelegate::from_registration(reg);
         (
@@ -2514,9 +2626,9 @@ impl ApplyFsm {
     }
 
     /// Handles apply tasks, and uses the apply delegate to handle the committed entries.
-    fn handle_apply<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_apply<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         apply: Apply,
     ) {
         if apply_ctx.timer.is_none() {
@@ -2562,7 +2674,7 @@ impl ApplyFsm {
     }
 
     /// Handles proposals, and appends the commands to the apply delegate.
-    fn handle_proposal(&mut self, region_proposal: RegionProposal) {
+    fn handle_proposal(&mut self, region_proposal: RegionProposal<E>) {
         let (region_id, peer_id) = (self.delegate.region_id(), self.delegate.id());
         let propose_num = region_proposal.props.len();
         assert_eq!(self.delegate.id, region_proposal.id);
@@ -2592,10 +2704,7 @@ impl ApplyFsm {
         APPLY_PROPOSAL.observe(propose_num as f64);
     }
 
-    fn destroy<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
-        &mut self,
-        ctx: &mut ApplyContext<W>,
-    ) {
+    fn destroy<W: WriteBatch + WriteBatchVecExt<E>>(&mut self, ctx: &mut ApplyContext<E, W>) {
         let region_id = self.delegate.region_id();
         if ctx.apply_res.iter().any(|res| res.region_id == region_id) {
             // Flush before destroying to avoid reordering messages.
@@ -2615,9 +2724,9 @@ impl ApplyFsm {
     }
 
     /// Handles peer destroy. When a peer is destroyed, the corresponding apply delegate should be removed too.
-    fn handle_destroy<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_destroy<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         d: Destroy,
     ) {
         assert_eq!(d.region_id, self.delegate.region_id());
@@ -2637,9 +2746,9 @@ impl ApplyFsm {
         }
     }
 
-    fn resume_pending<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn resume_pending<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
     ) {
         if let Some(ref state) = self.delegate.wait_merge_state {
             let source_region_id = state.logs_up_to_date.load(Ordering::SeqCst);
@@ -2672,9 +2781,9 @@ impl ApplyFsm {
         }
     }
 
-    fn logs_up_to_date_for_merge<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn logs_up_to_date_for_merge<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        ctx: &mut ApplyContext<W>,
+        ctx: &mut ApplyContext<E, W>,
         catch_up_logs: CatchUpLogs,
     ) {
         fail_point!("after_handle_catch_up_logs_for_merge");
@@ -2709,9 +2818,9 @@ impl ApplyFsm {
     }
 
     #[allow(unused_mut)]
-    fn handle_snapshot<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_snapshot<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         snap_task: GenSnapTask,
     ) {
         if self.delegate.pending_remove || self.delegate.stopped {
@@ -2766,12 +2875,12 @@ impl ApplyFsm {
         );
     }
 
-    fn handle_change<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_change<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
+        apply_ctx: &mut ApplyContext<E, W>,
         cmd: ChangeCmd,
         region_epoch: RegionEpoch,
-        cb: Callback<RocksEngine>,
+        cb: Callback<E>,
     ) {
         let (observe_id, region_id, enabled) = match cmd {
             ChangeCmd::RegisterObserver {
@@ -2813,7 +2922,7 @@ impl ApplyFsm {
                 }
                 ReadResponse {
                     response: Default::default(),
-                    snapshot: Some(RegionSnapshot::<RocksEngine>::from_snapshot(
+                    snapshot: Some(RegionSnapshot::<E>::from_snapshot(
                         apply_ctx.engine.snapshot().into_sync(),
                         self.delegate.region.clone(),
                     )),
@@ -2837,10 +2946,10 @@ impl ApplyFsm {
         cb.invoke_read(resp);
     }
 
-    fn handle_tasks<W: WriteBatch + WriteBatchVecExt<RocksEngine>>(
+    fn handle_tasks<W: WriteBatch + WriteBatchVecExt<E>>(
         &mut self,
-        apply_ctx: &mut ApplyContext<W>,
-        msgs: &mut Vec<Msg>,
+        apply_ctx: &mut ApplyContext<E, W>,
+        msgs: &mut Vec<Msg<E>>,
     ) {
         let mut channel_timer = None;
         let mut drainer = msgs.drain(..);
@@ -2879,8 +2988,11 @@ impl ApplyFsm {
     }
 }
 
-impl Fsm for ApplyFsm {
-    type Message = Msg;
+impl<E> Fsm for ApplyFsm<E>
+where
+    E: KvEngine,
+{
+    type Message = Msg<E>;
 
     #[inline]
     fn is_stopped(&self) -> bool {
@@ -2904,7 +3016,10 @@ impl Fsm for ApplyFsm {
     }
 }
 
-impl Drop for ApplyFsm {
+impl<E> Drop for ApplyFsm<E>
+where
+    E: KvEngine,
+{
     fn drop(&mut self) {
         self.delegate.clear_all_commands_as_stale();
     }
@@ -2923,15 +3038,21 @@ impl Fsm for ControlFsm {
     }
 }
 
-pub struct ApplyPoller<W: WriteBatch + WriteBatchVecExt<RocksEngine>> {
-    msg_buf: Vec<Msg>,
-    apply_ctx: ApplyContext<W>,
+pub struct ApplyPoller<E, W>
+where
+    E: KvEngine,
+    W: WriteBatch + WriteBatchVecExt<E>,
+{
+    msg_buf: Vec<Msg<E>>,
+    apply_ctx: ApplyContext<E, W>,
     messages_per_tick: usize,
     cfg_tracker: Tracker<Config>,
 }
 
-impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> PollHandler<ApplyFsm, ControlFsm>
-    for ApplyPoller<W>
+impl<E, W> PollHandler<ApplyFsm<E>, ControlFsm> for ApplyPoller<E, W>
+where
+    E: KvEngine,
+    W: WriteBatch + WriteBatchVecExt<E>,
 {
     fn begin(&mut self, _batch_size: usize) {
         if let Some(incoming) = self.cfg_tracker.any_new() {
@@ -2955,7 +3076,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> PollHandler<ApplyFsm, Contro
         unimplemented!()
     }
 
-    fn handle_normal(&mut self, normal: &mut ApplyFsm) -> Option<usize> {
+    fn handle_normal(&mut self, normal: &mut ApplyFsm<E>) -> Option<usize> {
         let mut expected_msg_count = None;
         normal.delegate.written = false;
         if normal.delegate.yield_state.is_some() {
@@ -3004,7 +3125,7 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> PollHandler<ApplyFsm, Contro
         expected_msg_count
     }
 
-    fn end(&mut self, fsms: &mut [Box<ApplyFsm>]) {
+    fn end(&mut self, fsms: &mut [Box<ApplyFsm<E>>]) {
         let is_synced = self.apply_ctx.flush();
         if is_synced {
             for fsm in fsms {
@@ -3017,11 +3138,11 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> PollHandler<ApplyFsm, Contro
 pub struct Builder<W: WriteBatch + WriteBatchVecExt<RocksEngine>> {
     tag: String,
     cfg: Arc<VersionTrack<Config>>,
-    coprocessor_host: CoprocessorHost,
+    coprocessor_host: CoprocessorHost<RocksEngine>,
     importer: Arc<SSTImporter>,
-    region_scheduler: Scheduler<RegionTask>,
+    region_scheduler: Scheduler<RegionTask<RocksEngine>>,
     engine: RocksEngine,
-    sender: Notifier,
+    sender: Notifier<RocksEngine>,
     router: ApplyRouter,
     _phantom: PhantomData<W>,
 }
@@ -3029,7 +3150,7 @@ pub struct Builder<W: WriteBatch + WriteBatchVecExt<RocksEngine>> {
 impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> Builder<W> {
     pub fn new<T, C>(
         builder: &RaftPollerBuilder<T, C>,
-        sender: Notifier,
+        sender: Notifier<RocksEngine>,
         router: ApplyRouter,
     ) -> Builder<W> {
         Builder::<W> {
@@ -3046,14 +3167,14 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> Builder<W> {
     }
 }
 
-impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> HandlerBuilder<ApplyFsm, ControlFsm>
-    for Builder<W>
+impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>>
+    HandlerBuilder<ApplyFsm<RocksEngine>, ControlFsm> for Builder<W>
 {
-    type Handler = ApplyPoller<W>;
+    type Handler = ApplyPoller<RocksEngine, W>;
 
-    fn build(&mut self) -> ApplyPoller<W> {
+    fn build(&mut self) -> ApplyPoller<RocksEngine, W> {
         let cfg = self.cfg.value();
-        ApplyPoller::<W> {
+        ApplyPoller::<RocksEngine, W> {
             msg_buf: Vec::with_capacity(cfg.messages_per_tick),
             apply_ctx: ApplyContext::new(
                 self.tag.clone(),
@@ -3073,25 +3194,25 @@ impl<W: WriteBatch + WriteBatchVecExt<RocksEngine>> HandlerBuilder<ApplyFsm, Con
 
 #[derive(Clone)]
 pub struct ApplyRouter {
-    pub router: BatchRouter<ApplyFsm, ControlFsm>,
+    pub router: BatchRouter<ApplyFsm<RocksEngine>, ControlFsm>,
 }
 
 impl Deref for ApplyRouter {
-    type Target = BatchRouter<ApplyFsm, ControlFsm>;
+    type Target = BatchRouter<ApplyFsm<RocksEngine>, ControlFsm>;
 
-    fn deref(&self) -> &BatchRouter<ApplyFsm, ControlFsm> {
+    fn deref(&self) -> &BatchRouter<ApplyFsm<RocksEngine>, ControlFsm> {
         &self.router
     }
 }
 
 impl DerefMut for ApplyRouter {
-    fn deref_mut(&mut self) -> &mut BatchRouter<ApplyFsm, ControlFsm> {
+    fn deref_mut(&mut self) -> &mut BatchRouter<ApplyFsm<RocksEngine>, ControlFsm> {
         &mut self.router
     }
 }
 
 impl ApplyRouter {
-    pub fn schedule_task(&self, region_id: u64, msg: Msg) {
+    pub fn schedule_task(&self, region_id: u64, msg: Msg<RocksEngine>) {
         let reg = match self.try_send(region_id, msg) {
             Either::Left(Ok(())) => return,
             Either::Left(Err(TrySendError::Disconnected(msg))) | Either::Right(msg) => match msg {
@@ -3165,19 +3286,19 @@ impl ApplyRouter {
 }
 
 pub struct ApplyBatchSystem {
-    system: BatchSystem<ApplyFsm, ControlFsm>,
+    system: BatchSystem<ApplyFsm<RocksEngine>, ControlFsm>,
 }
 
 impl Deref for ApplyBatchSystem {
-    type Target = BatchSystem<ApplyFsm, ControlFsm>;
+    type Target = BatchSystem<ApplyFsm<RocksEngine>, ControlFsm>;
 
-    fn deref(&self) -> &BatchSystem<ApplyFsm, ControlFsm> {
+    fn deref(&self) -> &BatchSystem<ApplyFsm<RocksEngine>, ControlFsm> {
         &self.system
     }
 }
 
 impl DerefMut for ApplyBatchSystem {
-    fn deref_mut(&mut self) -> &mut BatchSystem<ApplyFsm, ControlFsm> {
+    fn deref_mut(&mut self) -> &mut BatchSystem<ApplyFsm<RocksEngine>, ControlFsm> {
         &mut self.system
     }
 }
@@ -3300,14 +3421,14 @@ mod tests {
 
     fn validate<F>(router: &ApplyRouter, region_id: u64, validate: F)
     where
-        F: FnOnce(&ApplyDelegate) + Send + 'static,
+        F: FnOnce(&ApplyDelegate<RocksEngine>) + Send + 'static,
     {
         let (validate_tx, validate_rx) = mpsc::channel();
         router.schedule_task(
             region_id,
             Msg::Validate(
                 region_id,
-                Box::new(move |(delegate, _): (&ApplyDelegate, _)| {
+                Box::new(move |(delegate, _): (&ApplyDelegate<RocksEngine>, _)| {
                     validate(delegate);
                     validate_tx.send(()).unwrap();
                 }),
@@ -3317,7 +3438,7 @@ mod tests {
     }
 
     // Make sure msgs are handled in the same batch.
-    fn batch_messages(router: &ApplyRouter, region_id: u64, msgs: Vec<Msg>) {
+    fn batch_messages(router: &ApplyRouter, region_id: u64, msgs: Vec<Msg<RocksEngine>>) {
         let (notify1, wait1) = mpsc::channel();
         let (notify2, wait2) = mpsc::channel();
         router.schedule_task(
@@ -3339,7 +3460,9 @@ mod tests {
         notify2.send(()).unwrap();
     }
 
-    fn fetch_apply_res(receiver: &::std::sync::mpsc::Receiver<PeerMsg<RocksEngine>>) -> ApplyRes {
+    fn fetch_apply_res(
+        receiver: &::std::sync::mpsc::Receiver<PeerMsg<RocksEngine>>,
+    ) -> ApplyRes<RocksEngine> {
         match receiver.recv_timeout(Duration::from_secs(3)) {
             Ok(PeerMsg::ApplyRes { res, .. }) => match res {
                 TaskRes::Apply(res) => res,
@@ -3361,7 +3484,7 @@ mod tests {
         let builder = super::Builder::<RocksWriteBatch> {
             tag: "test-store".to_owned(),
             cfg,
-            coprocessor_host: CoprocessorHost::default(),
+            coprocessor_host: CoprocessorHost::<RocksEngine>::default(),
             importer,
             region_scheduler,
             sender,
@@ -3726,7 +3849,7 @@ mod tests {
         let (_path, engine) = create_tmp_engine("test-delegate");
         let (import_dir, importer) = create_tmp_importer("test-delegate");
         let obs = ApplyObserver::default();
-        let mut host = CoprocessorHost::default();
+        let mut host = CoprocessorHost::<RocksEngine>::default();
         host.registry
             .register_query_observer(1, BoxQueryObserver::new(obs.clone()));
 
@@ -3981,7 +4104,7 @@ mod tests {
     fn test_cmd_observer() {
         let (_path, engine) = create_tmp_engine("test-delegate");
         let (_import_dir, importer) = create_tmp_importer("test-delegate");
-        let mut host = CoprocessorHost::default();
+        let mut host = CoprocessorHost::<RocksEngine>::default();
         let mut obs = ApplyObserver::default();
         let (sink, cmdbatch_rx) = mpsc::channel();
         obs.cmd_sink = Some(Arc::new(Mutex::new(sink)));
@@ -4250,7 +4373,7 @@ mod tests {
         reg.region.set_peers(peers.clone().into());
         let (tx, _rx) = mpsc::channel();
         let sender = Notifier::Sender(tx);
-        let mut host = CoprocessorHost::default();
+        let mut host = CoprocessorHost::<RocksEngine>::default();
         let mut obs = ApplyObserver::default();
         let (sink, cmdbatch_rx) = mpsc::channel();
         obs.cmd_sink = Some(Arc::new(Mutex::new(sink)));
@@ -4457,7 +4580,7 @@ mod tests {
     #[test]
     fn pending_cmd_leak() {
         let res = panic_hook::recover_safe(|| {
-            let _cmd = PendingCmd::new(1, 1, Callback::None);
+            let _cmd = PendingCmd::<RocksEngine>::new(1, 1, Callback::None);
         });
         res.unwrap_err();
     }
@@ -4465,7 +4588,7 @@ mod tests {
     #[test]
     fn pending_cmd_leak_dtor_not_abort() {
         let res = panic_hook::recover_safe(|| {
-            let _cmd = PendingCmd::new(1, 1, Callback::None);
+            let _cmd = PendingCmd::<RocksEngine>::new(1, 1, Callback::None);
             panic!("Don't abort");
             // It would abort and fail if there was a double-panic in PendingCmd dtor.
         });
diff --git a/components/raftstore/src/store/fsm/peer.rs b/components/raftstore/src/store/fsm/peer.rs
index 73da6daa404..0068e54bdae 100644
--- a/components/raftstore/src/store/fsm/peer.rs
+++ b/components/raftstore/src/store/fsm/peer.rs
@@ -133,7 +133,7 @@ impl<E: KvEngine> PeerFsm<E> {
     pub fn create(
         store_id: u64,
         cfg: &Config,
-        sched: Scheduler<RegionTask>,
+        sched: Scheduler<RegionTask<RocksEngine>>,
         engines: KvEngines<RocksEngine, RocksEngine>,
         region: &metapb::Region,
     ) -> Result<SenderFsmPair<E>> {
@@ -177,7 +177,7 @@ impl<E: KvEngine> PeerFsm<E> {
     pub fn replicate(
         store_id: u64,
         cfg: &Config,
-        sched: Scheduler<RegionTask>,
+        sched: Scheduler<RegionTask<RocksEngine>>,
         engines: KvEngines<RocksEngine, RocksEngine>,
         region_id: u64,
         peer: metapb::Peer,
@@ -620,7 +620,7 @@ impl<'a, T: Transport, C: PdClient> PeerFsmDelegate<'a, T, C> {
         }
     }
 
-    pub fn collect_ready(&mut self, proposals: &mut Vec<RegionProposal>) {
+    pub fn collect_ready(&mut self, proposals: &mut Vec<RegionProposal<RocksEngine>>) {
         let has_ready = self.fsm.has_ready;
         self.fsm.has_ready = false;
         if !has_ready || self.fsm.stopped {
@@ -835,7 +835,7 @@ impl<'a, T: Transport, C: PdClient> PeerFsmDelegate<'a, T, C> {
         }
     }
 
-    fn on_apply_res(&mut self, res: ApplyTaskRes) {
+    fn on_apply_res(&mut self, res: ApplyTaskRes<RocksEngine>) {
         fail_point!("on_apply_res", |_| {});
         match res {
             ApplyTaskRes::Apply(mut res) => {
@@ -2182,7 +2182,11 @@ impl<'a, T: Transport, C: PdClient> PeerFsmDelegate<'a, T, C> {
         assert_eq!(prev, Some(prev_region));
     }
 
-    fn on_ready_result(&mut self, exec_results: &mut VecDeque<ExecResult>, metrics: &ApplyMetrics) {
+    fn on_ready_result(
+        &mut self,
+        exec_results: &mut VecDeque<ExecResult<RocksEngine>>,
+        metrics: &ApplyMetrics,
+    ) {
         // handle executing committed log results
         while let Some(result) = exec_results.pop_front() {
             match result {
@@ -2206,6 +2210,7 @@ impl<'a, T: Transport, C: PdClient> PeerFsmDelegate<'a, T, C> {
                     region,
                     index,
                     snap,
+                    _phantom,
                 } => self.on_ready_compute_hash(region, index, snap),
                 ExecResult::VerifyHash { index, hash } => self.on_ready_verify_hash(index, hash),
                 ExecResult::DeleteRange { .. } => {
diff --git a/components/raftstore/src/store/fsm/store.rs b/components/raftstore/src/store/fsm/store.rs
index e9493e1c600..f23ad8c23e8 100644
--- a/components/raftstore/src/store/fsm/store.rs
+++ b/components/raftstore/src/store/fsm/store.rs
@@ -76,8 +76,8 @@ const RAFT_WB_SHRINK_SIZE: usize = 1024 * 1024;
 pub const PENDING_VOTES_CAP: usize = 20;
 const UNREACHABLE_BACKOFF: Duration = Duration::from_secs(10);
 
-pub struct StoreInfo {
-    pub engine: RocksEngine,
+pub struct StoreInfo<E> {
+    pub engine: E,
     pub capacity: u64,
 }
 
@@ -120,7 +120,7 @@ impl StoreMeta {
     #[inline]
     pub fn set_region(
         &mut self,
-        host: &CoprocessorHost,
+        host: &CoprocessorHost<RocksEngine>,
         region: Region,
         peer: &mut crate::store::Peer,
     ) {
@@ -200,22 +200,22 @@ impl<E: KvEngine> RaftRouter<E> {
 pub struct PollContext<T, C: 'static> {
     pub cfg: Config,
     pub store: metapb::Store,
-    pub pd_scheduler: FutureScheduler<PdTask>,
+    pub pd_scheduler: FutureScheduler<PdTask<RocksEngine>>,
     pub consistency_check_scheduler: Scheduler<ConsistencyCheckTask<RocksEngine>>,
     pub split_check_scheduler: Scheduler<SplitCheckTask>,
     // handle Compact, CleanupSST task
     pub cleanup_scheduler: Scheduler<CleanupTask>,
     pub raftlog_gc_scheduler: Scheduler<RaftlogGcTask<RocksEngine>>,
-    pub region_scheduler: Scheduler<RegionTask>,
+    pub region_scheduler: Scheduler<RegionTask<RocksEngine>>,
     pub apply_router: ApplyRouter,
     pub router: RaftRouter<RocksEngine>,
     pub importer: Arc<SSTImporter>,
     pub store_meta: Arc<Mutex<StoreMeta>>,
     pub future_poller: ThreadPoolSender,
     pub raft_metrics: RaftMetrics,
-    pub snap_mgr: SnapManager,
+    pub snap_mgr: SnapManager<RocksEngine>,
     pub applying_snap_count: Arc<AtomicUsize>,
-    pub coprocessor_host: CoprocessorHost,
+    pub coprocessor_host: CoprocessorHost<RocksEngine>,
     pub timer: SteadyTimer,
     pub trans: T,
     pub pd_client: Arc<C>,
@@ -233,7 +233,7 @@ pub struct PollContext<T, C: 'static> {
     pub current_time: Option<Timespec>,
 }
 
-impl<T, C> HandleRaftReadyContext for PollContext<T, C> {
+impl<T, C> HandleRaftReadyContext<RocksWriteBatch, RocksWriteBatch> for PollContext<T, C> {
     fn wb_mut(&mut self) -> (&mut RocksWriteBatch, &mut RocksWriteBatch) {
         (&mut self.kv_wb, &mut self.raft_wb)
     }
@@ -467,7 +467,7 @@ pub struct RaftPoller<T: 'static, C: 'static> {
     previous_metrics: RaftMetrics,
     timer: TiInstant,
     poll_ctx: PollContext<T, C>,
-    pending_proposals: Vec<RegionProposal>,
+    pending_proposals: Vec<RegionProposal<RocksEngine>>,
     messages_per_tick: usize,
     cfg_tracker: Tracker<Config>,
 }
@@ -724,19 +724,19 @@ impl<T: Transport, C: PdClient> PollHandler<PeerFsm<RocksEngine>, StoreFsm> for
 pub struct RaftPollerBuilder<T, C> {
     pub cfg: Arc<VersionTrack<Config>>,
     pub store: metapb::Store,
-    pd_scheduler: FutureScheduler<PdTask>,
+    pd_scheduler: FutureScheduler<PdTask<RocksEngine>>,
     consistency_check_scheduler: Scheduler<ConsistencyCheckTask<RocksEngine>>,
     split_check_scheduler: Scheduler<SplitCheckTask>,
     cleanup_scheduler: Scheduler<CleanupTask>,
     raftlog_gc_scheduler: Scheduler<RaftlogGcTask<RocksEngine>>,
-    pub region_scheduler: Scheduler<RegionTask>,
+    pub region_scheduler: Scheduler<RegionTask<RocksEngine>>,
     apply_router: ApplyRouter,
     pub router: RaftRouter<RocksEngine>,
     pub importer: Arc<SSTImporter>,
     store_meta: Arc<Mutex<StoreMeta>>,
     future_poller: ThreadPoolSender,
-    snap_mgr: SnapManager,
-    pub coprocessor_host: CoprocessorHost,
+    snap_mgr: SnapManager<RocksEngine>,
+    pub coprocessor_host: CoprocessorHost<RocksEngine>,
     trans: T,
     pd_client: Arc<C>,
     global_stat: GlobalStoreStat,
@@ -967,14 +967,14 @@ where
 }
 
 struct Workers {
-    pd_worker: FutureWorker<PdTask>,
+    pd_worker: FutureWorker<PdTask<RocksEngine>>,
     consistency_check_worker: Worker<ConsistencyCheckTask<RocksEngine>>,
     split_check_worker: Worker<SplitCheckTask>,
     // handle Compact, CleanupSST task
     cleanup_worker: Worker<CleanupTask>,
     raftlog_gc_worker: Worker<RaftlogGcTask<RocksEngine>>,
-    region_worker: Worker<RegionTask>,
-    coprocessor_host: CoprocessorHost,
+    region_worker: Worker<RegionTask<RocksEngine>>,
+    coprocessor_host: CoprocessorHost<RocksEngine>,
     future_poller: ThreadPool,
 }
 
@@ -1003,10 +1003,10 @@ impl RaftBatchSystem {
         engines: KvEngines<RocksEngine, RocksEngine>,
         trans: T,
         pd_client: Arc<C>,
-        mgr: SnapManager,
-        pd_worker: FutureWorker<PdTask>,
+        mgr: SnapManager<RocksEngine>,
+        pd_worker: FutureWorker<PdTask<RocksEngine>>,
         store_meta: Arc<Mutex<StoreMeta>>,
-        mut coprocessor_host: CoprocessorHost,
+        mut coprocessor_host: CoprocessorHost<RocksEngine>,
         importer: Arc<SSTImporter>,
         split_check_worker: Worker<SplitCheckTask>,
         dyn_cfg: Box<dyn DynamicConfig>,
diff --git a/components/raftstore/src/store/msg.rs b/components/raftstore/src/store/msg.rs
index 16858bbc104..9601a8f2cb9 100644
--- a/components/raftstore/src/store/msg.rs
+++ b/components/raftstore/src/store/msg.rs
@@ -313,7 +313,7 @@ pub enum PeerMsg<E: KvEngine> {
     /// that the raft node will not work anymore.
     Tick(PeerTicks),
     /// Result of applying committed entries. The message can't be lost.
-    ApplyRes { res: ApplyTaskRes },
+    ApplyRes { res: ApplyTaskRes<E> },
     /// Message that can't be lost but rarely created. If they are lost, real bad
     /// things happen like some peers will be considered dead in the group.
     SignificantMsg(SignificantMsg),
diff --git a/components/raftstore/src/store/peer.rs b/components/raftstore/src/store/peer.rs
index 4cb8c6b35f3..2446ef6b5bf 100644
--- a/components/raftstore/src/store/peer.rs
+++ b/components/raftstore/src/store/peer.rs
@@ -170,14 +170,14 @@ pub struct Peer {
     pub peer: metapb::Peer,
 
     /// The Raft state machine of this Peer.
-    pub raft_group: RawNode<PeerStorage>,
+    pub raft_group: RawNode<PeerStorage<RocksEngine, RocksEngine>>,
     /// The cache of meta information for Region's other Peers.
     peer_cache: RefCell<HashMap<u64, metapb::Peer>>,
     /// Record the last instant of each peer's heartbeat response.
     pub peer_heartbeats: HashMap<u64, Instant>,
 
     proposals: ProposalQueue,
-    apply_proposals: Vec<Proposal>,
+    apply_proposals: Vec<Proposal<RocksEngine>>,
 
     leader_missing_time: Option<Instant>,
     leader_lease: Lease,
@@ -249,7 +249,7 @@ impl Peer {
     pub fn new(
         store_id: u64,
         cfg: &Config,
-        sched: Scheduler<RegionTask>,
+        sched: Scheduler<RegionTask<RocksEngine>>,
         engines: KvEngines<RocksEngine, RocksEngine>,
         region: &metapb::Region,
         peer: metapb::Peer,
@@ -579,7 +579,7 @@ impl Peer {
     /// has been preserved in a durable device.
     pub fn set_region(
         &mut self,
-        host: &CoprocessorHost,
+        host: &CoprocessorHost<RocksEngine>,
         reader: &mut ReadDelegate,
         region: metapb::Region,
     ) {
@@ -620,12 +620,12 @@ impl Peer {
     }
 
     #[inline]
-    pub fn get_store(&self) -> &PeerStorage {
+    pub fn get_store(&self) -> &PeerStorage<RocksEngine, RocksEngine> {
         self.raft_group.store()
     }
 
     #[inline]
-    pub fn mut_store(&mut self) -> &mut PeerStorage {
+    pub fn mut_store(&mut self) -> &mut PeerStorage<RocksEngine, RocksEngine> {
         self.raft_group.mut_store()
     }
 
@@ -1074,7 +1074,7 @@ impl Peer {
         self.get_store().last_index() >= index && self.get_store().last_term() >= term
     }
 
-    pub fn take_apply_proposals(&mut self) -> Option<RegionProposal> {
+    pub fn take_apply_proposals(&mut self) -> Option<RegionProposal<RocksEngine>> {
         if self.apply_proposals.is_empty() {
             return None;
         }
diff --git a/components/raftstore/src/store/peer_storage.rs b/components/raftstore/src/store/peer_storage.rs
index 97e152f7329..21a777c84e4 100644
--- a/components/raftstore/src/store/peer_storage.rs
+++ b/components/raftstore/src/store/peer_storage.rs
@@ -8,9 +8,8 @@ use std::sync::Arc;
 use std::time::Instant;
 use std::{cmp, error, u64};
 
-use engine_rocks::{RocksEngine, RocksSnapshot, RocksWriteBatch};
 use engine_traits::CF_RAFT;
-use engine_traits::{Iterable, KvEngine, KvEngines, MiscExt, Mutable, Peekable, SyncMutable};
+use engine_traits::{KvEngine, KvEngines, Mutable, Peekable, WriteBatch};
 use keys::{self, enc_end_key, enc_start_key};
 use kvproto::metapb::{self, Region};
 use kvproto::raft_serverpb::{
@@ -231,11 +230,15 @@ impl CacheQueryStats {
     }
 }
 
-pub trait HandleRaftReadyContext {
+pub trait HandleRaftReadyContext<WK, WR>
+where
+    WK: WriteBatch,
+    WR: WriteBatch,
+{
     /// Returns the mutable references of WriteBatch for both KvDB and RaftDB in one interface.
-    fn wb_mut(&mut self) -> (&mut RocksWriteBatch, &mut RocksWriteBatch);
-    fn kv_wb_mut(&mut self) -> &mut RocksWriteBatch;
-    fn raft_wb_mut(&mut self) -> &mut RocksWriteBatch;
+    fn wb_mut(&mut self) -> (&mut WK, &mut WR);
+    fn kv_wb_mut(&mut self) -> &mut WK;
+    fn raft_wb_mut(&mut self) -> &mut WR;
     fn sync_log(&self) -> bool;
     fn set_sync_log(&mut self, sync: bool);
 }
@@ -273,7 +276,7 @@ pub struct InvokeContext {
 }
 
 impl InvokeContext {
-    pub fn new(store: &PeerStorage) -> InvokeContext {
+    pub fn new(store: &PeerStorage<impl KvEngine, impl KvEngine>) -> InvokeContext {
         InvokeContext {
             region_id: store.get_region_id(),
             raft_state: store.raft_state.clone(),
@@ -289,7 +292,7 @@ impl InvokeContext {
     }
 
     #[inline]
-    pub fn save_raft_state_to(&self, raft_wb: &mut RocksWriteBatch) -> Result<()> {
+    pub fn save_raft_state_to(&self, raft_wb: &mut impl WriteBatch) -> Result<()> {
         raft_wb.put_msg(&keys::raft_state_key(self.region_id), &self.raft_state)?;
         Ok(())
     }
@@ -298,7 +301,7 @@ impl InvokeContext {
     pub fn save_snapshot_raft_state_to(
         &self,
         snapshot_index: u64,
-        kv_wb: &mut RocksWriteBatch,
+        kv_wb: &mut impl WriteBatch,
     ) -> Result<()> {
         let mut snapshot_raft_state = self.raft_state.clone();
         snapshot_raft_state
@@ -315,7 +318,7 @@ impl InvokeContext {
     }
 
     #[inline]
-    pub fn save_apply_state_to(&self, kv_wb: &mut RocksWriteBatch) -> Result<()> {
+    pub fn save_apply_state_to(&self, kv_wb: &mut impl WriteBatch) -> Result<()> {
         kv_wb.put_msg_cf(
             CF_RAFT,
             &keys::apply_state_key(self.region_id),
@@ -326,8 +329,8 @@ impl InvokeContext {
 }
 
 pub fn recover_from_applying_state(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
-    raft_wb: &mut RocksWriteBatch,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
+    raft_wb: &mut impl WriteBatch,
     region_id: u64,
 ) -> Result<()> {
     let snapshot_raft_state_key = keys::snapshot_raft_state_key(region_id);
@@ -362,7 +365,7 @@ pub fn recover_from_applying_state(
 }
 
 fn init_applied_index_term(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
     region: &Region,
     apply_state: &RaftApplyState,
 ) -> Result<u64> {
@@ -385,7 +388,7 @@ fn init_applied_index_term(
 }
 
 fn init_raft_state(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
     region: &Region,
 ) -> Result<RaftLocalState> {
     let state_key = keys::raft_state_key(region.get_id());
@@ -406,7 +409,7 @@ fn init_raft_state(
 }
 
 fn init_apply_state(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
     region: &Region,
 ) -> Result<RaftApplyState> {
     Ok(
@@ -431,7 +434,7 @@ fn init_apply_state(
 
 fn validate_states(
     region_id: u64,
-    engines: &KvEngines<RocksEngine, RocksEngine>,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
     raft_state: &mut RaftLocalState,
     apply_state: &RaftApplyState,
 ) -> Result<()> {
@@ -478,7 +481,7 @@ fn validate_states(
 }
 
 fn init_last_term(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
+    engines: &KvEngines<impl KvEngine, impl KvEngine>,
     region: &Region,
     raft_state: &RaftLocalState,
     apply_state: &RaftApplyState,
@@ -505,8 +508,11 @@ fn init_last_term(
     }
 }
 
-pub struct PeerStorage {
-    pub engines: KvEngines<RocksEngine, RocksEngine>,
+pub struct PeerStorage<EK, ER>
+where
+    EK: KvEngine,
+{
+    pub engines: KvEngines<EK, ER>,
 
     peer_id: u64,
     region: metapb::Region,
@@ -517,7 +523,7 @@ pub struct PeerStorage {
 
     snap_state: RefCell<SnapState>,
     gen_snap_task: RefCell<Option<GenSnapTask>>,
-    region_sched: Scheduler<RegionTask>,
+    region_sched: Scheduler<RegionTask<EK>>,
     snap_tried_cnt: RefCell<usize>,
 
     cache: EntryCache,
@@ -526,7 +532,11 @@ pub struct PeerStorage {
     pub tag: String,
 }
 
-impl Storage for PeerStorage {
+impl<EK, ER> Storage for PeerStorage<EK, ER>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+{
     fn initial_state(&self) -> raft::Result<RaftState> {
         self.initial_state()
     }
@@ -557,14 +567,18 @@ impl Storage for PeerStorage {
     }
 }
 
-impl PeerStorage {
+impl<EK, ER> PeerStorage<EK, ER>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+{
     pub fn new(
-        engines: KvEngines<RocksEngine, RocksEngine>,
+        engines: KvEngines<EK, ER>,
         region: &metapb::Region,
-        region_sched: Scheduler<RegionTask>,
+        region_sched: Scheduler<RegionTask<EK>>,
         peer_id: u64,
         tag: String,
-    ) -> Result<PeerStorage> {
+    ) -> Result<PeerStorage<EK, ER>> {
         debug!(
             "creating storage on specified path";
             "region_id" => region.get_id(),
@@ -760,8 +774,8 @@ impl PeerStorage {
         self.region = region;
     }
 
-    pub fn raw_snapshot(&self) -> RocksSnapshot {
-        RocksSnapshot::new(self.engines.kv.as_inner().clone())
+    pub fn raw_snapshot(&self) -> EK::Snapshot {
+        self.engines.kv.snapshot()
     }
 
     fn validate_snap(&self, snap: &Snapshot, request_index: u64) -> bool {
@@ -887,7 +901,7 @@ impl PeerStorage {
     // Append the given entries to the raft log using previous last index or self.last_index.
     // Return the new last index for later update. After we commit in engine, we can set last_index
     // to the return one.
-    pub fn append<H: HandleRaftReadyContext>(
+    pub fn append<H: HandleRaftReadyContext<EK::WriteBatch, ER::WriteBatch>>(
         &mut self,
         invoke_ctx: &mut InvokeContext,
         entries: &[Entry],
@@ -972,8 +986,8 @@ impl PeerStorage {
         &mut self,
         ctx: &mut InvokeContext,
         snap: &Snapshot,
-        kv_wb: &mut RocksWriteBatch,
-        raft_wb: &mut RocksWriteBatch,
+        kv_wb: &mut EK::WriteBatch,
+        raft_wb: &mut ER::WriteBatch,
     ) -> Result<()> {
         info!(
             "begin to apply snapshot";
@@ -1032,8 +1046,8 @@ impl PeerStorage {
     /// Delete all meta belong to the region. Results are stored in `wb`.
     pub fn clear_meta(
         &mut self,
-        kv_wb: &mut RocksWriteBatch,
-        raft_wb: &mut RocksWriteBatch,
+        kv_wb: &mut EK::WriteBatch,
+        raft_wb: &mut ER::WriteBatch,
     ) -> Result<()> {
         let region_id = self.get_region_id();
         clear_meta(&self.engines, kv_wb, raft_wb, region_id, &self.raft_state)?;
@@ -1075,7 +1089,7 @@ impl PeerStorage {
         Ok(())
     }
 
-    pub fn get_raft_engine(&self) -> RocksEngine {
+    pub fn get_raft_engine(&self) -> ER {
         self.engines.raft.clone()
     }
 
@@ -1204,7 +1218,7 @@ impl PeerStorage {
     /// to update the memory states properly.
     // Using `&Ready` here to make sure `Ready` struct is not modified in this function. This is
     // a requirement to advance the ready object properly later.
-    pub fn handle_raft_ready<H: HandleRaftReadyContext>(
+    pub fn handle_raft_ready<H: HandleRaftReadyContext<EK::WriteBatch, ER::WriteBatch>>(
         &mut self,
         ready_ctx: &mut H,
         ready: &Ready,
@@ -1245,13 +1259,13 @@ impl PeerStorage {
                 // but not write raft_local_state to raft rocksdb in time.
                 // we write raft state to default rocksdb, with last index set to snap index,
                 // in case of recv raft log after snapshot.
-                ctx.save_snapshot_raft_state_to(snapshot_index, &mut ready_ctx.kv_wb_mut())?;
+                ctx.save_snapshot_raft_state_to(snapshot_index, ready_ctx.kv_wb_mut())?;
             }
         }
 
         // only when apply snapshot
         if snapshot_index != 0 {
-            ctx.save_apply_state_to(&mut ready_ctx.kv_wb_mut())?;
+            ctx.save_apply_state_to(ready_ctx.kv_wb_mut())?;
         }
 
         Ok(ctx)
@@ -1311,7 +1325,7 @@ fn get_sync_log_from_entry(entry: &Entry) -> bool {
 }
 
 pub fn fetch_entries_to(
-    engine: &RocksEngine,
+    engine: &impl KvEngine,
     region_id: u64,
     low: u64,
     high: u64,
@@ -1384,13 +1398,17 @@ pub fn fetch_entries_to(
 }
 
 /// Delete all meta belong to the region. Results are stored in `wb`.
-pub fn clear_meta(
-    engines: &KvEngines<RocksEngine, RocksEngine>,
-    kv_wb: &mut RocksWriteBatch,
-    raft_wb: &mut RocksWriteBatch,
+pub fn clear_meta<EK, ER>(
+    engines: &KvEngines<EK, ER>,
+    kv_wb: &mut EK::WriteBatch,
+    raft_wb: &mut ER::WriteBatch,
     region_id: u64,
     raft_state: &RaftLocalState,
-) -> Result<()> {
+) -> Result<()>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+{
     let t = Instant::now();
     box_try!(kv_wb.delete_cf(CF_RAFT, &keys::region_state_key(region_id)));
     box_try!(kv_wb.delete_cf(CF_RAFT, &keys::apply_state_key(region_id)));
@@ -1423,7 +1441,7 @@ pub fn clear_meta(
 }
 
 pub fn do_snapshot<E>(
-    mgr: SnapManager,
+    mgr: SnapManager<E>,
     engine: &E,
     kv_snap: E::Snapshot,
     region_id: u64,
@@ -1485,7 +1503,7 @@ where
     let conf_state = conf_state_from_region(state.get_region());
     snapshot.mut_metadata().set_conf_state(conf_state);
 
-    let mut s = mgr.get_snapshot_for_building::<E>(&key)?;
+    let mut s = mgr.get_snapshot_for_building(&key)?;
     // Set snapshot data.
     let mut snap_data = RaftSnapshotData::default();
     snap_data.set_region(state.get_region().clone());
@@ -1566,8 +1584,8 @@ mod tests {
     use crate::store::{bootstrap_store, initial_region, prepare_bootstrap_cluster};
     use engine::rocks::util::new_engine;
     use engine::Engines;
-    use engine_rocks::{CloneCompat, Compat, RocksWriteBatch};
-    use engine_traits::WriteBatchExt;
+    use engine_rocks::{CloneCompat, Compat, RocksEngine, RocksWriteBatch};
+    use engine_traits::{Iterable, SyncMutable, WriteBatchExt};
     use engine_traits::{ALL_CFS, CF_DEFAULT};
     use kvproto::raft_serverpb::RaftSnapshotData;
     use raft::eraftpb::HardState;
@@ -1584,7 +1602,10 @@ mod tests {
 
     use super::*;
 
-    fn new_storage(sched: Scheduler<RegionTask>, path: &TempDir) -> PeerStorage {
+    fn new_storage(
+        sched: Scheduler<RegionTask<RocksEngine>>,
+        path: &TempDir,
+    ) -> PeerStorage<RocksEngine, RocksEngine> {
         let kv_db =
             Arc::new(new_engine(path.path().to_str().unwrap(), None, ALL_CFS, None).unwrap());
         let raft_path = path.path().join(Path::new("raft"));
@@ -1606,7 +1627,7 @@ mod tests {
     }
 
     impl ReadyContext {
-        fn new(s: &PeerStorage) -> ReadyContext {
+        fn new(s: &PeerStorage<RocksEngine, RocksEngine>) -> ReadyContext {
             ReadyContext {
                 kv_wb: s.engines.kv.write_batch(),
                 raft_wb: s.engines.raft.write_batch(),
@@ -1615,7 +1636,7 @@ mod tests {
         }
     }
 
-    impl HandleRaftReadyContext for ReadyContext {
+    impl HandleRaftReadyContext<RocksWriteBatch, RocksWriteBatch> for ReadyContext {
         fn wb_mut(&mut self) -> (&mut RocksWriteBatch, &mut RocksWriteBatch) {
             (&mut self.kv_wb, &mut self.raft_wb)
         }
@@ -1634,10 +1655,10 @@ mod tests {
     }
 
     fn new_storage_from_ents(
-        sched: Scheduler<RegionTask>,
+        sched: Scheduler<RegionTask<RocksEngine>>,
         path: &TempDir,
         ents: &[Entry],
-    ) -> PeerStorage {
+    ) -> PeerStorage<RocksEngine, RocksEngine> {
         let mut store = new_storage(sched, path);
         let mut kv_wb = store.engines.kv.write_batch();
         let mut ctx = InvokeContext::new(&store);
@@ -1659,7 +1680,7 @@ mod tests {
         store
     }
 
-    fn append_ents(store: &mut PeerStorage, ents: &[Entry]) {
+    fn append_ents(store: &mut PeerStorage<RocksEngine, RocksEngine>, ents: &[Entry]) {
         let mut ctx = InvokeContext::new(store);
         let mut ready_ctx = ReadyContext::new(store);
         store.append(&mut ctx, ents, &mut ready_ctx).unwrap();
@@ -1668,7 +1689,7 @@ mod tests {
         store.raft_state = ctx.raft_state;
     }
 
-    fn validate_cache(store: &PeerStorage, exp_ents: &[Entry]) {
+    fn validate_cache(store: &PeerStorage<RocksEngine, RocksEngine>, exp_ents: &[Entry]) {
         assert_eq!(store.cache.cache, exp_ents);
         for e in exp_ents {
             let key = keys::raft_log_key(store.get_region_id(), e.get_index());
@@ -1712,7 +1733,7 @@ mod tests {
         }
     }
 
-    fn get_meta_key_count(store: &PeerStorage) -> usize {
+    fn get_meta_key_count(store: &PeerStorage<RocksEngine, RocksEngine>) -> usize {
         let region_id = store.get_region_id();
         let mut count = 0;
         let (meta_start, meta_end) = (
@@ -1881,7 +1902,7 @@ mod tests {
     fn generate_and_schedule_snapshot(
         gen_task: GenSnapTask,
         engines: &KvEngines<RocksEngine, RocksEngine>,
-        sched: &Scheduler<RegionTask>,
+        sched: &Scheduler<RegionTask<RocksEngine>>,
     ) -> Result<()> {
         let apply_state: RaftApplyState = engines
             .kv
@@ -1921,7 +1942,7 @@ mod tests {
             0,
             true,
             Duration::from_secs(0),
-            CoprocessorHost::default(),
+            CoprocessorHost::<RocksEngine>::default(),
             router,
         );
         worker.start(runner).unwrap();
@@ -2238,7 +2259,7 @@ mod tests {
             0,
             true,
             Duration::from_secs(0),
-            CoprocessorHost::default(),
+            CoprocessorHost::<RocksEngine>::default(),
             router,
         );
         worker.start(runner).unwrap();
@@ -2426,7 +2447,7 @@ mod tests {
 
         let region = initial_region(1, 1, 1);
         prepare_bootstrap_cluster(&engines.c(), &region).unwrap();
-        let build_storage = || -> Result<PeerStorage> {
+        let build_storage = || -> Result<PeerStorage<RocksEngine, RocksEngine>> {
             PeerStorage::new(engines.c(), &region, sched.clone(), 0, "".to_owned())
         };
         let mut s = build_storage().unwrap();
diff --git a/components/raftstore/src/store/region_snapshot.rs b/components/raftstore/src/store/region_snapshot.rs
index 4413bc6ea56..305992cb8ef 100644
--- a/components/raftstore/src/store/region_snapshot.rs
+++ b/components/raftstore/src/store/region_snapshot.rs
@@ -34,7 +34,7 @@ where
     E: KvEngine,
 {
     #[allow(clippy::new_ret_no_self)] // temporary until this returns RegionSnapshot<E>
-    pub fn new(ps: &PeerStorage) -> RegionSnapshot<RocksEngine> {
+    pub fn new(ps: &PeerStorage<RocksEngine, RocksEngine>) -> RegionSnapshot<RocksEngine> {
         RegionSnapshot::from_snapshot(ps.raw_snapshot().into_sync(), ps.region().clone())
     }
 
@@ -407,14 +407,17 @@ mod tests {
 
     type DataSet = Vec<(Vec<u8>, Vec<u8>)>;
 
-    fn new_peer_storage(engines: KvEngines<RocksEngine, RocksEngine>, r: &Region) -> PeerStorage {
+    fn new_peer_storage(
+        engines: KvEngines<RocksEngine, RocksEngine>,
+        r: &Region,
+    ) -> PeerStorage<RocksEngine, RocksEngine> {
         let (sched, _) = worker::dummy_scheduler();
         PeerStorage::new(engines, r, sched, 0, "".to_owned()).unwrap()
     }
 
     fn load_default_dataset(
         engines: KvEngines<RocksEngine, RocksEngine>,
-    ) -> (PeerStorage, DataSet) {
+    ) -> (PeerStorage<RocksEngine, RocksEngine>, DataSet) {
         let mut r = Region::default();
         r.mut_peers().push(Peer::default());
         r.set_id(10);
@@ -438,7 +441,7 @@ mod tests {
 
     fn load_multiple_levels_dataset(
         engines: KvEngines<RocksEngine, RocksEngine>,
-    ) -> (PeerStorage, DataSet) {
+    ) -> (PeerStorage<RocksEngine, RocksEngine>, DataSet) {
         let mut r = Region::default();
         r.mut_peers().push(Peer::default());
         r.set_id(10);
diff --git a/components/raftstore/src/store/snap.rs b/components/raftstore/src/store/snap.rs
index 9acb5fc9526..8ce9141b53d 100644
--- a/components/raftstore/src/store/snap.rs
+++ b/components/raftstore/src/store/snap.rs
@@ -172,7 +172,7 @@ where
     pub region: Region,
     pub abort: Arc<AtomicUsize>,
     pub write_batch_size: usize,
-    pub coprocessor_host: CoprocessorHost,
+    pub coprocessor_host: CoprocessorHost<RocksEngine>,
 }
 
 /// `Snapshot` is a trait for snapshot.
@@ -1183,7 +1183,7 @@ struct SnapManagerCore {
     snap_size: Arc<AtomicU64>,
 }
 
-fn notify_stats(ch: Option<&RaftRouter<RocksEngine>>) {
+fn notify_stats(ch: Option<&RaftRouter<impl KvEngine>>) {
     if let Some(ch) = ch {
         if let Err(e) = ch.send_control(StoreMsg::SnapshotStats) {
             error!(
@@ -1196,17 +1196,23 @@ fn notify_stats(ch: Option<&RaftRouter<RocksEngine>>) {
 
 /// `SnapManagerCore` trace all current processing snapshots.
 #[derive(Clone)]
-pub struct SnapManager {
+pub struct SnapManager<E>
+where
+    E: KvEngine,
+{
     // directory to store snapfile.
     core: Arc<RwLock<SnapManagerCore>>,
-    router: Option<RaftRouter<RocksEngine>>,
+    router: Option<RaftRouter<E>>,
     limiter: Limiter,
     max_total_size: u64,
     encryption_key_manager: Option<Arc<DataKeyManager>>,
 }
 
-impl SnapManager {
-    pub fn new<T: Into<String>>(path: T, router: Option<RaftRouter<RocksEngine>>) -> Self {
+impl<E> SnapManager<E>
+where
+    E: KvEngine,
+{
+    pub fn new<T: Into<String>>(path: T, router: Option<RaftRouter<E>>) -> Self {
         SnapManagerBuilder::default().build(path, router)
     }
 
@@ -1303,7 +1309,7 @@ impl SnapManager {
         self.core.rl().registry.contains_key(key)
     }
 
-    pub fn get_snapshot_for_building<E: KvEngine>(
+    pub fn get_snapshot_for_building(
         &self,
         key: &SnapKey,
     ) -> RaftStoreResult<Box<dyn Snapshot<E>>> {
@@ -1420,7 +1426,7 @@ impl SnapManager {
         Ok(self.get_concrete_snapshot_for_applying(key)?)
     }
 
-    pub fn get_snapshot_for_applying_to_engine<E: KvEngine>(
+    pub fn get_snapshot_for_applying_to_engine(
         &self,
         key: &SnapKey,
     ) -> RaftStoreResult<Box<dyn Snapshot<E>>> {
@@ -1521,7 +1527,10 @@ impl SnapManager {
     }
 }
 
-impl SnapshotDeleter for SnapManager {
+impl<E> SnapshotDeleter for SnapManager<E>
+where
+    E: KvEngine,
+{
     fn delete_snapshot(
         &self,
         key: &SnapKey,
@@ -1576,11 +1585,11 @@ impl SnapManagerBuilder {
         self.key_manager = m;
         self
     }
-    pub fn build<T: Into<String>>(
+    pub fn build<T: Into<String>, E: KvEngine>(
         self,
         path: T,
-        router: Option<RaftRouter<RocksEngine>>,
-    ) -> SnapManager {
+        router: Option<RaftRouter<E>>,
+    ) -> SnapManager<E> {
         let limiter = Limiter::new(if self.max_write_bytes_per_sec > 0 {
             self.max_write_bytes_per_sec as f64
         } else {
@@ -1982,7 +1991,7 @@ pub mod tests {
             region,
             abort: Arc::new(AtomicUsize::new(JOB_STATUS_RUNNING)),
             write_batch_size: TEST_WRITE_BATCH_SIZE,
-            coprocessor_host: CoprocessorHost::default(),
+            coprocessor_host: CoprocessorHost::<RocksEngine>::default(),
         };
         // Verify thte snapshot applying is ok.
         assert!(s4.apply(options).is_ok());
@@ -2322,7 +2331,7 @@ pub mod tests {
             region,
             abort: Arc::new(AtomicUsize::new(JOB_STATUS_RUNNING)),
             write_batch_size: TEST_WRITE_BATCH_SIZE,
-            coprocessor_host: CoprocessorHost::default(),
+            coprocessor_host: CoprocessorHost::<RocksEngine>::default(),
         };
         assert!(s5.apply(options).is_err());
 
@@ -2469,7 +2478,7 @@ pub mod tests {
         let temp_path = temp_dir.path().join("snap1");
         let path = temp_path.to_str().unwrap().to_owned();
         assert!(!temp_path.exists());
-        let mut mgr = SnapManager::new(path, None);
+        let mut mgr = SnapManager::<RocksEngine>::new(path, None);
         mgr.init().unwrap();
         assert!(temp_path.exists());
 
@@ -2485,7 +2494,7 @@ pub mod tests {
     fn test_snap_mgr_v2() {
         let temp_dir = Builder::new().prefix("test-snap-mgr-v2").tempdir().unwrap();
         let path = temp_dir.path().to_str().unwrap().to_owned();
-        let mgr = SnapManager::new(path.clone(), None);
+        let mgr = SnapManager::<RocksEngine>::new(path.clone(), None);
         mgr.init().unwrap();
         assert_eq!(mgr.get_total_snap_size(), 0);
 
@@ -2567,7 +2576,7 @@ pub mod tests {
         assert!(!s3.exists());
         assert!(!s4.exists());
 
-        let mgr = SnapManager::new(path, None);
+        let mgr = SnapManager::<RocksEngine>::new(path, None);
         mgr.init().unwrap();
         assert_eq!(mgr.get_total_snap_size(), expected_size * 2);
 
@@ -2582,7 +2591,11 @@ pub mod tests {
         assert_eq!(mgr.get_total_snap_size(), 0);
     }
 
-    fn check_registry_around_deregister(mgr: SnapManager, key: &SnapKey, entry: &SnapEntry) {
+    fn check_registry_around_deregister(
+        mgr: SnapManager<RocksEngine>,
+        key: &SnapKey,
+        entry: &SnapEntry,
+    ) {
         let snap_keys = mgr.list_idle_snap().unwrap();
         assert!(snap_keys.is_empty());
         assert!(mgr.has_registered(key));
@@ -2616,9 +2629,7 @@ pub mod tests {
 
         // Ensure the snapshot being built will not be deleted on GC.
         src_mgr.register(key.clone(), SnapEntry::Generating);
-        let mut s1 = src_mgr
-            .get_snapshot_for_building::<RocksEngine>(&key)
-            .unwrap();
+        let mut s1 = src_mgr.get_snapshot_for_building(&key).unwrap();
         let mut snap_data = RaftSnapshotData::default();
         snap_data.set_region(region.clone());
         let mut stat = SnapshotStatistics::new();
@@ -2687,7 +2698,7 @@ pub mod tests {
         let max_total_size = 10240;
         let snap_mgr = SnapManagerBuilder::default()
             .max_total_size(max_total_size)
-            .build::<_>(snapfiles_path.path().to_str().unwrap(), None);
+            .build::<_, RocksEngine>(snapfiles_path.path().to_str().unwrap(), None);
         let snapshot = RocksSnapshot::new(engine.kv.clone());
 
         // Add an oldest snapshot for receiving.
@@ -2695,9 +2706,7 @@ pub mod tests {
         let recv_head = {
             let mut stat = SnapshotStatistics::new();
             let mut snap_data = RaftSnapshotData::default();
-            let mut s = snap_mgr
-                .get_snapshot_for_building::<RocksEngine>(&recv_key)
-                .unwrap();
+            let mut s = snap_mgr.get_snapshot_for_building(&recv_key).unwrap();
             s.build(
                 engine.kv.c(),
                 &snapshot,
@@ -2725,9 +2734,7 @@ pub mod tests {
         for (i, region_id) in regions.into_iter().enumerate() {
             let key = SnapKey::new(region_id, 1, 1);
             let region = gen_test_region(region_id, 1, 1);
-            let mut s = snap_mgr
-                .get_snapshot_for_building::<RocksEngine>(&key)
-                .unwrap();
+            let mut s = snap_mgr.get_snapshot_for_building(&key).unwrap();
             let mut snap_data = RaftSnapshotData::default();
             let mut stat = SnapshotStatistics::new();
             s.build(
diff --git a/components/raftstore/src/store/worker/cleanup.rs b/components/raftstore/src/store/worker/cleanup.rs
index 933b87228e7..bf6d2c751f0 100644
--- a/components/raftstore/src/store/worker/cleanup.rs
+++ b/components/raftstore/src/store/worker/cleanup.rs
@@ -6,6 +6,7 @@ use super::cleanup_sst::{Runner as CleanupSSTRunner, Task as CleanupSSTTask};
 use super::compact::{Runner as CompactRunner, Task as CompactTask};
 
 use crate::store::StoreRouter;
+use engine_traits::KvEngine;
 use pd_client::PdClient;
 use tikv_util::worker::Runnable;
 
@@ -23,13 +24,17 @@ impl Display for Task {
     }
 }
 
-pub struct Runner<C, S> {
-    compact: CompactRunner,
+pub struct Runner<E, C, S> {
+    compact: CompactRunner<E>,
     cleanup_sst: CleanupSSTRunner<C, S>,
 }
 
-impl<C: PdClient, S: StoreRouter> Runner<C, S> {
-    pub fn new(compact: CompactRunner, cleanup_sst: CleanupSSTRunner<C, S>) -> Runner<C, S> {
+impl<E, C, S> Runner<E, C, S>
+where
+    C: PdClient,
+    S: StoreRouter,
+{
+    pub fn new(compact: CompactRunner<E>, cleanup_sst: CleanupSSTRunner<C, S>) -> Runner<E, C, S> {
         Runner {
             compact,
             cleanup_sst,
@@ -37,7 +42,12 @@ impl<C: PdClient, S: StoreRouter> Runner<C, S> {
     }
 }
 
-impl<C: PdClient, S: StoreRouter> Runnable<Task> for Runner<C, S> {
+impl<E, C, S> Runnable<Task> for Runner<E, C, S>
+where
+    E: KvEngine,
+    C: PdClient,
+    S: StoreRouter,
+{
     fn run(&mut self, task: Task) {
         match task {
             Task::Compact(t) => self.compact.run(t),
diff --git a/components/raftstore/src/store/worker/compact.rs b/components/raftstore/src/store/worker/compact.rs
index a04be4a5d02..d9425d311b9 100644
--- a/components/raftstore/src/store/worker/compact.rs
+++ b/components/raftstore/src/store/worker/compact.rs
@@ -5,9 +5,8 @@ use std::error;
 use std::fmt::{self, Display, Formatter};
 use std::time::Instant;
 
-use engine_rocks::RocksEngine;
+use engine_traits::KvEngine;
 use engine_traits::CF_WRITE;
-use engine_traits::{CompactExt, KvEngine};
 use tikv_util::worker::Runnable;
 
 use super::metrics::COMPACT_RANGE_CF;
@@ -83,12 +82,15 @@ quick_error! {
     }
 }
 
-pub struct Runner {
-    engine: RocksEngine,
+pub struct Runner<E> {
+    engine: E,
 }
 
-impl Runner {
-    pub fn new(engine: RocksEngine) -> Runner {
+impl<E> Runner<E>
+where
+    E: KvEngine,
+{
+    pub fn new(engine: E) -> Runner<E> {
         Runner { engine }
     }
 
@@ -118,7 +120,10 @@ impl Runner {
     }
 }
 
-impl Runnable<Task> for Runner {
+impl<E> Runnable<Task> for Runner<E>
+where
+    E: KvEngine,
+{
     fn run(&mut self, task: Task) {
         match task {
             Task::Compact {
diff --git a/components/raftstore/src/store/worker/pd.rs b/components/raftstore/src/store/worker/pd.rs
index 79d6edc6a56..94512d55a0c 100644
--- a/components/raftstore/src/store/worker/pd.rs
+++ b/components/raftstore/src/store/worker/pd.rs
@@ -12,8 +12,7 @@ use futures::Future;
 use tokio_core::reactor::Handle;
 use tokio_timer::Delay;
 
-use engine_rocks::RocksEngine;
-use engine_traits::MiscExt;
+use engine_traits::KvEngine;
 use fs2;
 use kvproto::metapb;
 use kvproto::pdpb;
@@ -59,7 +58,10 @@ pub trait FlowStatsReporter: Send + Clone + Sync + 'static {
     fn report_read_stats(&self, read_stats: HashMap<u64, FlowStatistics>);
 }
 
-impl FlowStatsReporter for Scheduler<Task> {
+impl<E> FlowStatsReporter for Scheduler<Task<E>>
+where
+    E: KvEngine,
+{
     fn report_read_stats(&self, read_stats: HashMap<u64, FlowStatistics>) {
         if let Err(e) = self.schedule(Task::ReadStats { read_stats }) {
             error!("Failed to send read flow statistics"; "err" => ?e);
@@ -74,14 +76,17 @@ pub trait DynamicConfig: Send + 'static {
 }
 
 /// Uses an asynchronous thread to tell PD something.
-pub enum Task {
+pub enum Task<E>
+where
+    E: KvEngine,
+{
     AskSplit {
         region: metapb::Region,
         split_key: Vec<u8>,
         peer: metapb::Peer,
         // If true, right Region derives origin region_id.
         right_derive: bool,
-        callback: Callback<RocksEngine>,
+        callback: Callback<E>,
     },
     AskBatchSplit {
         region: metapb::Region,
@@ -89,7 +94,7 @@ pub enum Task {
         peer: metapb::Peer,
         // If true, right Region derives origin region_id.
         right_derive: bool,
-        callback: Callback<RocksEngine>,
+        callback: Callback<E>,
     },
     Heartbeat {
         term: u64,
@@ -104,7 +109,7 @@ pub enum Task {
     },
     StoreHeartbeat {
         stats: pdpb::StoreStats,
-        store_info: StoreInfo,
+        store_info: StoreInfo<E>,
     },
     ReportBatchSplit {
         regions: Vec<metapb::Region>,
@@ -180,7 +185,10 @@ pub struct PeerStat {
     pub last_report_ts: UnixSecs,
 }
 
-impl Display for Task {
+impl<E> Display for Task<E>
+where
+    E: KvEngine,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Task::AskSplit {
@@ -259,15 +267,21 @@ fn convert_record_pairs(m: HashMap<String, u64>) -> RecordPairVec {
         .collect()
 }
 
-struct StatsMonitor {
-    scheduler: Scheduler<Task>,
+struct StatsMonitor<E>
+where
+    E: KvEngine,
+{
+    scheduler: Scheduler<Task<E>>,
     handle: Option<JoinHandle<()>>,
     sender: Option<Sender<bool>>,
     interval: Duration,
 }
 
-impl StatsMonitor {
-    pub fn new(interval: Duration, scheduler: Scheduler<Task>) -> Self {
+impl<E> StatsMonitor<E>
+where
+    E: KvEngine,
+{
+    pub fn new(interval: Duration, scheduler: Scheduler<Task<E>>) -> Self {
         StatsMonitor {
             scheduler,
             handle: None,
@@ -324,12 +338,16 @@ impl StatsMonitor {
     }
 }
 
-pub struct Runner<T: PdClient + ConfigClient> {
+pub struct Runner<E, T>
+where
+    E: KvEngine,
+    T: PdClient + ConfigClient,
+{
     store_id: u64,
     pd_client: Arc<T>,
     config_handler: Box<dyn DynamicConfig>,
-    router: RaftRouter<RocksEngine>,
-    db: RocksEngine,
+    router: RaftRouter<E>,
+    db: E,
     region_peers: HashMap<u64, PeerStat>,
     store_stat: StoreStat,
     is_hb_receiver_scheduled: bool,
@@ -339,22 +357,26 @@ pub struct Runner<T: PdClient + ConfigClient> {
     // use for Runner inner handle function to send Task to itself
     // actually it is the sender connected to Runner's Worker which
     // calls Runner's run() on Task received.
-    scheduler: Scheduler<Task>,
-    stats_monitor: StatsMonitor,
+    scheduler: Scheduler<Task<E>>,
+    stats_monitor: StatsMonitor<E>,
 }
 
-impl<T: PdClient + ConfigClient> Runner<T> {
+impl<E, T> Runner<E, T>
+where
+    E: KvEngine,
+    T: PdClient + ConfigClient,
+{
     const INTERVAL_DIVISOR: u32 = 2;
 
     pub fn new(
         store_id: u64,
         pd_client: Arc<T>,
         config_handler: Box<dyn DynamicConfig>,
-        router: RaftRouter<RocksEngine>,
-        db: RocksEngine,
-        scheduler: Scheduler<Task>,
+        router: RaftRouter<E>,
+        db: E,
+        scheduler: Scheduler<Task<E>>,
         store_heartbeat_interval: u64,
-    ) -> Runner<T> {
+    ) -> Runner<E, T> {
         let interval = Duration::from_secs(store_heartbeat_interval) / Self::INTERVAL_DIVISOR;
         let mut stats_monitor = StatsMonitor::new(interval, scheduler.clone());
         if let Err(e) = stats_monitor.start() {
@@ -383,7 +405,7 @@ impl<T: PdClient + ConfigClient> Runner<T> {
         split_key: Vec<u8>,
         peer: metapb::Peer,
         right_derive: bool,
-        callback: Callback<RocksEngine>,
+        callback: Callback<E>,
     ) {
         let router = self.router.clone();
         let f = self.pd_client.ask_split(region.clone()).then(move |resp| {
@@ -424,7 +446,7 @@ impl<T: PdClient + ConfigClient> Runner<T> {
         mut split_keys: Vec<Vec<u8>>,
         peer: metapb::Peer,
         right_derive: bool,
-        callback: Callback<RocksEngine>,
+        callback: Callback<E>,
     ) {
         let router = self.router.clone();
         let scheduler = self.scheduler.clone();
@@ -533,7 +555,7 @@ impl<T: PdClient + ConfigClient> Runner<T> {
         &mut self,
         handle: &Handle,
         mut stats: pdpb::StoreStats,
-        store_info: StoreInfo,
+        store_info: StoreInfo<E>,
     ) {
         let disk_stats = match fs2::statvfs(store_info.engine.path()) {
             Err(e) => {
@@ -838,8 +860,12 @@ impl<T: PdClient + ConfigClient> Runner<T> {
     }
 }
 
-impl<T: PdClient + ConfigClient> Runnable<Task> for Runner<T> {
-    fn run(&mut self, task: Task, handle: &Handle) {
+impl<E, T> Runnable<Task<E>> for Runner<E, T>
+where
+    E: KvEngine,
+    T: PdClient + ConfigClient,
+{
+    fn run(&mut self, task: Task<E>, handle: &Handle) {
         debug!("executing task"; "task" => %task);
 
         if !self.is_hb_receiver_scheduled {
@@ -1019,14 +1045,16 @@ fn new_merge_request(merge: pdpb::Merge) -> AdminRequest {
     req
 }
 
-fn send_admin_request(
-    router: &RaftRouter<RocksEngine>,
+fn send_admin_request<E>(
+    router: &RaftRouter<E>,
     region_id: u64,
     epoch: metapb::RegionEpoch,
     peer: metapb::Peer,
     request: AdminRequest,
-    callback: Callback<RocksEngine>,
-) {
+    callback: Callback<E>,
+) where
+    E: KvEngine,
+{
     let cmd_type = request.get_cmd_type();
 
     let mut req = RaftCmdRequest::default();
@@ -1045,7 +1073,11 @@ fn send_admin_request(
 }
 
 /// Sends merge fail message to gc merge source.
-fn send_merge_fail(router: &RaftRouter<RocksEngine>, source_region_id: u64, target: metapb::Peer) {
+fn send_merge_fail(
+    router: &RaftRouter<impl KvEngine>,
+    source_region_id: u64,
+    target: metapb::Peer,
+) {
     let target_id = target.get_id();
     if let Err(e) = router.force_send(
         source_region_id,
@@ -1063,7 +1095,7 @@ fn send_merge_fail(router: &RaftRouter<RocksEngine>, source_region_id: u64, targ
 
 /// Sends a raft message to destroy the specified stale Peer
 fn send_destroy_peer_message(
-    router: &RaftRouter<RocksEngine>,
+    router: &RaftRouter<impl KvEngine>,
     local_region: metapb::Region,
     peer: metapb::Peer,
     pd_region: metapb::Region,
@@ -1086,6 +1118,7 @@ fn send_destroy_peer_message(
 #[cfg(not(target_os = "macos"))]
 #[cfg(test)]
 mod tests {
+    use engine_rocks::RocksEngine;
     use std::sync::Mutex;
     use std::time::Instant;
     use tikv_util::worker::FutureWorker;
@@ -1094,13 +1127,13 @@ mod tests {
 
     struct RunnerTest {
         store_stat: Arc<Mutex<StoreStat>>,
-        stats_monitor: StatsMonitor,
+        stats_monitor: StatsMonitor<RocksEngine>,
     }
 
     impl RunnerTest {
         fn new(
             interval: u64,
-            scheduler: Scheduler<Task>,
+            scheduler: Scheduler<Task<RocksEngine>>,
             store_stat: Arc<Mutex<StoreStat>>,
         ) -> RunnerTest {
             let mut stats_monitor = StatsMonitor::new(Duration::from_secs(interval), scheduler);
@@ -1127,8 +1160,8 @@ mod tests {
         }
     }
 
-    impl Runnable<Task> for RunnerTest {
-        fn run(&mut self, task: Task, _handle: &Handle) {
+    impl Runnable<Task<RocksEngine>> for RunnerTest {
+        fn run(&mut self, task: Task<RocksEngine>, _handle: &Handle) {
             if let Task::StoreInfos {
                 cpu_usages,
                 read_io_rates,
diff --git a/components/raftstore/src/store/worker/region.rs b/components/raftstore/src/store/worker/region.rs
index 998220bc5f1..5e5869344da 100644
--- a/components/raftstore/src/store/worker/region.rs
+++ b/components/raftstore/src/store/worker/region.rs
@@ -9,9 +9,9 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 use std::u64;
 
-use engine_rocks::{RocksEngine, RocksSnapshot};
+use engine_rocks::RocksEngine;
 use engine_traits::CF_RAFT;
-use engine_traits::{KvEngines, MiscExt, Mutable, Peekable, WriteBatchExt};
+use engine_traits::{KvEngine, KvEngines, Mutable};
 use kvproto::raft_serverpb::{PeerState, RaftApplyState, RegionLocalState};
 use raft::eraftpb::Snapshot as RaftSnapshot;
 
@@ -46,12 +46,15 @@ const CLEANUP_MAX_DURATION: Duration = Duration::from_secs(5);
 
 /// Region related task
 #[derive(Debug)]
-pub enum Task {
+pub enum Task<E>
+where
+    E: KvEngine,
+{
     Gen {
         region_id: u64,
         last_applied_index_term: u64,
         last_applied_state: RaftApplyState,
-        kv_snap: RocksSnapshot,
+        kv_snap: E::Snapshot,
         notifier: SyncSender<RaftSnapshot>,
     },
     Apply {
@@ -68,8 +71,11 @@ pub enum Task {
     },
 }
 
-impl Task {
-    pub fn destroy(region_id: u64, start_key: Vec<u8>, end_key: Vec<u8>) -> Task {
+impl<E> Task<E>
+where
+    E: KvEngine,
+{
+    pub fn destroy(region_id: u64, start_key: Vec<u8>, end_key: Vec<u8>) -> Task<E> {
         Task::Destroy {
             region_id,
             start_key,
@@ -78,7 +84,10 @@ impl Task {
     }
 }
 
-impl Display for Task {
+impl<E> Display for Task<E>
+where
+    E: KvEngine,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Task::Gen { region_id, .. } => write!(f, "Snap gen for {}", region_id),
@@ -206,29 +215,38 @@ impl PendingDeleteRanges {
 }
 
 #[derive(Clone)]
-struct SnapContext<R> {
-    engines: KvEngines<RocksEngine, RocksEngine>,
+struct SnapContext<EK, ER, R>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+{
+    engines: KvEngines<EK, ER>,
     batch_size: usize,
-    mgr: SnapManager,
+    mgr: SnapManager<EK>,
     use_delete_range: bool,
     clean_stale_peer_delay: Duration,
     pending_delete_ranges: PendingDeleteRanges,
-    coprocessor_host: CoprocessorHost,
+    coprocessor_host: CoprocessorHost<RocksEngine>,
     router: R,
 }
 
-impl<R: CasualRouter<RocksEngine>> SnapContext<R> {
+impl<EK, ER, R> SnapContext<EK, ER, R>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+    R: CasualRouter<EK>,
+{
     /// Generates the snapshot of the Region.
     fn generate_snap(
         &self,
         region_id: u64,
         last_applied_index_term: u64,
         last_applied_state: RaftApplyState,
-        kv_snap: RocksSnapshot,
+        kv_snap: EK::Snapshot,
         notifier: SyncSender<RaftSnapshot>,
     ) -> Result<()> {
         // do we need to check leader here?
-        let snap = box_try!(store::do_snapshot::<RocksEngine>(
+        let snap = box_try!(store::do_snapshot::<EK>(
             self.mgr.clone(),
             &self.engines.kv,
             kv_snap,
@@ -259,7 +277,7 @@ impl<R: CasualRouter<RocksEngine>> SnapContext<R> {
         region_id: u64,
         last_applied_index_term: u64,
         last_applied_state: RaftApplyState,
-        kv_snap: RocksSnapshot,
+        kv_snap: EK::Snapshot,
         notifier: SyncSender<RaftSnapshot>,
     ) {
         SNAP_COUNTER.generate.all.inc();
@@ -526,24 +544,33 @@ impl<R: CasualRouter<RocksEngine>> SnapContext<R> {
     }
 }
 
-pub struct Runner<R> {
+pub struct Runner<EK, ER, R>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+{
     pool: ThreadPool<TaskCell>,
-    ctx: SnapContext<R>,
+    ctx: SnapContext<EK, ER, R>,
     // we may delay some apply tasks if level 0 files to write stall threshold,
     // pending_applies records all delayed apply task, and will check again later
-    pending_applies: VecDeque<Task>,
+    pending_applies: VecDeque<Task<EK>>,
 }
 
-impl<R: CasualRouter<RocksEngine>> Runner<R> {
+impl<EK, ER, R> Runner<EK, ER, R>
+where
+    EK: KvEngine,
+    ER: KvEngine,
+    R: CasualRouter<EK>,
+{
     pub fn new(
-        engines: KvEngines<RocksEngine, RocksEngine>,
-        mgr: SnapManager,
+        engines: KvEngines<EK, ER>,
+        mgr: SnapManager<EK>,
         batch_size: usize,
         use_delete_range: bool,
         clean_stale_peer_delay: Duration,
-        coprocessor_host: CoprocessorHost,
+        coprocessor_host: CoprocessorHost<RocksEngine>,
         router: R,
-    ) -> Runner<R> {
+    ) -> Runner<EK, ER, R> {
         Runner {
             pool: Builder::new(thd_name!("snap-generator"))
                 .max_thread_count(GENERATE_POOL_SIZE)
@@ -592,11 +619,13 @@ impl<R: CasualRouter<RocksEngine>> Runner<R> {
     }
 }
 
-impl<R> Runnable<Task> for Runner<R>
+impl<EK, ER, R> Runnable<Task<EK>> for Runner<EK, ER, R>
 where
-    R: CasualRouter<RocksEngine> + Send + Clone + 'static,
+    EK: KvEngine,
+    ER: KvEngine,
+    R: CasualRouter<EK> + Send + Clone + 'static,
 {
-    fn run(&mut self, task: Task) {
+    fn run(&mut self, task: Task<EK>) {
         match task {
             Task::Gen {
                 region_id,
@@ -658,9 +687,11 @@ pub enum Event {
     CheckApply,
 }
 
-impl<R> RunnableWithTimer<Task, Event> for Runner<R>
+impl<EK, ER, R> RunnableWithTimer<Task<EK>, Event> for Runner<EK, ER, R>
 where
-    R: CasualRouter<RocksEngine> + Send + Clone + 'static,
+    EK: KvEngine,
+    ER: KvEngine,
+    R: CasualRouter<EK> + Send + Clone + 'static,
 {
     fn on_timeout(&mut self, timer: &mut Timer<Event>, event: Event) {
         match event {
@@ -698,7 +729,7 @@ mod tests {
     use engine::rocks;
     use engine::rocks::{ColumnFamilyOptions, Writable};
     use engine::Engines;
-    use engine_rocks::{CloneCompat, Compat, RocksSnapshot};
+    use engine_rocks::{CloneCompat, Compat, RocksEngine, RocksSnapshot};
     use engine_traits::{CompactExt, Mutable, Peekable, WriteBatchExt};
     use engine_traits::{CF_DEFAULT, CF_RAFT};
     use kvproto::raft_serverpb::{PeerState, RaftApplyState, RegionLocalState};
@@ -843,7 +874,7 @@ mod tests {
             0,
             true,
             Duration::from_secs(0),
-            CoprocessorHost::default(),
+            CoprocessorHost::<RocksEngine>::default(),
             router,
         );
         let mut timer = Timer::new(1);
@@ -884,7 +915,7 @@ mod tests {
             }
             let data = s1.get_data();
             let key = SnapKey::from_snap(&s1).unwrap();
-            let mgr = SnapManager::new(snap_dir.path().to_str().unwrap(), None);
+            let mgr = SnapManager::<RocksEngine>::new(snap_dir.path().to_str().unwrap(), None);
             let mut s2 = mgr.get_snapshot_for_sending(&key).unwrap();
             let mut s3 = mgr.get_snapshot_for_receiving(&key, &data[..]).unwrap();
             io::copy(&mut s2, &mut s3).unwrap();
diff --git a/components/raftstore/src/store/worker/split_check.rs b/components/raftstore/src/store/worker/split_check.rs
index 998e6ffec56..acf961d0419 100644
--- a/components/raftstore/src/store/worker/split_check.rs
+++ b/components/raftstore/src/store/worker/split_check.rs
@@ -5,8 +5,8 @@ use std::collections::BinaryHeap;
 use std::fmt::{self, Display, Formatter};
 use std::mem;
 
-use engine_rocks::{RocksEngine, RocksEngineIterator};
-use engine_traits::{CfName, IterOptions, Iterable, Iterator, CF_WRITE, LARGE_CFS};
+use engine_rocks::RocksEngine;
+use engine_traits::{CfName, IterOptions, Iterable, Iterator, KvEngine, CF_WRITE, LARGE_CFS};
 use kvproto::metapb::Region;
 use kvproto::metapb::RegionEpoch;
 use kvproto::pdpb::CheckPolicy;
@@ -66,19 +66,22 @@ impl Ord for KeyEntry {
     }
 }
 
-struct MergedIterator {
-    iters: Vec<(CfName, RocksEngineIterator)>,
+struct MergedIterator<I> {
+    iters: Vec<(CfName, I)>,
     heap: BinaryHeap<KeyEntry>,
 }
 
-impl MergedIterator {
-    fn new(
-        db: &RocksEngine,
+impl<I> MergedIterator<I>
+where
+    I: Iterator,
+{
+    fn new<E: KvEngine>(
+        db: &E,
         cfs: &[CfName],
         start_key: &[u8],
         end_key: &[u8],
         fill_cache: bool,
-    ) -> Result<MergedIterator> {
+    ) -> Result<MergedIterator<E::Iterator>> {
         let mut iters = Vec::with_capacity(cfs.len());
         let mut heap = BinaryHeap::with_capacity(cfs.len());
         for (pos, cf) in cfs.iter().enumerate() {
@@ -162,7 +165,7 @@ impl Display for Task {
 pub struct Runner<S> {
     engine: RocksEngine,
     router: S,
-    coprocessor: CoprocessorHost,
+    coprocessor: CoprocessorHost<RocksEngine>,
     cfg: Config,
 }
 
@@ -170,7 +173,7 @@ impl<S: CasualRouter<RocksEngine>> Runner<S> {
     pub fn new(
         engine: RocksEngine,
         router: S,
-        coprocessor: CoprocessorHost,
+        coprocessor: CoprocessorHost<RocksEngine>,
         cfg: Config,
     ) -> Runner<S> {
         Runner {
@@ -267,35 +270,40 @@ impl<S: CasualRouter<RocksEngine>> Runner<S> {
         end_key: &[u8],
     ) -> Result<Vec<Vec<u8>>> {
         let timer = CHECK_SPILT_HISTOGRAM.start_coarse_timer();
-        MergedIterator::new(&self.engine, LARGE_CFS, start_key, end_key, false).map(
-            |mut iter| {
-                let mut size = 0;
-                let mut keys = 0;
-                while let Some(e) = iter.next() {
-                    if host.on_kv(region, &e) {
-                        return;
-                    }
-                    size += e.entry_size() as u64;
-                    keys += 1;
+        MergedIterator::<<RocksEngine as Iterable>::Iterator>::new(
+            &self.engine,
+            LARGE_CFS,
+            start_key,
+            end_key,
+            false,
+        )
+        .map(|mut iter| {
+            let mut size = 0;
+            let mut keys = 0;
+            while let Some(e) = iter.next() {
+                if host.on_kv(region, &e) {
+                    return;
                 }
+                size += e.entry_size() as u64;
+                keys += 1;
+            }
 
-                // if we scan the whole range, we can update approximate size and keys with accurate value.
-                info!(
-                    "update approximate size and keys with accurate value";
-                    "region_id" => region.get_id(),
-                    "size" => size,
-                    "keys" => keys,
-                );
-                let _ = self.router.send(
-                    region.get_id(),
-                    CasualMessage::RegionApproximateSize { size },
-                );
-                let _ = self.router.send(
-                    region.get_id(),
-                    CasualMessage::RegionApproximateKeys { keys },
-                );
-            },
-        )?;
+            // if we scan the whole range, we can update approximate size and keys with accurate value.
+            info!(
+                "update approximate size and keys with accurate value";
+                "region_id" => region.get_id(),
+                "size" => size,
+                "keys" => keys,
+            );
+            let _ = self.router.send(
+                region.get_id(),
+                CasualMessage::RegionApproximateSize { size },
+            );
+            let _ = self.router.send(
+                region.get_id(),
+                CasualMessage::RegionApproximateKeys { keys },
+            );
+        })?;
         timer.observe_duration();
 
         Ok(host.split_keys())
diff --git a/components/test_raftstore/src/node.rs b/components/test_raftstore/src/node.rs
index 022470efe47..b46bc14b812 100644
--- a/components/test_raftstore/src/node.rs
+++ b/components/test_raftstore/src/node.rs
@@ -32,8 +32,8 @@ use tikv_util::config::VersionTrack;
 use tikv_util::worker::{FutureWorker, Worker};
 
 pub struct ChannelTransportCore {
-    snap_paths: HashMap<u64, (SnapManager, TempDir)>,
-    routers: HashMap<u64, SimulateTransport<ServerRaftStoreRouter>>,
+    snap_paths: HashMap<u64, (SnapManager<RocksEngine>, TempDir)>,
+    routers: HashMap<u64, SimulateTransport<ServerRaftStoreRouter<RocksEngine>>>,
 }
 
 #[derive(Clone)]
@@ -121,7 +121,8 @@ pub struct NodeCluster {
     pd_client: Arc<TestPdClient>,
     nodes: HashMap<u64, Node<TestPdClient>>,
     simulate_trans: HashMap<u64, SimulateChannelTransport>,
-    post_create_coprocessor_host: Option<Box<dyn Fn(u64, &mut CoprocessorHost)>>,
+    #[allow(clippy::type_complexity)]
+    post_create_coprocessor_host: Option<Box<dyn Fn(u64, &mut CoprocessorHost<RocksEngine>)>>,
 }
 
 impl NodeCluster {
@@ -138,7 +139,10 @@ impl NodeCluster {
 
 impl NodeCluster {
     #[allow(dead_code)]
-    pub fn get_node_router(&self, node_id: u64) -> SimulateTransport<ServerRaftStoreRouter> {
+    pub fn get_node_router(
+        &self,
+        node_id: u64,
+    ) -> SimulateTransport<ServerRaftStoreRouter<RocksEngine>> {
         self.trans
             .core
             .lock()
@@ -152,7 +156,11 @@ impl NodeCluster {
     // Set a function that will be invoked after creating each CoprocessorHost. The first argument
     // of `op` is the node_id.
     // Set this before invoking `run_node`.
-    pub fn post_create_coprocessor_host(&mut self, op: Box<dyn Fn(u64, &mut CoprocessorHost)>) {
+    #[allow(clippy::type_complexity)]
+    pub fn post_create_coprocessor_host(
+        &mut self,
+        op: Box<dyn Fn(u64, &mut CoprocessorHost<RocksEngine>)>,
+    ) {
         self.post_create_coprocessor_host = Some(op)
     }
 
diff --git a/components/test_raftstore/src/router.rs b/components/test_raftstore/src/router.rs
index 07e3b0418aa..0a7abc1f774 100644
--- a/components/test_raftstore/src/router.rs
+++ b/components/test_raftstore/src/router.rs
@@ -29,7 +29,7 @@ impl MockRaftStoreRouter {
     }
 }
 
-impl RaftStoreRouter for MockRaftStoreRouter {
+impl RaftStoreRouter<RocksEngine> for MockRaftStoreRouter {
     fn significant_send(&self, region_id: u64, msg: SignificantMsg) -> RaftStoreResult<()> {
         let mut senders = self.senders.lock().unwrap();
         if let Some(tx) = senders.get_mut(&region_id) {
diff --git a/components/test_raftstore/src/server.rs b/components/test_raftstore/src/server.rs
index cb8a2103208..b9600cce80f 100644
--- a/components/test_raftstore/src/server.rs
+++ b/components/test_raftstore/src/server.rs
@@ -45,7 +45,7 @@ use tikv_util::config::VersionTrack;
 use tikv_util::security::SecurityManager;
 use tikv_util::worker::{FutureWorker, Worker};
 
-type SimulateStoreTransport = SimulateTransport<ServerRaftStoreRouter>;
+type SimulateStoreTransport = SimulateTransport<ServerRaftStoreRouter<RocksEngine>>;
 type SimulateServerTransport =
     SimulateTransport<ServerTransport<SimulateStoreTransport, PdStoreAddrResolver>>;
 
@@ -62,7 +62,7 @@ struct ServerMeta {
 }
 
 type PendingServices = Vec<Box<dyn Fn() -> Service>>;
-type CopHooks = Vec<Box<dyn Fn(&mut CoprocessorHost)>>;
+type CopHooks = Vec<Box<dyn Fn(&mut CoprocessorHost<RocksEngine>)>>;
 
 pub struct ServerCluster {
     metas: HashMap<u64, ServerMeta>,
diff --git a/components/test_raftstore/src/transport_simulate.rs b/components/test_raftstore/src/transport_simulate.rs
index 28e403165ba..d3a39e9cb11 100644
--- a/components/test_raftstore/src/transport_simulate.rs
+++ b/components/test_raftstore/src/transport_simulate.rs
@@ -188,7 +188,7 @@ impl<C: Transport> Transport for SimulateTransport<C> {
     }
 }
 
-impl<C: RaftStoreRouter> RaftStoreRouter for SimulateTransport<C> {
+impl<C: RaftStoreRouter<RocksEngine>> RaftStoreRouter<RocksEngine> for SimulateTransport<C> {
     fn send_raft_msg(&self, msg: RaftMessage) -> Result<()> {
         filter_send(&self.filters, msg, |m| self.ch.send_raft_msg(m))
     }
diff --git a/src/config.rs b/src/config.rs
index 8677bd247e8..f234d784afe 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -2476,7 +2476,7 @@ impl ConfigHandler {
     pub fn start(
         id: String,
         mut controller: ConfigController,
-        scheduler: FutureScheduler<PdTask>,
+        scheduler: FutureScheduler<PdTask<RocksEngine>>,
     ) -> CfgResult<Self> {
         if controller.get_current().enable_dynamic_config {
             if let Err(e) = scheduler.schedule(PdTask::RefreshConfig) {
diff --git a/src/import/sst_service.rs b/src/import/sst_service.rs
index 5af2c8ff758..dc73fb43363 100644
--- a/src/import/sst_service.rs
+++ b/src/import/sst_service.rs
@@ -43,7 +43,7 @@ pub struct ImportSSTService<Router> {
     security_mgr: Arc<SecurityManager>,
 }
 
-impl<Router: RaftStoreRouter> ImportSSTService<Router> {
+impl<Router: RaftStoreRouter<RocksEngine>> ImportSSTService<Router> {
     pub fn new(
         cfg: Config,
         router: Router,
@@ -68,7 +68,7 @@ impl<Router: RaftStoreRouter> ImportSSTService<Router> {
     }
 }
 
-impl<Router: RaftStoreRouter> ImportSst for ImportSSTService<Router> {
+impl<Router: RaftStoreRouter<RocksEngine>> ImportSst for ImportSSTService<Router> {
     fn switch_mode(
         &mut self,
         ctx: RpcContext<'_>,
diff --git a/src/server/debug.rs b/src/server/debug.rs
index 00e95a5e0d2..76dc71d20a0 100644
--- a/src/server/debug.rs
+++ b/src/server/debug.rs
@@ -15,7 +15,7 @@ use engine::rocks::{
 };
 use engine::IterOptionsExt;
 use engine::{self, Engines};
-use engine_rocks::{CloneCompat, Compat, RocksWriteBatch};
+use engine_rocks::{CloneCompat, Compat, RocksEngine, RocksWriteBatch};
 use engine_traits::{
     IterOptions, Iterable, Mutable, Peekable, TableProperties, TablePropertiesCollection,
     TablePropertiesExt, WriteBatch, WriteOptions,
@@ -509,7 +509,7 @@ impl Debugger {
                 })?;
 
             let tag = format!("[region {}] {}", region.get_id(), peer_id);
-            let peer_storage = box_try!(PeerStorage::new(
+            let peer_storage = box_try!(PeerStorage::<RocksEngine, RocksEngine>::new(
                 self.engines.c(),
                 region,
                 fake_snap_worker.scheduler(),
diff --git a/src/server/gc_worker/applied_lock_collector.rs b/src/server/gc_worker/applied_lock_collector.rs
index 0ee6b4f5808..838ed1a0816 100644
--- a/src/server/gc_worker/applied_lock_collector.rs
+++ b/src/server/gc_worker/applied_lock_collector.rs
@@ -6,6 +6,7 @@ use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use txn_types::Key;
 
+use engine_rocks::RocksEngine;
 use engine_traits::{CfName, CF_LOCK};
 use kvproto::kvrpcpb::LockInfo;
 use kvproto::raft_cmdpb::{CmdType, Request as RaftRequest};
@@ -97,7 +98,7 @@ impl LockObserver {
         Self { state, sender }
     }
 
-    pub fn register(self, coprocessor_host: &mut CoprocessorHost) {
+    pub fn register(self, coprocessor_host: &mut CoprocessorHost<RocksEngine>) {
         coprocessor_host
             .registry
             .register_apply_snapshot_observer(1, BoxApplySnapshotObserver::new(self.clone()));
@@ -355,7 +356,7 @@ pub struct AppliedLockCollector {
 }
 
 impl AppliedLockCollector {
-    pub fn new(coprocessor_host: &mut CoprocessorHost) -> Result<Self> {
+    pub fn new(coprocessor_host: &mut CoprocessorHost<RocksEngine>) -> Result<Self> {
         let worker = Mutex::new(WorkerBuilder::new("lock-collector").create());
 
         let scheduler = worker.lock().unwrap().scheduler();
@@ -480,7 +481,7 @@ mod tests {
         res
     }
 
-    fn new_test_collector() -> (AppliedLockCollector, CoprocessorHost) {
+    fn new_test_collector() -> (AppliedLockCollector, CoprocessorHost<RocksEngine>) {
         let mut coprocessor_host = CoprocessorHost::default();
         let collector = AppliedLockCollector::new(&mut coprocessor_host).unwrap();
         (collector, coprocessor_host)
diff --git a/src/server/gc_worker/gc_worker.rs b/src/server/gc_worker/gc_worker.rs
index 82b1f3e4a7c..9b580ec4488 100644
--- a/src/server/gc_worker/gc_worker.rs
+++ b/src/server/gc_worker/gc_worker.rs
@@ -137,7 +137,7 @@ impl Display for GcTask {
 struct GcRunner<E: Engine> {
     engine: E,
     local_storage: Option<RocksEngine>,
-    raft_store_router: Option<ServerRaftStoreRouter>,
+    raft_store_router: Option<ServerRaftStoreRouter<RocksEngine>>,
     region_info_accessor: Option<RegionInfoAccessor>,
 
     /// Used to limit the write flow of GC.
@@ -153,7 +153,7 @@ impl<E: Engine> GcRunner<E> {
     pub fn new(
         engine: E,
         local_storage: Option<RocksEngine>,
-        raft_store_router: Option<ServerRaftStoreRouter>,
+        raft_store_router: Option<ServerRaftStoreRouter<RocksEngine>>,
         cfg_tracker: Tracker<GcConfig>,
         region_info_accessor: Option<RegionInfoAccessor>,
         cfg: GcConfig,
@@ -658,7 +658,7 @@ pub struct GcWorker<E: Engine> {
     /// `local_storage` represent the underlying RocksDB of the `engine`.
     local_storage: Option<RocksEngine>,
     /// `raft_store_router` is useful to signal raftstore clean region size informations.
-    raft_store_router: Option<ServerRaftStoreRouter>,
+    raft_store_router: Option<ServerRaftStoreRouter<RocksEngine>>,
     /// Access the region's meta before getting snapshot, which will wake hibernating regions up.
     /// This is useful to do the `need_gc` check without waking hibernatin regions up.
     /// This is not set for tests.
@@ -721,7 +721,7 @@ impl<E: Engine> GcWorker<E> {
     pub fn new(
         engine: E,
         local_storage: Option<RocksEngine>,
-        raft_store_router: Option<ServerRaftStoreRouter>,
+        raft_store_router: Option<ServerRaftStoreRouter<RocksEngine>>,
         region_info_accessor: Option<RegionInfoAccessor>,
         cfg: GcConfig,
     ) -> GcWorker<E> {
@@ -771,7 +771,7 @@ impl<E: Engine> GcWorker<E> {
 
     pub fn start_observe_lock_apply(
         &mut self,
-        coprocessor_host: &mut CoprocessorHost,
+        coprocessor_host: &mut CoprocessorHost<RocksEngine>,
     ) -> Result<()> {
         assert!(self.applied_lock_collector.is_none());
         let collector = Arc::new(AppliedLockCollector::new(coprocessor_host)?);
diff --git a/src/server/lock_manager/deadlock.rs b/src/server/lock_manager/deadlock.rs
index ce9fba54bab..46fb82bee7f 100644
--- a/src/server/lock_manager/deadlock.rs
+++ b/src/server/lock_manager/deadlock.rs
@@ -7,6 +7,7 @@ use super::waiter_manager::Scheduler as WaiterMgrScheduler;
 use super::{Error, Result};
 use crate::server::resolve::StoreAddrResolver;
 use crate::storage::lock_manager::Lock;
+use engine_rocks::RocksEngine;
 use futures::{Future, Sink, Stream};
 use grpcio::{
     self, DuplexSink, Environment, RequestStream, RpcContext, RpcStatus, RpcStatusCode, UnarySink,
@@ -398,7 +399,7 @@ impl RoleChangeNotifier {
         }
     }
 
-    pub(crate) fn register(self, host: &mut CoprocessorHost) {
+    pub(crate) fn register(self, host: &mut CoprocessorHost<RocksEngine>) {
         host.registry
             .register_role_observer(1, BoxRoleObserver::new(self.clone()));
         host.registry
@@ -1085,7 +1086,9 @@ pub mod tests {
         }
     }
 
-    fn start_deadlock_detector(host: &mut CoprocessorHost) -> (FutureWorker<Task>, Scheduler) {
+    fn start_deadlock_detector(
+        host: &mut CoprocessorHost<RocksEngine>,
+    ) -> (FutureWorker<Task>, Scheduler) {
         let waiter_mgr_worker = FutureWorker::new("dummy-waiter-mgr");
         let waiter_mgr_scheduler = WaiterMgrScheduler::new(waiter_mgr_worker.scheduler());
         let mut detector_worker = FutureWorker::new("test-deadlock-detector");
diff --git a/src/server/lock_manager/mod.rs b/src/server/lock_manager/mod.rs
index 73cc26fc643..087e5918789 100644
--- a/src/server/lock_manager/mod.rs
+++ b/src/server/lock_manager/mod.rs
@@ -26,6 +26,7 @@ use crate::storage::{
 };
 use raftstore::coprocessor::CoprocessorHost;
 
+use engine_rocks::RocksEngine;
 use parking_lot::Mutex;
 use pd_client::PdClient;
 use tikv_util::collections::HashSet;
@@ -182,7 +183,7 @@ impl LockManager {
 
     /// Creates a `RoleChangeNotifier` of the deadlock detector worker and registers it to
     /// the `CoprocessorHost` to observe the role change events of the leader region.
-    pub fn register_detector_role_change_observer(&self, host: &mut CoprocessorHost) {
+    pub fn register_detector_role_change_observer(&self, host: &mut CoprocessorHost<RocksEngine>) {
         let role_change_notifier = RoleChangeNotifier::new(self.detector_scheduler.clone());
         role_change_notifier.register(host);
     }
diff --git a/src/server/node.rs b/src/server/node.rs
index 37b50d96452..3564881fd9d 100644
--- a/src/server/node.rs
+++ b/src/server/node.rs
@@ -41,7 +41,7 @@ pub fn create_raft_storage<S>(
     pipelined_pessimistic_lock: bool,
 ) -> Result<Storage<RaftKv<S>, LockManager>>
 where
-    S: RaftStoreRouter + 'static,
+    S: RaftStoreRouter<RocksEngine> + 'static,
 {
     let store = Storage::from_engine(engine, cfg, read_pool, lock_mgr, pipelined_pessimistic_lock)?;
     Ok(store)
@@ -118,10 +118,10 @@ where
         &mut self,
         engines: Engines,
         trans: T,
-        snap_mgr: SnapManager,
-        pd_worker: FutureWorker<PdTask>,
+        snap_mgr: SnapManager<RocksEngine>,
+        pd_worker: FutureWorker<PdTask<RocksEngine>>,
         store_meta: Arc<Mutex<StoreMeta>>,
-        coprocessor_host: CoprocessorHost,
+        coprocessor_host: CoprocessorHost<RocksEngine>,
         importer: Arc<SSTImporter>,
         split_check_worker: Worker<SplitCheckTask>,
         dyn_cfg: Box<dyn DynamicConfig>,
@@ -334,10 +334,10 @@ where
         store_id: u64,
         engines: Engines,
         trans: T,
-        snap_mgr: SnapManager,
-        pd_worker: FutureWorker<PdTask>,
+        snap_mgr: SnapManager<RocksEngine>,
+        pd_worker: FutureWorker<PdTask<RocksEngine>>,
         store_meta: Arc<Mutex<StoreMeta>>,
-        coprocessor_host: CoprocessorHost,
+        coprocessor_host: CoprocessorHost<RocksEngine>,
         importer: Arc<SSTImporter>,
         split_check_worker: Worker<SplitCheckTask>,
         dyn_cfg: Box<dyn DynamicConfig>,
diff --git a/src/server/raft_client.rs b/src/server/raft_client.rs
index 20d4300929d..848fff260d2 100644
--- a/src/server/raft_client.rs
+++ b/src/server/raft_client.rs
@@ -10,6 +10,7 @@ use super::load_statistics::ThreadLoad;
 use super::metrics::*;
 use super::{Config, Result};
 use crossbeam::channel::SendError;
+use engine_rocks::RocksEngine;
 use futures::{future, stream, Future, Poll, Sink, Stream};
 use grpcio::{
     ChannelBuilder, Environment, Error as GrpcError, RpcStatus, RpcStatusCode, WriteFlags,
@@ -40,7 +41,7 @@ struct Conn {
 }
 
 impl Conn {
-    fn new<T: RaftStoreRouter + 'static>(
+    fn new<T: RaftStoreRouter<RocksEngine> + 'static>(
         env: Arc<Environment>,
         router: T,
         addr: &str,
@@ -150,7 +151,7 @@ pub struct RaftClient<T: 'static> {
     timer: Handle,
 }
 
-impl<T: RaftStoreRouter> RaftClient<T> {
+impl<T: RaftStoreRouter<RocksEngine>> RaftClient<T> {
     pub fn new(
         env: Arc<Environment>,
         cfg: Arc<Config>,
diff --git a/src/server/raftkv.rs b/src/server/raftkv.rs
index 27225d2d0cd..17c41ac17fd 100644
--- a/src/server/raftkv.rs
+++ b/src/server/raftkv.rs
@@ -105,7 +105,7 @@ impl From<RaftServerError> for KvError {
 
 /// `RaftKv` is a storage engine base on `RaftStore`.
 #[derive(Clone)]
-pub struct RaftKv<S: RaftStoreRouter + 'static> {
+pub struct RaftKv<S: RaftStoreRouter<RocksEngine> + 'static> {
     router: S,
     engine: RocksEngine,
 }
@@ -161,7 +161,7 @@ fn on_read_result(
     }
 }
 
-impl<S: RaftStoreRouter> RaftKv<S> {
+impl<S: RaftStoreRouter<RocksEngine>> RaftKv<S> {
     /// Create a RaftKv using specified configuration.
     pub fn new(router: S, engine: RocksEngine) -> RaftKv<S> {
         RaftKv { router, engine }
@@ -256,19 +256,19 @@ fn invalid_resp_type(exp: CmdType, act: CmdType) -> Error {
     ))
 }
 
-impl<S: RaftStoreRouter> Display for RaftKv<S> {
+impl<S: RaftStoreRouter<RocksEngine>> Display for RaftKv<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "RaftKv")
     }
 }
 
-impl<S: RaftStoreRouter> Debug for RaftKv<S> {
+impl<S: RaftStoreRouter<RocksEngine>> Debug for RaftKv<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(f, "RaftKv")
     }
 }
 
-impl<S: RaftStoreRouter> Engine for RaftKv<S> {
+impl<S: RaftStoreRouter<RocksEngine>> Engine for RaftKv<S> {
     type Snap = RegionSnapshot<RocksEngine>;
 
     fn async_write(
diff --git a/src/server/server.rs b/src/server/server.rs
index 324a12728a1..985088967c1 100644
--- a/src/server/server.rs
+++ b/src/server/server.rs
@@ -18,6 +18,7 @@ use crate::coprocessor::Endpoint;
 use crate::server::gc_worker::GcWorker;
 use crate::storage::lock_manager::LockManager;
 use crate::storage::{Engine, Storage};
+use engine_rocks::RocksEngine;
 use raftstore::router::RaftStoreRouter;
 use raftstore::store::SnapManager;
 use tikv_util::security::SecurityManager;
@@ -44,7 +45,7 @@ pub const STATS_THREAD_PREFIX: &str = "transport-stats";
 ///
 /// It hosts various internal components, including gRPC, the raftstore router
 /// and a snapshot worker.
-pub struct Server<T: RaftStoreRouter + 'static, S: StoreAddrResolver + 'static> {
+pub struct Server<T: RaftStoreRouter<RocksEngine> + 'static, S: StoreAddrResolver + 'static> {
     env: Arc<Environment>,
     /// A GrpcServer builder or a GrpcServer.
     ///
@@ -55,7 +56,7 @@ pub struct Server<T: RaftStoreRouter + 'static, S: StoreAddrResolver + 'static>
     trans: ServerTransport<T, S>,
     raft_router: T,
     // For sending/receiving snapshots.
-    snap_mgr: SnapManager,
+    snap_mgr: SnapManager<RocksEngine>,
     snap_worker: Worker<SnapTask>,
 
     // Currently load statistics is done in the thread.
@@ -66,7 +67,7 @@ pub struct Server<T: RaftStoreRouter + 'static, S: StoreAddrResolver + 'static>
     timer: Handle,
 }
 
-impl<T: RaftStoreRouter, S: StoreAddrResolver + 'static> Server<T, S> {
+impl<T: RaftStoreRouter<RocksEngine>, S: StoreAddrResolver + 'static> Server<T, S> {
     #[allow(clippy::too_many_arguments)]
     pub fn new<E: Engine, L: LockManager>(
         cfg: &Arc<Config>,
@@ -75,7 +76,7 @@ impl<T: RaftStoreRouter, S: StoreAddrResolver + 'static> Server<T, S> {
         cop: Endpoint<E>,
         raft_router: T,
         resolver: S,
-        snap_mgr: SnapManager,
+        snap_mgr: SnapManager<RocksEngine>,
         gc_worker: GcWorker<E>,
         yatp_read_pool: Option<ReadPool>,
     ) -> Result<Self> {
@@ -319,7 +320,7 @@ mod tests {
         significant_msg_sender: Sender<SignificantMsg>,
     }
 
-    impl RaftStoreRouter for TestRaftStoreRouter {
+    impl RaftStoreRouter<RocksEngine> for TestRaftStoreRouter {
         fn send_raft_msg(&self, _: RaftMessage) -> RaftStoreResult<()> {
             self.tx.send(1).unwrap();
             Ok(())
diff --git a/src/server/service/debug.rs b/src/server/service/debug.rs
index e2773ddb36a..f02d05b72c6 100644
--- a/src/server/service/debug.rs
+++ b/src/server/service/debug.rs
@@ -4,6 +4,7 @@ use std::sync::Arc;
 
 use engine::rocks::util::stats as rocksdb_stats;
 use engine::Engines;
+use engine_rocks::RocksEngine;
 use fail;
 use futures::{future, stream, Future, Stream};
 use futures_cpupool::CpuPool;
@@ -47,7 +48,7 @@ fn error_to_grpc_error(tag: &'static str, e: Error) -> GrpcError {
 
 /// Service handles the RPC messages for the `Debug` service.
 #[derive(Clone)]
-pub struct Service<T: RaftStoreRouter> {
+pub struct Service<T: RaftStoreRouter<RocksEngine>> {
     pool: CpuPool,
     debugger: Debugger,
     raft_router: T,
@@ -55,7 +56,7 @@ pub struct Service<T: RaftStoreRouter> {
     security_mgr: Arc<SecurityManager>,
 }
 
-impl<T: RaftStoreRouter> Service<T> {
+impl<T: RaftStoreRouter<RocksEngine>> Service<T> {
     /// Constructs a new `Service` with `Engines`, a `RaftStoreRouter` and a `GcWorker`.
     pub fn new(
         engines: Engines,
@@ -93,7 +94,7 @@ impl<T: RaftStoreRouter> Service<T> {
     }
 }
 
-impl<T: RaftStoreRouter + 'static> debugpb::Debug for Service<T> {
+impl<T: RaftStoreRouter<RocksEngine> + 'static> debugpb::Debug for Service<T> {
     fn get(&mut self, ctx: RpcContext<'_>, mut req: GetRequest, sink: UnarySink<GetResponse>) {
         if !check_common_name(self.security_mgr.cert_allowed_cn(), &ctx) {
             return;
@@ -517,7 +518,7 @@ impl<T: RaftStoreRouter + 'static> debugpb::Debug for Service<T> {
     }
 }
 
-fn region_detail<T: RaftStoreRouter>(
+fn region_detail<T: RaftStoreRouter<RocksEngine>>(
     raft_router: T,
     region_id: u64,
     store_id: u64,
@@ -555,7 +556,7 @@ fn region_detail<T: RaftStoreRouter>(
         })
 }
 
-fn consistency_check<T: RaftStoreRouter>(
+fn consistency_check<T: RaftStoreRouter<RocksEngine>>(
     raft_router: T,
     mut detail: RegionDetailResponse,
 ) -> impl Future<Item = (), Error = Error> {
diff --git a/src/server/service/kv.rs b/src/server/service/kv.rs
index 10bfa46388e..def87678c76 100644
--- a/src/server/service/kv.rs
+++ b/src/server/service/kv.rs
@@ -21,6 +21,7 @@ use crate::storage::{
     lock_manager::LockManager,
     PointGetCommand, Storage, TxnStatus,
 };
+use engine_rocks::RocksEngine;
 use futures::executor::{self, Notify, Spawn};
 use futures::{future, Async, Future, Sink, Stream};
 use grpcio::{
@@ -47,7 +48,7 @@ const GRPC_MSG_NOTIFY_SIZE: usize = 8;
 
 /// Service handles the RPC messages for the `Tikv` service.
 #[derive(Clone)]
-pub struct Service<T: RaftStoreRouter + 'static, E: Engine, L: LockManager> {
+pub struct Service<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> {
     /// Used to handle requests related to GC.
     gc_worker: GcWorker<E>,
     // For handling KV requests.
@@ -72,7 +73,7 @@ pub struct Service<T: RaftStoreRouter + 'static, E: Engine, L: LockManager> {
     security_mgr: Arc<SecurityManager>,
 }
 
-impl<T: RaftStoreRouter + 'static, E: Engine, L: LockManager> Service<T, E, L> {
+impl<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> Service<T, E, L> {
     /// Constructs a new `Service` which provides the `Tikv` service.
     pub fn new(
         storage: Storage<E, L>,
@@ -142,7 +143,9 @@ macro_rules! handle_request {
     }
 }
 
-impl<T: RaftStoreRouter + 'static, E: Engine, L: LockManager> Tikv for Service<T, E, L> {
+impl<T: RaftStoreRouter<RocksEngine> + 'static, E: Engine, L: LockManager> Tikv
+    for Service<T, E, L>
+{
     handle_request!(kv_get, future_get, GetRequest, GetResponse);
     handle_request!(kv_scan, future_scan, ScanRequest, ScanResponse);
     handle_request!(
diff --git a/src/server/snap.rs b/src/server/snap.rs
index e617f8bc314..7e81d9f4bc1 100644
--- a/src/server/snap.rs
+++ b/src/server/snap.rs
@@ -15,6 +15,7 @@ use kvproto::raft_serverpb::RaftMessage;
 use kvproto::raft_serverpb::{Done, SnapshotChunk};
 use kvproto::tikvpb::TikvClient;
 
+use engine_rocks::RocksEngine;
 use raftstore::router::RaftStoreRouter;
 use raftstore::store::{GenericSnapshot, SnapEntry, SnapKey, SnapManager};
 use tikv_util::security::SecurityManager;
@@ -102,7 +103,7 @@ struct SendStat {
 /// It will first send the normal raft snapshot message and then send the snapshot file.
 fn send_snap(
     env: Arc<Environment>,
-    mgr: SnapManager,
+    mgr: SnapManager<RocksEngine>,
     security_mgr: Arc<SecurityManager>,
     cfg: &Config,
     addr: &str,
@@ -181,7 +182,7 @@ struct RecvSnapContext {
 }
 
 impl RecvSnapContext {
-    fn new(head_chunk: Option<SnapshotChunk>, snap_mgr: &SnapManager) -> Result<Self> {
+    fn new(head_chunk: Option<SnapshotChunk>, snap_mgr: &SnapManager<RocksEngine>) -> Result<Self> {
         // head_chunk is None means the stream is empty.
         let mut head = head_chunk.ok_or_else(|| Error::Other("empty gRPC stream".into()))?;
         if !head.has_message() {
@@ -217,7 +218,7 @@ impl RecvSnapContext {
         })
     }
 
-    fn finish<R: RaftStoreRouter>(self, raft_router: R) -> Result<()> {
+    fn finish<R: RaftStoreRouter<RocksEngine>>(self, raft_router: R) -> Result<()> {
         let key = self.key;
         if let Some(mut file) = self.file {
             info!("saving snapshot file"; "snap_key" => %key, "file" => file.path());
@@ -234,10 +235,10 @@ impl RecvSnapContext {
     }
 }
 
-fn recv_snap<R: RaftStoreRouter + 'static>(
+fn recv_snap<R: RaftStoreRouter<RocksEngine> + 'static>(
     stream: RequestStream<SnapshotChunk>,
     sink: ClientStreamingSink<Done>,
-    snap_mgr: SnapManager,
+    snap_mgr: SnapManager<RocksEngine>,
     raft_router: R,
 ) -> impl Future<Item = (), Error = Error> {
     let stream = stream.map_err(Error::from);
@@ -290,9 +291,9 @@ fn recv_snap<R: RaftStoreRouter + 'static>(
     .map_err(Error::from)
 }
 
-pub struct Runner<R: RaftStoreRouter + 'static> {
+pub struct Runner<R: RaftStoreRouter<RocksEngine> + 'static> {
     env: Arc<Environment>,
-    snap_mgr: SnapManager,
+    snap_mgr: SnapManager<RocksEngine>,
     pool: CpuPool,
     raft_router: R,
     security_mgr: Arc<SecurityManager>,
@@ -301,10 +302,10 @@ pub struct Runner<R: RaftStoreRouter + 'static> {
     recving_count: Arc<AtomicUsize>,
 }
 
-impl<R: RaftStoreRouter + 'static> Runner<R> {
+impl<R: RaftStoreRouter<RocksEngine> + 'static> Runner<R> {
     pub fn new(
         env: Arc<Environment>,
-        snap_mgr: SnapManager,
+        snap_mgr: SnapManager<RocksEngine>,
         r: R,
         security_mgr: Arc<SecurityManager>,
         cfg: Arc<Config>,
@@ -325,7 +326,7 @@ impl<R: RaftStoreRouter + 'static> Runner<R> {
     }
 }
 
-impl<R: RaftStoreRouter + 'static> Runnable<Task> for Runner<R> {
+impl<R: RaftStoreRouter<RocksEngine> + 'static> Runnable<Task> for Runner<R> {
     fn run(&mut self, task: Task) {
         match task {
             Task::Recv { stream, sink } => {
diff --git a/src/server/status_server.rs b/src/server/status_server.rs
index 82ef32b77a3..6fb5e0af6f5 100644
--- a/src/server/status_server.rs
+++ b/src/server/status_server.rs
@@ -26,6 +26,7 @@ use std::sync::Arc;
 
 use super::Result;
 use crate::config::TiKvConfig;
+use engine_rocks::RocksEngine;
 use raftstore::store::PdTask;
 use tikv_alloc::error::ProfError;
 use tikv_util::collections::HashMap;
@@ -88,11 +89,14 @@ pub struct StatusServer {
     tx: Sender<()>,
     rx: Option<Receiver<()>>,
     addr: Option<SocketAddr>,
-    pd_sender: Arc<FutureScheduler<PdTask>>,
+    pd_sender: Arc<FutureScheduler<PdTask<RocksEngine>>>,
 }
 
 impl StatusServer {
-    pub fn new(status_thread_pool_size: usize, pd_sender: FutureScheduler<PdTask>) -> Self {
+    pub fn new(
+        status_thread_pool_size: usize,
+        pd_sender: FutureScheduler<PdTask<RocksEngine>>,
+    ) -> Self {
         let thread_pool = Builder::new()
             .pool_size(status_thread_pool_size)
             .name_prefix("status-server-")
@@ -215,7 +219,7 @@ impl StatusServer {
     }
 
     fn config_handler(
-        pd_sender: &FutureScheduler<PdTask>,
+        pd_sender: &FutureScheduler<PdTask<RocksEngine>>,
     ) -> Box<dyn Future<Item = Response<Body>, Error = hyper::Error> + Send> {
         let (cfg_sender, rx) = oneshot::channel();
         if pd_sender
@@ -618,6 +622,7 @@ mod tests {
 
     use crate::config::TiKvConfig;
     use crate::server::status_server::StatusServer;
+    use engine_rocks::RocksEngine;
     use raftstore::store::PdTask;
     use test_util::new_security_cfg;
     use tikv_util::collections::HashSet;
@@ -672,8 +677,8 @@ mod tests {
     #[test]
     fn test_config_endpoint() {
         struct Runner;
-        impl FutureRunnable<PdTask> for Runner {
-            fn run(&mut self, t: PdTask, _: &Handle) {
+        impl FutureRunnable<PdTask<RocksEngine>> for Runner {
+            fn run(&mut self, t: PdTask<RocksEngine>, _: &Handle) {
                 match t {
                     PdTask::GetConfig { cfg_sender } => cfg_sender.send(String::new()).unwrap(),
                     _ => unreachable!(),
diff --git a/src/server/transport.rs b/src/server/transport.rs
index 5e3f7b44072..bde129635fd 100644
--- a/src/server/transport.rs
+++ b/src/server/transport.rs
@@ -9,6 +9,7 @@ use crate::server::raft_client::RaftClient;
 use crate::server::resolve::StoreAddrResolver;
 use crate::server::snap::Task as SnapTask;
 use crate::server::Result;
+use engine_rocks::RocksEngine;
 use raft::SnapshotStatus;
 use raftstore::router::RaftStoreRouter;
 use raftstore::store::Transport;
@@ -19,7 +20,7 @@ use tikv_util::HandyRwLock;
 
 pub struct ServerTransport<T, S>
 where
-    T: RaftStoreRouter + 'static,
+    T: RaftStoreRouter<RocksEngine> + 'static,
     S: StoreAddrResolver + 'static,
 {
     raft_client: Arc<RwLock<RaftClient<T>>>,
@@ -31,7 +32,7 @@ where
 
 impl<T, S> Clone for ServerTransport<T, S>
 where
-    T: RaftStoreRouter + 'static,
+    T: RaftStoreRouter<RocksEngine> + 'static,
     S: StoreAddrResolver + 'static,
 {
     fn clone(&self) -> Self {
@@ -45,7 +46,9 @@ where
     }
 }
 
-impl<T: RaftStoreRouter + 'static, S: StoreAddrResolver + 'static> ServerTransport<T, S> {
+impl<T: RaftStoreRouter<RocksEngine> + 'static, S: StoreAddrResolver + 'static>
+    ServerTransport<T, S>
+{
     pub fn new(
         raft_client: Arc<RwLock<RaftClient<T>>>,
         snap_scheduler: Scheduler<SnapTask>,
@@ -228,7 +231,7 @@ impl<T: RaftStoreRouter + 'static, S: StoreAddrResolver + 'static> ServerTranspo
 
 impl<T, S> Transport for ServerTransport<T, S>
 where
-    T: RaftStoreRouter + 'static,
+    T: RaftStoreRouter<RocksEngine> + 'static,
     S: StoreAddrResolver + 'static,
 {
     fn send(&mut self, msg: RaftMessage) -> RaftStoreResult<()> {
@@ -242,14 +245,14 @@ where
     }
 }
 
-struct SnapshotReporter<T: RaftStoreRouter + 'static> {
+struct SnapshotReporter<T: RaftStoreRouter<RocksEngine> + 'static> {
     raft_router: T,
     region_id: u64,
     to_peer_id: u64,
     to_store_id: u64,
 }
 
-impl<T: RaftStoreRouter + 'static> SnapshotReporter<T> {
+impl<T: RaftStoreRouter<RocksEngine> + 'static> SnapshotReporter<T> {
     pub fn report(&self, status: SnapshotStatus) {
         debug!(
             "send snapshot";
diff --git a/tests/benches/misc/raftkv/mod.rs b/tests/benches/misc/raftkv/mod.rs
index 63178978121..36634163181 100644
--- a/tests/benches/misc/raftkv/mod.rs
+++ b/tests/benches/misc/raftkv/mod.rs
@@ -64,7 +64,7 @@ impl SyncBenchRouter {
     }
 }
 
-impl RaftStoreRouter for SyncBenchRouter {
+impl RaftStoreRouter<RocksEngine> for SyncBenchRouter {
     fn send_raft_msg(&self, _: RaftMessage) -> Result<()> {
         Ok(())
     }