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