Merge branch 'release_v4.7.6' into feature/test_isolated3

Author: 317787106

framework/src/main/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandler.java

@@ -164,6 +164,10 @@ private void check(PeerConnection peer, FetchInvDataMessage fetchInvDataMsg) thr
             throw new P2pException(TypeEnum.BAD_MESSAGE,
                 "minBlockNum: " + minBlockNum + ", blockNum: " + blockNum);
           }
+          if (blockNum > peer.getLastSyncBlockId().getNum()) {
+            throw new P2pException(TypeEnum.BAD_MESSAGE,
+                "maxBlockNum: " + peer.getLastSyncBlockId().getNum() + ", blockNum: " + blockNum);
+          }
           if (peer.getSyncBlockIdCache().getIfPresent(hash) != null) {
             throw new P2pException(TypeEnum.BAD_MESSAGE,
                 new BlockId(hash).getString() + " is exist");

framework/src/main/java/org/tron/core/net/peer/PeerConnection.java

@@ -172,7 +172,11 @@ public void setBlockBothHave(BlockId blockId) {
   }
 
   public boolean isIdle() {
-    return advInvRequest.isEmpty() && syncBlockRequested.isEmpty() && syncChainRequested == null;
+    return advInvRequest.isEmpty() && isSyncIdle();
+  }
+
+  public boolean isSyncIdle() {
+    return syncBlockRequested.isEmpty() && syncChainRequested == null;
   }
 
   public void sendMessage(Message message) {

framework/src/main/java/org/tron/core/net/peer/PeerManager.java

@@ -94,7 +94,11 @@ private static void remove(PeerConnection peerConnection) {
   }
 
   public static synchronized void sortPeers() {
-    peers.sort(Comparator.comparingDouble(c -> c.getChannel().getAvgLatency()));
+    try {
+      peers.sort(Comparator.comparingLong(c -> c.getChannel().getAvgLatency()));
+    } catch (Exception e) {
+      logger.warn("Sort peers failed. {}", e.getMessage());
+    }
   }
 
   public static PeerConnection getPeerConnection(Channel channel) {

framework/src/main/java/org/tron/core/net/service/sync/SyncService.java

@@ -134,7 +134,7 @@ public void processBlock(PeerConnection peer, BlockMessage blockMessage) {
       blockJustReceived.put(blockMessage, peer);
     }
     handleFlag = true;
-    if (peer.isIdle()) {
+    if (peer.isSyncIdle()) {
       if (peer.getRemainNum() > 0
           && peer.getSyncBlockToFetch().size() <= syncFetchBatchNum) {
         syncNext(peer);
@@ -226,7 +226,7 @@ private BlockId getBlockIdByNum(long num) throws P2pException {
   private void startFetchSyncBlock() {
     HashMap<PeerConnection, List<BlockId>> send = new HashMap<>();
     tronNetDelegate.getActivePeer().stream()
-        .filter(peer -> peer.isNeedSyncFromPeer() && peer.isIdle())
+        .filter(peer -> peer.isNeedSyncFromPeer() && peer.isSyncIdle())
         .filter(peer -> peer.isFetchAble())
         .forEach(peer -> {
           if (!send.containsKey(peer)) {

framework/src/test/java/org/tron/core/net/messagehandler/FetchInvDataMsgHandlerTest.java

@@ -21,8 +21,6 @@
 import org.tron.core.net.service.adv.AdvService;
 import org.tron.protos.Protocol;
 
-
-
 public class FetchInvDataMsgHandlerTest {
 
   @Test
@@ -62,4 +60,37 @@ public void testProcessMessage() throws Exception {
         new FetchInvDataMessage(blockIds, Protocol.Inventory.InventoryType.BLOCK));
     Assert.assertNotNull(syncBlockIdCache.getIfPresent(blockId));
   }
+
+  @Test
+  public void testSyncFetchCheck() {
+    BlockCapsule.BlockId blockId = new BlockCapsule.BlockId(Sha256Hash.ZERO_HASH, 10000L);
+    List<Sha256Hash> blockIds = new LinkedList<>();
+    blockIds.add(blockId);
+    FetchInvDataMessage msg =
+        new FetchInvDataMessage(blockIds, Protocol.Inventory.InventoryType.BLOCK);
+
+    PeerConnection peer = Mockito.mock(PeerConnection.class);
+    Mockito.when(peer.isNeedSyncFromUs()).thenReturn(true);
+    Cache<Item, Long> advInvSpread = CacheBuilder.newBuilder().maximumSize(100)
+        .expireAfterWrite(1, TimeUnit.HOURS).recordStats().build();
+    Mockito.when(peer.getAdvInvSpread()).thenReturn(advInvSpread);
+
+    FetchInvDataMsgHandler fetchInvDataMsgHandler = new FetchInvDataMsgHandler();
+
+    try {
+      Mockito.when(peer.getLastSyncBlockId())
+        .thenReturn(new BlockCapsule.BlockId(Sha256Hash.ZERO_HASH, 1000L));
+      fetchInvDataMsgHandler.processMessage(peer, msg);
+    } catch (Exception e) {
+      Assert.assertEquals(e.getMessage(), "maxBlockNum: 1000, blockNum: 10000");
+    }
+
+    try {
+      Mockito.when(peer.getLastSyncBlockId())
+        .thenReturn(new BlockCapsule.BlockId(Sha256Hash.ZERO_HASH, 20000L));
+      fetchInvDataMsgHandler.processMessage(peer, msg);
+    } catch (Exception e) {
+      Assert.assertEquals(e.getMessage(), "minBlockNum: 16000, blockNum: 10000");
+    }
+  }
 }

framework/src/test/java/org/tron/core/net/peer/PeerConnectionTest.java

@@ -98,6 +98,36 @@ public void testIsIdle() {
     Assert.assertTrue(!f);
   }
 
+  @Test
+  public void testIsSyncIdle() {
+    PeerConnection peerConnection = new PeerConnection();
+    boolean f = peerConnection.isSyncIdle();
+    Assert.assertTrue(f);
+
+    Item item = new Item(Sha256Hash.ZERO_HASH, Protocol.Inventory.InventoryType.TRX);
+    Long time = System.currentTimeMillis();
+    peerConnection.getAdvInvRequest().put(item, time);
+    f = peerConnection.isSyncIdle();
+    Assert.assertTrue(f);
+
+    peerConnection.getAdvInvRequest().clear();
+    f = peerConnection.isSyncIdle();
+    Assert.assertTrue(f);
+
+    BlockCapsule.BlockId blockId = new BlockCapsule.BlockId();
+    peerConnection.getSyncBlockRequested().put(blockId, time);
+    f = peerConnection.isSyncIdle();
+    Assert.assertTrue(!f);
+
+    peerConnection.getSyncBlockRequested().clear();
+    f = peerConnection.isSyncIdle();
+    Assert.assertTrue(f);
+
+    peerConnection.setSyncChainRequested(new Pair<>(new LinkedList<>(), time));
+    f = peerConnection.isSyncIdle();
+    Assert.assertTrue(!f);
+  }
+
   @Test
   public void testOnConnect() {
     PeerConnection peerConnection = new PeerConnection();

framework/src/test/java/org/tron/core/net/peer/PeerManagerTest.java

@@ -135,4 +135,32 @@ public void testGetPeers() throws Exception {
     Assert.assertEquals(2, peers.size());
   }
 
+  @Test
+  public void testSortPeers() throws Exception {
+    PeerConnection p1 = new PeerConnection();
+    PeerConnection p2 = new PeerConnection();
+
+    List<PeerConnection> peers = new ArrayList<>();
+    peers.add(p1);
+    peers.add(p2);
+
+    Field field = PeerManager.class.getDeclaredField("peers");
+    field.setAccessible(true);
+    field.set(PeerManager.class, Collections.synchronizedList(peers));
+
+    PeerManager.sortPeers();
+
+    Channel c1 = new Channel();
+    c1.updateAvgLatency(100000L);
+    ReflectUtils.setFieldValue(p1, "channel", c1);
+
+    Channel c2 = new Channel();
+    c2.updateAvgLatency(1000L);
+    ReflectUtils.setFieldValue(p2, "channel", c2);
+
+    PeerManager.sortPeers();
+
+    Assert.assertEquals(PeerManager.getPeers().get(0), p2);
+  }
+
 }