starter/client/XuluStarterController.java

package appl.parallel.starter.client;

import java.awt.Color;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.rmi.RemoteException;
import java.util.Vector;

import javax.swing.DefaultListCellRenderer;
import javax.swing.JList;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import appl.parallel.services.HostnameDiscoveryService;
import appl.parallel.starter.Starter;
import appl.parallel.starter.server.XuluServerStarter;

/**
 * This is the Controller for the {@link XuluStarterControllerFrame}, which is
 * the user interface for the {@link XuluServerStarter}. All events are handled
 * here. <br>
 * 
 * The controller updates a list of {@link Starter}s it finds in the network.
 * At the moment is uses the {@link HostnameDiscoveryService} to discover
 * starters.
 * 
 * @see HostnameDiscoveryService#getStarterContainers()
 * @author Dominik Appl
 */
public class XuluStarterController implements ActionListener {

        Logger LOG = LogManager.getLogger(this.getClass().getName());

        private XuluStarterClientPanel GUI;

        private HostnameDiscoveryService discovery;

        private Vector<StarterContainer> currentData;

        /**
         * 
         */
        public XuluStarterController() {
                GUI = new XuluStarterClientPanel();
                // start simpleDiscovery service
                discovery = new HostnameDiscoveryService();
                discovery.startService();
                updateList();
                initGUI();
        }

        private void initGUI() {
                GUI.startButton.addActionListener(this);
                GUI.stopButton.addActionListener(this);
                GUI.refreshButton.addActionListener(this);
                GUI.restartButton.addActionListener(this);
        }

        public XuluStarterClientPanel getPanel() {
                return GUI;
        }

        /**
         * 
         */
        private void updateList() {
                currentData = discovery.getStarterContainers();
                GUI.serverList.setCellRenderer(new MyCellRenderer(currentData));
                // DefaultListModel serverListModel = new DefaultListModel();
                // GUI.serverList.setModel(serverListModel);
                GUI.serverList.setListData(currentData);
        }

        private Starter getSelectedStarter() {
                Object value = GUI.serverList.getSelectedValue();
                if (value != null) {
                        return ((StarterContainer) value).getStarter();
                }
                return null;
        }

        public void actionPerformed(ActionEvent e) {
                if (e.getSource() == GUI.refreshButton) {
                        updateList();
                }
                Starter selectedStarter = getSelectedStarter();
                // if nothing selected: return
                if (selectedStarter == null)
                        return;
                try {
                        if (e.getSource() == GUI.startButton) {
                                selectedStarter.start();
                                updateList();
                        }
                        if (e.getSource() == GUI.stopButton) {
                                selectedStarter.stop();
                                updateList();
                        }
                        if (e.getSource() == GUI.restartButton) {
                                selectedStarter.restart();
                                updateList();
                        }
                } catch (RemoteException e1) {
                        LOG
                                        .error(
                                                        "Could not access selected Starter. Remote Exeception occured.",
                                                        e1);
                }
        }

        class MyCellRenderer extends DefaultListCellRenderer {
                private final Vector<StarterContainer> containers;

                public MyCellRenderer(Vector<StarterContainer> containers) {
                        this.containers = containers;
                        // TODO Auto-generated constructor stub
                }

