parallel/gui/ParallelControlPanelEngine.java

package appl.parallel.gui;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Iterator;
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 javax.swing.table.TableModel;

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

import appl.ext.XuluConfig;
import appl.parallel.ComputingResource;
import appl.parallel.ComputingResourceContainer;
import appl.parallel.ComputingResourceProperties;
import appl.parallel.client.RemoteExecutionController;
import appl.parallel.client.ResourceChangeListener;
import appl.util.NonEditableTableModel;
import schmitzm.data.event.ObjectEvent;
import schmitzm.data.event.ObjectListener;

import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.appl.ModelControlManager;
import edu.bonn.xulu.appl.XuluPlugin;
import edu.bonn.xulu.data.XuluDataException;
import edu.bonn.xulu.gui.ModelContentManagerContainer;
import edu.bonn.xulu.gui.ModelControlFrame;
import edu.bonn.xulu.gui.XuluGUIMessages;
import edu.bonn.xulu.model.ModelContentManager;
import edu.bonn.xulu.model.XuluModel;
import edu.bonn.xulu.plugin.gui.ModelControlContainer;
import edu.bonn.xulu.plugin.gui.ModelControlFrame_Basic;

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