parallel/services/GlobalDiscoveryService.java

package appl.parallel.services;

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