                @Override
                public Component getListCellRendererComponent(JList list, Object value,
                                int index, boolean isSelected, boolean cellHasFocus) {
                        // TODO Auto-generated method stub
                        Component listCellRendererComponent = super
                                        .getListCellRendererComponent(list, value, index,
                                                        isSelected, cellHasFocus);
                        if (!isSelected) {
                                if (containers.get(index).isServerRunning())
                                        listCellRendererComponent.setBackground(Color.green);
                                else
                                        listCellRendererComponent.setBackground(Color.red);
                        }
                        return listCellRendererComponent;
                }

        }
}
1	package appl.parallel.starter.client;
2
3	import java.awt.Color;
4	import java.awt.Component;
5	import java.awt.event.ActionEvent;
6	import java.awt.event.ActionListener;
7	import java.rmi.RemoteException;
8	import java.util.Vector;
9
10	import javax.swing.DefaultListCellRenderer;
11	import javax.swing.JList;
12
13	import org.apache.log4j.LogManager;
14	import org.apache.log4j.Logger;
15
16	import appl.parallel.services.HostnameDiscoveryService;
17	import appl.parallel.starter.Starter;
18	import appl.parallel.starter.server.XuluServerStarter;
19
20	/**
21	* This is the Controller for the {@link XuluStarterControllerFrame}, which is
22	* the user interface for the {@link XuluServerStarter}. All events are handled
23	* here. <br>
24	*
25	* The controller updates a list of {@link Starter}s it finds in the network.
26	* At the moment is uses the {@link HostnameDiscoveryService} to discover
27	* starters.
28	*
29	* @see HostnameDiscoveryService#getStarterContainers()
30	* @author Dominik Appl
31	*/
32	public class XuluStarterController implements ActionListener {
33
34	Logger LOG = LogManager.getLogger(this.getClass().getName());
35
36	private XuluStarterClientPanel GUI;
37
38	private HostnameDiscoveryService discovery;
39
40	private Vector<StarterContainer> currentData;
41
42	/**
43	*
44	*/
45	public XuluStarterController() {
46	GUI = new XuluStarterClientPanel();
47	// start simpleDiscovery service
48	discovery = new HostnameDiscoveryService();
49	discovery.startService();
50	updateList();
51	initGUI();
52	}
53
54	private void initGUI() {
55	GUI.startButton.addActionListener(this);
56	GUI.stopButton.addActionListener(this);
57	GUI.refreshButton.addActionListener(this);
58	GUI.restartButton.addActionListener(this);
59	}
60
61	public XuluStarterClientPanel getPanel() {
62	return GUI;
63	}
64
65	/**
66	*
67	*/
68	private void updateList() {
69	currentData = discovery.getStarterContainers();
70	GUI.serverList.setCellRenderer(new MyCellRenderer(currentData));
71	// DefaultListModel serverListModel = new DefaultListModel();
72	// GUI.serverList.setModel(serverListModel);
73	GUI.serverList.setListData(currentData);
74	}
75
76	private Starter getSelectedStarter() {
77	Object value = GUI.serverList.getSelectedValue();
78	if (value != null) {
79	return ((StarterContainer) value).getStarter();
80	}
81	return null;
82	}
83
84	public void actionPerformed(ActionEvent e) {
85	if (e.getSource() == GUI.refreshButton) {
86	updateList();
87	}
88	Starter selectedStarter = getSelectedStarter();
89	// if nothing selected: return
90	if (selectedStarter == null)
91	return;
92	try {
93	if (e.getSource() == GUI.startButton) {
94	selectedStarter.start();
95	updateList();
96	}
97	if (e.getSource() == GUI.stopButton) {
98	selectedStarter.stop();
99	updateList();
100	}
101	if (e.getSource() == GUI.restartButton) {
102	selectedStarter.restart();
103	updateList();
104	}
105	} catch (RemoteException e1) {
106	LOG
107	.error(
108	"Could not access selected Starter. Remote Exeception occured.",
109	e1);
110	}
111	}
112
113	class MyCellRenderer extends DefaultListCellRenderer {
114	private final Vector<StarterContainer> containers;
115
116	public MyCellRenderer(Vector<StarterContainer> containers) {
117	this.containers = containers;
118	// TODO Auto-generated constructor stub
119	}
120
121	@Override
122	public Component getListCellRendererComponent(JList list, Object value,
123	int index, boolean isSelected, boolean cellHasFocus) {
124	// TODO Auto-generated method stub
125	Component listCellRendererComponent = super
126	.getListCellRendererComponent(list, value, index,
127	isSelected, cellHasFocus);
128	if (!isSelected) {
129	if (containers.get(index).isServerRunning())
130	listCellRendererComponent.setBackground(Color.green);
131	else
132	listCellRendererComponent.setBackground(Color.red);
133	}
134	return listCellRendererComponent;
135	}
136
137	}
138	}