fix error handling about rocksdb iterator (#6327)

src/import/stream.rs

@@ -159,7 +159,7 @@ impl RangeIterator {
     }
 
     pub fn next(&mut self) -> Result<bool> {
-        if !self.iter.next() {
+        if !self.iter.next().unwrap() {
             return Ok(false);
         }
         {
@@ -174,7 +174,7 @@ impl RangeIterator {
 
     fn seek_next(&mut self) -> Result<bool> {
         while let Some(range) = self.ranges.get(self.ranges_index) {
-            if !self.iter.seek(SeekKey::Key(range.get_start())) {
+            if !self.iter.seek(SeekKey::Key(range.get_start())).unwrap() {
                 break;
             }
             assert!(self.iter.key() >= range.get_start());
@@ -195,13 +195,10 @@ impl RangeIterator {
     }
 
     pub fn valid(&self) -> Result<bool> {
-        if !self.iter.valid() {
-            if let Err(e) = self.iter.status() {
-                return Err(Error::RocksDB(e));
-            }
-            Ok(false)
-        } else {
-            Ok(self.ranges_index < self.ranges.len())
+        match self.iter.valid() {
+            Err(e) => Err(Error::RocksDB(e)),
+            Ok(false) => Ok(false),
+            _ => Ok(self.ranges_index < self.ranges.len()),
         }
     }
 }

src/lib.rs

@@ -28,6 +28,7 @@
 #![feature(specialization)]
 #![feature(ascii_ctype)]
 #![feature(const_int_ops)]
+#![feature(tool_lints)]
 #![feature(use_extern_macros)]
 #![recursion_limit = "200"]
 // Currently this raises some false positives, so we allow it:

src/raftstore/coprocessor/split_check/table.rs

@@ -187,7 +187,7 @@ fn last_key_of_region(db: &DB, region: &Region) -> Result<Option<Vec<u8>>> {
     let mut iter = box_try!(db.new_iterator_cf(CF_WRITE, iter_opt));
 
     // the last key
-    if iter.seek(SeekKey::End) {
+    if iter.seek(SeekKey::End).unwrap() {
         let key = iter.key().to_vec();
         last_key = Some(key);
     } // else { No data in this CF }

src/raftstore/store/engine.rs

@@ -299,31 +299,32 @@ pub trait Iterable {
     // Seek the first key >= given key, if no found, return None.
     fn seek(&self, key: &[u8]) -> Result<Option<(Vec<u8>, Vec<u8>)>> {
         let mut iter = self.new_iterator(IterOption::default());
-        iter.seek(key.into());
-        Ok(iter.kv())
+        if iter.seek(key.into())? {
+            let kv = (iter.key().to_vec(), iter.value().to_vec());
+            return Ok(Some(kv));
+        }
+        Ok(None)
     }
 
     // Seek the first key >= given key, if no found, return None.
     fn seek_cf(&self, cf: &str, key: &[u8]) -> Result<Option<(Vec<u8>, Vec<u8>)>> {
         let mut iter = self.new_iterator_cf(cf, IterOption::default())?;
-        iter.seek(key.into());
-        Ok(iter.kv())
+        if iter.seek(key.into())? {
+            let kv = (iter.key().to_vec(), iter.value().to_vec());
+            return Ok(Some(kv));
+        }
+        Ok(None)
     }
 }
 
 fn scan_impl<F>(mut it: DBIterator<&DB>, start_key: &[u8], mut f: F) -> Result<()>
 where
     F: FnMut(&[u8], &[u8]) -> Result<bool>,
 {
-    it.seek(start_key.into());
-    while it.valid() {
-        let r = f(it.key(), it.value())?;
-
-        if !r || !it.next() {
-            break;
-        }
+    let mut remained = it.seek(start_key.into())?;
+    while remained {
+        remained = f(it.key(), it.value())? && it.next()?;
     }
-
     Ok(())
 }