1 Moved the stuff to trunk!

1 files changed, 442 insertions, 0 deletions

diff --git a/sources/core/VSProcess.java b/sources/core/VSProcess.java
new file mode 100644
index 0000000..bb65959
--- /dev/null
+++ b/sources/core/VSProcess.java
@@ -0,0 +1,442 @@
+package core;
+
+import java.awt.*;
+import java.util.*;
+
+import prefs.*;
+import protocols.*;
+import simulator.*;
+import utils.*;
+import events.*;
+
+public final class VSProcess extends VSPrefs {
+    private VSTask randomCrashTask;
+    private Color currentColor;
+    private Color tmpColor;
+    private Color crashedColor;;
+    private VSLogging logging;
+    private VSPrefs prefs;
+    private VSRandom random;
+    private VSSimulationPanel simulationPanel;
+    private boolean hasStarted;
+    private boolean isHighlighted;
+    private boolean isPaused;
+    private boolean timeModified;
+    private double clockOffset;
+    private float clockVariance;
+    private int num;
+    private int processID;
+    private long globalTime;
+    private long localTime;
+    private static int processCounter;
+    private boolean isCrashed;
+    private long lamportTime;
+    private ArrayList<VSLamport> lamportTimestamps;
+    private ArrayList<Integer> vectorTimestamps;
+
+    /* This array contains all Integer prefs of the process which should show
+     * up in the prefs menu! All keys which dont start with "sim." only show
+     * up in the extended prefs menu!
+     */
+    private static final String DEFAULT_INTEGER_VALUE_KEYS[] = {
+        "sim.process.prob.crash",
+        "sim.message.prob.outage",
+    };
+
+    /* This array contains all Long prefs of the process which should show
+     * up in the prefs menu! All keys which dont start with "sim." only show
+     * up in the extended prefs menu!
+     */
+    private static final String DEFAULT_LONG_VALUE_KEYS[] = {
+        "sim.message.sendingtime.min",
+        "sim.message.sendingtime.max",
+    };
+
+    /* This array contains all Float prefs of the process which should show
+     * up in the prefs menu! All keys which dont start with "sim." only show
+     * up in the extended prefs menu!
+     */
+    private static final String DEFAULT_FLOAT_VALUE_KEYS[] = {
+        "sim.process.clock.variance",
+    };
+
+    /* This array contains all Color prefs of the process which should show
+     * up in the prefs menu! All keys which dont start with "sim." only show
+     * up in the extended prefs menu!
+     */
+    private static final String DEFAULT_COLOR_VALUE_KEYS[] = {
+        "process.default",
+        "process.running",
+        "process.stopped",
+        "process.highlight",
+        "process.crashed",
+    };
+
+    /* This array contains all String prefs of the process which should show
+     * up in the prefs menu! All keys which dont start with "sim." only show
+     * up in the extended prefs menu!
+     */
+    private static final String DEFAULT_STRING_VALUE_KEYS[] = {
+    };
+
+    public VSProcess(VSPrefs prefs, VSSimulationPanel simulationPanel, VSLogging logging, int num) {
+        this.prefs = prefs;
+        this.simulationPanel = simulationPanel;
+        this.logging = logging;
+        this.num = num;
+        this.random = new VSRandom(processID+processCounter);
+        this.lamportTimestamps = new ArrayList<VSLamport>();
+        this.vectorTimestamps = new ArrayList<Integer>();
+        setLamportTime(0);
+
+        setObject("protocols", new ArrayList<VSProtocol>());
+
+        isPaused = true;
+        processID = ++processCounter;
+
+        /* Create the super.VSPrefs with it's default prefs */
+        fillWithDefaults();
+
+        /* Make local copys in order to have more performance */
+        clockVariance = getFloat("sim.process.clock.variance");
+        currentColor = getColor("process.default");
+
+        /* Make additional process settings editable through GUI */
+        initInteger("sim.process.id", processID,
+                    prefs.getString("lang.process.id"), 1, processID + 10);
+        setLongIfUnset("sim.process.localtime", localTime, prefs.getString("lang.process.time.local"));
+
+        crashedColor = getColor("process.crashed");
+        createRandomCrashTask();
+    }
+
+    /**
+     * Called from the VSProcessEditor, after finishing editing!
+     */
+    public synchronized void updateFromVSPrefs() {
+        setClockVariance(getFloat("sim.process.clock.variance"));
+        setProcessID(getInteger("sim.process.id"));
+        setLocalTime(getLong("sim.process.localtime"));
+        crashedColor = getColor("process.crashed");
+        simulationPanel.repaint();
+        createRandomCrashTask();
+    }
+
+    /**
+     * Called from the VSProcessEditor, before starting editing!
+     */
+    public synchronized void updatePrefs() {
+        setFloat("sim.process.clock.variance", getClockVariance());
+        setInteger("sim.process.id", getProcessID());
+        setLong("sim.process.localtime", getTime());
+    }
+
+    public synchronized void syncTime(final long globalTime) {
+        final long currentGlobalTimestep = globalTime - this.globalTime;
+        this.globalTime = globalTime;
+
+        if (!isCrashed) {
+            localTime += currentGlobalTimestep;
+            clockOffset += currentGlobalTimestep * (double) clockVariance;
+        }
+
+        while (clockOffset >= 1) {
+            clockOffset -= 1;
+            ++localTime;
+        }
+
+        while (clockOffset <= -1) {
+            clockOffset += 1;
+            --localTime;
+        }
+
+        if (localTime < 0)
+            localTime = 0;
+    }
+
+    private void setCurrentColor(Color newColor) {
+        if (isHighlighted)
+            tmpColor = newColor;
+        else
+            currentColor = newColor;
+    }
+
+    public synchronized void highlightOn() {
+        tmpColor = currentColor;
+        currentColor = getColor("process.highlight");
+        isHighlighted = true;
+    }
+
+    public synchronized void highlightOff() {
+        currentColor = tmpColor;
+        isHighlighted = false;
+    }
+
+    public synchronized void reset() {
+        isPaused = true;
+        isCrashed = false;
+        localTime = 0;
+        globalTime = 0;
+        clockOffset = 0;
+        lamportTime = 0;
+        lamportTimestamps.clear();
+        vectorTimestamps.clear();
+
+        if (objectExists("protocols.registered")) {
+            Object protocolsObj = getObject("protocols.registered");
+            if (protocolsObj instanceof Vector) {
+                Vector<VSProtocol> protocols = (Vector<VSProtocol>) protocolsObj;
+                for (VSProtocol protocol : protocols)
+                    protocol.reset();
+            }
+        }
+
+        setCurrentColor(getColor("process.default"));
+        createRandomCrashTask();
+    }
+
+    private void createRandomCrashTask() {
+        if (!isCrashed) {
+            VSTaskManager taskManager = simulationPanel.getTaskManager();
+            long crashTime = getARandomCrashTime();
+
+            if (randomCrashTask != null)
+                taskManager.removeTask(randomCrashTask);
+
+            if (crashTime >= 0 && crashTime >= getGlobalTime())  {
+                randomCrashTask = new VSTask(crashTime, this, new ProcessCrashEvent());
+                taskManager.addTask(randomCrashTask);
+                //System.out.println("DEBUG " + processID + " crashes at " + crashTime);
+
+            } else {
+                randomCrashTask = null;
+            }
+        }
+    }
+
+    public synchronized void addClockOffset(long add) {
+        this.clockOffset += add;
+    }
+
+    public synchronized void play() {
+        isPaused = false;
+        setCurrentColor(getColor("process.running"));
+    }
+
+    public synchronized void pause() {
+        isPaused = true;
+        setCurrentColor(getColor("process.stopped"));
+    }
+
+    public synchronized void finish() {
+        isPaused = true;
+        setCurrentColor(getColor("process.default"));
+    }
+
+    public synchronized int getProcessID() {
+        return processID;
+    }
+
+    public synchronized void setProcessID(int processID) {
+        this.processID = processID;
+    }
+
+    public synchronized Color getColor() {
+        return currentColor;
+    }
+
+    public synchronized void setLocalTime(final long localTime) {
+        if (localTime >= 0)
+            this.localTime = localTime;
+        else
+            this.localTime = 0;
+    }
+
+    public synchronized long getTime() {
+        return localTime;
+    }
+
+    public synchronized void setTime(final long time) {
+        if (time >= 0)
+            this.localTime = time;
+        else
+            this.localTime = 0;
+
+        this.timeModified = true;
+    }
+
+    public synchronized boolean isCrashed() {
+        return isCrashed;
+    }
+
+    public synchronized void isCrashed(boolean isCrashed) {
+        this.isCrashed = isCrashed;
+    }
+
+    public synchronized Color getCrashedColor() {
+        return crashedColor;
+    }
+
+    public int getNum() {
+        return num;
+    }
+
+    public synchronized boolean timeModified() {
+        return timeModified;
+    }
+
+    public synchronized void timeModified(boolean timeModified) {
+        this.timeModified = timeModified;
+    }
+
+    public synchronized long getGlobalTime() {
+        return globalTime;
+    }
+
+    public synchronized void setGlobalTime(final long globalTime) {
+        this.globalTime = globalTime >= 0 ? globalTime : 0;
+    }
+
+    public synchronized float getClockVariance() {
+        return clockVariance;
+    }
+
+    public synchronized void setClockVariance(float clockVariance) {
+        /* If negative, only allow < 1 prefs */
+        if (clockVariance < 0) {
+            int part = (int) -clockVariance;
+            if (part > 0) {
+                this.clockVariance = 0;
+                return;
+            }
+        }
+
+        this.clockVariance = clockVariance;
+    }
+
+    public synchronized long getDurationTime() {
+        final long maxDurationTime = getLong("sim.message.sendingtime.max");
+        final long minDurationTime = getLong("sim.message.sendingtime.min");
+
+        if (maxDurationTime <= minDurationTime)
+            return minDurationTime;
+
+        final int diff = (int) (maxDurationTime - minDurationTime);
+
+        /* Integer overflow */
+        if (diff <= 0)
+            return minDurationTime;
+
+        return minDurationTime + random.nextInt(diff+1);
+    }
+
+    public synchronized long getARandomMessageOutageTime(final long durationTime) {
+        /* Check if the message will have an outage or not */
+        if (random.nextInt(100) <= getInteger("sim.message.prob.outage")) {
+            /* Calculate the random outage time! */
+            final long outageTime = globalTime + random.nextLong(durationTime+1) % simulationPanel.getUntilTime();
+            return outageTime;
+        }
+
+        /* No outage */
+        return -1;
+    }
+
+    private long getARandomCrashTime() {
+        /* Check if the process will crash or not */
+        if (random.nextInt(100) <= getInteger("sim.process.prob.crash")) {
+            /* Calculate the random crash time! */
+            final long crashTime =  random.nextLong(simulationPanel.getUntilTime()+1) % simulationPanel.getUntilTime();
+            return crashTime;
+        }
+
+        /* No crash */
+        return -1;
+    }
+
+    public synchronized VSTask getCrashTask() {
+        return randomCrashTask;
+    }
+
+    public synchronized boolean isPaused() {
+        return isPaused;
+    }
+
+    public synchronized long getLamportTime() {
+        return lamportTime;
+    }
+
+    public synchronized void setLamportTime(long lamportTime) {
+        this.lamportTime = lamportTime;
+        lamportTimestamps.add(new VSLamport(globalTime, lamportTime));
+    }
+
+    public synchronized VSLamport[] getLamportArray() {
+        final int size = lamportTimestamps.size();
+        final VSLamport[] arr = new VSLamport[size];
+
+        for (int i = 0; i < size; ++i)
+            arr[i] = lamportTimestamps.get(i);
+
+        return arr;
+    }
+
+    public synchronized int[] getVectorTime() {
+        final int size = vectorTimestamps.size();
+        final int[] arr = new int[size];
+
+        for (int i = 0; i < size; ++i)
+            arr[i] = vectorTimestamps.get(i);
+
+        return arr;
+    }
+
+
+    public void sendMessage(VSMessage message) {
+        logg(prefs.getString("lang.message.sent") + "; "
+             + prefs.getString("lang.protocol") + ": " + message.getProtocolName() + "; "
+             + prefs.getString("lang.message") + " " + message.toStringFull());
+        simulationPanel.sendMessage(message);
+    }
+
+    public void logg(String message) {
+        logging.logg(toString() + "; " + message, globalTime);
+    }
+
+    public void fillWithDefaults() {
+        prefs.copyIntegers(this, DEFAULT_INTEGER_VALUE_KEYS);
+        prefs.copyLongs(this, DEFAULT_LONG_VALUE_KEYS);
+        prefs.copyFloats(this, DEFAULT_FLOAT_VALUE_KEYS);
+        prefs.copyColors(this, DEFAULT_COLOR_VALUE_KEYS);
+        prefs.copyStrings(this, DEFAULT_STRING_VALUE_KEYS);
+    }
+
+    public String toString() {
+        return
+            prefs.getString("lang.process.id") + ": "
+            + getProcessID() + "; "
+            + prefs.getString("lang.process.time.local") + ": "
+            + VSTools.getTimeString(getTime())
+            + "; Lamport: " + lamportTime;
+    }
+
+    public String toStringFull() {
+        return toString() + "; paused: " + isPaused + "; crashed: " + isCrashed + "; crashTask: " + randomCrashTask;
+    }
+
+    public boolean equals(VSProcess process) {
+        return process.getNum() == getNum();
+    }
+
+    public VSSimulationPanel getSimulationPanel() {
+        return simulationPanel;
+    }
+
+    public VSPrefs getPrefs() {
+        return prefs;
+    }
+
+    public static void resetProcessCounter() {
+        processCounter = 0;
+    }
+}