starter/server/XuluServerStarter.java

package appl.parallel.starter.server;

import java.awt.AWTException;
import java.awt.Image;
import java.awt.MenuItem;
import java.awt.PopupMenu;
import java.awt.SystemTray;
import java.awt.Toolkit;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.SequenceInputStream;
import java.rmi.AccessException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

import schmitzm.swing.TextAreaPrintStream;
import schmitzm.swing.event.PopupMenuListener;

import appl.ext.XuluConfig;
import appl.parallel.ComputingResource;
import appl.parallel.server.XuluServer;
import appl.parallel.starter.Starter;
import appl.parallel.util.Helper;
import appl.util.GeneralUtil;

/**
 * A running instance of the XuluServerStarter waits for a signal to start a
 * {@link XuluServer}. When {@link #start()} is called the Server is started.
 * All output from the new Serverprocess are forwarded to the actual screen (if
 * any). The Server can also be {@link #restart() restarted} or
 * {@link #stop() stopped}. <br>
 * <br>
 * For configuration of the XuluServer the {@link XuluConfig} is used. The
 * following configuration entries are supported <TABLE border="1"
 * <tr>
 * <th>Entry</th>
 * <th>Default</th>
 * <th>Description</th>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.port</td>
 * <td>1099</td>
 * <td> The port which is used for the registry creation (if none is running)</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.javaprogram</td>
 * <td>java</td>
 * <td> The path to the java program</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.codebasedir</td>
 * <td></td>
 * <td> The absolute path to the codebase directory (should be the path to the
 * binaries)</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.securitypolicy</td>
 * <td></td>
 * <td> The path to the security policy</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.furtherjavaarguments</td>
 * <td></td>
 * <td> further JVM arguments</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.classpath</td>
 * <td></td>
 * <td> The libaries needed</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.memorymax</td>
 * <td>64</td>
 * <td> The maximum memory the XuluSever attempts to use (-xmx)</td>
 * </tr>
 * <tr>
 * <td>XuluServerStarter.memorymin</td>
 * <td>4</td>
 * <td> The inital memory the XuluServer uses (-xms)</td>
 * </tr>
 * </TABLE>
 * 
 * @author Dominik Appl
 */
