parallel/client/RemoteEventHandler.java

package appl.parallel.client;

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