parallel/data/XuluClientLoader.java

package appl.parallel.data;

import java.awt.Rectangle;
import java.io.IOException;
import java.io.Serializable;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.rmi.Naming;

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

import appl.data.LoadingException;
import appl.parallel.client.ClientDataServer;
import appl.parallel.client.DataServer;
import appl.parallel.spmd.split.DataPartition;

/**
 * Loads partitioned data from a {@link ClientDataServer}. And unloads the data
 * 
 * @author Dominik Appl
 */
public class XuluClientLoader extends AbstractDataHandler implements
                PartitionDataHandler {

        protected InetAddress address;

        protected String namingString;

        private String unloadTarget = null;

        /**
         * constructs a new {@link XuluClientLoader}. The local IP adress at the
         * time of construction is later used on serverside for communication (e.g.
         * unloading).
         * 
         * @param rootID
         *            the id of the data
         * @param partitionBounds
         *            the bounds of the partition to be retrieved on server side
         * @param unloadBounds
         *            the bounds of the partition which is to be uploaded to the
         *            client after calculation
         */
        public XuluClientLoader(int rootID, ClientDataServer client,
                        Rectangle partitionBounds, Rectangle unloadBounds) {
                super(rootID, client, partitionBounds, unloadBounds);
                address = null;
                namingString = null;
                try {
                        this.address = InetAddress.getLocalHost();
                        unloadTarget = address.getHostAddress();
                        namingString = "rmi://" + unloadTarget + "/DataServer";
                } catch (UnknownHostException e) {
                        LOG.error("The client IP could not be determined!!", e);
                        e.printStackTrace();
                }
        }

        /**
         * constructs a new {@link XuluClientLoader}. The unloading is done to the
         * {@link DataServer} at the machine given with the parameter unloadTarget
         * (IP/Adress or Hostname).
         * 
         * @param rootID
         *            the id of the data
         * @param partitionBounds
         *            the bounds of the partition to be retrieved on server side
         * @param unloadBounds
         *            the bounds of the partition which is to be uploaded to the
         *            client after calculation
         */
        public XuluClientLoader(int rootID, ClientDataServer client,
                        Rectangle partitionBounds, Rectangle unloadBounds,
                        String unloadTarget) {
                spmdClient = client;
                this.unloadTarget = unloadTarget;
                address = null;
                namingString = null;
                try {
                        this.address = InetAddress.getLocalHost();
                        namingString = "rmi://" + unloadTarget + "/DataServer";
                } catch (UnknownHostException e) {
                        LOG.error("The client IP could not be determined!!", e);
                        e.printStackTrace();
                }
                this.rootID = rootID;
                this.partitionBounds = partitionBounds;
                this.unloadBounds = unloadBounds;
        }

        public XuluClientLoader newInstance(int rootID, ClientDataServer client,
                        Rectangle partitionBounds, Rectangle unloadBounds) {
                return new XuluClientLoader(rootID, client, partitionBounds,
                                unloadBounds);
        }

        /**
         * Used for deserialization. Do not use for other purposes
         */
        public XuluClientLoader() {
                super();
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#getLoadInfo()
         */
        public String getLoadInfo() {
                return "XuluClientLoader tries to load data with rootID " + rootID
                                + " from IP: " + address.getHostAddress() + " with naming: "
                                + namingString;
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#getLoadInfo()
         */
        public String getUnloadInfo() {
                return "XuluClientLoader tries to unload data with rootID " + rootID
                                + " to IP: " + address.getHostAddress() + " with naming: "
                                + namingString;
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataLoader#load()
         */
        public DataPartition load() throws LoadingException {
                try {
                        LOG.debug(getLoadInfo());
                        DataServer client = (DataServer) Naming.lookup(namingString);
                        data = client.getPartition(rootID, partitionBounds);
                        LOG.debug("Partition with id  " + rootID
                                        + " successfully retrieved from client");
                        return data;
                } catch (Exception e) {
                        LOG.error("Partition retrieval failed: " + e.getMessage());
                }
                return null;
        }

        /**
         * Initializes the {@link Logger} after deserialization (used by
         * {@link java.io.Serializable}
         * 
         * @author Dominik Appl
         * @param s
         * @throws IOException
         * @see Serializable
         */
        private synchronized void readObject(java.io.ObjectInputStream s)
                        throws IOException, ClassNotFoundException {
                // reading standard fields
                s.defaultReadObject();
                // initialize Logger
                LOG = LogManager.getLogger(this.getClass().getName());
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.data.DataUnloader#unload()
         */
        public void unload() {
                try {
                        if (LOG.isDebugEnabled())
                                LOG.debug(getUnloadInfo());
                        if (data == null) {
                                if (LOG.isDebugEnabled())
                                        LOG.debug("No data loaded -> nothing to unload");
                                return;
                        }
                        // construct return grid only if necessary
                        DataPartition returnPartition = null;
                        if (unloadBounds.equals(data.getPartitionBounds()))
                                returnPartition = data;
                        else
                                returnPartition = data.getPartition(unloadBounds);
                        // if there is a local spmdClient try to use it
                        if (spmdClient != null)
                                spmdClient.updatePartition(rootID, returnPartition,
                                                unloadBounds);
                        // else connect remotely to client
                        else {
                                DataServer client = (DataServer) Naming.lookup(namingString);
                                client.updatePartition(rootID, returnPartition, unloadBounds);
                        }

                        LOG.debug("Partition with id  " + rootID
                                        + " was transfered back to client!");
                } catch (Exception e) {
                        LOG.error("Backtransfer of data to client failed!", e);
                }
        }

}
1	package appl.parallel.data;
2
3	import java.awt.Rectangle;
4	import java.io.IOException;
5	import java.io.Serializable;
6	import java.net.InetAddress;
7	import java.net.UnknownHostException;
8	import java.rmi.Naming;
9
10	import org.apache.log4j.LogManager;
11	import org.apache.log4j.Logger;
12
13	import appl.data.LoadingException;
14	import appl.parallel.client.ClientDataServer;
15	import appl.parallel.client.DataServer;
16	import appl.parallel.spmd.split.DataPartition;
17
18	/**
19	* Loads partitioned data from a {@link ClientDataServer}. And unloads the data
20	*
21	* @author Dominik Appl
22	*/
23	public class XuluClientLoader extends AbstractDataHandler implements
24	PartitionDataHandler {
25
26	protected InetAddress address;
27
28	protected String namingString;
29
30	private String unloadTarget = null;
31
32	/**
33	* constructs a new {@link XuluClientLoader}. The local IP adress at the
34	* time of construction is later used on serverside for communication (e.g.
35	* unloading).
36	*
37	* @param rootID
38	* the id of the data
39	* @param partitionBounds
40	* the bounds of the partition to be retrieved on server side
41	* @param unloadBounds
42	* the bounds of the partition which is to be uploaded to the
43	* client after calculation
44	*/
45	public XuluClientLoader(int rootID, ClientDataServer client,
46	Rectangle partitionBounds, Rectangle unloadBounds) {
47	super(rootID, client, partitionBounds, unloadBounds);
48	address = null;
49	namingString = null;
50	try {
51	this.address = InetAddress.getLocalHost();
52	unloadTarget = address.getHostAddress();
53	namingString = "rmi://" + unloadTarget + "/DataServer";
54	} catch (UnknownHostException e) {
55	LOG.error("The client IP could not be determined!!", e);
56	e.printStackTrace();
57	}
58	}
59
60	/**
61	* constructs a new {@link XuluClientLoader}. The unloading is done to the
62	* {@link DataServer} at the machine given with the parameter unloadTarget
63	* (IP/Adress or Hostname).
64	*
65	* @param rootID
66	* the id of the data
67	* @param partitionBounds
68	* the bounds of the partition to be retrieved on server side
69	* @param unloadBounds
70	* the bounds of the partition which is to be uploaded to the
71	* client after calculation
72	*/
73	public XuluClientLoader(int rootID, ClientDataServer client,
74	Rectangle partitionBounds, Rectangle unloadBounds,
75	String unloadTarget) {
76	spmdClient = client;
77	this.unloadTarget = unloadTarget;
78	address = null;
79	namingString = null;
80	try {
81	this.address = InetAddress.getLocalHost();
82	namingString = "rmi://" + unloadTarget + "/DataServer";
83	} catch (UnknownHostException e) {
84	LOG.error("The client IP could not be determined!!", e);
85	e.printStackTrace();
86	}
87	this.rootID = rootID;
88	this.partitionBounds = partitionBounds;
89	this.unloadBounds = unloadBounds;
90	}
91
92	public XuluClientLoader newInstance(int rootID, ClientDataServer client,
93	Rectangle partitionBounds, Rectangle unloadBounds) {
94	return new XuluClientLoader(rootID, client, partitionBounds,
95	unloadBounds);
96	}
97
98	/**
99	* Used for deserialization. Do not use for other purposes
100	*/
101	public XuluClientLoader() {
102	super();
103	}
104
105	/*
106	* (non-Javadoc)
107	*
108	* @see appl.data.DataLoader#getLoadInfo()
109	*/
110	public String getLoadInfo() {
111	return "XuluClientLoader tries to load data with rootID " + rootID
112	+ " from IP: " + address.getHostAddress() + " with naming: "
113	+ namingString;
114	}
115
116	/*
117	* (non-Javadoc)
118	*
119	* @see appl.data.DataLoader#getLoadInfo()
120	*/
121	public String getUnloadInfo() {
122	return "XuluClientLoader tries to unload data with rootID " + rootID
123	+ " to IP: " + address.getHostAddress() + " with naming: "
124	+ namingString;
125	}
126
127	/*
128	* (non-Javadoc)
129	*
130	* @see appl.data.DataLoader#load()
131	*/
132	public DataPartition load() throws LoadingException {
133	try {
134	LOG.debug(getLoadInfo());
135	DataServer client = (DataServer) Naming.lookup(namingString);
136	data = client.getPartition(rootID, partitionBounds);
137	LOG.debug("Partition with id " + rootID
138	+ " successfully retrieved from client");
139	return data;
140	} catch (Exception e) {
141	LOG.error("Partition retrieval failed: " + e.getMessage());
142	}
143	return null;
144	}
145
146	/**
147	* Initializes the {@link Logger} after deserialization (used by
148	* {@link java.io.Serializable}
149	*
150	* @author Dominik Appl
151	* @param s
152	* @throws IOException
153	* @see Serializable
154	*/
155	private synchronized void readObject(java.io.ObjectInputStream s)
156	throws IOException, ClassNotFoundException {
157	// reading standard fields
158	s.defaultReadObject();
159	// initialize Logger
160	LOG = LogManager.getLogger(this.getClass().getName());
161	}
162
163	/*
164	* (non-Javadoc)
165	*
166	* @see appl.data.DataUnloader#unload()
167	*/
168	public void unload() {
169	try {
170	if (LOG.isDebugEnabled())
171	LOG.debug(getUnloadInfo());
172	if (data == null) {
173	if (LOG.isDebugEnabled())
174	LOG.debug("No data loaded -> nothing to unload");
175	return;
176	}
177	// construct return grid only if necessary
178	DataPartition returnPartition = null;
179	if (unloadBounds.equals(data.getPartitionBounds()))
180	returnPartition = data;
181	else
182	returnPartition = data.getPartition(unloadBounds);
183	// if there is a local spmdClient try to use it
184	if (spmdClient != null)
185	spmdClient.updatePartition(rootID, returnPartition,
186	unloadBounds);
187	// else connect remotely to client
188	else {
189	DataServer client = (DataServer) Naming.lookup(namingString);
190	client.updatePartition(rootID, returnPartition, unloadBounds);
191	}
192
193	LOG.debug("Partition with id " + rootID
194	+ " was transfered back to client!");
195	} catch (Exception e) {
196	LOG.error("Backtransfer of data to client failed!", e);
197	}
198	}
199
200	}