public class XuluServerStarter extends UnicastRemoteObject implements Starter,
                ActionListener {

        private enum Status {
                /** server is not started */
                serverOff,
                /** * Server is started */
                serverStarted,
                /** A client is connected */
                serverActive
        }

        private String bindingName = "XuluServerStarter";

        private int port = 1099;

        private String javaprogram = "java";

        private String codebase = "";

        private String securitypolicy = "";

        private String furtherjavaarguments = "";

        private String xuluserverarguments = "";

        private String classpath = "";

        private String XuluServerString = "appl.parallel.server.XuluServer";

        private Process p;

        // private BufferedReader input;

        private SimpleConsoleOutputThread thread;

        private int xms = 64;

        private int xmx = 128;

        private SequenceInputStream twoStreams;

        private XuluStarterServerGUI starterServerGUI;

        private TextAreaPrintStream textAreaOutput;

        private MenuItem menu_exit;

        private MenuItem menu_start;

        private MenuItem menu_stop;

        private MenuItem menu_showConsole;

        private TrayIcon trayIcon;

        private ComputingResource xuluServer;

        private Image redIcon;

        private Image greenIcon;

        private Image yellowIcon;

        private String cmd;

        /**
         * @param cmd
         *            the command to be executed by the starter. If null, the
         *            XuluConfig is used to create the commandline
         * @param showGUI
         *            if false, no GUI/Tray is shown
         * @throws RemoteException
         */
        private XuluServerStarter(String cmd, boolean showGUI)
                        throws RemoteException {
                super();
                this.cmd = cmd;
                this.bind(bindingName, this, port);
                if (showGUI) {
                        redIcon = Toolkit.getDefaultToolkit().getImage(
                                        "resource/xulu_icon_red.gif");
                        greenIcon = Toolkit.getDefaultToolkit().getImage(
                                        "resource/xulu_icon_green.gif");
                        yellowIcon = Toolkit.getDefaultToolkit().getImage(
                                        "resource/xulu_icon_yellow.gif");
                        createGUI();
                        createTray();
                        setStatus(Status.serverOff);
                }
        }

        /**
         * Should be called if the status has changed (changes tray icon)
         * 
         * @param newStatus
         *            the new status
         */
        private void setStatus(Status newStatus) {
                // if tray disabled: return
                if (trayIcon == null)
                        return;
                switch (newStatus) {
                case serverOff:
                        trayIcon.setImage(redIcon);
                        trayIcon.setToolTip("XuluServer is disabled");
                        break;
                case serverStarted:
                        trayIcon.setImage(greenIcon);
                        trayIcon.setToolTip("Xulu Server is ready and waiting for tasks");
                        break;
                case serverActive:
                        trayIcon.setImage(yellowIcon);
                        trayIcon.setToolTip("A client is connected to the XuluServer");
                        break;
                }
        }

        /**
         * creates and inits the tray icon.
         */
        private void createTray() {

                if (SystemTray.isSupported()) {

                        SystemTray tray = SystemTray.getSystemTray();
                        Image image = Toolkit.getDefaultToolkit().getImage(
                                        "temp/xulu_icon.gif");

                        // create menu entries
                        PopupMenu popup = new PopupMenu();
                        menu_exit = new MenuItem("Exit");
                        menu_start = new MenuItem("Start Server");
                        menu_stop = new MenuItem("Stop Server");
                        menu_showConsole = new MenuItem("Show contol window");
                        menu_exit.addActionListener(this);
                        menu_start.addActionListener(this);
                        menu_stop.addActionListener(this);
                        menu_showConsole.addActionListener(this);

                        popup.add(menu_start);
                        popup.add(menu_stop);
                        popup.add(menu_showConsole);
                        popup.add(menu_exit);
                        trayIcon = new TrayIcon(image, "Xulu Server", popup);
                        trayIcon.setImageAutoSize(true);
                        trayIcon.addMouseListener(new MouseAdapter() {
                                // on doubleclick popup the control-window
                                public void mouseClicked(MouseEvent e) {
                                        if (e.getClickCount() > 1) {
                                                starterServerGUI.setVisible(!starterServerGUI
                                                                .isVisible());
                                        }
                                }
                        });

                        try {
                                tray.add(trayIcon);
                        } catch (AWTException e) {
                                System.err.println("TrayIcon could not be added.");
                                tray = null;
                        }

                } else {
                        // System Tray is not supported
                        System.out.println("System Tray not supported"); 
                        trayIcon = null;
                }

        }

        /**
         * creates the GUI for the Starter
         */
        private void createGUI() {
                // create new GUI
                starterServerGUI = new XuluStarterServerGUI();
                // register this instance as button listener
                starterServerGUI.button_exit.addActionListener(this);
                starterServerGUI.button_start.addActionListener(this);
                starterServerGUI.button_stop.addActionListener(this);

                // register TextArea as OutputStream
                textAreaOutput = new TextAreaPrintStream(starterServerGUI.consoleArea);
                System.setErr(textAreaOutput);
                System.setOut(textAreaOutput);

        }

        /**
         * reads the configuration out of the {@link XuluConfig}
         */
        private void loadConfig() {
                XuluConfig config = XuluConfig.getXuluConfig();
                if (config.getIntProperty("XuluServerStarter.port") != 0)
                        port = config.getIntProperty("XuluServerStarter.port");
                if (config.getProperty("XuluServerStarter.javaprogram") != null)
                        javaprogram = config.getProperty("XuluServerStarter.javaprogram");
                if (config.getProperty("XuluServerStarter.codebasedir") != null)
                        codebase = config.getProperty("XuluServerStarter.codebasedir");
                if (config.getProperty("XuluServerStarter.securitypolicy") != null)
                        securitypolicy = config
                                        .getProperty("XuluServerStarter.securitypolicy");
                if (config.getProperty("XuluServerStarter.furtherjavaarguments") != null)
                        furtherjavaarguments = config
                                        .getProperty("XuluServerStarter.furtherjavaarguments");
                if (config.getProperty("XuluServerStarter.classpath") != null)
                        classpath = config.getProperty("XuluServerStarter.classpath");
                if (config.getProperty("XuluServerStarter.memorymax") != null)
                        xmx = config.getIntProperty("XuluServerStarter.memorymax");
                if (config.getProperty("XuluServerStarter.memorymin") != null)
                        xms = config.getIntProperty("XuluServerStarter.memorymin");
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.starter.Starter#restart()
         */
        public void restart() throws RemoteException {
                this.stop();
                this.start();
        }

        /**
         * Creates the Java commandline and starts the {@link XuluServer}
         * 
         * @see appl.parallel.starter.Starter#start()
         */
        public void start() throws RemoteException {
                loadConfig();
                try {
                        if (p != null) {
                                System.out
                                                .println("Process is already running. Stop process first");
                                return;
                        }
                        String commandline = "\"" + javaprogram + "\"" + " -cp \""
                                        + codebase;
                        if (!(classpath.equals("")))
                                commandline += (";" + classpath);
                        commandline += "\" ";
                        if (xms != 0)
                                commandline += (" -Xms" + xms + "M ");
                        if (xmx != 0)
                                commandline += (" -Xmx" + xmx + "M ");

                        commandline += (" -Djava.rmi.server.codebase=file:///" + codebase
                                        + " -Djava.security.policy=" + securitypolicy + " "
                                        + furtherjavaarguments + " " + XuluServerString + " " + xuluserverarguments);
                        // if there is a user commandline, use this instead
                        if (cmd != null)
                                commandline = cmd;
                        System.out.println("Executing commandline: " + commandline);
                        p = Runtime.getRuntime().exec(commandline);
                        xuluServer = null;
                        // forward the inputstream of the new process to the
                        // console/textarea
                        InputStream standardInput = p.getInputStream();
                        InputStream errorInput = p.getErrorStream();
                        thread = new SimpleConsoleOutputThread(standardInput, errorInput);
                        thread.startThread();
                        // wait until the server is bound to the registry
                        Thread.sleep(5000);
                        // lookup the new Server
                        xuluServer = (ComputingResource) Naming
                                        .lookup("rmi://localhost/XuluServer");
                        setStatus(Status.serverStarted);
                        System.out
                                        .println("The Starter has successfully discovered the XuluServer instance");

                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (NotBoundException e) {
                        System.out
                                        .println("Could not find the Xulu server instance(NotBoundException).\n Creation of the XuluServer failed..please correct the commandline...");

                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.starter.Starter#stop()
         */
        public void stop() throws RemoteException {
                try {
                        if (twoStreams != null)
                                twoStreams.close();
                        if (thread != null)
                                thread.stopThread();
                        // if (input != null)
                        // input.close();
                        if (p != null)
                                p.destroy();
                        p = null;
                        System.out.println("Process stopped");
                        this.setStatus(Status.serverOff);
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        /**
         * Starts the XuluServerStarter <br/> The parameter -start can be used to
         * start the Server at launch of the Starter. <br>
         * The parameter -cmd <command> will use the given command to try to start
         * the server. Else the XuluConfig will be used. <br>
         * The parameter -noGUI forces the starter to not use any GUI functionality.
         */
        public static void main(String[] args) {
                try {
                        System.out
                                        .println("Use the parameter -help to see all available commandline options");
                        String cmd = null;
                        boolean noGUI = false;
                        boolean start = false;
                        // search for command parameter
                        for (int i = 0; i < args.length; i++) {
                                if (args[i].toLowerCase().equals("-cmd") && i < args.length)
                                        cmd = args[i + 1];
                                if (args[i].toLowerCase().equals("-nogui") && i < args.length)
                                        noGUI = true;
                                if (args[i].toLowerCase().equals("-start"))
                                        start = true;
                                if (args[i].toLowerCase().equals("-help"))
                                        printHelp();
                        }
                        XuluServerStarter starter = new XuluServerStarter(cmd, !noGUI);
                        System.out.println("XuluServerStarter initialized .... ");
                        if (start) {
                                starter.start();
                        }
                        if (!starter.isRunning()) {
                                System.out
                                                .println("Hint: use parameter '-start' to start the server directly");
                        }
                } catch (RemoteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

        /**
         * 
         */
        private static void printHelp() {
                System.out
                                .println("The following commands can be used: \n\n"
                                                + "-start can be used to start the Server at launch of the Starter.\n"
                                                + "-cmd <command> will use the given command to try to start the server."
                                                + " Else the XuluConfig will be used.\n"
                                                + "-noGUI doesn't use any GUI functionality.\n"
                                                + "-help displays this help");

        }

        public boolean isRunning() throws RemoteException {
                return (p != null);

        }

        /**
         * Copied from {@link Helper} and modified so that it does not depend on
         * log4j. Binds the remote object's stub in the registry. Creates a registry
         * if no running registry is found.
         * 
         * @param bindingName
         *            the name to be used for binding
         * @param bindingInstance
         *            an instance of the type to bind to the registry
         * @param defaultPort
         *            the default registry port
         * @throws RemoteException
         *             if something goes wrong
         */
        public void bind(String bindingName, Remote bindingInstance, int defaultPort)
                        throws RemoteException {
                boolean failed = true;
                Registry registry;
                try {
                        registry = LocateRegistry.getRegistry();
                        registry.rebind(bindingName, bindingInstance);
                        failed = false;
                } catch (AccessException e) {
                        System.err.println("Not enough permissions to bind" + bindingName
                                        + "to the registry! Adjust your security permission file!");
                        e.printStackTrace();
                } catch (RemoteException e) {
                        if (e instanceof java.rmi.ConnectException) {
                                System.out
                                                .println("Could not connect to registry! Trying to create new one...");
                                try {
                                        registry = LocateRegistry.createRegistry(defaultPort);
                                        registry.rebind(bindingName, bindingInstance);
                                        System.out.println("Registry successfully created at port "
                                                        + defaultPort);
                                        failed = false;
                                } catch (RemoteException e1) {
                                        // TODO Auto-generated catch block
                                        e1.printStackTrace();
                                }
                        } else
                                e.printStackTrace();
                }
                if (failed)
                        throw new RemoteException("Could not find or create registry!");
        }

        /**
         * The Thread is used to direct the output of the process to System.out.
         * Notice that this stream may be redirected to a
         * {@link TextAreaPrintStream} or any other printstream using
         * {@link System#setOut(java.io.PrintStream)}
         * 
         * @author appl
         */
        class SimpleConsoleOutputThread implements Runnable {
                private volatile Thread outputThread;

                private boolean exit;

                private final InputStream standardInput;

                private final InputStream errorInput;

                private final BufferedReader input;

                private final SequenceInputStream twoStreams;

                private boolean availableLastTime = false;

                /**
                 * Creates a new thread. The parmeters are the inputstreams which should
                 * be forwarded to System.out
                 * 
                 * @param standardInput
                 * @param errorInput
                 */
                public SimpleConsoleOutputThread(InputStream standardInput,
                                InputStream errorInput) {
                        this.standardInput = standardInput;
                        this.errorInput = errorInput;
                        // combine the streams
                        twoStreams = new SequenceInputStream(standardInput, errorInput);
                        input = new BufferedReader(new InputStreamReader(twoStreams));
                }

                public void startThread() {
                        exit = false;
                        if (outputThread == null)
                                outputThread = new Thread(this);
                        outputThread.start();
                }

                public void stopThread() {
                        exit = true;
                        outputThread.interrupt();
                        try {
                                input.close();
                        } catch (IOException e) {
                                System.out.println("Input closed");
                                e.printStackTrace();
                        }
                }

                public void run() {
                        String line;
                        while (exit == false) {
                                try {
                                        while (input.ready()) {
                                                line = input.readLine();
                                                System.out.println(line);
                                        }
                                        Thread.sleep(1000);
                                        // check if server is active for tray icon change
                                        if (xuluServer != null)
                                                if (availableLastTime != xuluServer.isAvailable()) {
                                                        if (availableLastTime)
                                                                setStatus(Status.serverActive);
                                                        else
                                                                setStatus(Status.serverStarted);
                                                        availableLastTime = (!availableLastTime);
                                                }

                                } catch (IOException e) {
                                        System.out
                                                        .println("Connection to server failed. Input closed");
                                        e.printStackTrace();
                                        exit = true;
                                } catch (InterruptedException e) {
                                        if (exit == true)
                                                System.out.println("Stopped output thread...");
                                }
                        }
                }
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
         */
        public void actionPerformed(ActionEvent e) {
                if (e.getSource() == starterServerGUI.button_stop
                                || e.getSource() == menu_stop) {
                        try {
                                this.stop();
                        } catch (Exception e1) {
                                System.out
                                                .println("Could not stop the Server. Reason follows: ");
                                e1.printStackTrace();
                        }
                } else if (e.getSource() == starterServerGUI.button_exit
                                || e.getSource() == menu_exit) {
                        // if user does not confirm: return.
                        if (JOptionPane
                                        .showConfirmDialog(
                                                        starterServerGUI,
                                                        "Are you sure that you want to exit the Starter-Application?",
                                                        "Confirm exit", JOptionPane.OK_CANCEL_OPTION) != JOptionPane.OK_OPTION)
                                return;
                        try {
                                this.stop();
                        } catch (RemoteException e1) {
                        }
                        System.exit(1);

                } else if (e.getSource() == starterServerGUI.button_start
                                || e.getSource() == menu_start) {
                        try {
                                this.start();
                        } catch (Exception e1) {
                                System.out
                                                .println("Could not start the Server. Reason follows: ");
                                e1.printStackTrace();
                        }
                } else if (e.getSource() == menu_showConsole) {
                        starterServerGUI.setVisible(true);
                }

        }
}
1	mojays	2	package appl.parallel.starter.server;
2
3			import java.awt.AWTException;
4			import java.awt.Image;
5			import java.awt.MenuItem;
6			import java.awt.PopupMenu;
7			import java.awt.SystemTray;
8			import java.awt.Toolkit;
9			import java.awt.TrayIcon;
10			import java.awt.event.ActionEvent;
11			import java.awt.event.ActionListener;
12			import java.awt.event.MouseAdapter;
13			import java.awt.event.MouseEvent;
14			import java.awt.event.MouseListener;
15			import java.io.BufferedReader;
16			import java.io.IOException;
17			import java.io.InputStream;
18			import java.io.InputStreamReader;
19			import java.io.SequenceInputStream;
20			import java.rmi.AccessException;
21			import java.rmi.Naming;
22			import java.rmi.NotBoundException;
23			import java.rmi.Remote;
24			import java.rmi.RemoteException;
25			import java.rmi.registry.LocateRegistry;
26			import java.rmi.registry.Registry;
27			import java.rmi.server.UnicastRemoteObject;
28
29			import javax.swing.JOptionPane;
30			import javax.swing.JTextArea;
31
32			import schmitzm.swing.TextAreaPrintStream;
33			import schmitzm.swing.event.PopupMenuListener;
34
35			import appl.ext.XuluConfig;
36			import appl.parallel.ComputingResource;
37			import appl.parallel.server.XuluServer;
38			import appl.parallel.starter.Starter;
39			import appl.parallel.util.Helper;
40			import appl.util.GeneralUtil;
41
42			/**
43			* A running instance of the XuluServerStarter waits for a signal to start a
44			* {@link XuluServer}. When {@link #start()} is called the Server is started.
45			* All output from the new Serverprocess are forwarded to the actual screen (if
46			* any). The Server can also be {@link #restart() restarted} or
47			* {@link #stop() stopped}. <br>
48			* <br>
49			* For configuration of the XuluServer the {@link XuluConfig} is used. The
50			* following configuration entries are supported <TABLE border="1"
51			* <tr>
52			* <th>Entry</th>
53			* <th>Default</th>
54			* <th>Description</th>
55			* </tr>
56			* <tr>
57			* <td>XuluServerStarter.port</td>
58			* <td>1099</td>
59			* <td> The port which is used for the registry creation (if none is running)</td>
60			* </tr>
61			* <tr>
62			* <td>XuluServerStarter.javaprogram</td>
63			* <td>java</td>
64			* <td> The path to the java program</td>
65			* </tr>
66			* <tr>
67			* <td>XuluServerStarter.codebasedir</td>
68			* <td></td>
69			* <td> The absolute path to the codebase directory (should be the path to the
70			* binaries)</td>
71			* </tr>
72			* <tr>
73			* <td>XuluServerStarter.securitypolicy</td>
74			* <td></td>
75			* <td> The path to the security policy</td>
76			* </tr>
77			* <tr>
78			* <td>XuluServerStarter.furtherjavaarguments</td>
79			* <td></td>
80			* <td> further JVM arguments</td>
81			* </tr>
82			* <tr>
83			* <td>XuluServerStarter.classpath</td>
84			* <td></td>
85			* <td> The libaries needed</td>
86			* </tr>
87			* <tr>
88			* <td>XuluServerStarter.memorymax</td>
89			* <td>64</td>
90			* <td> The maximum memory the XuluSever attempts to use (-xmx)</td>
91			* </tr>
92			* <tr>
93			* <td>XuluServerStarter.memorymin</td>
94			* <td>4</td>
95			* <td> The inital memory the XuluServer uses (-xms)</td>
96			* </tr>
97			* </TABLE>
98			*
99			* @author Dominik Appl
100			*/
101			public class XuluServerStarter extends UnicastRemoteObject implements Starter,
102			ActionListener {
103
104			private enum Status {
105			/** server is not started */
106			serverOff,
107			/** * Server is started */
108			serverStarted,
109			/** A client is connected */
110			serverActive
111			}
112
113			private String bindingName = "XuluServerStarter";
114
115			private int port = 1099;
116
117			private String javaprogram = "java";
118
119			private String codebase = "";
120
121			private String securitypolicy = "";
122
123			private String furtherjavaarguments = "";
124
125			private String xuluserverarguments = "";
126
127			private String classpath = "";
128
129			private String XuluServerString = "appl.parallel.server.XuluServer";
130
131			private Process p;
132
133			// private BufferedReader input;
134
135			private SimpleConsoleOutputThread thread;
136
137			private int xms = 64;
138
139			private int xmx = 128;
140
141			private SequenceInputStream twoStreams;
142
143			private XuluStarterServerGUI starterServerGUI;
144
145			private TextAreaPrintStream textAreaOutput;
146
147			private MenuItem menu_exit;
148
149			private MenuItem menu_start;
150
151			private MenuItem menu_stop;
152
153			private MenuItem menu_showConsole;
154
155			private TrayIcon trayIcon;
156
157			private ComputingResource xuluServer;
158
159			private Image redIcon;
160
161			private Image greenIcon;
162
163			private Image yellowIcon;
164
165			private String cmd;
166
167			/**
168			* @param cmd
169			* the command to be executed by the starter. If null, the
170			* XuluConfig is used to create the commandline
171			* @param showGUI
172			* if false, no GUI/Tray is shown
173			* @throws RemoteException
174			*/
175			private XuluServerStarter(String cmd, boolean showGUI)
176			throws RemoteException {
177			super();
178			this.cmd = cmd;
179			this.bind(bindingName, this, port);
180			if (showGUI) {
181			redIcon = Toolkit.getDefaultToolkit().getImage(
182			"resource/xulu_icon_red.gif");
183			greenIcon = Toolkit.getDefaultToolkit().getImage(
184			"resource/xulu_icon_green.gif");
185			yellowIcon = Toolkit.getDefaultToolkit().getImage(
186			"resource/xulu_icon_yellow.gif");
187			createGUI();
188			createTray();
189			setStatus(Status.serverOff);
190			}
191			}
192
193			/**
194			* Should be called if the status has changed (changes tray icon)
195			*
196			* @param newStatus
197			* the new status
198			*/
199			private void setStatus(Status newStatus) {
200			// if tray disabled: return
201			if (trayIcon == null)
202			return;
203			switch (newStatus) {
204			case serverOff:
205			trayIcon.setImage(redIcon);
206			trayIcon.setToolTip("XuluServer is disabled");
207			break;
208			case serverStarted:
209			trayIcon.setImage(greenIcon);
210			trayIcon.setToolTip("Xulu Server is ready and waiting for tasks");
211			break;
212			case serverActive:
213			trayIcon.setImage(yellowIcon);
214			trayIcon.setToolTip("A client is connected to the XuluServer");
215			break;
216			}
217			}
218
219			/**
220			* creates and inits the tray icon.
221			*/
222			private void createTray() {
223
224			if (SystemTray.isSupported()) {
225
226			SystemTray tray = SystemTray.getSystemTray();
227			Image image = Toolkit.getDefaultToolkit().getImage(
228			"temp/xulu_icon.gif");
229
230			// create menu entries
231			PopupMenu popup = new PopupMenu();
232			menu_exit = new MenuItem("Exit");
233			menu_start = new MenuItem("Start Server");
234			menu_stop = new MenuItem("Stop Server");
235			menu_showConsole = new MenuItem("Show contol window");
236			menu_exit.addActionListener(this);
237			menu_start.addActionListener(this);
238			menu_stop.addActionListener(this);
239			menu_showConsole.addActionListener(this);
240
241			popup.add(menu_start);
242			popup.add(menu_stop);
243			popup.add(menu_showConsole);
244			popup.add(menu_exit);
245			trayIcon = new TrayIcon(image, "Xulu Server", popup);
246			trayIcon.setImageAutoSize(true);
247			trayIcon.addMouseListener(new MouseAdapter() {
248			// on doubleclick popup the control-window
249			public void mouseClicked(MouseEvent e) {
250			if (e.getClickCount() > 1) {
251			starterServerGUI.setVisible(!starterServerGUI
252			.isVisible());
253			}
254			}
255			});
256
257			try {
258			tray.add(trayIcon);
259			} catch (AWTException e) {
260			System.err.println("TrayIcon could not be added.");
261			tray = null;
262			}
263
264			} else {
265			// System Tray is not supported
266			System.out.println("System Tray not supported");
267			trayIcon = null;
268			}
269
270			}
271
272			/**
273			* creates the GUI for the Starter
274			*/
275			private void createGUI() {
276			// create new GUI
277			starterServerGUI = new XuluStarterServerGUI();
278			// register this instance as button listener
279			starterServerGUI.button_exit.addActionListener(this);
280			starterServerGUI.button_start.addActionListener(this);
281			starterServerGUI.button_stop.addActionListener(this);
282
283			// register TextArea as OutputStream
284			textAreaOutput = new TextAreaPrintStream(starterServerGUI.consoleArea);
285			System.setErr(textAreaOutput);
286			System.setOut(textAreaOutput);
287
288			}
289
290			/**
291			* reads the configuration out of the {@link XuluConfig}
292			*/
293			private void loadConfig() {
294			XuluConfig config = XuluConfig.getXuluConfig();
295			if (config.getIntProperty("XuluServerStarter.port") != 0)
296			port = config.getIntProperty("XuluServerStarter.port");
297			if (config.getProperty("XuluServerStarter.javaprogram") != null)
298			javaprogram = config.getProperty("XuluServerStarter.javaprogram");
299			if (config.getProperty("XuluServerStarter.codebasedir") != null)
300			codebase = config.getProperty("XuluServerStarter.codebasedir");
301			if (config.getProperty("XuluServerStarter.securitypolicy") != null)
302			securitypolicy = config
303			.getProperty("XuluServerStarter.securitypolicy");
304			if (config.getProperty("XuluServerStarter.furtherjavaarguments") != null)
305			furtherjavaarguments = config
306			.getProperty("XuluServerStarter.furtherjavaarguments");
307			if (config.getProperty("XuluServerStarter.classpath") != null)
308			classpath = config.getProperty("XuluServerStarter.classpath");
309			if (config.getProperty("XuluServerStarter.memorymax") != null)
310			xmx = config.getIntProperty("XuluServerStarter.memorymax");
311			if (config.getProperty("XuluServerStarter.memorymin") != null)
312			xms = config.getIntProperty("XuluServerStarter.memorymin");
313			}
314
315			/*
316			* (non-Javadoc)
317			*
318			* @see appl.parallel.starter.Starter#restart()
319			*/
320			public void restart() throws RemoteException {
321			this.stop();
322			this.start();
323			}
324
325			/**
326			* Creates the Java commandline and starts the {@link XuluServer}
327			*
328			* @see appl.parallel.starter.Starter#start()
329			*/
330			public void start() throws RemoteException {
331			loadConfig();
332			try {
333			if (p != null) {
334			System.out
335			.println("Process is already running. Stop process first");
336			return;
337			}
338			String commandline = "\"" + javaprogram + "\"" + " -cp \""
339			+ codebase;
340			if (!(classpath.equals("")))
341			commandline += (";" + classpath);
342			commandline += "\" ";
343			if (xms != 0)
344			commandline += (" -Xms" + xms + "M ");
345			if (xmx != 0)
346			commandline += (" -Xmx" + xmx + "M ");
347
348			commandline += (" -Djava.rmi.server.codebase=file:///" + codebase
349			+ " -Djava.security.policy=" + securitypolicy + " "
350			+ furtherjavaarguments + " " + XuluServerString + " " + xuluserverarguments);
351			// if there is a user commandline, use this instead
352			if (cmd != null)
353			commandline = cmd;
354			System.out.println("Executing commandline: " + commandline);
355			p = Runtime.getRuntime().exec(commandline);
356			xuluServer = null;
357			// forward the inputstream of the new process to the
358			// console/textarea
359			InputStream standardInput = p.getInputStream();
360			InputStream errorInput = p.getErrorStream();
361			thread = new SimpleConsoleOutputThread(standardInput, errorInput);
362			thread.startThread();
363			// wait until the server is bound to the registry
364			Thread.sleep(5000);
365			// lookup the new Server
366			xuluServer = (ComputingResource) Naming
367			.lookup("rmi://localhost/XuluServer");
368			setStatus(Status.serverStarted);
369			System.out
370			.println("The Starter has successfully discovered the XuluServer instance");
371
372			} catch (IOException e) {
373			// TODO Auto-generated catch block
374			e.printStackTrace();
375			} catch (NotBoundException e) {
376			System.out
377			.println("Could not find the Xulu server instance(NotBoundException).\n Creation of the XuluServer failed..please correct the commandline...");
378
379			} catch (InterruptedException e) {
380			// TODO Auto-generated catch block
381			e.printStackTrace();
382			}
383			}
384
385			/*
386			* (non-Javadoc)
387			*
388			* @see appl.parallel.starter.Starter#stop()
389			*/
390			public void stop() throws RemoteException {
391			try {
392			if (twoStreams != null)
393			twoStreams.close();
394			if (thread != null)
395			thread.stopThread();
396			// if (input != null)
397			// input.close();
398			if (p != null)
399			p.destroy();
400			p = null;
401			System.out.println("Process stopped");
402			this.setStatus(Status.serverOff);
403			} catch (IOException e) {
404			e.printStackTrace();
405			}
406			}
407
408			/**
409			* Starts the XuluServerStarter <br/> The parameter -start can be used to
410			* start the Server at launch of the Starter. <br>
411			* The parameter -cmd <command> will use the given command to try to start
412			* the server. Else the XuluConfig will be used. <br>
413			* The parameter -noGUI forces the starter to not use any GUI functionality.
414			*/
415			public static void main(String[] args) {
416			try {
417			System.out
418			.println("Use the parameter -help to see all available commandline options");
419			String cmd = null;
420			boolean noGUI = false;
421			boolean start = false;
422			// search for command parameter
423			for (int i = 0; i < args.length; i++) {
424			if (args[i].toLowerCase().equals("-cmd") && i < args.length)
425			cmd = args[i + 1];
426			if (args[i].toLowerCase().equals("-nogui") && i < args.length)
427			noGUI = true;
428			if (args[i].toLowerCase().equals("-start"))
429			start = true;
430			if (args[i].toLowerCase().equals("-help"))
431			printHelp();
432			}
433			XuluServerStarter starter = new XuluServerStarter(cmd, !noGUI);
434			System.out.println("XuluServerStarter initialized .... ");
435			if (start) {
436			starter.start();
437			}
438			if (!starter.isRunning()) {
439			System.out
440			.println("Hint: use parameter '-start' to start the server directly");
441			}
442			} catch (RemoteException e) {
443			// TODO Auto-generated catch block
444			e.printStackTrace();
445			}
446			}
447
448			/**
449			*
450			*/
451			private static void printHelp() {
452			System.out
453			.println("The following commands can be used: \n\n"
454			+ "-start can be used to start the Server at launch of the Starter.\n"
455			+ "-cmd <command> will use the given command to try to start the server."
456			+ " Else the XuluConfig will be used.\n"
457			+ "-noGUI doesn't use any GUI functionality.\n"
458			+ "-help displays this help");
459
460			}
461
462			public boolean isRunning() throws RemoteException {
463			return (p != null);
464
465			}
466
467			/**
468			* Copied from {@link Helper} and modified so that it does not depend on
469			* log4j. Binds the remote object's stub in the registry. Creates a registry
470			* if no running registry is found.
471			*
472			* @param bindingName
473			* the name to be used for binding
474			* @param bindingInstance
475			* an instance of the type to bind to the registry
476			* @param defaultPort
477			* the default registry port
478			* @throws RemoteException
479			* if something goes wrong
480			*/
481			public void bind(String bindingName, Remote bindingInstance, int defaultPort)
482			throws RemoteException {
483			boolean failed = true;
484			Registry registry;
485			try {
486			registry = LocateRegistry.getRegistry();
487			registry.rebind(bindingName, bindingInstance);
488			failed = false;
489			} catch (AccessException e) {
490			System.err.println("Not enough permissions to bind" + bindingName
491			+ "to the registry! Adjust your security permission file!");
492			e.printStackTrace();
493			} catch (RemoteException e) {
494			if (e instanceof java.rmi.ConnectException) {
495			System.out
496			.println("Could not connect to registry! Trying to create new one...");
497			try {
498			registry = LocateRegistry.createRegistry(defaultPort);
499			registry.rebind(bindingName, bindingInstance);
500			System.out.println("Registry successfully created at port "
501			+ defaultPort);
502			failed = false;
503			} catch (RemoteException e1) {
504			// TODO Auto-generated catch block
505			e1.printStackTrace();
506			}
507			} else
508			e.printStackTrace();
509			}
510			if (failed)
511			throw new RemoteException("Could not find or create registry!");
512			}
513
514			/**
515			* The Thread is used to direct the output of the process to System.out.
516			* Notice that this stream may be redirected to a
517			* {@link TextAreaPrintStream} or any other printstream using
518			* {@link System#setOut(java.io.PrintStream)}
519			*
520			* @author appl
521			*/
522			class SimpleConsoleOutputThread implements Runnable {
523			private volatile Thread outputThread;
524
525			private boolean exit;
526
527			private final InputStream standardInput;
528
529			private final InputStream errorInput;
530
531			private final BufferedReader input;
532
533			private final SequenceInputStream twoStreams;
534
535			private boolean availableLastTime = false;
536
537			/**
538			* Creates a new thread. The parmeters are the inputstreams which should
539			* be forwarded to System.out
540			*
541			* @param standardInput
542			* @param errorInput
543			*/
544			public SimpleConsoleOutputThread(InputStream standardInput,
545			InputStream errorInput) {
546			this.standardInput = standardInput;
547			this.errorInput = errorInput;
548			// combine the streams
549			twoStreams = new SequenceInputStream(standardInput, errorInput);
550			input = new BufferedReader(new InputStreamReader(twoStreams));
551			}
552
553			public void startThread() {
554			exit = false;
555			if (outputThread == null)
556			outputThread = new Thread(this);
557			outputThread.start();
558			}
559
560			public void stopThread() {
561			exit = true;
562			outputThread.interrupt();
563			try {
564			input.close();
565			} catch (IOException e) {
566			System.out.println("Input closed");
567			e.printStackTrace();
568			}
569			}
570
571			public void run() {
572			String line;
573			while (exit == false) {
574			try {
575			while (input.ready()) {
576			line = input.readLine();
577			System.out.println(line);
578			}
579			Thread.sleep(1000);
580			// check if server is active for tray icon change
581			if (xuluServer != null)
582			if (availableLastTime != xuluServer.isAvailable()) {
583			if (availableLastTime)
584			setStatus(Status.serverActive);
585			else
586			setStatus(Status.serverStarted);
587			availableLastTime = (!availableLastTime);
588			}
589
590			} catch (IOException e) {
591			System.out
592			.println("Connection to server failed. Input closed");
593			e.printStackTrace();
594			exit = true;
595			} catch (InterruptedException e) {
596			if (exit == true)
597			System.out.println("Stopped output thread...");
598			}
599			}
600			}
601			}
602
603			/*
604			* (non-Javadoc)
605			*
606			* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
607			*/
608			public void actionPerformed(ActionEvent e) {
609			if (e.getSource() == starterServerGUI.button_stop
610			\|\| e.getSource() == menu_stop) {
611			try {
612			this.stop();
613			} catch (Exception e1) {
614			System.out
615			.println("Could not stop the Server. Reason follows: ");
616			e1.printStackTrace();
617			}
618			} else if (e.getSource() == starterServerGUI.button_exit
619			\|\| e.getSource() == menu_exit) {
620			// if user does not confirm: return.
621			if (JOptionPane
622			.showConfirmDialog(
623			starterServerGUI,
624			"Are you sure that you want to exit the Starter-Application?",
625			"Confirm exit", JOptionPane.OK_CANCEL_OPTION) != JOptionPane.OK_OPTION)
626			return;
627			try {
628			this.stop();
629			} catch (RemoteException e1) {
630			}
631			System.exit(1);
632
633			} else if (e.getSource() == starterServerGUI.button_start
634			\|\| e.getSource() == menu_start) {
635			try {
636			this.start();
637			} catch (Exception e1) {
638			System.out
639			.println("Could not start the Server. Reason follows: ");
640			e1.printStackTrace();
641			}
642			} else if (e.getSource() == menu_showConsole) {
643			starterServerGUI.setVisible(true);
644			}
645
646			}
647			}