parallel/services/GlobalDiscoveryService.java

package appl.parallel.services;

import java.util.Iterator;
import java.util.Vector;

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

import appl.ext.XuluConfig;
import appl.parallel.ComputingResource;
import appl.parallel.ComputingResourceContainer;

/**
 * This class is responsible for discovering Resources. For this it first starts
 * all known {@link DiscoveryService DiscoveryServices} and queries them for
 * known {@link ComputingResource Computing Resources}. <br>
 * <br>
 * This class starts all {@link DiscoveryService}s registered with the following
 * property in the {@link XuluConfig}: <br>
 * <br>
 * DiscoveryServices.activeServices<br>
 * <br>
 * Register {@link DiscoveryService DiscoveryServices} with their fully
 * qualified java name because
 * {@link java.lang.Class#forName(String)  Class.forName} will be called on that
 * String.
 * 
 * @author Dominik Appl
 */
public class GlobalDiscoveryService implements Service {

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

        private static GlobalDiscoveryService instance;

        Vector<DiscoveryService> services = new Vector<DiscoveryService>();

        private boolean isRunning;

        /**
         * @return all active {@link ComputingResource RemoteResources} in a
         *          container class with meta in the a ComputingResourceContainer
         *          Object. They are queried from all known Discovery Services. Do
         *          not query more than necessary!
         */
        public Vector<ComputingResourceContainer> getRemoteResources() {
                Vector<ComputingResourceContainer> discResources = new Vector<ComputingResourceContainer>();
                // query all services for RemoteResources
                for (DiscoveryService disc : services) {
                        Vector<ComputingResourceContainer> newResources = disc
                                        .getResources();
                        // do not add double entrys
                        for (ComputingResourceContainer container : newResources) {
                                if (!(checkAlreadyInside(container, discResources)))
                                        discResources.add(container);
                        }
                }
                return discResources;
        }

        /**
         * checks if the a remoteResource of a given container is in a Vector of
         * RemoteResourceContainers
         *
         * @param container
         * @return
         */
        private boolean checkAlreadyInside(ComputingResourceContainer container,
                        Vector<ComputingResourceContainer> containers) {
                for (ComputingResourceContainer originalcontainer : containers) {
                        if (originalcontainer.getResource().equals(container.getResource()))
                                return true;
                }
                return false;
        }

