parallel/client/RemoteExecutionController.java

package appl.parallel.client;

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

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

import schmitzm.lang.AbstractNamedObject;
import appl.ext.XuluConfig;
import appl.parallel.ComputingResourceContainer;
import appl.parallel.model.ParallelStepModel;
import appl.parallel.server.XuluServer;
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 com.sun.jini.tool.ClassServer;

import edu.bonn.xulu.XuluModellingPlatform;
import edu.bonn.xulu.appl.XuluPlugin;

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