1 Moved the stuff to trunk!

8 files changed, 493 insertions, 0 deletions

diff --git a/sources/protocols/BroadcastSturmProtocol.java b/sources/protocols/BroadcastSturmProtocol.java
new file mode 100644
index 0000000..3940e5f
--- /dev/null
+++ b/sources/protocols/BroadcastSturmProtocol.java
@@ -0,0 +1,47 @@
+package protocols;
+
+import java.util.ArrayList;
+
+import prefs.VSPrefs;
+import core.VSMessage;
+
+public class BroadcastSturmProtocol extends VSProtocol {
+    private ArrayList<VSMessage> sentMessages;
+    private static int broadcastCount;
+
+    public BroadcastSturmProtocol() {
+        setProtocolClassname(getClass().toString());
+        sentMessages = new ArrayList<VSMessage>();
+    }
+
+    protected void onClientReset() {
+    }
+
+    protected void onClientStart() {
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setInteger("Broadcast", broadcastCount++);
+        sentMessages.add(message);
+        sendMessage(message);
+    }
+
+    protected void onClientRecv(VSMessage recvMessage) {
+    }
+
+    protected void onServerReset() {
+        sentMessages.clear();
+    }
+
+    protected void onServerRecv(VSMessage recvMessage) {
+        if (!sentMessages.contains(recvMessage)) {
+            VSMessage message = new VSMessage(getProtocolClassname());
+            message.setInteger("Broadcast", recvMessage.getInteger("Broadcast"));
+
+            sentMessages.add(message);
+            sendMessage(message);
+        }
+    }
+
+    public String toString() {
+        return super.toString();
+    }
+}
diff --git a/sources/protocols/DummyProtocol.java b/sources/protocols/DummyProtocol.java
new file mode 100644
index 0000000..8c9009c
--- /dev/null
+++ b/sources/protocols/DummyProtocol.java
@@ -0,0 +1,45 @@
+package protocols;
+
+import core.VSMessage;
+
+public class DummyProtocol extends VSProtocol {
+    public DummyProtocol() {
+        setProtocolClassname(getClass().toString());
+    }
+
+    protected void onClientReset() {
+        logg("onClientReset()");
+    }
+
+    protected void onClientStart() {
+        logg("onClientStart()");
+
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setString("Greeting", "Hello World!");
+        message.setInteger("A number", 1);
+        message.setBoolean("A boolean", true);
+        message.setFloat("A float", 1.2f);
+        sendMessage(message);
+    }
+
+    protected void onClientRecv(VSMessage recvMessage) {
+        logg("onClientRecv("+recvMessage+")");
+
+        String s = recvMessage.getString("Greeting");
+        int n = recvMessage.getInteger("A number");
+        boolean b = recvMessage.getBoolean("A boolean");
+        float f = recvMessage.getFloat("A float");
+    }
+
+    protected void onServerReset() {
+        logg("onClientReset()");
+    }
+
+    protected void onServerRecv(VSMessage recvMessage) {
+        logg("onServerRecv("+recvMessage+")");
+    }
+
+    public String toString() {
+        return super.toString() + "; Dummy Test";
+    }
+}
diff --git a/sources/protocols/ExternalTimeSyncProtocol.java b/sources/protocols/ExternalTimeSyncProtocol.java
new file mode 100644
index 0000000..33a60ad
--- /dev/null
+++ b/sources/protocols/ExternalTimeSyncProtocol.java
@@ -0,0 +1,62 @@
+package protocols;
+
+import prefs.VSPrefs;
+import core.VSMessage;
+
+public class ExternalTimeSyncProtocol extends VSProtocol {
+    private long requestTime;
+    private boolean waitingForResponse;
+
+    public ExternalTimeSyncProtocol() {
+        setProtocolClassname(getClass().toString());
+    }
+
+    protected void onClientReset() {
+    }
+
+    protected void onClientStart() {
+        requestTime = process.getTime();
+        waitingForResponse = true;
+
+        /* Multicast message to all processes */
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setBoolean("isClientRequest", true);
+        sendMessage(message);
+    }
+
+    protected void onClientRecv(VSMessage recvMessage) {
+        if (!recvMessage.getBoolean("isServerResponse"))
+            return;
+
+        if (waitingForResponse)
+            waitingForResponse = false;
+        else
+            return;
+
+        long recvTime = process.getTime();
+        long roundTripTime = recvTime - requestTime;
+        long serverTime = recvMessage.getLong("time");
+        long newTime = serverTime + (long) (roundTripTime / 2);
+
+        logg("Server Zeit: " + serverTime + "; RTT: " + roundTripTime + "; Alte Zeit: " + recvTime + "; Neue Zeit: " + newTime + "; Offset: " + (newTime - recvTime));
+        process.setTime(newTime);
+    }
+
+    protected void onServerReset() {
+    }
+
+    protected void onServerRecv(VSMessage recvMessage) {
+        if (!recvMessage.getBoolean("isClientRequest"))
+            return;
+
+        /* Multicast message to all processes */
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setLong("time", process.getTime());
+        message.setBoolean("isServerResponse", true);
+        sendMessage(message);
+    }
+
+    public String toString() {
+        return super.toString(); //+ "; " + prefs.getString("lang.requesttime") + ": " + requestTime;
+    }
+}
diff --git a/sources/protocols/InternalTimeSyncProtocol.java b/sources/protocols/InternalTimeSyncProtocol.java
new file mode 100644
index 0000000..48b57e0
--- /dev/null
+++ b/sources/protocols/InternalTimeSyncProtocol.java
@@ -0,0 +1,69 @@
+package protocols;
+
+import prefs.VSPrefs;
+import core.VSMessage;
+
+public class InternalTimeSyncProtocol extends VSProtocol {
+    private boolean waitingForResponse;
+
+    public InternalTimeSyncProtocol() {
+        setProtocolClassname(getClass().toString());
+
+        /* Those prefs are editable through the VSProtocol VSEditor GUI. t_min and t_max in milliseconds  */
+        setLong("t_min", 1000);
+        setLong("t_max", 5000);
+    }
+
+    protected void onClientReset() {
+    }
+
+    protected void onClientStart() {
+        waitingForResponse = true;
+
+        /* Multicast message to all processes */
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setBoolean("isClientRequest", true);
+        sendMessage(message);
+    }
+
+    protected void onClientRecv(VSMessage recvMessage) {
+        /* Ignore all protocol messages which are not a response message, e.g. itself */
+        if (!recvMessage.getBoolean("isServerResponse"))
+            return;
+
+        if (waitingForResponse)
+            waitingForResponse = false;
+        else
+            return;
+
+        long tMax = getLong("t_max");
+        long tMin = getLong("t_min");
+        long serverTime = recvMessage.getLong("time");
+        long newTime = serverTime + (long) ((tMax + tMin) / 2 );
+
+        logg("Server Zeit: " + serverTime + "; (t_min,t_max): (" + tMin + "," + tMax
+             + "); Alte Zeit: " + process.getTime() + "; Neue Zeit: " + newTime
+             + "; Offset: " + (process.getTime() - newTime));
+
+        process.setTime(newTime);
+    }
+
+    protected void onServerReset() {
+    }
+
+    protected void onServerRecv(VSMessage recvMessage) {
+        /* Ignore all protocol messages which are not a request message, e.g. itself */
+        if (!recvMessage.getBoolean("isClientRequest"))
+            return;
+
+        /* Multicast message to all processes */
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setLong("time", process.getTime());
+        message.setBoolean("isServerResponse", true);
+        sendMessage(message);
+    }
+
+    public String toString() {
+        return super.toString();
+    }
+}
diff --git a/sources/protocols/PingPongProtocol.java b/sources/protocols/PingPongProtocol.java
new file mode 100644
index 0000000..6244b9a
--- /dev/null
+++ b/sources/protocols/PingPongProtocol.java
@@ -0,0 +1,57 @@
+package protocols;
+
+import prefs.VSPrefs;
+import core.VSMessage;
+
+public class PingPongProtocol extends VSProtocol {
+    private int clientCounter;
+    private int serverCounter;
+
+    public PingPongProtocol() {
+        setProtocolClassname(getClass().toString());
+    }
+
+    protected void onClientReset() {
+        clientCounter = 0;
+    }
+
+    protected void onClientStart() {
+
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setBoolean("fromClient", true);
+        message.setInteger("counter", ++clientCounter);
+        sendMessage(message);
+    }
+
+    protected void onClientRecv(VSMessage recvMessage) {
+        if (!recvMessage.getBoolean("fromServer"))
+            return;
+
+        logg("message: " + recvMessage.getInteger("counter"));
+
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setBoolean("fromClient", true);
+        message.setInteger("counter", ++clientCounter);
+        sendMessage(message);
+    }
+
+    protected void onServerReset() {
+        serverCounter = 0;
+    }
+
+    protected void onServerRecv(VSMessage recvMessage) {
+        if (!recvMessage.getBoolean("fromClient"))
+            return;
+
+        logg("message: " + recvMessage.getInteger("counter"));
+
+        VSMessage message = new VSMessage(getProtocolClassname());
+        message.setBoolean("fromServer", true);
+        message.setInteger("counter", ++serverCounter);
+        sendMessage(message);
+    }
+
+    public String toString() {
+        return super.toString();
+    }
+}
diff --git a/sources/protocols/README b/sources/protocols/README
new file mode 100644
index 0000000..3bf4f6d
--- /dev/null
+++ b/sources/protocols/README
@@ -0,0 +1,10 @@
+How to add a new protocol:
+
+1. Copy the file DummyProtocol.java into YourOwnNiceProtocol.java
+
+2. Edit YourOwnNiceProtocol.java and replace the classname!
+
+3. Edit the initialize method of RegisteredProtocols.java and add the classname
+of your protocol.  E.g.: "org.buetow.vs.protocols.YourOwnNiceProtocol"
+
+
diff --git a/sources/protocols/RegisteredProtocols.java b/sources/protocols/RegisteredProtocols.java
new file mode 100644
index 0000000..542d686
--- /dev/null
+++ b/sources/protocols/RegisteredProtocols.java
@@ -0,0 +1,78 @@
+package protocols;
+
+import java.util.*;
+
+import prefs.*;
+import core.*;
+import utils.*;
+
+public final class RegisteredProtocols {
+    private static HashMap<String,String> protocolClassnames;
+    private static HashMap<String,String> protocolNames;
+    private static VSPrefs prefs;
+
+    public static void initialize(VSPrefs prefs_) {
+        prefs = prefs_;
+        protocolNames = new HashMap<String, String>();
+        protocolClassnames = new HashMap<String, String>();
+
+        registerProtocol("protocols.DummyProtocol");
+        registerProtocol("protocols.PingPongProtocol");
+        registerProtocol("protocols.ExternalTimeSyncProtocol");
+        registerProtocol("protocols.InternalTimeSyncProtocol");
+        registerProtocol("protocols.BroadcastSturmProtocol");
+    }
+
+    public static Vector<String> getProtocolNames() {
+        Set<String> set =  protocolClassnames.keySet();
+        Vector<String> vector = new Vector<String>();
+
+        for (String protocolName : set)
+            vector.add(protocolName);
+
+        Collections.sort(vector);
+
+        return vector;
+    }
+
+    public static String getProtocolClassname(String protocolName) {
+        return protocolClassnames.get(protocolName);
+    }
+
+    public static String getProtocolName(String protocolClassname) {
+        return protocolNames.get(protocolClassname);
+    }
+
+    public static VSProtocol getProtocolInstanceByName(String protocolName) {
+        final String protocolClassname = protocolClassnames.get(protocolName);
+        final Object protocolObj = new VSClassLoader().newInstance(protocolClassname);
+
+        if (protocolObj instanceof VSProtocol)
+            return (VSProtocol) protocolObj;
+
+        return null;
+    }
+
+    public static void registerProtocol(String protocolClassname) {
+        int index = protocolClassname.lastIndexOf('.');
+
+        if (index < 0) {
+            protocolNames.put(protocolClassname, protocolClassname);
+            protocolClassnames.put(protocolClassname, protocolClassname);
+            return;
+        }
+
+        String protocolName = protocolClassname.substring(index + 1);
+        index = protocolName.lastIndexOf("Protocol");
+
+        if (index < 0 || index != protocolName.length() - 8) {
+            protocolNames.put(protocolClassname, protocolName);
+            protocolClassnames.put(protocolName, protocolClassname);
+            return;
+        }
+
+        protocolName = protocolName.substring(0, index);
+        protocolNames.put(protocolClassname, protocolName);
+        protocolClassnames.put(protocolName, protocolClassname);
+    }
+}
diff --git a/sources/protocols/VSProtocol.java b/sources/protocols/VSProtocol.java
new file mode 100644
index 0000000..b66f034
--- /dev/null
+++ b/sources/protocols/VSProtocol.java
@@ -0,0 +1,125 @@
+package protocols;
+
+import prefs.VSPrefs;
+import events.VSEvent;
+import core.*;
+
+abstract public class VSProtocol extends VSPrefs implements VSEvent {
+    protected VSPrefs prefs;
+    private String protocolClassname;
+    private boolean isServer;
+    private boolean isClient;
+    protected VSProcess process;
+    private boolean currentContextIsServer;
+    private boolean lamportIncreased;
+
+    public VSProtocol() {
+    }
+
+    protected final void setProtocolClassname(String protocolClassname) {
+        if (protocolClassname.startsWith("class "))
+            protocolClassname = protocolClassname.substring(6);
+
+        this.protocolClassname = protocolClassname;
+    }
+
+    public final String getProtocolClassname() {
+        return protocolClassname;
+    }
+
+    public final String getProtocolName() {
+        return RegisteredProtocols.getProtocolName(protocolClassname);
+    }
+
+    public final VSProcess getProcess() {
+        return process;
+    }
+
+    protected void sendMessage(VSMessage message) {
+        process.setLamportTime(process.getLamportTime()+1);
+        message.setSendingProcess(process);
+        process.sendMessage(message);
+    }
+
+    private final boolean isIncorrectProtocol(VSMessage message) {
+        return !message.getProtocolClassname().equals(getProtocolClassname());
+    }
+
+    public final void onStart() {
+        if (isClient) {
+            onClientStart();
+            currentContextIsServer = false;
+        }
+    }
+
+    public final void onMessageRecv(VSMessage message) {
+        if (isIncorrectProtocol(message))
+            return;
+
+        if (isServer) {
+            currentContextIsServer = true;
+            onServerRecv(message);
+        }
+
+        if (isClient) {
+            currentContextIsServer = false;
+            onClientRecv(message);
+        }
+    }
+
+    public final void isServer(boolean isServer) {
+        this.isServer = isServer;
+    }
+
+    public final void isClient(boolean isClient) {
+        this.isClient = isClient;
+    }
+
+    public final void setVSPrefs(VSPrefs prefs) {
+        this.prefs = prefs;
+    }
+
+    public final void setProcess(VSProcess process) {
+        this.process = process;
+    }
+
+    public void reset() {
+        if (isServer) {
+            currentContextIsServer = true;
+            onServerReset();
+        }
+
+        if (isClient) {
+            currentContextIsServer = false;
+            onClientReset();
+        }
+    }
+
+    abstract protected void onClientStart();
+    abstract protected void onClientReset();
+    abstract protected void onClientRecv(VSMessage message);
+
+    abstract protected void onServerReset();
+    abstract protected void onServerRecv(VSMessage message);
+
+    protected void logg(String message) {
+        process.logg(toString() + "; " + message);
+    }
+
+    public boolean equals(VSProtocol protocol) {
+        return protocol.getID() == getID();
+    }
+
+    public String toString() {
+        String type = new String();
+
+        if (currentContextIsServer)
+            type += prefs.getString("lang.server");
+
+        else
+            type += prefs.getString("lang.client");
+
+        return prefs.getString("lang.protocol") + ": "
+               + RegisteredProtocols.getProtocolName(getProtocolClassname()) + " " + type;// + "; ID: " + getID();
+    }
+}