parallel/util/Helper.java

package appl.parallel.util;

import java.rmi.AccessException;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

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


import appl.parallel.ComputingResource;
import appl.parallel.ComputingResourceContainer;
import appl.parallel.ComputingResourceProperties;
import appl.parallel.test.PingTestObject;

/**
 * See method description for details.
 *
 * @author Dominik Appl
 */
public class Helper {
        private static final Logger LOG = LogManager.getLogger("appl.parallel.util.Helper");

        /**
         *      Bind the remote object's stub in the registry. Creates a registry if no running registry
         * is found.
         *
         * @param bindingName the name to be used for binding (with port specified, if necessary)
         * @param bindingInstance an instance of the type to bind to the registry
         * @param registryPort the default registry port
         * @throws RemoteException if something goes wrong
         */
        public static void bind(String bindingName, Remote bindingInstance, int registryPort) throws RemoteException{
                boolean failed=true;
                Registry registry;
                try {
                         registry = LocateRegistry.getRegistry(registryPort);
                         registry.rebind(bindingName, bindingInstance);
                         failed = false;
                } catch (AccessException e) {
                        System.err.println("Not enough permissions to bind" + bindingName +
                                        "to the registry! Adjust your security permission file!");
                        LOG.error("Not enough permissions to bind" + bindingName +
                                        "to the registry! Adjust your security permission file!",e);
                        e.printStackTrace();
                } catch (RemoteException e) {
                        if(e instanceof java.rmi.ConnectException){
                                System.out.println("Could not connect to registry! Trying to create new one...");
                                try {
                                        registry = LocateRegistry.createRegistry(registryPort);
                                        registry.rebind(bindingName, bindingInstance);
                                        System.out.println("Registry successfully created at port " + registryPort);
                                        failed = false;
                                } catch (RemoteException e1) {
                                        // TODO Auto-generated catch block
                                        e1.printStackTrace();
                                }
                        }
                        else
                          e.printStackTrace();
                }
                if(failed)
                        throw new RemoteException("Could not find or create registry!");
        }

        /**
         * Unbinds a a stub from the registry!
         * @param bindingName
         */
        public static void unbind(String bindingName){
        Registry registry;
        try {
                registry = LocateRegistry.getRegistry();
                registry.unbind(bindingName);
                LOG.debug("Sucessfully removed " + bindingName + " from reggie");
        } catch (RemoteException e) {
                LOG.debug("tried to unbind " + bindingName
                                + " from reggie, but an exception occured: "
                                + e.getMessage());
        } catch (NotBoundException e) {
                LOG.debug("tried to unbind " + bindingName
                                + " from reggie, but the name was not bound "
                                + e.getMessage());
        }
        }

