Added another (static) random generator and a class that dumps a graph (in dot-format) to a file

ws2012/P2P/uebungen/4/src/RandomGenerator2.java

@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.logging.LogManager;
+
+import analysis.NetworkDumper;
+
+import node.Node;
+
+public class RandomGenerator2 {
+
+    private int ROUNDS = 100;
+
+    public static double BIRTH_RATE = 0.80;
+
+    public static List<Node> nodes = new ArrayList<Node>();
+    public static Random gen = new Random();
+
+    private int maxNodes = 0;
+    private int numSpawned = 0;
+    private int numKilled = 0;
+
+    private Node firstNode;
+
+    public RandomGenerator2() {
+        firstNode = new Node();
+        nodes.add(firstNode);
+        new NetworkDumper(firstNode);
+        
+        for (int i = 0; i < ROUNDS - 1; i++) {
+
+            if (gen.nextDouble() > 1 - BIRTH_RATE) {
+                spawn();
+            } else {
+                kill();
+            }
+
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException e) {
+            }
+        }
+
+        System.out.println("Executed " + ROUNDS
+                + " rounds (with a spawn rate of " + BIRTH_RATE + "). "
+                + numSpawned + " nodes were spawned, " + numKilled
+                + " nodes were killed. Currently " + "there are "
+                + nodes.size() + " nodes remaining. At one point we had"
+                + " a maximum of " + maxNodes + " nodes.");
+    }
+
+    private void spawn() {
+        try {
+            if (nodes.isEmpty()) {
+                nodes.add(new Node());
+            } else {
+                Node randomNode = getRandomNode();
+                Node newNode = randomNode.spawn();
+                nodes.add(newNode);
+            }
+            numSpawned++;
+            if (maxNodes < nodes.size()) {
+                maxNodes = nodes.size();
+            }
+        } catch (IOException e) {
+        }
+    }
+
+    private void kill() {
+        if (nodes.isEmpty())
+            return;
+        Node randomNode;
+        while ((randomNode = getRandomNode()) == firstNode) {
+            // Dont kill first node
+        }
+        randomNode.leave();
+        numKilled++;
+    }
+    
+    private Node getRandomNode() {
+        return nodes.get(gen.nextInt(nodes.size()));
+    }
+
+    public static void main(String args[]) {
+        System.setProperty("java.util.logging.config.file",
+                "logging.properties");
+
+        try {
+            LogManager.getLogManager().readConfiguration();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        new RandomGenerator2();
+    }
+
+}

ws2012/P2P/uebungen/4/src/analysis/NetworkDumper.java

@@ -0,0 +1,83 @@
+package analysis;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import node.Node;
+
+public class NetworkDumper implements Runnable {
+
+    Node node = null;
+    private boolean running = true;
+
+    public NetworkDumper(Node n) {
+        this.node = n;
+
+        new Thread(this).start();
+    }
+
+    public String networkToDot(Map<String, List<String>> network) {
+        StringBuilder result = new StringBuilder(512);
+        result.append("graph g{\n");
+
+        Set<String> alreadyIn = new HashSet<String>();
+
+        for (Map.Entry<String, List<String>> entry : network.entrySet()) {
+
+            for (String s : entry.getValue()) {
+                String nodeA = getName(entry.getKey());
+                String nodeB = getName(s);
+
+                if (!alreadyIn.contains(nodeB + nodeA)) {
+
+                    result.append("\t");
+                    result.append(nodeA).append(" -- ").append(nodeB);
+                    result.append(";\n");
+
+                    alreadyIn.add(nodeA + nodeB);
+                }
+            }
+        }
+        result.append("}\n");
+        return result.toString();
+    }
+
+    private String getName(String s) {
+        return s.split(":")[1];
+    }
+
+    private void write(String s) {
+        try {
+            // Create file
+            FileWriter fstream = new FileWriter("graph.dot");
+            BufferedWriter out = new BufferedWriter(fstream);
+            out.write(s);
+            // Close the output stream
+            out.close();
+        } catch (Exception e) {// Catch exception if any
+            System.err.println("Error: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void run() {
+        while (running) {
+            try {
+                node.gatherInformationOfNetwork();
+
+                // Wait 1s to broadcast to network
+                Thread.sleep(1000);
+
+                write(networkToDot(node.getNetwork()));
+
+                // Wait 10s for update
+                Thread.sleep(10000);
+            } catch (InterruptedException e) {
+            }
+        }
+    }
+}