BatchServer.java

package edu.stanford.hci.r3.pen.batch;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import edu.stanford.hci.r3.PaperToolkit;
import edu.stanford.hci.r3.config.Constants;
import edu.stanford.hci.r3.events.EventEngine;
import edu.stanford.hci.r3.pattern.PatternPackage;
import edu.stanford.hci.r3.util.DebugUtils;

public class BatchServer {

        public static final int DEFAULT_PLAINTEXT_PORT = Constants.Ports.BATCH_SERVER;

        public static final String EXIT_COMMAND = "[[exit]]";

        private List<Socket> clients = new ArrayList<Socket>();

        private EventEngine eventEngine;

        private List<BatchedEventHandler> eventHandlers = new ArrayList<BatchedEventHandler>();

        private boolean exitFlag = false;

        private Map<String, PatternPackage> patternPackages = PatternPackage
                        .getAvailablePatternPackages(PaperToolkit.getPatternPath());

        private int serverPort;

        private ServerSocket serverSocket;

        public BatchServer(EventEngine theEventEngine) {
                try {
                        eventEngine = theEventEngine;
                        serverSocket = new ServerSocket(DEFAULT_PLAINTEXT_PORT);
                        serverPort = DEFAULT_PLAINTEXT_PORT;
                        // start thread to accept connections
                        getDaemonThread().start();
                } catch (IOException e) {
                        System.out.println("Error with server socket: " + e.getLocalizedMessage());
                }
        }

        private Thread getClientHandlerThread(final Socket clientSocket) {
                return new Thread() {

                        private BufferedReader br;

                        public synchronized void disconnect() {
                                try {
                                        if (!clientSocket.isClosed()) {
                                                clientSocket.close();
                                        }
                                        if (br != null) {
                                                br.close();
                                                br = null;
                                        }
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }

                        public void run() {
                                try {
                                        final InputStream inputStream = clientSocket.getInputStream();
                                        br = new BufferedReader(new InputStreamReader(inputStream));
                                        String line = null;
                                        while ((line = br.readLine()) != null) {
                                                // DebugUtils.println(line);
                                                if (line.toLowerCase().equals(EXIT_COMMAND)) {
                                                        break;
                                                }

                                                // the server's exit flag
                                                // it can kill all clients at the same time
                                                if (exitFlag) {
                                                        break;
                                                }

                                                // the file name is everything after...
                                                if (line.toLowerCase().startsWith("xml: ")) {
                                                        // get the file name of the xml file
                                                        final String fileName = line.substring(5).trim();
                                                        // DebugUtils.println(fileName); // everything afterward
                                                        final File xmlFile = new File(fileName);
                                                        DebugUtils.println("Retrieving: " + xmlFile.getAbsolutePath());
                                                        if (xmlFile.exists()) {
                                                                // System.out.println("The file exists!");
                                                                for (BatchedEventHandler beh : eventHandlers) {
                                                                        // send the xml file to the batched event handler...
                                                                        beh.batchedDataArrived(xmlFile);
                                                                }
                                                        } else {
                                                                DebugUtils.println("The file does not exist. =(");
                                                        }
                                                }
                                        }
                                        DebugUtils.println("Import Thread Finished...");
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                                disconnect();
                        }

                };
        }

        private Thread getDaemonThread() {
                return new Thread() {

                        public void run() {
                                while (true) {
                                        Socket client = null;
                                        try {
                                                if (exitFlag) {
                                                        log("Closing BatchServer.");
                                                        break;
                                                }

                                                log("Waiting for a connection on port [" + serverPort + "]");

                                                client = serverSocket.accept();

                                                final InetAddress inetAddress = client.getInetAddress();
                                                final String ipAddr = inetAddress.toString();
                                                final String dnsName = inetAddress.getHostName();

                                                // we got a connection with the client
                                                log("Got a connection on server port " + serverPort);
                                                log("               from client: " + ipAddr + " :: " + dnsName);

                                                // keep it around
                                                clients.add(client);
                                                getClientHandlerThread(client).start();
                                        } catch (IOException ioe) {
                                                log("Error with server socket: " + ioe.getLocalizedMessage());
                                        }
                                }
                        }
                };
        }

        private void log(String msg) {
                System.out.println("Batch Server: " + msg);
        }

        public void registerBatchEventHandlers(List<BatchedEventHandler> batchEventHandlers) {
                for (BatchedEventHandler beh : batchEventHandlers) {
                        eventHandlers.add(beh);
                }
        }

        public void stopDaemon() {
                try {
                        exitFlag = true;
                        for (Socket client : clients) {
                                client.close();
                        }
                        System.out.println("BatchServer on port " + serverSocket.getLocalPort() + " is stopping...");
                        serverSocket.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        public void unregisterBatchEventHandlers(List<BatchedEventHandler> batchEventHandlers) {
                for (BatchedEventHandler beh : batchEventHandlers) {
                        eventHandlers.remove(beh);
                        DebugUtils.println("Unregistering BatchEventHandler [" + beh + "]");
                }
        }

}

---