parallel/client/RemoteEventHandler.java

package appl.parallel.client;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Vector;

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

import appl.ext.XuluConfig;
import appl.parallel.event.CommEventSink;
import appl.parallel.event.RemoteEvent;
import appl.parallel.event.TimeEvent;
import appl.parallel.event.TimeMonitor;
import appl.parallel.event.TransferEvent;
import appl.parallel.event.TransferMonitor;
import appl.parallel.services.Service;
import appl.parallel.util.Helper;

/**
 * Starts a Service for receiving local and remote events. Monitors can register
 * to this service. All events are forwarded the registered listeners. The
 * service tries to get info for registry port from property
 * <code>XuluClient.registryport</code> in {@link XuluConfig}.
 * 
 * @author Dominik Appl
 */
public class RemoteEventHandler extends UnicastRemoteObject implements Service,
                CommEventSink {

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

        // defaults
        private String bindingName = "RemoteEventReceiver";

        private int registryPort = 1099;

        private Vector<TimeMonitor> timeMonitors = new Vector<TimeMonitor>();

        private Vector<TransferMonitor> transferMonitors = new Vector<TransferMonitor>();

        private boolean timeMonitoring = false;

        private boolean transferMonitoring = false;

        private boolean isRunning;

        /**
         * @throws RemoteException
         * @throws RemoteException
         *             if binding fails
         */
        public RemoteEventHandler() throws RemoteException {
                super();
                isRunning = false;
        }

        /**
         * tries to bind to a running registry or creates one.
         * 
         * @throws RemoteException
         *             if binding fails
         */
        private void bind() throws RemoteException {
                // try to get port from registry
                int port = XuluConfig.getXuluConfig().getIntProperty(
                                "XuluClient.registryport");
                if (port != 0)
                        registryPort = port;
                // bind it
                CommEventSink sink = this;
                Helper.bind(bindingName, sink, registryPort);
        }

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

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.services.Service#startService()
         */
        public void startService() {
                try {
                        bind();
                } catch (RemoteException e) {
                        LOG.error("Could not bind " + bindingName
                                        + " to the registry! Eventsystem will fail.");
                }
                isRunning = true;
        }

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

        /**
         * unbinds the Service
         */
        private void unbind() {
                Helper.unbind(bindingName);
        }

        public void fireRemoteEvent(TimeEvent t) throws RemoteException {
                for (TimeMonitor timeMonitor : timeMonitors) {
                        timeMonitor.receiveTimeEvent(t);
                }
        }


        public void fireRemoteEvent(TransferEvent t) throws RemoteException {
                for (TransferMonitor transferMonitor : transferMonitors) {
                        transferMonitor.receiveTransferEvent(t);
                }
        }

        
        /**
         * Adds a new time monitor
         * 
         * @param monitor
         *            a time monitor
         */
        public void addTimeEventListener(TimeMonitor monitor) {
                if (monitor != null) {
                        timeMonitors.add(monitor);
                        timeMonitoring = true;
                }
        }

        /**
         * Adds a new {@link TransferMonitor}
         * 
         * @param monitor
         *            a time monitor
         */
        public void addTransferEventListener(TransferMonitor monitor) {
                if (monitor != null) {
                        transferMonitors.add(monitor);
                        transferMonitoring = true;
                }
        }

        /**
         * removes the given monitor
         * 
         * @param monitor
         */
        public void removeTimeMonitor(TimeMonitor monitor) {
                timeMonitors.remove(monitor);
                if (timeMonitors.size() == 0)
                        timeMonitoring = false;
        }

        /**
         * adds the given Monitor
         * 
         * @param monitor
         */
        public void removeTransferMonitor(TransferMonitor monitor) {
                transferMonitors.remove(monitor);
                if (transferMonitors.size() == 0)
                        transferMonitoring = false;

        }

        /**
         * @return true if the service is running and time monitoring is enabled
         */
        public boolean isTimeMonitoringEnabled() throws RemoteException {
                return timeMonitoring;
        }

        /**
         * @return true if the service is running and transfer monitoring is enabled
         */
        public boolean isTransferMonitoringEnabled() throws RemoteException {
                return transferMonitoring;
        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.event.RemoteEventSink#fireRemoteEvent(appl.parallel.event.RemoteEvent)
         */
        public void fireRemoteEvent(RemoteEvent e) throws RemoteException {
                if (e instanceof TimeEvent)
                        fireRemoteEvent((TimeEvent) e);
                else if (e instanceof TransferEvent)
                        fireRemoteEvent((TransferEvent) e);
                else
                        // All events should be handled properly
                        System.err.println("Received unknown event of class "
                                        + e.getClass().getName());

        }

        /*
         * (non-Javadoc)
         * 
         * @see appl.parallel.event.RemoteEventSink#fireRemoteEvents(appl.parallel.event.RemoteEvent[])
         */
        public void fireRemoteEvents(RemoteEvent[] e) throws RemoteException {
                for (RemoteEvent event : e) {
                        fireRemoteEvent(event);
                }
        }

}
1	mojays	2	package appl.parallel.client;
2
3			import java.rmi.RemoteException;
4			import java.rmi.server.UnicastRemoteObject;
5			import java.util.Vector;
6
7			import org.apache.log4j.LogManager;
8			import org.apache.log4j.Logger;
9
10			import appl.ext.XuluConfig;
11			import appl.parallel.event.CommEventSink;
12			import appl.parallel.event.RemoteEvent;
13			import appl.parallel.event.TimeEvent;
14			import appl.parallel.event.TimeMonitor;
15			import appl.parallel.event.TransferEvent;
16			import appl.parallel.event.TransferMonitor;
17			import appl.parallel.services.Service;
18			import appl.parallel.util.Helper;
19
20			/**
21			* Starts a Service for receiving local and remote events. Monitors can register
22			* to this service. All events are forwarded the registered listeners. The
23			* service tries to get info for registry port from property
24			* <code>XuluClient.registryport</code> in {@link XuluConfig}.
25			*
26			* @author Dominik Appl
27			*/
28			public class RemoteEventHandler extends UnicastRemoteObject implements Service,
29			CommEventSink {
30
31			private final Logger LOG = LogManager.getLogger(this.getClass().getName());
32
33			// defaults
34			private String bindingName = "RemoteEventReceiver";
35
36			private int registryPort = 1099;
37
38			private Vector<TimeMonitor> timeMonitors = new Vector<TimeMonitor>();
39
40			private Vector<TransferMonitor> transferMonitors = new Vector<TransferMonitor>();
41
42			private boolean timeMonitoring = false;
43
44			private boolean transferMonitoring = false;
45
46			private boolean isRunning;
47
48			/**
49			* @throws RemoteException
50			* @throws RemoteException
51			* if binding fails
52			*/
53			public RemoteEventHandler() throws RemoteException {
54			super();
55			isRunning = false;
56			}
57
58			/**
59			* tries to bind to a running registry or creates one.
60			*
61			* @throws RemoteException
62			* if binding fails
63			*/
64			private void bind() throws RemoteException {
65			// try to get port from registry
66			int port = XuluConfig.getXuluConfig().getIntProperty(
67			"XuluClient.registryport");
68			if (port != 0)
69			registryPort = port;
70			// bind it
71			CommEventSink sink = this;
72			Helper.bind(bindingName, sink, registryPort);
73			}
74
75			/*
76			* (non-Javadoc)
77			*
78			* @see appl.parallel.services.Service#isRunning()
79			*/
80			public boolean isRunning() {
81			return isRunning;
82			}
83
84			/*
85			* (non-Javadoc)
86			*
87			* @see appl.parallel.services.Service#startService()
88			*/
89			public void startService() {
90			try {
91			bind();
92			} catch (RemoteException e) {
93			LOG.error("Could not bind " + bindingName
94			+ " to the registry! Eventsystem will fail.");
95			}
96			isRunning = true;
97			}
98
99			/*
100			* (non-Javadoc)
101			*
102			* @see appl.parallel.services.Service#stopService()
103			*/
104			public void stopService() {
105			unbind();
106			isRunning = false;
107			}
108
109			/**
110			* unbinds the Service
111			*/
112			private void unbind() {
113			Helper.unbind(bindingName);
114			}
115
116			public void fireRemoteEvent(TimeEvent t) throws RemoteException {
117			for (TimeMonitor timeMonitor : timeMonitors) {
118			timeMonitor.receiveTimeEvent(t);
119			}
120			}
121
122
123			public void fireRemoteEvent(TransferEvent t) throws RemoteException {
124			for (TransferMonitor transferMonitor : transferMonitors) {
125			transferMonitor.receiveTransferEvent(t);
126			}
127			}
128
129
130
131			/**
132			* Adds a new time monitor
133			*
134			* @param monitor
135			* a time monitor
136			*/
137			public void addTimeEventListener(TimeMonitor monitor) {
138			if (monitor != null) {
139			timeMonitors.add(monitor);
140			timeMonitoring = true;
141			}
142			}
143
144			/**
145			* Adds a new {@link TransferMonitor}
146			*
147			* @param monitor
148			* a time monitor
149			*/
150			public void addTransferEventListener(TransferMonitor monitor) {
151			if (monitor != null) {
152			transferMonitors.add(monitor);
153			transferMonitoring = true;
154			}
155			}
156
157			/**
158			* removes the given monitor
159			*
160			* @param monitor
161			*/
162			public void removeTimeMonitor(TimeMonitor monitor) {
163			timeMonitors.remove(monitor);
164			if (timeMonitors.size() == 0)
165			timeMonitoring = false;
166			}
167
168			/**
169			* adds the given Monitor
170			*
171			* @param monitor
172			*/
173			public void removeTransferMonitor(TransferMonitor monitor) {
174			transferMonitors.remove(monitor);
175			if (transferMonitors.size() == 0)
176			transferMonitoring = false;
177
178			}
179
180			/**
181			* @return true if the service is running and time monitoring is enabled
182			*/
183			public boolean isTimeMonitoringEnabled() throws RemoteException {
184			return timeMonitoring;
185			}
186
187			/**
188			* @return true if the service is running and transfer monitoring is enabled
189			*/
190			public boolean isTransferMonitoringEnabled() throws RemoteException {
191			return transferMonitoring;
192			}
193
194			/*
195			* (non-Javadoc)
196			*
197			* @see appl.parallel.event.RemoteEventSink#fireRemoteEvent(appl.parallel.event.RemoteEvent)
198			*/
199			public void fireRemoteEvent(RemoteEvent e) throws RemoteException {
200			if (e instanceof TimeEvent)
201			fireRemoteEvent((TimeEvent) e);
202			else if (e instanceof TransferEvent)
203			fireRemoteEvent((TransferEvent) e);
204			else
205			// All events should be handled properly
206			System.err.println("Received unknown event of class "
207			+ e.getClass().getName());
208
209			}
210
211			/*
212			* (non-Javadoc)
213			*
214			* @see appl.parallel.event.RemoteEventSink#fireRemoteEvents(appl.parallel.event.RemoteEvent[])
215			*/
216			public void fireRemoteEvents(RemoteEvent[] e) throws RemoteException {
217			for (RemoteEvent event : e) {
218			fireRemoteEvent(event);
219			}
220			}
221
222			}