address comment

src/raftstore/store/store.rs

@@ -250,46 +250,28 @@ impl<T: Transport, C: PdClient> Store<T, C> {
         self.register_raft_base_tick(event_loop);
     }
 
-    // Clippy doesn't allow hash_map contains_key followed by insert, and suggests
-    // using entry().or_insert() instead, but we can't use this because creating peer
-    // may fail, so we allow map_entry.
-    fn on_raft_message(&mut self, mut msg: RaftMessage) -> Result<()> {
-        let region_id = msg.get_region_id();
-        if !self.is_raft_msg_valid(&msg) {
-            return Ok(());
-        }
-
-        if msg.get_is_tombstone() {
-            // we receive a message tells us to remove ourself.
-            self.handle_gc_peer_msg(&msg);
-            return Ok(());
-        }
-
-        if try!(self.is_msg_stale(&msg)) {
-            return Ok(());
-        }
-
+    fn check_target_peer_valid(&mut self, region_id: u64, target: &metapb::Peer) -> Result<bool> {
         // we may encounter a message with larger peer id, which means
         // current peer is stale, then we should remove current peer
         let mut has_peer = false;
         let mut stale_peer = None;
         if let Some(p) = self.region_peers.get(&region_id) {
             has_peer = true;
-            let target_peer_id = msg.get_to_peer().get_id();
+            let target_peer_id = target.get_id();
             if p.peer_id() < target_peer_id {
                 if p.is_applying_snap() {
                     // to remove the applying peer, we should find a reliable way to abort
                     // the apply process.
                     warn!("Stale peer {} is applying snapshot, will destroy next time.",
                           p.peer_id());
-                    return Ok(());
+                    return Ok(false);
                 }
                 stale_peer = Some(p.peer.clone());
             } else if p.peer_id() > target_peer_id {
                 warn!("target peer id {} is less than {}, msg maybe stale.",
                       target_peer_id,
                       p.peer_id());
-                return Ok(());
+                return Ok(false);
             }
         }
         if let Some(p) = stale_peer {
@@ -298,11 +280,36 @@ impl<T: Transport, C: PdClient> Store<T, C> {
         }
 
         if !has_peer {
-            let peer = try!(Peer::replicate(self, region_id, msg.get_to_peer().get_id()));
+            let peer = try!(Peer::replicate(self, region_id, target.get_id()));
             // We don't have start_key of the region, so there is no need to insert into
             // region_ranges
             self.region_peers.insert(region_id, peer);
         }
+        Ok(true)
+    }
+
+    // Clippy doesn't allow hash_map contains_key followed by insert, and suggests
+    // using entry().or_insert() instead, but we can't use this because creating peer
+    // may fail, so we allow map_entry.
+    fn on_raft_message(&mut self, mut msg: RaftMessage) -> Result<()> {
+        let region_id = msg.get_region_id();
+        if !self.is_raft_msg_valid(&msg) {
+            return Ok(());
+        }
+
+        if msg.get_is_tombstone() {
+            // we receive a message tells us to remove ourself.
+            self.handle_gc_peer_msg(&msg);
+            return Ok(());
+        }
+
+        if try!(self.is_msg_stale(&msg)) {
+            return Ok(());
+        }
+
+        if !try!(self.check_target_peer_valid(region_id, msg.get_to_peer())) {
+            return Ok(());
+        }
 
         if try!(self.check_snapshot_overlapped(&msg)) {
             return Ok(());