parallel/server/ServerMulticastReceiver.java

package appl.parallel.server;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.SocketException;

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

import appl.ext.XuluConfig;
import appl.parallel.services.MulticastDiscoveryService;

/**
 * Waits for multicast messages from clients and responds properly.
 * 
 * @see MulticastDiscoveryService
 * @author Dominik Appl
 */
public class ServerMulticastReceiver extends Thread {

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

        private static final String helloFromXuluMessage = "Hello Servers";

        private static final String helloFromServerMessage = "Hello Xulu from XuluServer";

        boolean exit = false;

        MulticastSocket socket;

        int multicastPort = XuluConfig.getXuluConfig().getIntProperty(
                        "XuluServer.multicastport");

        /**
         * @param socket
         *            Socket which is used for listening. Set a timeout for the
         *            socket via {@link MulticastSocket#setSoTimeout(int)} so that
         *            the thread can be stopped (because of the blocked reading)
         */
        public ServerMulticastReceiver(MulticastSocket socket) {
                this.socket = socket;
                // try {
                // socket.setSoTimeout(5000);
                // } catch (SocketException e) {
                // //do not printout the timeout
                // }
        }

        /**
         * Safe method to stop the Thread. Use this method instead of {@link Thread}
         */
        public void stopThread() {
                exit = true;
        }

        public void run() {
                System.out.println("Listening on port " + socket.getLocalPort()
                                + " for Xulu hello messages!");
                while (!exit) {
                        try {
                                // receive buffer
                                byte[] buffer = new byte[256];
                                DatagramPacket datagram = new DatagramPacket(buffer,
                                                buffer.length);
                                socket.receive(datagram);

                                // get right message format (cut out null bytes)
                                byte[] result = new byte[datagram.getLength()];
                                System.arraycopy(datagram.getData(), 0, result, 0, datagram
                                                .getLength());

                                // check message:
                                if (new String(result).equals(helloFromXuluMessage)) {
                                        // LOG.info("received hello from Client " +
                                        // datagram.getAddress());
                                        LOG.info("received hello from Client "
                                                        + datagram.getAddress());

                                        // get the IP again and send the answer
                                        String IP = XuluConfig.getXuluConfig().getProperty(
                                                        "XuluServer.multicastgroup");
                                        DatagramPacket answer = new DatagramPacket(
                                                        helloFromServerMessage.getBytes(),
                                                        helloFromServerMessage.length(), InetAddress
                                                                        .getByName(IP), multicastPort);
                                        socket.send(answer);
                                }
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (Exception e) {
                                if (!(e instanceof InterruptedException))
                                        e.printStackTrace();
                        }
                }
        }
}
1	mojays	2	package appl.parallel.server;
2
3			import java.io.IOException;
4			import java.net.DatagramPacket;
5			import java.net.InetAddress;
6			import java.net.MulticastSocket;
7			import java.net.SocketException;
8
9			import org.apache.log4j.LogManager;
10			import org.apache.log4j.Logger;
11
12			import appl.ext.XuluConfig;
13			import appl.parallel.services.MulticastDiscoveryService;
14
15			/**
16			* Waits for multicast messages from clients and responds properly.
17			*
18			* @see MulticastDiscoveryService
19			* @author Dominik Appl
20			*/
21			public class ServerMulticastReceiver extends Thread {
22
23			private final Logger LOG = LogManager.getLogger(this.getClass().getName());
24
25			private static final String helloFromXuluMessage = "Hello Servers";
26
27			private static final String helloFromServerMessage = "Hello Xulu from XuluServer";
28
29			boolean exit = false;
30
31			MulticastSocket socket;
32
33			int multicastPort = XuluConfig.getXuluConfig().getIntProperty(
34			"XuluServer.multicastport");
35
36			/**
37			* @param socket
38			* Socket which is used for listening. Set a timeout for the
39			* socket via {@link MulticastSocket#setSoTimeout(int)} so that
40			* the thread can be stopped (because of the blocked reading)
41			*/
42			public ServerMulticastReceiver(MulticastSocket socket) {
43			this.socket = socket;
44			// try {
45			// socket.setSoTimeout(5000);
46			// } catch (SocketException e) {
47			// //do not printout the timeout
48			// }
49			}
50
51			/**
52			* Safe method to stop the Thread. Use this method instead of {@link Thread}
53			*/
54			public void stopThread() {
55			exit = true;
56			}
57
58			public void run() {
59			System.out.println("Listening on port " + socket.getLocalPort()
60			+ " for Xulu hello messages!");
61			while (!exit) {
62			try {
63			// receive buffer
64			byte[] buffer = new byte[256];
65			DatagramPacket datagram = new DatagramPacket(buffer,
66			buffer.length);
67			socket.receive(datagram);
68
69			// get right message format (cut out null bytes)
70			byte[] result = new byte[datagram.getLength()];
71			System.arraycopy(datagram.getData(), 0, result, 0, datagram
72			.getLength());
73
74			// check message:
75			if (new String(result).equals(helloFromXuluMessage)) {
76			// LOG.info("received hello from Client " +
77			// datagram.getAddress());
78			LOG.info("received hello from Client "
79			+ datagram.getAddress());
80
81			// get the IP again and send the answer
82			String IP = XuluConfig.getXuluConfig().getProperty(
83			"XuluServer.multicastgroup");
84			DatagramPacket answer = new DatagramPacket(
85			helloFromServerMessage.getBytes(),
86			helloFromServerMessage.length(), InetAddress
87			.getByName(IP), multicastPort);
88			socket.send(answer);
89			}
90			} catch (IOException e) {
91			// TODO Auto-generated catch block
92			e.printStackTrace();
93			} catch (Exception e) {
94			if (!(e instanceof InterruptedException))
95			e.printStackTrace();
96			}
97			}
98			}
99			}