parallel/gui/ParallelControlPanelEngine.java

package appl.parallel.gui;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Vector;

import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableModel;

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

import appl.ext.XuluConfig;
import appl.parallel.ComputingResourceContainer;
import appl.parallel.ComputingResourceProperties;
import appl.parallel.client.RemoteExecutionController;
import appl.parallel.client.ResourceChangeListener;
import appl.util.NonEditableTableModel;
import edu.bonn.xulu.XuluModellingPlatform;

/**
 * This class controls the {@link ParallelControlPanel}.
 *
 * @author Dominik Appl
 */
public class ParallelControlPanelEngine implements ActionListener,
                ListSelectionListener, TableModelListener, ResourceChangeListener {

        ParallelControlPanel panel;

        XuluModellingPlatform xulu;

        // get logger for this class
        protected final Logger LOG = LogManager
                        .getLogger(this.getClass().getName());

        private DefaultTableModel resTableModel;

        private JTable resTable;

        private Vector<ComputingResourceContainer> resources;

        private RemoteExecutionController remoteExecutionController;

        /**
         * @param xulu
         *            the active modeling platform
         */
        public ParallelControlPanelEngine(XuluModellingPlatform xulu) {
                this.xulu = xulu;
                this.panel = new ParallelControlPanel();
                init();
        }

        /**
         * @param xulu
         *            the active modeling platform
         * @param panel
         *            the panel to integrate
         */
        public ParallelControlPanelEngine(XuluModellingPlatform xulu,
                        ParallelControlPanel panel) {
                this.xulu = xulu;
                this.panel = panel;
                init();
        }

        /**
         * The init method must be called after all Components of the GUI are
         * initialized.
         */
        void init() {
                remoteExecutionController = RemoteExecutionController
                                .getRemoteExecutionController(xulu);
                if (remoteExecutionController != null)
                        remoteExecutionController.addResourceChangeListener(this);
                resTable = panel.computingResourcesList;

                // add listeners
                resTable.getSelectionModel().addListSelectionListener(this);
                panel.refreshButton.addActionListener(this);
                panel.selectAllButton.addActionListener(this);

                resTableModel = new NonEditableTableModel(new Object[] { "Name",
                                "Rating" }, new boolean[] { false, true }, 1);
                resTable.setModel(resTableModel);
                resTable.getModel().addTableModelListener(this);
                selectAvailableResources();
        }

        /*
         * (non-Javadoc)
         *
         * @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
         */
        public void actionPerformed(ActionEvent e) {
                // the source of the event.
                Object src = e.getSource();
                if (src == panel.refreshButton) {
                        handleRefresh();
                } else if (src == panel.selectAllButton) {
                        selectAvailableResources();
                }

        }

        /**
         * handles the refresh button
         */
        private void handleRefresh() {
                if (remoteExecutionController != null)
                        remoteExecutionController.refreshResources();
                else
                        JOptionPane
                                        .showMessageDialog(
                                                        getPanel(),
                                                        "Error: no discovery possible. The RemoteExecutionController-Plugin can " +
                                                        "not be found. The plugin is required for parallel " +
                                                        "computation","Error",JOptionPane.ERROR_MESSAGE);
        }

        private Vector<String> getVectorOfSelectedNames() {

                Object[] selectedComputingResources = getSelectedResourceContainers();

                // write selected names in vector
                Vector<String> names = new Vector<String>();
                for (int i = 0; i < selectedComputingResources.length; i++) {
                        names
                                        .add(((ComputingResourceContainer) selectedComputingResources[i])
                                                        .getInformation().getName());
                }
                return names;
        }

        private void setSelectedElements(Vector<String> names) {
                for (int i = 0; i < resTableModel.getRowCount(); i++) {
                        ComputingResourceContainer container = (ComputingResourceContainer) resTableModel
                                        .getValueAt(i, 0);
                        if (container == null)
                                return;
                        String name = ((ComputingResourceContainer) resTableModel
                                        .getValueAt(i, 0)).getInformation().getName();
                        if (names.contains(name))
                                resTable.getSelectionModel().addSelectionInterval(i, i);
                }
        }

        private void selectAvailableResources() {
                // write available selected names in vector
                Vector<String> names = new Vector<String>();
                for (int i = 0; i < resTableModel.getRowCount(); i++) {
                        ComputingResourceContainer container = ((ComputingResourceContainer) resTableModel
                                        .getValueAt(i, 0));
                        if (container == null)
                                return;
                        ComputingResourceProperties info = container.getInformation();
                        if (info.isAvailable())
                                names.add(info.getName());

                }
                setSelectedElements(names);
        }

        /**
         * @return the first current selected ComputingResourceContainer from the
         *          resouce list
         */
        private ComputingResourceContainer getSelectedResourceContainer() {
                int selectedRow = resTable.getSelectedRow();
                if (selectedRow == -1)
                        return null;
                return (ComputingResourceContainer) resTableModel.getValueAt(
                                selectedRow, 0);
        }

        /**
         * @return all current selected ComputingResourceContainer from the resouce
         *         list
         */
        ComputingResourceContainer[] getSelectedResourceContainers() {
                int[] selRows = panel.computingResourcesList.getSelectedRows();
                Object[] selectedValues = new Object[selRows.length];
                for (int i = 0; i < selRows.length; i++) {
                        selectedValues[i] = resTableModel.getValueAt(selRows[i], 0);
                        if (selectedValues[i] == null)
                                return new ComputingResourceContainer[0];
                }
                ComputingResourceContainer[] selectedContainers = new ComputingResourceContainer[selectedValues.length];
                for (int i = 0; i < selectedValues.length; i++)
                        selectedContainers[i] = (ComputingResourceContainer) selectedValues[i];
                return selectedContainers;
        }

        /*
         * (non-Javadoc)
         *
         * @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
         */
        public void valueChanged(ListSelectionEvent e) {
                Object src = e.getSource();
                if (src == resTable.getSelectionModel()) {
                        ComputingResourceContainer selValue = getSelectedResourceContainer();
                        if (selValue == null)
                                return;
                        panel.propertyTable.setPropertyData(selValue.getInformation()
                                        .getProperties());
                }
        }

        /**
         * Listens for user changes of the rating
         *
         * @see javax.swing.event.TableModelListener#tableChanged(javax.swing.event.TableModelEvent)
         */
        public void tableChanged(TableModelEvent e) {
                // enter the new rating information to the configuration
                XuluConfig config = XuluConfig.getXuluConfig();
                if (e.getType() == TableModelEvent.UPDATE) {
                        int changedRow = e.getFirstRow();
                        // only the 2nd col is editable
                        String newRating = resTableModel.getValueAt(changedRow, 1)
                                        .toString();
                        try {
                                int rating = Integer.valueOf(newRating);
                                if (rating < 0) {
                                        resTableModel.setValueAt(0, changedRow, 1);
                                        throw new UnsupportedOperationException(
                                                        "Rating must be > 0");
                                }

                        } catch (Exception f) {
                                resTableModel.setValueAt(0, changedRow, 1);
                                throw new UnsupportedOperationException(
                                                "Rating must be an integer!");
                        }
                        String computerName = resTableModel.getValueAt(changedRow, 0)
                                        .toString();
                        String prefix = "PerformanceRating";
                        String key = prefix + "." + computerName;
                        config.setProperty(key, newRating);
                }
        }

        /**
         * @return the panel
         */
        public ParallelControlPanel getPanel() {
                return this.panel;
        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.client.ResourceChangeListener#updateResources(java.util.Vector)
         */
        public void updateResources(
                        Vector<ComputingResourceContainer> currentResources) {
                // get the selected values (and restore the selection after list
                // initializing)
                Vector names = getVectorOfSelectedNames();

                // clear list
                resTableModel.setRowCount(0);
                for (ComputingResourceContainer res : currentResources) {
                        // init the rating from the configuration
                        XuluConfig config = XuluConfig.getXuluConfig();
                        String computerName = res.getInformation().getName();
                        String prefix = "PerformanceRating";
                        String key = prefix + "." + computerName;
                        String rating = config.getProperty(key, false);
                        // if no rating found use the selfrating of the machine
                        if (rating == null || rating.equals("0"))
                                rating = res.getInformation().getProperty("Rating");
                        if (rating == null)
                                rating = "0"; // '0' means average
                        resTableModel.addRow(new Object[] { res, rating });
                }

                // restore selection
                this.setSelectedElements(names);
        }
}
1	package appl.parallel.gui;
2
3	import java.awt.event.ActionEvent;
4	import java.awt.event.ActionListener;
5	import java.util.Vector;
6
7	import javax.swing.JOptionPane;
8	import javax.swing.JTable;
9	import javax.swing.event.ListSelectionEvent;
10	import javax.swing.event.ListSelectionListener;
11	import javax.swing.event.TableModelEvent;
12	import javax.swing.event.TableModelListener;
13	import javax.swing.table.DefaultTableModel;
14
15	import org.apache.log4j.LogManager;
16	import org.apache.log4j.Logger;
17
18	import appl.ext.XuluConfig;
19	import appl.parallel.ComputingResourceContainer;
20	import appl.parallel.ComputingResourceProperties;
21	import appl.parallel.client.RemoteExecutionController;
22	import appl.parallel.client.ResourceChangeListener;
23	import appl.util.NonEditableTableModel;
24	import edu.bonn.xulu.XuluModellingPlatform;
25
26	/**
27	* This class controls the {@link ParallelControlPanel}.
28	*
29	* @author Dominik Appl
30	*/
31	public class ParallelControlPanelEngine implements ActionListener,
32	ListSelectionListener, TableModelListener, ResourceChangeListener {
33
34	ParallelControlPanel panel;
35
36	XuluModellingPlatform xulu;
37
38	// get logger for this class
39	protected final Logger LOG = LogManager
40	.getLogger(this.getClass().getName());
41
42	private DefaultTableModel resTableModel;
43
44	private JTable resTable;
45
46	private Vector<ComputingResourceContainer> resources;
47
48	private RemoteExecutionController remoteExecutionController;
49
50	/**
51	* @param xulu
52	* the active modeling platform
53	*/
54	public ParallelControlPanelEngine(XuluModellingPlatform xulu) {
55	this.xulu = xulu;
56	this.panel = new ParallelControlPanel();
57	init();
58	}
59
60	/**
61	* @param xulu
62	* the active modeling platform
63	* @param panel
64	* the panel to integrate
65	*/
66	public ParallelControlPanelEngine(XuluModellingPlatform xulu,
67	ParallelControlPanel panel) {
68	this.xulu = xulu;
69	this.panel = panel;
70	init();
71	}
72
73	/**
74	* The init method must be called after all Components of the GUI are
75	* initialized.
76	*/
77	void init() {
78	remoteExecutionController = RemoteExecutionController
79	.getRemoteExecutionController(xulu);
80	if (remoteExecutionController != null)
81	remoteExecutionController.addResourceChangeListener(this);
82	resTable = panel.computingResourcesList;
83
84	// add listeners
85	resTable.getSelectionModel().addListSelectionListener(this);
86	panel.refreshButton.addActionListener(this);
87	panel.selectAllButton.addActionListener(this);
88
89	resTableModel = new NonEditableTableModel(new Object[] { "Name",
90	"Rating" }, new boolean[] { false, true }, 1);
91	resTable.setModel(resTableModel);
92	resTable.getModel().addTableModelListener(this);
93	selectAvailableResources();
94	}
95
96	/*
97	* (non-Javadoc)
98	*
99	* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
100	*/
101	public void actionPerformed(ActionEvent e) {
102	// the source of the event.
103	Object src = e.getSource();
104	if (src == panel.refreshButton) {
105	handleRefresh();
106	} else if (src == panel.selectAllButton) {
107	selectAvailableResources();
108	}
109
110	}
111
112	/**
113	* handles the refresh button
114	*/
115	private void handleRefresh() {
116	if (remoteExecutionController != null)
117	remoteExecutionController.refreshResources();
118	else
119	JOptionPane
120	.showMessageDialog(
121	getPanel(),
122	"Error: no discovery possible. The RemoteExecutionController-Plugin can " +
123	"not be found. The plugin is required for parallel " +
124	"computation","Error",JOptionPane.ERROR_MESSAGE);
125	}
126
127	private Vector<String> getVectorOfSelectedNames() {
128
129	Object[] selectedComputingResources = getSelectedResourceContainers();
130
131	// write selected names in vector
132	Vector<String> names = new Vector<String>();
133	for (int i = 0; i < selectedComputingResources.length; i++) {
134	names
135	.add(((ComputingResourceContainer) selectedComputingResources[i])
136	.getInformation().getName());
137	}
138	return names;
139	}
140
141	private void setSelectedElements(Vector<String> names) {
142	for (int i = 0; i < resTableModel.getRowCount(); i++) {
143	ComputingResourceContainer container = (ComputingResourceContainer) resTableModel
144	.getValueAt(i, 0);
145	if (container == null)
146	return;
147	String name = ((ComputingResourceContainer) resTableModel
148	.getValueAt(i, 0)).getInformation().getName();
149	if (names.contains(name))
150	resTable.getSelectionModel().addSelectionInterval(i, i);
151	}
152	}
153
154	private void selectAvailableResources() {
155	// write available selected names in vector
156	Vector<String> names = new Vector<String>();
157	for (int i = 0; i < resTableModel.getRowCount(); i++) {
158	ComputingResourceContainer container = ((ComputingResourceContainer) resTableModel
159	.getValueAt(i, 0));
160	if (container == null)
161	return;
162	ComputingResourceProperties info = container.getInformation();
163	if (info.isAvailable())
164	names.add(info.getName());
165
166	}
167	setSelectedElements(names);
168	}
169
170	/**
171	* @return the first current selected ComputingResourceContainer from the
172	* resouce list
173	*/
174	private ComputingResourceContainer getSelectedResourceContainer() {
175	int selectedRow = resTable.getSelectedRow();
176	if (selectedRow == -1)
177	return null;
178	return (ComputingResourceContainer) resTableModel.getValueAt(
179	selectedRow, 0);
180	}
181
182	/**
183	* @return all current selected ComputingResourceContainer from the resouce
184	* list
185	*/
186	ComputingResourceContainer[] getSelectedResourceContainers() {
187	int[] selRows = panel.computingResourcesList.getSelectedRows();
188	Object[] selectedValues = new Object[selRows.length];
189	for (int i = 0; i < selRows.length; i++) {
190	selectedValues[i] = resTableModel.getValueAt(selRows[i], 0);
191	if (selectedValues[i] == null)
192	return new ComputingResourceContainer[0];
193	}
194	ComputingResourceContainer[] selectedContainers = new ComputingResourceContainer[selectedValues.length];
195	for (int i = 0; i < selectedValues.length; i++)
196	selectedContainers[i] = (ComputingResourceContainer) selectedValues[i];
197	return selectedContainers;
198	}
199
200	/*
201	* (non-Javadoc)
202	*
203	* @see javax.swing.event.ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent)
204	*/
205	public void valueChanged(ListSelectionEvent e) {
206	Object src = e.getSource();
207	if (src == resTable.getSelectionModel()) {
208	ComputingResourceContainer selValue = getSelectedResourceContainer();
209	if (selValue == null)
210	return;
211	panel.propertyTable.setPropertyData(selValue.getInformation()
212	.getProperties());
213	}
214	}
215
216	/**
217	* Listens for user changes of the rating
218	*
219	* @see javax.swing.event.TableModelListener#tableChanged(javax.swing.event.TableModelEvent)
220	*/
221	public void tableChanged(TableModelEvent e) {
222	// enter the new rating information to the configuration
223	XuluConfig config = XuluConfig.getXuluConfig();
224	if (e.getType() == TableModelEvent.UPDATE) {
225	int changedRow = e.getFirstRow();
226	// only the 2nd col is editable
227	String newRating = resTableModel.getValueAt(changedRow, 1)
228	.toString();
229	try {
230	int rating = Integer.valueOf(newRating);
231	if (rating < 0) {
232	resTableModel.setValueAt(0, changedRow, 1);
233	throw new UnsupportedOperationException(
234	"Rating must be > 0");
235	}
236
237	} catch (Exception f) {
238	resTableModel.setValueAt(0, changedRow, 1);
239	throw new UnsupportedOperationException(
240	"Rating must be an integer!");
241	}
242	String computerName = resTableModel.getValueAt(changedRow, 0)
243	.toString();
244	String prefix = "PerformanceRating";
245	String key = prefix + "." + computerName;
246	config.setProperty(key, newRating);
247	}
248	}
249
250	/**
251	* @return the panel
252	*/
253	public ParallelControlPanel getPanel() {
254	return this.panel;
255	}
256
257	/*
258	* (non-Javadoc)
259	*
260	* @see appl.parallel.client.ResourceChangeListener#updateResources(java.util.Vector)
261	*/
262	public void updateResources(
263	Vector<ComputingResourceContainer> currentResources) {
264	// get the selected values (and restore the selection after list
265	// initializing)
266	Vector names = getVectorOfSelectedNames();
267
268	// clear list
269	resTableModel.setRowCount(0);
270	for (ComputingResourceContainer res : currentResources) {
271	// init the rating from the configuration
272	XuluConfig config = XuluConfig.getXuluConfig();
273	String computerName = res.getInformation().getName();
274	String prefix = "PerformanceRating";
275	String key = prefix + "." + computerName;
276	String rating = config.getProperty(key, false);
277	// if no rating found use the selfrating of the machine
278	if (rating == null \|\| rating.equals("0"))
279	rating = res.getInformation().getProperty("Rating");
280	if (rating == null)
281	rating = "0"; // '0' means average
282	resTableModel.addRow(new Object[] { res, rating });
283	}
284
285	// restore selection
286	this.setSelectedElements(names);
287	}
288	}