parallel/client/RemoteExecutionController.java

package appl.parallel.client;

import java.io.IOException;
import java.rmi.RemoteException;
import java.util.Iterator;
import java.util.Vector;

import javax.swing.JOptionPane;

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

import com.sun.jini.tool.ClassServer;

import appl.ext.XuluConfig;
import appl.parallel.ComputingResource;
import appl.parallel.ComputingResourceContainer;
import appl.parallel.ComputingResourceProperties;
import appl.parallel.model.ParallelStepModel;
import appl.parallel.server.XuluServer;
import appl.parallel.services.DiscoveryService;
import appl.parallel.services.GlobalDiscoveryService;
import appl.parallel.spmd.AdvancedSPMDClientController;
import appl.parallel.spmd.SPMDClientController;
import appl.parallel.spmd.SPMDClientInterface;
import appl.parallel.spmd.split.SplitMap;
import appl.parallel.util.Helper;
import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.appl.XuluPlugin;
import edu.bonn.xulu.model.AbstractStepModel;
import edu.bonn.xulu.model.XuluModel;
import schmitzm.lang.AbstractNamedObject;

/**
 * This plugin is responsible that all services required for remote
 * execution are properly started. It first starts the
 * {@link GlobalDiscoveryService}. Then it uses the following entries of
 * {@link XuluConfig} for configuration: <br>
 * <br>
 * <code>RemoteExecutionController.spmd.start</code> - if, <code>true</code>
 * the {@link ClientDataServer} is started. <br><br>
 * <code>RemoteExecutionController.http.start</code> - if, <code>true</code>
 * the {@link ClassServer HTTP-Class server} is started. <br><br>
 * <code>RemoteExecutionController.startLocalXuluServer</code> - if,
 * <code>true</code> a local {@link XuluServer} is started. <br>.
 * 
 * @author Dominik Appl
 */
