Replacement buckets

simulator/config/kademlia.cfg

@@ -22,7 +22,8 @@ TRAFFIC_STEP  300000 #10000000/SIZE
 OBSERVER_STEP 100000
 #Turbulence module is executed every TURBULENCE_STEP enabling churning
 TURBULENCE_STEP  (SIM_TIME*20)/SIZE   #100000000/SIZE
-
+#Every REFRESH_STEP nodes check a random bucket for dead nodes
+REFRESH_STEP 100000
 
 # add network config parameters to simulation
 random.seed 24680
@@ -71,6 +72,10 @@ control.0traffic peersim.kademlia.TrafficGenerator
 control.0traffic.protocol 3kademlia
 control.0traffic.step TRAFFIC_STEP
 
+#refresh buckets
+control.1 peersim.kademlia.RefreshBuckets
+control.1.step REFRESH_STEP
+
 # turbulence
 #control.2turbolenceAdd peersim.kademlia.Turbulence
 #control.2turbolenceAdd.protocol 3kademlia

simulator/src/main/java/peersim/kademlia/KBucket.java

@@ -1,8 +1,12 @@
 package peersim.kademlia;
 
 import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 import java.util.TreeMap;
 import peersim.core.CommonState;
+import peersim.core.Node;
 
 /**
  * This class implements a kademlia k-bucket. Function for the management of the neighbours update
@@ -12,30 +16,108 @@
  * @version 1.0
  */
 public class KBucket implements Cloneable {
+  // Replacement bucket
+  protected List<BigInteger> replacements;
 
   // k-bucket array
   protected TreeMap<BigInteger, Long> neighbours = null;
 
-  // empty costructor
+  // k-bucket size, max replacement bucket size
+  protected int k, maxReplacements;
+
+  // empty constructor
   public KBucket() {
     neighbours = new TreeMap<BigInteger, Long>();
+    replacements = new ArrayList<BigInteger>();
+  }
+
+  public KBucket(int k, int maxReplacements) {
+    neighbours = new TreeMap<BigInteger, Long>();
+    replacements = new ArrayList<BigInteger>();
+    this.k = k;
+    this.maxReplacements = maxReplacements;
+  }
+
+  public void checkAndReplaceLast() {
+    if (neighbours.size() == 0 || CommonState.getTime() == 0)
+      // Entry has moved, don't replace it.
+      return;
+
+    // System.out.println("Replace node "+neighbours.get(neighbours.size()-1)+" at
+    // "+CommonState.getTime());
+
+    // Get a random node
+    Random random = new Random();
+
+    int min = 0;
+    int max = neighbours.size();
+    BigInteger randomIndex = new BigInteger(String.valueOf(random.nextInt(max - min + 1) + min));
+
+    // KademliaProtocol object to access nodeIDtoNode()
+    KademliaProtocol kProtocol = new KademliaProtocol(null);
+
+    Node node = kProtocol.nodeIdtoNode(randomIndex);
+
+    // System.out.println("Replace node "+neighbours.get(neighbours.size()-1)+" at
+    // "+CommonState.getTime());
+
+    // System.out.println("checkAndReplaceLast "+remote.getNode().getId()+" at
+    // "+CommonState.getTime()+" at "+rTable.nodeId);
+
+    if (node.getFailState() != Node.OK) {
+      // Still the last entry.
+      removeNeighbour(randomIndex);
+
+      if (replacements.size() > 0) {
+        // Random rand = new Random();
+        // BigInteger n = replacements.get(rand.nextInt(replacements.size()));
+        BigInteger n = replacements.get(CommonState.r.nextInt(replacements.size()));
+        addNeighbour(n);
+        removeReplacement(n);
+      }
+    }
   }
 
   // add a neighbour to this k-bucket
   public boolean addNeighbour(BigInteger node) {
     long time = CommonState.getTime();
-    if (neighbours.size() < KademliaCommonConfig.K) { // k-bucket isn't full
+    if (neighbours.size() < k) { // k-bucket isn't full
+
       neighbours.put(node, time); // add neighbour to the tail of the list
+      removeReplacement(node);
+
       return true;
+
+    } else {
+
+      addReplacement(node);
+
+      return false;
     }
-    return false;
   }
 
   // remove a neighbour from this k-bucket
   public void removeNeighbour(BigInteger node) {
     neighbours.remove(node);
   }
 
+  public void addReplacement(BigInteger node) {
+    if (!replacements.contains(node)) {
+      replacements.add(0, node);
+
+      if (replacements.size() > maxReplacements) {
+        // Replacements is full - remove the last item
+        replacements.remove(replacements.size() - 1);
+      }
+    }
+  }
+
+  public void removeReplacement(BigInteger node) {
+    if (replacements.size() > 0) {
+      replacements.remove(node);
+    }
+  }
+
   public Object clone() {
     KBucket dolly = new KBucket();
     for (BigInteger node : neighbours.keySet()) {

simulator/src/main/java/peersim/kademlia/KademliaProtocol.java

@@ -130,7 +130,7 @@ private void _init() {
    * @param searchNodeId BigInteger
    * @return Node
    */
-  private Node nodeIdtoNode(BigInteger searchNodeId) {
+  public Node nodeIdtoNode(BigInteger searchNodeId) {
     if (searchNodeId == null) return null;
 
     int inf = 0;
@@ -499,6 +499,11 @@ public RoutingTable getRoutingTable() {
     return this.routingTable;
   }
 
+  public void refreshBuckets() {
+    // logger.warning("Calling refreshbuckets");
+    routingTable.refreshBuckets();
+  }
+
   /** Set the protocol ID for this node. */
   public void setProtocolID(int protocolID) {
     this.kademliaid = protocolID;

simulator/src/main/java/peersim/kademlia/RefreshBuckets.java

@@ -0,0 +1,28 @@
+package peersim.kademlia;
+
+import peersim.core.Control;
+import peersim.core.Network;
+import peersim.core.Node;
+
+public class RefreshBuckets implements Control {
+
+  private String prefix;
+
+  // ______________________________________________________________________________________________
+  public RefreshBuckets(String prefix) {
+    this.prefix = prefix;
+  }
+
+  // ______________________________________________________________________________________________
+  public boolean execute() {
+    for (int i = 0; i < Network.size(); i++) {
+      Node iNode = Network.get(i);
+      if (iNode.getFailState() == Node.OK) {
+        KademliaProtocol iKad = iNode.getKademliaProtocol();
+        iKad.refreshBuckets();
+      }
+    }
+
+    return false;
+  }
+} // End of class

simulator/src/main/java/peersim/kademlia/RoutingTable.java

@@ -4,6 +4,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.TreeMap;
+import peersim.core.CommonState;
 
 /**
  * Gives an implementation for the rounting table component of a kademlia node
@@ -20,7 +21,7 @@ public class RoutingTable implements Cloneable {
   protected TreeMap<Integer, KBucket> k_buckets = null;
 
   // number of k-buckets
-  protected int nBuckets;
+  protected int kBuckets;
 
   // bucket size
   protected int k;
@@ -34,21 +35,21 @@ public class RoutingTable implements Cloneable {
   // ______________________________________________________________________________________________
   /** instanciates a new empty routing table with the specified size */
   // public RoutingTable() {
-  public RoutingTable(int nBuckets, int k, int maxReplacements) {
+  public RoutingTable(int kBuckets, int k, int maxReplacements) {
 
     k_buckets = new TreeMap<Integer, KBucket>();
-    // initialize k-bukets
+    // initialize k-buckets
 
-    this.nBuckets = nBuckets;
+    this.kBuckets = kBuckets;
 
     this.k = k;
 
     this.maxReplacements = maxReplacements;
 
-    bucketMinDistance = KademliaCommonConfig.BITS - nBuckets;
+    bucketMinDistance = KademliaCommonConfig.BITS - kBuckets;
 
-    for (int i = 0; i <= nBuckets; i++) {
-      k_buckets.put(i, new KBucket());
+    for (int i = 0; i <= kBuckets; i++) {
+      k_buckets.put(i, new KBucket(k, maxReplacements));
     }
   }
 
@@ -137,13 +138,23 @@ public BigInteger[] getNeighbours(final BigInteger key, final BigInteger src) {
 
   // ______________________________________________________________________________________________
   public Object clone() {
-    RoutingTable dolly = new RoutingTable(nBuckets, k, maxReplacements);
+    RoutingTable dolly = new RoutingTable(kBuckets, k, maxReplacements);
     for (int i = 0; i < k_buckets.size(); i++) {
-      k_buckets.put(i, new KBucket()); // (KBucket) k_buckets.get(i).clone());
+      k_buckets.put(i, new KBucket(k, maxReplacements)); // (KBucket) k_buckets.get(i).clone());
     }
     return dolly;
   }
 
+  public void refreshBuckets() {
+    KBucket b = k_buckets.get(CommonState.r.nextInt(kBuckets));
+
+    // Replace the last item in kbucket if its full
+    if (b != null && b.neighbours.size() > 0) {
+      b.checkAndReplaceLast();
+      return;
+    }
+  }
+
   // ______________________________________________________________________________________________
   /**
    * print a string representation of the table