Region properties middle key

src/raftstore/store/util.rs

@@ -11,6 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::collections::Bound::Excluded;
 use std::option::Option;
 use std::{fmt, u64};
 
@@ -326,6 +327,37 @@ pub fn get_region_approximate_size_cf(
     Ok(size)
 }
 
+/// Get the approxmiate middle key of the region. The returned key maybe
+/// is timpstamped if transaction KV is used, and must start with "z".
+pub fn get_region_approximate_middle_cf(
+    db: &DB,
+    cfname: &str,
+    region: &metapb::Region,
+) -> Result<Option<Vec<u8>>> {
+    let cf = rocksdb_util::get_cf_handle(db, cfname)?;
+    let start = keys::enc_start_key(region);
+    let end = keys::enc_end_key(region);
+    let range = Range::new(&start, &end);
+    let collection = db.get_properties_of_tables_in_range(cf, &[range])?;
+
+    let mut keys = Vec::new();
+    for (_, v) in &*collection {
+        let props = SizeProperties::decode(v.user_collected_properties())?;
+        keys.extend(
+            props
+                .index_handles
+                .range::<[u8], _>((Excluded(start.as_slice()), Excluded(end.as_slice())))
+                .map(|(k, _)| k.to_owned()),
+        );
+    }
+    keys.sort();
+    if keys.is_empty() {
+        return Ok(None);
+    }
+    let middle = (keys.len() - 1) / 2;
+    Ok(Some(keys.swap_remove(middle)))
+}
+
 pub fn get_region_approximate_size(db: &DB, region: &metapb::Region) -> Result<u64> {
     let mut size = 0;
     for cfname in LARGE_CFS {
@@ -544,8 +576,7 @@ pub fn conf_state_from_region(region: &metapb::Region) -> ConfState {
 
 #[cfg(test)]
 mod tests {
-    use std::process;
-    use std::thread;
+    use std::{iter, process, thread};
 
     use kvproto::metapb::{self, RegionEpoch};
     use kvproto::raft_cmdpb::AdminRequest;
@@ -558,6 +589,7 @@ mod tests {
     use raftstore::store::peer_storage;
     use storage::mvcc::{Write, WriteType};
     use storage::{Key, ALL_CFS, CF_DEFAULT};
+    use util::escape;
     use util::properties::{MvccPropertiesCollectorFactory, SizePropertiesCollectorFactory};
     use util::rocksdb::{get_cf_handle, new_engine_opt, CFOptions};
     use util::time::{monotonic_now, monotonic_raw_now};
@@ -1174,4 +1206,42 @@ mod tests {
             check_region_epoch(&req, &region, true).unwrap_err();
         }
     }
+
+    #[test]
+    fn test_get_region_approximate_middle_cf() {
+        let tmp = TempDir::new("test_raftstore_util").unwrap();
+        let path = tmp.path().to_str().unwrap();
+
+        let db_opts = DBOptions::new();
+        let mut cf_opts = ColumnFamilyOptions::new();
+        cf_opts.set_level_zero_file_num_compaction_trigger(10);
+        let f = Box::new(SizePropertiesCollectorFactory::default());
+        cf_opts.add_table_properties_collector_factory("tikv.size-collector", f);
+        let cfs_opts = LARGE_CFS
+            .iter()
+            .map(|cf| CFOptions::new(cf, cf_opts.clone()))
+            .collect();
+        let engine = rocksdb_util::new_engine_opt(path, db_opts, cfs_opts).unwrap();
+
+        let cf_handle = engine.cf_handle(CF_DEFAULT).unwrap();
+        let mut big_value = Vec::with_capacity(256);
+        big_value.extend(iter::repeat(b'v').take(256));
+        for i in 0..100 {
+            let k = format!("key_{:03}", i).into_bytes();
+            let k = keys::data_key(Key::from_raw(&k).encoded());
+            engine.put_cf(cf_handle, &k, &big_value).unwrap();
+            // Flush for every key so that we can know the exact middle key.
+            engine.flush_cf(cf_handle, true).unwrap();
+        }
+
+        let region = make_region(1, vec![], vec![]);
+        let middle_key = get_region_approximate_middle_cf(&engine, CF_DEFAULT, &region)
+            .unwrap()
+            .unwrap();
+
+        let middle_key = Key::from_encoded(keys::origin_key(&middle_key).to_owned())
+            .raw()
+            .unwrap();
+        assert_eq!(escape(&middle_key), "key_049");
+    }
 }

src/server/debug.rs

@@ -18,11 +18,10 @@ use std::rc::Rc;
 use std::str::FromStr;
 use std::sync::Arc;
 use std::{error, result};
-use util::collections::HashSet;
 
 use protobuf::{self, Message, RepeatedField};
 
-use kvproto::debugpb::{DB as DBType, MODULE};
+use kvproto::debugpb::{DB as DBType, *};
 use kvproto::kvrpcpb::{MvccInfo, MvccLock, MvccValue, MvccWrite, Op};
 use kvproto::metapb::Region;
 use kvproto::raft_serverpb::*;
@@ -40,6 +39,8 @@ use raftstore::store::{keys, CacheQueryStats, Engines, Iterable, Peekable, PeerS
 use storage::mvcc::{Lock, LockType, Write, WriteType};
 use storage::types::{truncate_ts, Key};
 use storage::{CF_DEFAULT, CF_LOCK, CF_RAFT, CF_WRITE};
+use util::codec::bytes;
+use util::collections::HashSet;
 use util::config::ReadableSize;
 use util::escape;
 use util::properties::MvccProperties;
@@ -630,7 +631,33 @@ impl Debugger {
             mvcc_properties.add(&mvcc);
         }
 
-        let res = [
+        // Calculate region middle key based on default and write cf size.
+        // It's in encoded format, no timestamp padding and escaped to string.
+        let get_cf_size =
+            |cf: &str| raftstore_util::get_region_approximate_size_cf(db, cf, &region);
+
+        let default_cf_size = box_try!(get_cf_size(CF_DEFAULT));
+        let write_cf_size = box_try!(get_cf_size(CF_WRITE));
+
+        let middle_by_cf = if default_cf_size >= write_cf_size {
+            CF_DEFAULT
+        } else {
+            CF_WRITE
+        };
+
+        let middle_key = match box_try!(raftstore_util::get_region_approximate_middle_cf(
+            db,
+            middle_by_cf,
+            &region
+        )) {
+            Some(data_key) => {
+                let mut key = keys::origin_key(&data_key);
+                box_try!(bytes::decode_bytes(&mut key, false))
+            }
+            None => Vec::new(),
+        };
+
+        let mut res: Vec<(String, String)> = [
             ("num_files", collection.len() as u64),
             ("num_entries", num_entries),
             ("num_deletes", num_entries - mvcc_properties.num_versions),
@@ -643,6 +670,10 @@ impl Debugger {
         ].iter()
             .map(|(k, v)| (k.to_string(), v.to_string()))
             .collect();
+        res.push((
+            "middle_key_by_approximate_size".to_string(),
+            escape(&middle_key),
+        ));
         Ok(res)
     }
 }

src/server/service/debug.rs

@@ -382,13 +382,11 @@ impl<T: RaftStoreRouter + 'static + Send> debugpb_grpc::Debug for Service<T> {
         sink: UnarySink<GetRegionPropertiesResponse>,
     ) {
         const TAG: &str = "get_region_properties";
+        let debugger = self.debugger.clone();
 
         let f = self
             .pool
-            .spawn(
-                future::ok(self.debugger.clone())
-                    .and_then(move |debugger| debugger.get_region_properties(req.get_region_id())),
-            )
+            .spawn_fn(move || debugger.get_region_properties(req.get_region_id()))
             .map(|props| {
                 let mut resp = GetRegionPropertiesResponse::new();
                 for (name, value) in props {