        /**
         * Looks up all services from the config file, loads them and also starts
         * them.
         */
        public GlobalDiscoveryService() {
                String[] classnames = XuluConfig.getXuluConfig().getMultiProperty(
                                "DiscoveryServices.activeServices");
                for (String classname : classnames) {
                        Class serviceclass;
                        try {
                                serviceclass = Class.forName(classname);
                                DiscoveryService service = (DiscoveryService) serviceclass
                                                .newInstance();
                                services.add(service);
                                service.startService();

                        } catch (ClassNotFoundException e) {
                                LOG.error("Class was not found for string" + classname);
                                LOG.error(e.getMessage());
                        } catch (InstantiationException e) {
                                LOG.error("Could not load class " + classname);
                                LOG.error(e.getMessage());
                        } catch (IllegalAccessException e) {
                                LOG.error("Could not load class " + classname);
                                LOG.error(e.getMessage());
                        }
                }
                // allow some time for the services to discover Resources
                try {
                        Thread.currentThread().sleep(200);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }

        
        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.services.Service#isRunning()
         */
        public boolean isRunning() {
                return isRunning;
        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.services.Service#startService()
         */
        public void startService() {
                isRunning = true;

        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.services.Service#stopService()
         */
        public void stopService() {
                for (DiscoveryService s : services) {
                        s.stopService();
                }
                isRunning = false;

        }

}
1	package appl.parallel.services;
2
3	import java.util.Iterator;
4	import java.util.Vector;
5
6	import org.apache.log4j.LogManager;
7	import org.apache.log4j.Logger;
8
9	import appl.ext.XuluConfig;
10	import appl.parallel.ComputingResource;
11	import appl.parallel.ComputingResourceContainer;
12
13	/**
14	* This class is responsible for discovering Resources. For this it first starts
15	* all known {@link DiscoveryService DiscoveryServices} and queries them for
16	* known {@link ComputingResource Computing Resources}. <br>
17	* <br>
18	* This class starts all {@link DiscoveryService}s registered with the following
19	* property in the {@link XuluConfig}: <br>
20	* <br>
21	* DiscoveryServices.activeServices<br>
22	* <br>
23	* Register {@link DiscoveryService DiscoveryServices} with their fully
24	* qualified java name because
25	* {@link java.lang.Class#forName(String) Class.forName} will be called on that
26	* String.
27	*
28	* @author Dominik Appl
29	*/
30	public class GlobalDiscoveryService implements Service {
31
32	private final Logger LOG = LogManager.getLogger(this.getClass().getName());
33
34	private static GlobalDiscoveryService instance;
35
36	Vector<DiscoveryService> services = new Vector<DiscoveryService>();
37
38	private boolean isRunning;
39
40	/**
41	* @return all active {@link ComputingResource RemoteResources} in a
42	* container class with meta in the a ComputingResourceContainer
43	* Object. They are queried from all known Discovery Services. Do
44	* not query more than necessary!
45	*/
46	public Vector<ComputingResourceContainer> getRemoteResources() {
47	Vector<ComputingResourceContainer> discResources = new Vector<ComputingResourceContainer>();
48	// query all services for RemoteResources
49	for (DiscoveryService disc : services) {
50	Vector<ComputingResourceContainer> newResources = disc
51	.getResources();
52	// do not add double entrys
53	for (ComputingResourceContainer container : newResources) {
54	if (!(checkAlreadyInside(container, discResources)))
55	discResources.add(container);
56	}
57	}
58	return discResources;
59	}
60
61	/**
62	* checks if the a remoteResource of a given container is in a Vector of
63	* RemoteResourceContainers
64	*
65	* @param container
66	* @return
67	*/
68	private boolean checkAlreadyInside(ComputingResourceContainer container,
69	Vector<ComputingResourceContainer> containers) {
70	for (ComputingResourceContainer originalcontainer : containers) {
71	if (originalcontainer.getResource().equals(container.getResource()))
72	return true;
73	}
74	return false;
75	}
76
77	/**
78	* Looks up all services from the config file, loads them and also starts
79	* them.
80	*/
81	public GlobalDiscoveryService() {
82	String[] classnames = XuluConfig.getXuluConfig().getMultiProperty(
83	"DiscoveryServices.activeServices");
84	for (String classname : classnames) {
85	Class serviceclass;
86	try {
87	serviceclass = Class.forName(classname);
88	DiscoveryService service = (DiscoveryService) serviceclass
89	.newInstance();
90	services.add(service);
91	service.startService();
92
93	} catch (ClassNotFoundException e) {
94	LOG.error("Class was not found for string" + classname);
95	LOG.error(e.getMessage());
96	} catch (InstantiationException e) {
97	LOG.error("Could not load class " + classname);
98	LOG.error(e.getMessage());
99	} catch (IllegalAccessException e) {
100	LOG.error("Could not load class " + classname);
101	LOG.error(e.getMessage());
102	}
103	}
104	// allow some time for the services to discover Resources
105	try {
106	Thread.currentThread().sleep(200);
107	} catch (InterruptedException e) {
108	// TODO Auto-generated catch block
109	e.printStackTrace();
110	}
111	}
112
113
114	/*
115	* (non-Javadoc)
116	*
117	* @see appl.parallel.services.Service#isRunning()
118	*/
119	public boolean isRunning() {
120	return isRunning;
121	}
122
123	/*
124	* (non-Javadoc)
125	*
126	* @see appl.parallel.services.Service#startService()
127	*/
128	public void startService() {
129	isRunning = true;
130
131	}
132
133	/*
134	* (non-Javadoc)
135	*
136	* @see appl.parallel.services.Service#stopService()
137	*/
138	public void stopService() {
139	for (DiscoveryService s : services) {
140	s.stopService();
141	}
142	isRunning = false;
143
144	}
145
146	}