        /**
         * Gets the remote resources from all given {@link ComputingResource} objects.
         * For this all resources are queried. If a ressouce does not respond the
         * Resource is removed form the Vector(!!!!!) and a warning is given to the
         * logger.
         *
         * @param res
         */
        public static Vector<ComputingResourceContainer> getResourceContainersForVector(
                        Vector<ComputingResource> res) {

        final Vector<ComputingResourceContainer> containers = new Vector<ComputingResourceContainer>();
    ExecutorService executor = Executors.newCachedThreadPool();

        //this is not a for each loop to avoid ConcurrentModificationException form threads

        Future[] results = new Future[res.size()];
        int i = res.size() - 1;
        while (i >= 0) {
                        results[i] = executor.submit(new Helper().new SimpleConnectionThread(res,i));
                i--;
        }
        //wait for the threads to finish  /
        //add the responding containers to a new Vector and return it
        for (int j = 0; j < results.length; j++) {
                Object result;
                try {
                        result = results[j].get();
                        if(result!=null)
                                containers.add((ComputingResourceContainer) result);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (ExecutionException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }

        }
        return containers;
}

        /**
         * if a connection to the given resource is possible the ResourceProperties of this object
         * are returned. Else NULL is returned.
         *
         * @author Dominik Appl
         */
        public class SimpleConnectionThread implements Callable {

                private final Vector<ComputingResource> containers;

                private final int position;

                public SimpleConnectionThread(
                                Vector<ComputingResource> containers, int position) {
                        this.containers = containers;
                        this.position = position;
                }

                /*
                 * (non-Javadoc)
                 *
                 * @see java.util.concurrent.Callable#call()
                 */
                public Object call() throws Exception {
//                      will remain true, if there is a connection error
                        boolean error = true;
                        ComputingResource r = (ComputingResource) containers.get(position);
                        try {
                                // throw a exeception in case of a connection error:
                                ComputingResourceProperties rp = r.getResourceInformation();
                                error = false;
                                if (LOG.isDebugEnabled())
                                        LOG.debug("Getting of resInfo of <"
                                                        + rp.getProperty("Name") + "> was successfull!");
                                return new ComputingResourceContainer(r, rp);
                        } catch (Exception e) {
                                LOG.warn("A server was not responding .. removing ressouce!");
                                if (LOG.isDebugEnabled())
                                        LOG.debug("Reason was: " + e.getMessage());
                        }
                        return null;
                }
        }


        /**
         * Calculates weights out of ratings. A rating is a value >=1. If the rating
         * is 0 an average rating is assumed. This method weights the ratings
         * relative to each other so that a weight is a double value between 0 and
         * 1 and the sum of all calculated weights is 1.
         *
         * @param ratings
         */
        public static double[] calculateWeights(int ratings[]){
                // values with 0 are weightes average. Add all values and count the
                // values ==0
                double sum = 0;
                double nulls = 0;
                for (int i : ratings) {
                        sum += i;
                        if (i == 0)
                                nulls++;
                }
                // for each null add the average
                double average = (sum / (ratings.length - nulls));
                // if there are ONLY nulls define the average seperately
                if (nulls == ratings.length)
                        average = 1000.0 / ratings.length;
                sum += average * nulls;

                // calculate weights
                double[] weights = new double[ratings.length];
                for (int i = 0; i < weights.length; i++) {
                        if (ratings[i] == 0)
                                ratings[i] = (int) average;
                        weights[i] = ratings[i] / sum;
                }

                if (true == true) {
                        String weightString = "Calculated weights: ";
                        for (double d : weights) {
                                weightString += (d + " ");
                        }
                        LOG.debug("Calculated weights: + " + weightString);
                        System.out.println(weightString);
                }
                return weights;


        }

}


1	package appl.parallel.util;
2
3	import java.rmi.AccessException;
4	import java.rmi.NotBoundException;
5	import java.rmi.Remote;
6	import java.rmi.RemoteException;
7	import java.rmi.registry.LocateRegistry;
8	import java.rmi.registry.Registry;
9	import java.util.Vector;
10	import java.util.concurrent.Callable;
11	import java.util.concurrent.ExecutionException;
12	import java.util.concurrent.Executor;
13	import java.util.concurrent.ExecutorService;
14	import java.util.concurrent.Executors;
15	import java.util.concurrent.Future;
16
17	import org.apache.log4j.LogManager;
18	import org.apache.log4j.Logger;
19
20
21	import appl.parallel.ComputingResource;
22	import appl.parallel.ComputingResourceContainer;
23	import appl.parallel.ComputingResourceProperties;
24	import appl.parallel.test.PingTestObject;
25
26	/**
27	* See method description for details.
28	*
29	* @author Dominik Appl
30	*/
31	public class Helper {
32	private static final Logger LOG = LogManager.getLogger("appl.parallel.util.Helper");
33
34	/**
35	* Bind the remote object's stub in the registry. Creates a registry if no running registry
36	* is found.
37	*
38	* @param bindingName the name to be used for binding (with port specified, if necessary)
39	* @param bindingInstance an instance of the type to bind to the registry
40	* @param registryPort the default registry port
41	* @throws RemoteException if something goes wrong
42	*/
43	public static void bind(String bindingName, Remote bindingInstance, int registryPort) throws RemoteException{
44	boolean failed=true;
45	Registry registry;
46	try {
47	registry = LocateRegistry.getRegistry(registryPort);
48	registry.rebind(bindingName, bindingInstance);
49	failed = false;
50	} catch (AccessException e) {
51	System.err.println("Not enough permissions to bind" + bindingName +
52	"to the registry! Adjust your security permission file!");
53	LOG.error("Not enough permissions to bind" + bindingName +
54	"to the registry! Adjust your security permission file!",e);
55	e.printStackTrace();
56	} catch (RemoteException e) {
57	if(e instanceof java.rmi.ConnectException){
58	System.out.println("Could not connect to registry! Trying to create new one...");
59	try {
60	registry = LocateRegistry.createRegistry(registryPort);
61	registry.rebind(bindingName, bindingInstance);
62	System.out.println("Registry successfully created at port " + registryPort);
63	failed = false;
64	} catch (RemoteException e1) {
65	// TODO Auto-generated catch block
66	e1.printStackTrace();
67	}
68	}
69	else
70	e.printStackTrace();
71	}
72	if(failed)
73	throw new RemoteException("Could not find or create registry!");
74	}
75
76	/**
77	* Unbinds a a stub from the registry!
78	* @param bindingName
79	*/
80	public static void unbind(String bindingName){
81	Registry registry;
82	try {
83	registry = LocateRegistry.getRegistry();
84	registry.unbind(bindingName);
85	LOG.debug("Sucessfully removed " + bindingName + " from reggie");
86	} catch (RemoteException e) {
87	LOG.debug("tried to unbind " + bindingName
88	+ " from reggie, but an exception occured: "
89	+ e.getMessage());
90	} catch (NotBoundException e) {
91	LOG.debug("tried to unbind " + bindingName
92	+ " from reggie, but the name was not bound "
93	+ e.getMessage());
94	}
95	}
96
97	/**
98	* Gets the remote resources from all given {@link ComputingResource} objects.
99	* For this all resources are queried. If a ressouce does not respond the
100	* Resource is removed form the Vector(!!!!!) and a warning is given to the
101	* logger.
102	*
103	* @param res
104	*/
105	public static Vector<ComputingResourceContainer> getResourceContainersForVector(
106	Vector<ComputingResource> res) {
107
108	final Vector<ComputingResourceContainer> containers = new Vector<ComputingResourceContainer>();
109	ExecutorService executor = Executors.newCachedThreadPool();
110
111	//this is not a for each loop to avoid ConcurrentModificationException form threads
112
113	Future[] results = new Future[res.size()];
114	int i = res.size() - 1;
115	while (i >= 0) {
116	results[i] = executor.submit(new Helper().new SimpleConnectionThread(res,i));
117	i--;
118	}
119	//wait for the threads to finish /
120	//add the responding containers to a new Vector and return it
121	for (int j = 0; j < results.length; j++) {
122	Object result;
123	try {
124	result = results[j].get();
125	if(result!=null)
126	containers.add((ComputingResourceContainer) result);
127	} catch (InterruptedException e) {
128	// TODO Auto-generated catch block
129	e.printStackTrace();
130	} catch (ExecutionException e) {
131	// TODO Auto-generated catch block
132	e.printStackTrace();
133	}
134
135	}
136	return containers;
137	}
138
139	/**
140	* if a connection to the given resource is possible the ResourceProperties of this object
141	* are returned. Else NULL is returned.
142	*
143	* @author Dominik Appl
144	*/
145	public class SimpleConnectionThread implements Callable {
146
147	private final Vector<ComputingResource> containers;
148
149	private final int position;
150
151	public SimpleConnectionThread(
152	Vector<ComputingResource> containers, int position) {
153	this.containers = containers;
154	this.position = position;
155	}
156
157	/*
158	* (non-Javadoc)
159	*
160	* @see java.util.concurrent.Callable#call()
161	*/
162	public Object call() throws Exception {
163	// will remain true, if there is a connection error
164	boolean error = true;
165	ComputingResource r = (ComputingResource) containers.get(position);
166	try {
167	// throw a exeception in case of a connection error:
168	ComputingResourceProperties rp = r.getResourceInformation();
169	error = false;
170	if (LOG.isDebugEnabled())
171	LOG.debug("Getting of resInfo of <"
172	+ rp.getProperty("Name") + "> was successfull!");
173	return new ComputingResourceContainer(r, rp);
174	} catch (Exception e) {
175	LOG.warn("A server was not responding .. removing ressouce!");
176	if (LOG.isDebugEnabled())
177	LOG.debug("Reason was: " + e.getMessage());
178	}
179	return null;
180	}
181	}
182
183
184	/**
185	* Calculates weights out of ratings. A rating is a value >=1. If the rating
186	* is 0 an average rating is assumed. This method weights the ratings
187	* relative to each other so that a weight is a double value between 0 and
188	* 1 and the sum of all calculated weights is 1.
189	*
190	* @param ratings
191	*/
192	public static double[] calculateWeights(int ratings[]){
193	// values with 0 are weightes average. Add all values and count the
194	// values ==0
195	double sum = 0;
196	double nulls = 0;
197	for (int i : ratings) {
198	sum += i;
199	if (i == 0)
200	nulls++;
201	}
202	// for each null add the average
203	double average = (sum / (ratings.length - nulls));
204	// if there are ONLY nulls define the average seperately
205	if (nulls == ratings.length)
206	average = 1000.0 / ratings.length;
207	sum += average * nulls;
208
209	// calculate weights
210	double[] weights = new double[ratings.length];
211	for (int i = 0; i < weights.length; i++) {
212	if (ratings[i] == 0)
213	ratings[i] = (int) average;
214	weights[i] = ratings[i] / sum;
215	}
216
217	if (true == true) {
218	String weightString = "Calculated weights: ";
219	for (double d : weights) {
220	weightString += (d + " ");
221	}
222	LOG.debug("Calculated weights: + " + weightString);
223	System.out.println(weightString);
224	}
225	return weights;
226
227
228
229	}
230
231	}
232
233