toxiclibs 0.2-java → 0.5.0-java

data/src/com/toxi/net/ClientListener.java

@@ -0,0 +1,41 @@
+package com.toxi.net;
+
+/**
+ *
+ * @author tux
+ */
+public interface ClientListener {
+    /**
+     * Callback to trigger an update of the server managed process. This might
+     * be called several times in a row if the client has fallen behind in time.
+     * There should be NO rendering related tasks being called from this
+     * callback.
+     */
+    public void triggerUpdate();
+
+    /**
+     * Callback to trigger the rendering of a new frame. This method will ALWAYS
+     * be called after {{@link #triggerUpdate()} and should be purely focused on
+     * drawing/rendering specific tasks, but no CPU intensive model updates.
+     */
+    public void triggerFrame();
+
+    /**
+     * Callback to confirm client has successfully connected
+     */
+    public void notifyConnected();
+
+    /**
+     * Callback to notify client has disconnected from the server.
+     */
+    public void notifyDisconnected();
+
+    /**
+     * Callback to give the client a chance to react to the encountered
+     * exception.
+     * 
+     * @param e
+     *            the exception which caused the callback
+     */
+    public void handleError(Exception e);
+}

data/src/com/toxi/net/ServerListener.java

@@ -0,0 +1,70 @@
+package com.toxi.net;
+
+import java.net.DatagramPacket;
+
+/**
+ *
+ * @author tux
+ */
+public interface ServerListener {
+
+    /**
+     * Notifies listener immediately after the server socket has been created.
+     */
+    public void serverStarted();
+
+    /**
+     * Notifies the listener server is shutting down.
+     */
+    public void serverShutdown();
+
+    /**
+     * Gives listener a chance to react to any fatal server errors.
+     * 
+     * @param e
+     */
+    public void serverError(Exception e);
+
+    /**
+     * Notifies the listener of a new server state. The state info itself is
+     * attached.
+     * 
+     * @param s
+     */
+    public void serverStateChanged(ServerState s);
+
+    /**
+     * Notifies listener of a new client connection. Details are attached.
+     * 
+     * @param conn
+     */
+    public void clientConnected(UDPConnection conn);
+
+    /**
+     * Notifies listener a client has disconnected. Connection details are
+     * attached.
+     * 
+     * @param conn
+     */
+    public void clientDisconnected(UDPConnection conn);
+
+    /**
+     * Notifies and forwards received client data to the listener for further
+     * analysis.
+     * 
+     * @param conn
+     *            client connection details
+     * @param receivePacket
+     *            data sent by the client
+     */
+    public void clientUpdated(UDPConnection conn, DatagramPacket receivePacket);
+
+    /**
+     * Gives the listener a chance to add extra data to the payload packet
+     * distributed to each client.
+     * 
+     * @return additional data, or null if none required
+     */
+    public byte[] getSyncPayload();
+
+}

data/src/com/toxi/net/ServerListenerAdapter.java

@@ -0,0 +1,47 @@
+/**
+ * 
+ */
+package com.toxi.net;
+
+import java.net.DatagramPacket;
+
+/**
+ * @author toxi
+ * 
+ */
+public class ServerListenerAdapter implements ServerListener {
+
+    @Override
+    public void clientConnected(UDPConnection conn) {
+
+    }
+
+    @Override
+    public void clientDisconnected(UDPConnection conn) {
+    }
+
+    @Override
+    public void clientUpdated(UDPConnection conn, DatagramPacket receivePacket) {
+    }
+
+    @Override
+    public byte[] getSyncPayload() {
+        return new byte[0];
+    }
+
+    @Override
+    public void serverError(Exception e) {
+    }
+
+    @Override
+    public void serverShutdown() {
+    }
+
+    @Override
+    public void serverStarted() {
+    }
+
+    @Override
+    public void serverStateChanged(ServerState s) {
+    }
+}

data/src/com/toxi/net/ServerState.java

@@ -0,0 +1,18 @@
+package com.toxi.net;
+
+/**
+ *
+ * @author tux
+ */
+public enum ServerState {
+
+    /**
+     *
+     */
+    WAITING_FOR_CLIENTS,
+
+    /**
+     *
+     */
+    SYNCHING
+}

data/src/com/toxi/net/UDPConnection.java