public class RemoteExecutionController extends AbstractNamedObject implements
                XuluPlugin {

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

        private ClientDataServer spmdClient;

        private boolean started = false;

        private XuluServer localServer;

        private ClassServer httpServer;

        private RemoteEventHandler eventHandlerProxy;

        private GlobalDiscoveryService discoveryService;

        private boolean startHTTP = false;

        private boolean startSPMD = false;

        private boolean startXuluServer = false;

        private boolean httpVerbose = false;

        private int httpPort = 80;

        private String httpBaseDir = ".\\classes"; //default: will be overwritten with the configuration
        
        private Vector<ResourceChangeListener> activeChangeListeners = new Vector<ResourceChangeListener>();

        private Vector<ComputingResourceContainer> lastKnownResources;
        
        public RemoteExecutionController() {
                startDiscovery();
        }

        /**
         * Starts the Plugin
         * 
         * @see edu.bonn.xulu.appl.XuluPlugin#execute(edu.bonn.xulu.XuluModellingPlatform)
         */
        public void execute(XuluModellingPlatform appl) {
                started = true;
                loadConfig();
                startEventSystem();
                startSPMDClient();
                startXuluServer();
                startDiscovery();
                startHTTPServer();
                //discover own server
                refreshResources();
        }

        private void startEventSystem() {
                // start EventProxy
                try {
                        eventHandlerProxy = new RemoteEventHandler();
                        eventHandlerProxy.startService();
                } catch (RemoteException e1) {
                        // TODO Auto-generated catch block
                        e1.printStackTrace();
                }
        }

        private void startDiscovery() {
                if (discoveryService != null)
                        discoveryService.stopService();
                discoveryService = new GlobalDiscoveryService();
        }

        /**
         * Load the configuration form the {@link XuluConfig}
         */
        private void loadConfig() {
                XuluConfig config = XuluConfig.getXuluConfig();
                startSPMD = config
                                .getBooleanProperty("RemoteExecutionController.spmd.start");
                startXuluServer = config
                                .getBooleanProperty("RemoteExecutionController.startlocalxuluserver");
                startHTTP = config
                                .getBooleanProperty("RemoteExecutionController.http.start");
                httpVerbose = config
                                .getBooleanProperty("RemoteExecutionController.http.verbose");
                if (config.getIntProperty("RemoteExecutionController.http.port") != 0)
                        httpPort = config
                                        .getIntProperty("RemoteExecutionController.http.port");
                if (config.getProperty("RemoteExecutionController.http.basedir") != null)
                        httpBaseDir = config
                                        .getProperty("RemoteExecutionController.http.basedir");
        }

        private void startHTTPServer() {
                // start the http server
                if (startHTTP) {
                        try {
                                httpServer = new ClassServer(httpPort, httpBaseDir, true,
                                                httpVerbose);
                                httpServer.start();
                        } catch (IOException e) {
                                LOG.error("Could not create HTTP-Server!", e);
                                e.printStackTrace();
                        }
                }
        }

        private void startSPMDClient() {
                try {
                        if (startSPMD)
                                spmdClient = new ClientDataServer(eventHandlerProxy);
                } catch (RemoteException e) {
                        LOG.error("SPMD Client could NOT be started. " + e.getMessage());
                        e.printStackTrace();
                }
        }

        private void startXuluServer() {
                try {
                        if (startXuluServer)
                                localServer = new XuluServer(false, spmdClient);
                } catch (RemoteException e) {
                        LOG.error("XuluServer could NOT be started. " + e.getMessage());
                        e.printStackTrace();
                }
        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.bonn.xulu.appl.XuluPlugin#isStarted()
         */
        public boolean isStarted() {
                return started;
        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.bonn.xulu.appl.XuluPlugin#isVisible()
         */
        public boolean isVisible() {
                // TODO Auto-generated method stub
                return false;
        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.bonn.xulu.appl.XuluPlugin#setVisible(boolean)
         */
        public void setVisible(boolean visible) {
                // TODO Auto-generated method stub

        }

        /*
         * (non-Javadoc)
         * 
         * @see edu.bonn.xulu.appl.XuluPlugin#stop()
         */
        public void stop() {
                started = false;
                if (httpServer != null)
                        httpServer.stop();
                if (spmdClient != null)
                        spmdClient.close();
                spmdClient = null;
                if (localServer != null)
                        localServer.stopServer();
                spmdClient = null;
                eventHandlerProxy.stopService();
        }

        /**
         * Gets active Resources and triggers the discovery-process. After
         * the resources are found an update is called on all registered 
         * {@link ResourceChangeListener}s.
         *       * 
         */
        public void refreshResources() {
                Vector<ComputingResourceContainer> remoteResources = discoveryService
                                .getRemoteResources();
                
                lastKnownResources = remoteResources;
                //notify listeners about the resource update
                for (ResourceChangeListener listener : activeChangeListeners) {
                        listener.updateResources(remoteResources);
                }

                // The advanced Server still makes some problems and therefore is here
                // deactivated. May be fixed later.
                // try {
                // if(localServer!=null){
                // ComputingResourceProperties localInfo =
                // localServer.getResourceInformation();
                // localInfo.setProperty("Name", "Advanced Internal Server");
                // remoteResources.add(new ComputingResourceContainer(localServer,
                // localInfo));
                // }
                //                              
                // } catch (RemoteException e) {
                // // TODO Auto-generated catch block
                // e.printStackTrace();
                // }
        }
        
        
        /**
         * adds the change lister
         * 
         * @param r the change listener
         */
        public void addResourceChangeListener(ResourceChangeListener r){
                activeChangeListeners.add(r);
        }
        
        /**
         * Removes the change listener
         * @param r the change listener to remove
         */
        public void removeResourceChangeListener(ResourceChangeListener r){
                activeChangeListeners.remove(r);
        }

        

        /**
         * Calculates weight for the given resources for the use in {@link SplitMap}
         * splitmaps. For this the PerfomanceRating read out of the
         * {@link XuluConfig} property <br>
         * "PerformanceRating." + name of the machine <br>
         * If the rating is 0 an average rating is assumed.
         * 
         * @param computingResources
         * @return the weights
         */
        private double[] calculateWeights(
                        Vector<ComputingResourceContainer> computingResources) {
                // first get the rating. Try to find the value in the
                // (user defined)configuration first, if not there try resource info.
                int ratings[] = new int[computingResources.size()];
                for (int i = 0; i < ratings.length; i++) {
                        ComputingResourceContainer container = computingResources.get(i);
                        String resName = container.getInformation().getName();
                        String rating = XuluConfig.getXuluConfig().getProperty(
                                        "PerformanceRating." + resName, false);
                        // if not found take the benchmark value
                        if (rating == null) {
                                rating = container.getInformation().getProperty("Rating");
                        }
                        if (rating == null)
                                rating = "0";
                        ratings[i] = Integer.valueOf(rating);
                }
                return Helper.calculateWeights(ratings);
        }

        /**
         * Gives a new {@link SPMDClientController}.
         * 
         * @param computingResources
         *            the resources to be used by the new controller
         * @return a new {@link SPMDClientController} for the given resources
         */
        public SPMDClientController getNewSPMDClientController(
                        ComputingResourceContainer[] computingResources) {
                Vector<ComputingResourceContainer> resvec = new Vector<ComputingResourceContainer>(
                                computingResources.length);
                for (ComputingResourceContainer container : computingResources) {
                        resvec.add(container);
                }
                return getNewSPMDClientController(resvec);
        }

        /**
         * Gives a new {@link SPMDClientController}.
         * 
         * @param computingResources
         *            the resources to be used by the new controller
         * @return a new {@link SPMDClientController} for the given resources
         */
        public SPMDClientController getNewSPMDClientController(
                        Vector<ComputingResourceContainer> computingResources) {
                double[] weights = calculateWeights(computingResources);
                return new AdvancedSPMDClientController(computingResources, weights,
                                spmdClient, eventHandlerProxy);
        }

        /**
         * @return the execution controller of the given
         *         {@link XuluModellingPlatform} or null, if not found
         */
        public static RemoteExecutionController getRemoteExecutionController(
                        XuluModellingPlatform modellingPlatform) {
                XuluPlugin[] plugins = modellingPlatform.getRegistry().getPlugins();
                for (XuluPlugin plugin : plugins) {
                        if (plugin instanceof RemoteExecutionController)
                                return (RemoteExecutionController) plugin;
                }
                return null;
        }

        public RemoteEventHandler getEventProxy() {
                return eventHandlerProxy;
        }

        /**
         * Prepares a Model for execution, which means it creates a
         * {@link SPMDClientController} with the given Resources
         * 
         * @param model
         *            the model which is to be executed parallel
         * @param selectedResourceContainers
         *            the resources on which the model is executed
         */
        public void prepareModelForSPMDExecution(ParallelStepModel model,
                        ComputingResourceContainer[] selectedResourceContainers) {
                SPMDClientInterface controller = getNewSPMDClientController(selectedResourceContainers);
                model.setSPMDController(controller);
        }
}
1	package appl.parallel.client;
2
3	import java.io.IOException;
4	import java.rmi.RemoteException;
5	import java.util.Iterator;
6	import java.util.Vector;
7
8	import javax.swing.JOptionPane;
9
10	import org.apache.log4j.LogManager;
11	import org.apache.log4j.Logger;
12	import org.apache.log4j.lf5.StartLogFactor5;
13
14	import com.sun.jini.tool.ClassServer;
15
16	import appl.ext.XuluConfig;
17	import appl.parallel.ComputingResource;
18	import appl.parallel.ComputingResourceContainer;
19	import appl.parallel.ComputingResourceProperties;
20	import appl.parallel.model.ParallelStepModel;
21	import appl.parallel.server.XuluServer;
22	import appl.parallel.services.DiscoveryService;
23	import appl.parallel.services.GlobalDiscoveryService;
24	import appl.parallel.spmd.AdvancedSPMDClientController;
25	import appl.parallel.spmd.SPMDClientController;
26	import appl.parallel.spmd.SPMDClientInterface;
27	import appl.parallel.spmd.split.SplitMap;
28	import appl.parallel.util.Helper;
29	import edu.bonn.xulu.XuluModellingPlatform;
30	import edu.bonn.xulu.appl.XuluPlugin;
31	import edu.bonn.xulu.model.AbstractStepModel;
32	import edu.bonn.xulu.model.XuluModel;
33	import schmitzm.lang.AbstractNamedObject;
34
35	/**
36	* This plugin is responsible that all services required for remote
37	* execution are properly started. It first starts the
38	* {@link GlobalDiscoveryService}. Then it uses the following entries of
39	* {@link XuluConfig} for configuration: <br>
40	* <br>
41	* <code>RemoteExecutionController.spmd.start</code> - if, <code>true</code>
42	* the {@link ClientDataServer} is started. <br><br>
43	* <code>RemoteExecutionController.http.start</code> - if, <code>true</code>
44	* the {@link ClassServer HTTP-Class server} is started. <br><br>
45	* <code>RemoteExecutionController.startLocalXuluServer</code> - if,
46	* <code>true</code> a local {@link XuluServer} is started. <br>.
47	*
48	* @author Dominik Appl
49	*/
50	public class RemoteExecutionController extends AbstractNamedObject implements
51	XuluPlugin {
52
53	private final Logger LOG = LogManager.getLogger(this.getClass().getName());
54
55	private ClientDataServer spmdClient;
56
57	private boolean started = false;
58
59	private XuluServer localServer;
60
61	private ClassServer httpServer;
62
63	private RemoteEventHandler eventHandlerProxy;
64
65	private GlobalDiscoveryService discoveryService;
66
67	private boolean startHTTP = false;
68
69	private boolean startSPMD = false;
70
71	private boolean startXuluServer = false;
72
73	private boolean httpVerbose = false;
74
75	private int httpPort = 80;
76
77	private String httpBaseDir = ".\\classes"; //default: will be overwritten with the configuration
78
79	private Vector<ResourceChangeListener> activeChangeListeners = new Vector<ResourceChangeListener>();
80
81	private Vector<ComputingResourceContainer> lastKnownResources;
82
83	public RemoteExecutionController() {
84	startDiscovery();
85	}
86
87	/**
88	* Starts the Plugin
89	*
90	* @see edu.bonn.xulu.appl.XuluPlugin#execute(edu.bonn.xulu.XuluModellingPlatform)
91	*/
92	public void execute(XuluModellingPlatform appl) {
93	started = true;
94	loadConfig();
95	startEventSystem();
96	startSPMDClient();
97	startXuluServer();
98	startDiscovery();
99	startHTTPServer();
100	//discover own server
101	refreshResources();
102	}
103
104	private void startEventSystem() {
105	// start EventProxy
106	try {
107	eventHandlerProxy = new RemoteEventHandler();
108	eventHandlerProxy.startService();
109	} catch (RemoteException e1) {
110	// TODO Auto-generated catch block
111	e1.printStackTrace();
112	}
113	}
114
115	private void startDiscovery() {
116	if (discoveryService != null)
117	discoveryService.stopService();
118	discoveryService = new GlobalDiscoveryService();
119	}
120
121	/**
122	* Load the configuration form the {@link XuluConfig}
123	*/
124	private void loadConfig() {
125	XuluConfig config = XuluConfig.getXuluConfig();
126	startSPMD = config
127	.getBooleanProperty("RemoteExecutionController.spmd.start");
128	startXuluServer = config
129	.getBooleanProperty("RemoteExecutionController.startlocalxuluserver");
130	startHTTP = config
131	.getBooleanProperty("RemoteExecutionController.http.start");
132	httpVerbose = config
133	.getBooleanProperty("RemoteExecutionController.http.verbose");
134	if (config.getIntProperty("RemoteExecutionController.http.port") != 0)
135	httpPort = config
136	.getIntProperty("RemoteExecutionController.http.port");
137	if (config.getProperty("RemoteExecutionController.http.basedir") != null)
138	httpBaseDir = config
139	.getProperty("RemoteExecutionController.http.basedir");
140	}
141
142	private void startHTTPServer() {
143	// start the http server
144	if (startHTTP) {
145	try {
146	httpServer = new ClassServer(httpPort, httpBaseDir, true,
147	httpVerbose);
148	httpServer.start();
149	} catch (IOException e) {
150	LOG.error("Could not create HTTP-Server!", e);
151	e.printStackTrace();
152	}
153	}
154	}
155
156	private void startSPMDClient() {
157	try {
158	if (startSPMD)
159	spmdClient = new ClientDataServer(eventHandlerProxy);
160	} catch (RemoteException e) {
161	LOG.error("SPMD Client could NOT be started. " + e.getMessage());
162	e.printStackTrace();
163	}
164	}
165
166	private void startXuluServer() {
167	try {
168	if (startXuluServer)
169	localServer = new XuluServer(false, spmdClient);
170	} catch (RemoteException e) {
171	LOG.error("XuluServer could NOT be started. " + e.getMessage());
172	e.printStackTrace();
173	}
174	}
175
176	/*
177	* (non-Javadoc)
178	*
179	* @see edu.bonn.xulu.appl.XuluPlugin#isStarted()
180	*/
181	public boolean isStarted() {
182	return started;
183	}
184
185	/*
186	* (non-Javadoc)
187	*
188	* @see edu.bonn.xulu.appl.XuluPlugin#isVisible()
189	*/
190	public boolean isVisible() {
191	// TODO Auto-generated method stub
192	return false;
193	}
194
195	/*
196	* (non-Javadoc)
197	*
198	* @see edu.bonn.xulu.appl.XuluPlugin#setVisible(boolean)
199	*/
200	public void setVisible(boolean visible) {
201	// TODO Auto-generated method stub
202
203	}
204
205	/*
206	* (non-Javadoc)
207	*
208	* @see edu.bonn.xulu.appl.XuluPlugin#stop()
209	*/
210	public void stop() {
211	started = false;
212	if (httpServer != null)
213	httpServer.stop();
214	if (spmdClient != null)
215	spmdClient.close();
216	spmdClient = null;
217	if (localServer != null)
218	localServer.stopServer();
219	spmdClient = null;
220	eventHandlerProxy.stopService();
221	}
222
223	/**
224	* Gets active Resources and triggers the discovery-process. After
225	* the resources are found an update is called on all registered
226	* {@link ResourceChangeListener}s.
227	* *
228	*/
229	public void refreshResources() {
230	Vector<ComputingResourceContainer> remoteResources = discoveryService
231	.getRemoteResources();
232
233	lastKnownResources = remoteResources;
234	//notify listeners about the resource update
235	for (ResourceChangeListener listener : activeChangeListeners) {
236	listener.updateResources(remoteResources);
237	}
238
239	// The advanced Server still makes some problems and therefore is here
240	// deactivated. May be fixed later.
241	// try {
242	// if(localServer!=null){
243	// ComputingResourceProperties localInfo =
244	// localServer.getResourceInformation();
245	// localInfo.setProperty("Name", "Advanced Internal Server");
246	// remoteResources.add(new ComputingResourceContainer(localServer,
247	// localInfo));
248	// }
249	//
250	// } catch (RemoteException e) {
251	// // TODO Auto-generated catch block
252	// e.printStackTrace();
253	// }
254	}
255
256
257	/**
258	* adds the change lister
259	*
260	* @param r the change listener
261	*/
262	public void addResourceChangeListener(ResourceChangeListener r){
263	activeChangeListeners.add(r);
264	}
265
266	/**
267	* Removes the change listener
268	* @param r the change listener to remove
269	*/
270	public void removeResourceChangeListener(ResourceChangeListener r){
271	activeChangeListeners.remove(r);
272	}
273
274
275
276	/**
277	* Calculates weight for the given resources for the use in {@link SplitMap}
278	* splitmaps. For this the PerfomanceRating read out of the
279	* {@link XuluConfig} property <br>
280	* "PerformanceRating." + name of the machine <br>
281	* If the rating is 0 an average rating is assumed.
282	*
283	* @param computingResources
284	* @return the weights
285	*/
286	private double[] calculateWeights(
287	Vector<ComputingResourceContainer> computingResources) {
288	// first get the rating. Try to find the value in the
289	// (user defined)configuration first, if not there try resource info.
290	int ratings[] = new int[computingResources.size()];
291	for (int i = 0; i < ratings.length; i++) {
292	ComputingResourceContainer container = computingResources.get(i);
293	String resName = container.getInformation().getName();
294	String rating = XuluConfig.getXuluConfig().getProperty(
295	"PerformanceRating." + resName, false);
296	// if not found take the benchmark value
297	if (rating == null) {
298	rating = container.getInformation().getProperty("Rating");
299	}
300	if (rating == null)
301	rating = "0";
302	ratings[i] = Integer.valueOf(rating);
303	}
304	return Helper.calculateWeights(ratings);
305	}
306
307	/**
308	* Gives a new {@link SPMDClientController}.
309	*
310	* @param computingResources
311	* the resources to be used by the new controller
312	* @return a new {@link SPMDClientController} for the given resources
313	*/
314	public SPMDClientController getNewSPMDClientController(
315	ComputingResourceContainer[] computingResources) {
316	Vector<ComputingResourceContainer> resvec = new Vector<ComputingResourceContainer>(
317	computingResources.length);
318	for (ComputingResourceContainer container : computingResources) {
319	resvec.add(container);
320	}
321	return getNewSPMDClientController(resvec);
322	}
323
324	/**
325	* Gives a new {@link SPMDClientController}.
326	*
327	* @param computingResources
328	* the resources to be used by the new controller
329	* @return a new {@link SPMDClientController} for the given resources
330	*/
331	public SPMDClientController getNewSPMDClientController(
332	Vector<ComputingResourceContainer> computingResources) {
333	double[] weights = calculateWeights(computingResources);
334	return new AdvancedSPMDClientController(computingResources, weights,
335	spmdClient, eventHandlerProxy);
336	}
337
338	/**
339	* @return the execution controller of the given
340	* {@link XuluModellingPlatform} or null, if not found
341	*/
342	public static RemoteExecutionController getRemoteExecutionController(
343	XuluModellingPlatform modellingPlatform) {
344	XuluPlugin[] plugins = modellingPlatform.getRegistry().getPlugins();
345	for (XuluPlugin plugin : plugins) {
346	if (plugin instanceof RemoteExecutionController)
347	return (RemoteExecutionController) plugin;
348	}
349	return null;
350	}
351
352	public RemoteEventHandler getEventProxy() {
353	return eventHandlerProxy;
354	}
355
356	/**
357	* Prepares a Model for execution, which means it creates a
358	* {@link SPMDClientController} with the given Resources
359	*
360	* @param model
361	* the model which is to be executed parallel
362	* @param selectedResourceContainers
363	* the resources on which the model is executed
364	*/
365	public void prepareModelForSPMDExecution(ParallelStepModel model,
366	ComputingResourceContainer[] selectedResourceContainers) {
367	SPMDClientInterface controller = getNewSPMDClientController(selectedResourceContainers);
368	model.setSPMDController(controller);
369	}
370	}