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.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;

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