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	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	}