onNeighboursPacketReceived

ethereum/p2p/src/main/java/tech/pegasys/pantheon/ethereum/p2p/discovery/internal/RecursivePeerRefreshState.java

@@ -35,7 +35,7 @@ class RecursivePeerRefreshState {
     private final PingDispatcher pingDispatcher;
     private final FindNeighbourDispatcher findNeighbourDispatcher;
 
-    private final SortedMap<BytesValue, MetadataPeer> oneTrueList;
+    private final SortedMap<BytesValue, MetadataPeer> oneTrueMap;
 
     RecursivePeerRefreshState(
             final BytesValue target,
@@ -48,18 +48,103 @@ class RecursivePeerRefreshState {
         this.peerWhitelist = peerWhitelist;
         this.pingDispatcher = bondingAgent;
         this.findNeighbourDispatcher = neighborFinder;
-
-        this.oneTrueList = new TreeMap<>();
+        this.oneTrueMap = new TreeMap<>();
     }
 
-    void addToOneTrueList(final List<DiscoveryPeer> bootstrapPeers) {
+    void kickstartBootstrapPeers(final List<DiscoveryPeer> bootstrapPeers) {
         for (DiscoveryPeer bootstrapPeer : bootstrapPeers) {
             final MetadataPeer iterationParticipant = new MetadataPeer(bootstrapPeer, distance(target, bootstrapPeer.getId()));
-            oneTrueList.put(bootstrapPeer.getId(), iterationParticipant);
+            oneTrueMap.put(bootstrapPeer.getId(), iterationParticipant);
+        }
+        initiateBondingRound();
+    }
+
+    private void initiateBondingRound() {
+        final List<DiscoveryPeer> bondingRoundCandidatesList = bondingRoundCandidates(3, oneTrueMap);
+        for(DiscoveryPeer discoPeer : bondingRoundCandidatesList) {
+            pingDispatcher.ping(discoPeer);
+            final MetadataPeer metadataPeer = oneTrueMap.get(discoPeer.getId());
+            metadataPeer.setBondQueried();
+        }
+    }
+
+    private void initiateNeighboursRound() {
+        final List<DiscoveryPeer> neighboursRoundCandidatesList = neighboursRoundCandidates(3, oneTrueMap);
+        for(DiscoveryPeer discoPeer : neighboursRoundCandidatesList) {
+            findNeighbourDispatcher.findNeighbours(discoPeer, target);
+            final MetadataPeer metadataPeer = oneTrueMap.get(discoPeer.getId());
+            metadataPeer.setNeighbourQueried();
         }
     }
 
+    /**
+     *  What we're doing here is indicating that the message sender (peer), has responded to
+     *  our outgoing request for nodes with a neighbours packet. Moreover, we examine that
+     *  packet, and for each one of it's constituent nodes, if we've not hitherto encountered
+     *  that node, we add it to our one true map.
+     */
+    void onNeighboursPacketReceived(final DiscoveryPeer peer, final NeighborsPacketData neighboursPacket) {
+        final MetadataPeer metadataPeer = oneTrueMap.get(peer.getId());
+
+        final List<DiscoveryPeer> receivedPeerList = neighboursPacket.getNodes();
+        for (DiscoveryPeer receivedDiscoPeer : receivedPeerList) {
+            if(!oneTrueMap.containsKey(receivedDiscoPeer.getId())){
+                final MetadataPeer receivedMetadataPeer = new MetadataPeer(receivedDiscoPeer, distance(target, receivedDiscoPeer.getId()));
+                oneTrueMap.put(receivedDiscoPeer.getId(), receivedMetadataPeer);
+            }
+        }
+        metadataPeer.setNeighbourResponded();
+
+        peer.setStatus(DiscoveryPeerStatus.RECEIVED_NEIGHBOURS_FROM); // <-- This is an artifact...
+    }
+
+    void onPongPacketReceived(final DiscoveryPeer peer) {
+        final MetadataPeer iterationParticipant = oneTrueMap.get(peer.getId());
+        iterationParticipant.setBondResponded();
+    }
+
+    private List<DiscoveryPeer> bondingRoundCandidates(final int max, final SortedMap<BytesValue, MetadataPeer> source) {
+        final List<DiscoveryPeer> candidatesList = new ArrayList<>();
+
+        int count = 0;
+        for (Map.Entry<BytesValue, MetadataPeer> candidateEntry : source.entrySet()) {
+            if (count >= max) {
+                break;
+            }
+            final MetadataPeer candidate = candidateEntry.getValue();
+
+            if(!candidate.getNeighbourEvaluation() &&
+                    !candidate.getNeighbourResponded()  &&
+                    !candidate.getNeighbourQueried()    &&
+                    //
+                    !candidate.getBondEvaluation()      &&
+                    !candidate.getBondResponded()       &&
+                    !candidate.getBondQueried()) {
+
+                candidatesList.add(candidate.getPeer());
+                count++;
+            }
+        }
+        return candidatesList;
+    }
+
+    private List<DiscoveryPeer> neighboursRoundCandidates(final int max, final SortedMap<BytesValue, MetadataPeer> source) {
+        final List<DiscoveryPeer> candidatesList = new ArrayList<>();
+
+        int count = 0;
+        for (Map.Entry<BytesValue, MetadataPeer> candidateEntry : source.entrySet()) {
+            if (count >= max) {
+                break;
+            }
+            final MetadataPeer candidate = candidateEntry.getValue();
 
+            if(candidate.getBondQueried() && candidate.getBondResponded()) {
+                candidatesList.add(candidate.getPeer());
+                count++;
+            }
+        }
+        return candidatesList;
+    }
 
     public class MetadataPeer implements Comparable<MetadataPeer> {
         DiscoveryPeer peer;
@@ -101,49 +186,29 @@ public Integer getDistance() {
             return distance;
         }
 
-        void setBondQueried() {
-            this.bondQueried = true;
-        }
+        void setBondQueried() {this.bondQueried = true;}
 
-        void setBondResponded() {
-            this.bondResponded = true;
-        }
+        boolean getBondQueried() {return bondQueried;}
 
-        void setBondEvaluation() {
-            this.bondEvaluated = true;
-        }
+        void setBondResponded() {this.bondResponded = true;}
 
-        boolean getBondQueried() {
-            return bondQueried;
-        }
+        boolean getBondResponded() {return bondResponded;}
 
-        boolean getBondResponded() {
-            return bondResponded;
-        }
+        void setBondEvaluation() {this.bondEvaluated = true;}
 
-        boolean getBondEvaluation() {
-            return bondEvaluated;
-        }
+        boolean getBondEvaluation() {return bondEvaluated;}
 
-        void setNeighbourQueried() {
-            this.neighbourQueried = true;
-        }
+        void setNeighbourQueried() {this.neighbourQueried = true;}
 
-        boolean getNeighbourQueried() {
-            return neighbourQueried;
-        }
+        boolean getNeighbourQueried() {return neighbourQueried;}
 
-        void setNeighbourResponded() {
-            this.neighbourResponded = true;
-        }
+        void setNeighbourResponded() {this.neighbourResponded = true;}
 
-        void setNeighbourEvaluation() {
-            this.neighbourEvaluated = true;
-        }
+        boolean getNeighbourResponded() {return neighbourResponded;}
 
-        boolean getNeighbourEvaluation() {
-            return neighbourEvaluated;
-        }
+        void setNeighbourEvaluation() {this.neighbourEvaluated = true;}
+
+        boolean getNeighbourEvaluation() {return neighbourEvaluated;}
 
         @Override
         public boolean equals(final Object o) {