refactor(net): when multi master occurs, the master with bigger blockId is elected to produce block

Author: 317787106

consensus/src/main/java/org/tron/consensus/dpos/StateManager.java

@@ -90,12 +90,14 @@ public void receiveBlock(BlockCapsule blockCapsule) {
       return;
     }
 
-    if (dupBlockCount.get() == 0) {
-      dupBlockCount.set(new Random().nextInt(10));
-    } else {
-      dupBlockCount.set(10);
+    //multi master occurs. If currentBlockId is bigger, we continue to produce block at next cycle.
+    if (null != currentBlockId
+        && currentBlockId.toString().compareTo(blockCapsule.getBlockId().toString()) > 0) {
+      return;
     }
 
+    //currentBlockId is smaller, we may pause one cycle
+    dupBlockCount.set(1);
     dupBlockTime.set(System.currentTimeMillis());
 
     logger.warn("Dup block produced: {}", blockCapsule);

framework/src/test/java/org/tron/common/overlay/discover/table/NodeEntryTest.java

@@ -3,6 +3,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 import org.tron.common.overlay.discover.node.Node;
+import org.tron.common.utils.ByteArray;
 
 public class NodeEntryTest {
 
@@ -23,4 +24,46 @@ public void test() throws InterruptedException {
     Assert.assertTrue(isDif);
   }
 
+  @Test
+  public void testDistance() {
+    byte[] randomId = Node.getNodeId();
+    String hexRandomIdStr = ByteArray.toHexString(randomId);
+    Assert.assertEquals(128, hexRandomIdStr.length());
+
+    byte[] nodeId1 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            + "0000000000000000000000000000000000000000000000000000000000000000");
+    byte[] nodeId2 = ByteArray.fromHexString(
+        "a000000000000000000000000000000000000000000000000000000000000000"
+            + "0000000000000000000000000000000000000000000000000000000000000000");
+    Assert.assertEquals(256, NodeEntry.distance(nodeId1, nodeId2));
+
+    byte[] nodeId3 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000001"
+            + "0000000000000000000000000000000000000000000000000000000000000000");
+    Assert.assertEquals(1, NodeEntry.distance(nodeId1, nodeId3));
+
+    byte[] nodeId4 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            + "8000000000000000000000000000000000000000000000000000000000000000");
+    Assert.assertEquals(0, NodeEntry.distance(nodeId1, nodeId4)); // => 0
+
+    byte[] nodeId5 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            + "4000000000000000000000000000000000000000000000000000000000000000");
+    Assert.assertEquals(-1, NodeEntry.distance(nodeId1, nodeId5)); // => 0
+
+    byte[] nodeId6 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            + "2000000000000000000000000000000000000000000000000000000000000000");
+    Assert.assertEquals(-2, NodeEntry.distance(nodeId1, nodeId6)); // => 0
+
+    byte[] nodeId7 = ByteArray.fromHexString(
+        "0000000000000000000000000000000000000000000000000000000000000000"
+            + "0000000000000000000000000000000000000000000000000000000000000001");
+    Assert.assertEquals(-255, NodeEntry.distance(nodeId1, nodeId7)); // => 0
+
+    Assert.assertEquals(-256, NodeEntry.distance(nodeId1, nodeId1)); // => 0
+  }
+
 }