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.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 schmitzm.swing.TextAreaPrintStream;
import appl.ext.XuluConfig;
import appl.parallel.ComputingResource;
import appl.parallel.server.XuluServer;
import appl.parallel.starter.Starter;
import appl.parallel.util.Helper;

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