@@ -0,0 +1,66 @@
+package com.toxi.net;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * @author Karsten Schmidt <info@postspectacular.com>
+ */
+
+class UDPConnection {
+
+    /**
+     * Default time-to-live duration
+     */
+    static int TTL = 10000;
+
+    protected InetAddress ip;
+    protected int port;
+
+    protected long lastUpdate;
+
+    UDPConnection(InetAddress ip, int port) {
+        this.ip = ip;
+        this.port = port;
+        lastUpdate = System.currentTimeMillis();
+    }
+
+    public boolean isAlive() {
+        return System.currentTimeMillis() - lastUpdate < TTL;
+    }
+
+    public void update() {
+        lastUpdate = System.currentTimeMillis();
+    }
+
+    public void send(DatagramSocket socket, byte[] data) throws IOException {
+        DatagramPacket sendPacket = new DatagramPacket(data, data.length, ip,
+                port);
+        socket.send(sendPacket);
+    }
+
+    public InetAddress getIP() {
+        return ip;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public long getLastUpdate() {
+        return lastUpdate;
+    }
+
+    @Override
+    public String toString() {
+        return UDPConnection.buildHash(ip, port);
+    }
+
+    static final void setTTL(int ttl) {
+        TTL = ttl;
+    }
+
+    public static final String buildHash(InetAddress ip, int port) {
+        return ip.getHostAddress() + ":" + port;
+    }
+}

data/src/com/toxi/net/UDPSyncClient.java

@@ -0,0 +1,81 @@
+package com.toxi.net;
+
+import java.io.IOException;
+import java.net.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+class UDPSyncClient extends Thread {
+    private ClientListener listener;
+
+    protected String serverName;
+    protected int port;
+    protected int clientID;
+    protected int ttl;
+
+    private int frameCount;
+    protected long lastUpdate;
+
+    private static final Logger logger = Logger.getLogger(UDPSyncClient.class
+            .getName());
+
+    UDPSyncClient(String serverName, int port, int clientID, int ttl) {
+        this.serverName = serverName;
+        this.port = port;
+        this.clientID = clientID;
+        this.ttl = ttl;
+    }
+
+    @Override
+    public void run() {
+        DatagramSocket clientSocket = null;
+        lastUpdate = System.currentTimeMillis();
+        try {
+            clientSocket = new DatagramSocket();
+            InetAddress ip = InetAddress.getByName(serverName);
+            byte[] sendData = new byte[] { 1 };
+            byte[] receiveData = new byte[8];
+            // do initial sign on by sending a message to the server
+            DatagramPacket sendPacket = new DatagramPacket(sendData,
+                    sendData.length, ip, port);
+            clientSocket.send(sendPacket);
+            while (true) {
+                DatagramPacket receivePacket = new DatagramPacket(receiveData,
+                        receiveData.length);
+                clientSocket.receive(receivePacket);
+                String payload = new String(receivePacket.getData(), 0,
+                        receivePacket.getLength());
+                if (logger != null)
+                    logger.finest(payload);
+                int newFrameCount = Integer.parseInt(payload);
+                if (newFrameCount > 0) {
+                    while (frameCount < newFrameCount) {
+                        if (listener != null)
+                            listener.triggerUpdate();
+                        frameCount++;
+                    }
+                }
+                if (listener != null)
+                    listener.triggerFrame();
+                long now = System.currentTimeMillis();
+                if (now - lastUpdate > ttl) {
+                    sendPacket = new DatagramPacket(sendData, sendData.length,
+                            ip, port);
+                    clientSocket.send(sendPacket);
+                    lastUpdate = now;
+                    if (logger != null)
+                        logger.log(Level.FINER, "TTL updated on: {0}", lastUpdate);
+                }
+            }
+        } catch (IOException | NumberFormatException ex) {
+            logger.log(Level.SEVERE, null, ex);
+        } finally {
+            if (clientSocket != null)
+                clientSocket.close();
+        }
+    }
+
+    public void setListener(ClientListener l) {
+        listener = l;
+    }
+}

data/src/com/toxi/net/UDPSyncServer.java

@@ -0,0 +1,450 @@
+package com.toxi.net;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketTimeoutException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.kohsuke.args4j.CmdLineException;
+import org.kohsuke.args4j.CmdLineParser;
+import org.kohsuke.args4j.Option;
+
+import toxi.util.datatypes.TypedProperties;
+
+/**
+ * <p>
+ * An <a href="http://mostpixelsever.com">MPE</a> inspired synch server for
+ * networked multi-screen applications. All communication is realised via UDP.
+ * Clients are not requested to acknowledge every single packet received, but
+ * need to send a heart beat in a regular (configurable) interval. The server
+ * discards any data received from clients, so it doesn't matter what is being
+ * sent back. A single byte will suffice.
+ * </p>
+ * 
+ * <p>
+ * The server can be configured via CLI arguments and/or Java property files and
+ * can be connected to an existing logger. When run on from the commandline a
+ * console logger is automatically added.
+ * </p>
+ * 
+ * @author Karsten Schmidt <info@postspectacular.com>
+ */
+public class UDPSyncServer {
+
+    private static final int DEFAULT_RECEIVE_PACKET_SIZE = 32;
+
+    private static final int DEFAULT_NUM_CLIENTS = 1;
+
+    private static final int DEFAULT_FRAMERATE = 30;
+
+    private static final int DEFAULT_PORT = 9002;
+
+    private static final int DEFAULT_RECEIVE_TIMEOUT = 1;
+
+    private ServerState state;
+
+    DatagramSocket socket;
+    HashMap<String, UDPConnection> connections = new HashMap<>();
+
+    /**
+     *
+     */
+    @Option(name = "-port", aliases = "-p", usage = "server socket port number")
+    protected int port = DEFAULT_PORT;
+
+    @Option(name = "-config", aliases = "-c", usage = "path to configuration file", metaVar = "PATH")
+    private String configFile;
+    private TypedProperties config;
+
+    @Option(name = "-packetsize", aliases = "-s", usage = "receive packet size")
+    private int receivePacketSize = DEFAULT_RECEIVE_PACKET_SIZE;
+    private byte[] receiveData;
+
+    /**
+     *
+     */
+    @Option(name = "-rectimeout", aliases = "-rt", usage = "receive timeout (in ms), minimum 1ms")
+    protected int receiveTimeOut = DEFAULT_RECEIVE_TIMEOUT;
+
+    /**
+     *
+     */
+    @Option(name = "-ttl", usage = "client time-to-live, max. time interval after which clients expire")
+    protected int connectionTimeOut = UDPConnection.TTL;
+
+    /**
+     *
+     */
+    @Option(name = "-numclients", aliases = "-num", usage = "number of clients")
+    protected int numClients = DEFAULT_NUM_CLIENTS;
+
+    /**
+     *
+     */
+    @Option(name = "-framerate", aliases = "-fps", usage = "target framerate")
+    protected int frameRate = DEFAULT_FRAMERATE;
+
+    /**
+     *
+     */
+    protected int frameDuration;
+
+    /**
+     *
+     */
+    protected int frameCount;
+
+    private static Logger logger;
+
+    /**
+     * Optional server event listener
+     */
+    protected ServerListener listener;
+
+    /**
+     *
+     */
+    public UDPSyncServer() {
+        config = new TypedProperties();
+        setMaxReceivePacketSize(DEFAULT_RECEIVE_PACKET_SIZE);
+    }
+
+    /**
+     *
+     * @param args
+     */
+    public static void main(String args[]) {
+        new UDPSyncServer().execute(args);
+    }
+
+    /**
+     * Main entry point for CLI.
+     * 
+     * @param args
+     *            command line arguments
+     */
+    public void execute(String[] args) {
+        CmdLineParser parser = new CmdLineParser(this);
+        parser.setUsageWidth(80);
+        try {
+            parser.parseArgument(args);
+        } catch (CmdLineException e) {
+            System.err.println(e.getMessage());
+            System.err.println("java UDPSyncServer [options]");
+            parser.printUsage(System.err);
+            System.err.println();
+            return;
+        }
+
+        try {
+            if (configFile != null)
+                config.load(new FileInputStream(configFile));
+            logger = Logger.getLogger("com.postspectacular");
+            logger.addHandler(new ConsoleHandler());
+            logger.setLevel(Level.CONFIG);
+            configure(config);
+            run();
+        } catch (FileNotFoundException e) {
+            System.err.println("cannot find config file @ " + args[0]);
+        } catch (IOException e) {
+            System.err.println("cannot read config file @ " + args[0]);
+        }
+    }
+
+    /**
+     * Configures the server with settings using the passed-in properties.
+     * 
+     * @param config
+     */
+    public void configure(TypedProperties config) {
+        this.config = config;
+        port = config.getInt("server.port", port);
+        setMaxReceivePacketSize(config.getInt("udp.packetsize",
+                receivePacketSize));
+        numClients = config.getInt("server.numclients", numClients);
+        frameRate = config.getInt("server.framerate", frameRate);
+        frameDuration = 1000 / frameRate;
+        connectionTimeOut = config.getInt("udp.ttl", connectionTimeOut);
+        UDPConnection.setTTL(connectionTimeOut);
+        receiveTimeOut = config.getInt("udp.receivetimeout", receiveTimeOut);
+        if (logger != null) {
+            logger.log(Level.INFO, "configured server... port:{0} clients:{1} fps:{2} ttl:{3} rto:{4}", new Object[]{port, numClients, frameRate, connectionTimeOut, receiveTimeOut});
+        }
+        setState(ServerState.WAITING_FOR_CLIENTS);
+    }
+
+    /**
+     * Main server loop/state machine. Creates socket and handles syncing of
+     * connected clients.
+     */
+    public void run() {
+        try {
+            socket = new DatagramSocket(port);
+            if (logger != null)
+                logger.log(Level.INFO, "creating socket @ port {0}", port);
+            if (listener != null) {
+                listener.serverStarted();
+            }
+            while (true) {
+                switch (state) {
+
+                    case WAITING_FOR_CLIENTS:
+                        if (logger != null)
+                            logger.info("Server running, waiting for connections...");
+                        // disable timeout, i.e socket will block indefinitely
+                        // until
+                        // a packet is received
+                        socket.setSoTimeout(0);
+                        while (connections.size() < numClients) {
+                            receiveAndAddConnection();
+                        }
+                        // all connected, start syncing...
+                        setState(ServerState.SYNCHING);
+                        break;
+
+                    case SYNCHING:
+                        socket.setSoTimeout(receiveTimeOut);
+                        if (connections.size() > 0) {
+                            doHeartBeat();
+                            byte[] payload = getSyncPayload();
+                            Iterator<UDPConnection> iter = connections.values()
+                                    .iterator();
+                            // Uses nanoTime for better precision / more stable
+                            // framerate, but unavailable on OSX!!!
+                            long beginSynch = System.nanoTime();
+                            while (iter.hasNext()) {
+                                UDPConnection conn = iter.next();
+                                if (!conn.isAlive()) {
+                                    iter.remove();
+                                    if (logger != null)
+                                        logger.log(Level.WARNING, "{0} disconnected", conn);
+                                    if (listener != null)
+                                        listener.clientDisconnected(conn);
+                                }
+                                conn.send(socket, payload);
+                            }
+                            int returnCount = 0;
+                            while (returnCount < numClients
+                                    && returnCount < connections.size() + 1) {
+                                try {
+                                    DatagramPacket receivePacket = new DatagramPacket(
+                                            receiveData, receiveData.length);
+                                    socket.receive(receivePacket);
+                                    InetAddress ip = receivePacket.getAddress();
+                                    int portDP = receivePacket.getPort();
+                                    String connID = UDPConnection.buildHash(ip,
+                                            portDP);
+                                    UDPConnection conn = connections
+                                            .get(connID);
+                                    if (conn != null) {
+                                        conn.update();
+                                        returnCount++;
+                                    } else {
+                                        // renewed connection
+                                        conn = new UDPConnection(ip, portDP);
+                                        conn.send(socket, getSyncPayload());
+                                        connections.put(connID, conn);
+                                        if (logger != null)
+                                            logger.log(Level.FINE, "re-adding connection: {0}", conn);
+                                    }
+                                    if (listener != null)
+                                        listener.clientUpdated(conn,
+                                                receivePacket);
+                                } catch (SocketTimeoutException e) {
+                                    // no further packets available
+                                    break;
+                                }
+                            }
+                            long endSynch = System.nanoTime();
+                            long delta = (endSynch - beginSynch) / 1000000;
+                            if (delta < frameDuration) {
+                                int sleep = frameDuration - (int) delta;
+                                if (logger != null)
+                                    logger.log(Level.FINEST, "sleeping: {0}", sleep);
+                                Thread.sleep(sleep);
+                            }
+                        } else {
+                            if (logger != null)
+                                logger.info("all clients disconnected");
+                            setState(ServerState.WAITING_FOR_CLIENTS);
+                        }
+                }
+            }
+        } catch (IOException | InterruptedException e) {
+            handleException(e);
+        } finally {
+            if (logger != null)
+                logger.info("server shutting down...");
+            if (socket != null)
+                socket.close();
+        }
+    }
+
+    /**
+     * Attempts to receive data sent from clients to confirm they're still
+     * connected. The timeout for this action is set to 1ms by default, so
+     * currently not more than 25 machines can be reliably connected & synched
+     * at 25fps.
+     * 
+     * If a connection times out it's removed from the list of active clients.
+     * On the other hand if a new connection hash is found we know a client has
+     * reconnected and will be added back to the pool.
+     */
+    protected void receiveAndAddConnection() {
+        try {
+            DatagramPacket receivePacket = new DatagramPacket(receiveData,
+                    receiveData.length);
+            if (logger != null)
+                logger.log(Level.INFO, "waiting for {0} more clients to reconnect...", (numClients - connections.size()));
+            socket.receive(receivePacket);
+            InetAddress ip = receivePacket.getAddress();
+            int portDP = receivePacket.getPort();
+            String connID = UDPConnection.buildHash(ip, portDP);
+            if (connections.get(connID) == null) {
+                if (connections.isEmpty()) {
+                    frameCount = 0;
+                    if (logger != null)
+                        logger.info("resetting frame count");
+                }
+                UDPConnection conn = new UDPConnection(ip, portDP);
+                connections.put(connID, conn);
+                conn.send(socket, getSyncPayload());
+                if (logger != null)
+                    logger.log(Level.FINE, "added new connection: {0}", conn);
+                if (listener != null) {
+                    listener.clientConnected(conn);
+                }
+            }
+        } catch (SocketTimeoutException e) {
+        } catch (IOException e) {
+            handleException(e);
+        }
+    }
+
+    private void handleException(Exception e) {
+        if (listener != null)
+            listener.serverError(e);
+        if (logger != null)
+            logger.log(Level.SEVERE, "Server error", e);
+        else
+            e.printStackTrace();
+    }
+
+    /**
+     * Updates the internal state of the heartbeat info sent out later.
+     */
+    protected void doHeartBeat() {
+        frameCount++;
+    }
+
+    /**
+     * Collects and formats payload data sent via UDP to all clients. By default
+     * only the current frame number is sent. If more data is required you can
+     * either overwrite this method or append data via an attached
+     * {@link ServerListener}.
+     * 
+     * @return payload data as byte array
+     */
+    protected byte[] getSyncPayload() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(frameCount);
+        byte[] defaultPayload = sb.toString().getBytes();
+        if (listener != null) {
+            byte[] userPayload = listener.getSyncPayload();
+            if (userPayload != null) {
+                byte[] combinedPayload = new byte[defaultPayload.length
+                        + userPayload.length];
+                System.arraycopy(defaultPayload, 0, combinedPayload, 0,
+                        defaultPayload.length);
+                System.arraycopy(userPayload, 0, combinedPayload,
+                        defaultPayload.length, userPayload.length);
+                return combinedPayload;
+            }
+        }
+        return defaultPayload;
+    }
+
+    /**
+     * Triggers and logs a new server state. If present, this will also notify
+     * the {@link ServerListener}.
+     * 
+     * @param s
+     *            new server state
+     */
+    private void setState(ServerState s) {
+        state = s;
+        if (logger != null)
+            logger.log(Level.CONFIG, "new server state: {0}", state);
+        if (listener != null)
+            listener.serverStateChanged(s);
+    }
+
+    /**
+     * @return Maximum size of UDP packets the server is able to receive
+     */
+    public int getMaxPacketSize() {
+        return receiveData.length;
+    }
+
+    /**
+     * Sets the max. size of UDP packets the server is able to receive
+     * 
+     * @param size
+     */
+    public final void setMaxReceivePacketSize(int size) {
+        receivePacketSize = size;
+        if (receiveData == null) {
+            receiveData = new byte[size];
+        } else if (receiveData.length != size) {
+            synchronized (receiveData) {
+                receiveData = new byte[size];
+            }
+        }
+    }
+
+    /**
+     * @return configured number of clients the server is expecting and
+     *         initially waiting for to connect before any syncing begins.
+     */
+    public int getNumClients() {
+        return numClients;
+    }
+
+    /**
+     * Sets the number of clients the server is expecting and initially waiting
+     * for to connect before any syncing begins.
+     * 
+     * @param numClients
+     */
+    public void setNumClients(int numClients) {
+        this.numClients = numClients;
+    }
+
+    /**
+     * Attaches a logger to the server.
+     * 
+     * @param logger
+     */
+    public void setLogger(Logger logger) {
+        UDPSyncServer.logger = logger;
+    }
+
+    /**
+     * Attaches an event listener to the server.
+     * 
+     * @param listener
+     */
+    public void setListener(ServerListener listener) {
+        this.listener = listener;
+        if (logger != null)
+            logger.log(Level.INFO, "new server listener: {0}", listener);
+    }
+}