diff --git a/core/src/main/java/hudson/UDPBroadcastThread.java b/core/src/main/java/hudson/UDPBroadcastThread.java
index c13dea8189..fcbad5b9af 100644
--- a/core/src/main/java/hudson/UDPBroadcastThread.java
+++ b/core/src/main/java/hudson/UDPBroadcastThread.java
@@ -24,19 +24,21 @@
package hudson;
import hudson.model.Hudson;
+import hudson.util.OneShotEvent;
import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
import java.net.BindException;
-import java.nio.ByteBuffer;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
import java.nio.channels.ClosedByInterruptException;
-import java.nio.channels.DatagramChannel;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
- * Monitors a UDP broadcast and respond with the location of the Hudson service.
+ * Monitors a UDP multicast broadcast and respond with the location of the Hudson service.
*
*
* Useful for auto-discovery of Hudson in the network.
@@ -45,6 +47,9 @@ import java.util.logging.Logger;
*/
public class UDPBroadcastThread extends Thread {
private final Hudson hudson;
+
+ public final OneShotEvent ready = new OneShotEvent();
+
public UDPBroadcastThread(Hudson hudson) {
super("Hudson UDP "+PORT+" monitoring thread");
this.hudson = hudson;
@@ -53,42 +58,39 @@ public class UDPBroadcastThread extends Thread {
@Override
public void run() {
try {
- DatagramChannel ch = DatagramChannel.open();
- try {
- ch.socket().bind(new InetSocketAddress(PORT));
+ MulticastSocket mcs = new MulticastSocket(PORT);
+ mcs.joinGroup(MULTICAST);
+ ready.signal();
- ByteBuffer b = ByteBuffer.allocate(2048);
- while(true) {
- // the only thing that matters here is who sent it, not what was sent.
- SocketAddress sender = ch.receive(b);
+ while(true) {
+ byte[] buf = new byte[2048];
+ DatagramPacket p = new DatagramPacket(buf,buf.length);
+ mcs.receive(p);
- // prepare a response
- TcpSlaveAgentListener tal = hudson.getTcpSlaveAgentListener();
+ SocketAddress sender = p.getSocketAddress();
- StringBuilder buf = new StringBuilder("");
- tag(buf,"version",Hudson.VERSION);
- tag(buf,"url",hudson.getRootUrl());
- tag(buf,"slave-port",tal==null?null:tal.getPort());
+ // prepare a response
+ TcpSlaveAgentListener tal = hudson.getTcpSlaveAgentListener();
- for (UDPBroadcastFragment f : UDPBroadcastFragment.all())
- f.buildFragment(buf,sender);
+ StringBuilder rsp = new StringBuilder("");
+ tag(rsp,"version",Hudson.VERSION);
+ tag(rsp,"url",hudson.getRootUrl());
+ tag(rsp,"slave-port",tal==null?null:tal.getPort());
- buf.append("");
+ for (UDPBroadcastFragment f : UDPBroadcastFragment.all())
+ f.buildFragment(rsp,sender);
- b.clear();
- b.put(buf.toString().getBytes("UTF-8"));
- b.flip();
- ch.send(b, sender);
- }
- } finally {
- ch.close();
+ rsp.append("");
+
+ byte[] response = rsp.toString().getBytes("UTF-8");
+ mcs.send(new DatagramPacket(response,response.length,sender));
}
} catch (ClosedByInterruptException e) {
// shut down
} catch (BindException e) {
// if we failed to listen to UDP, just silently abandon it, as a stack trace
// makes people unnecessarily concerned, for a feature that currently does no good.
- LOGGER.log(Level.FINE, "Failed to listen to UDP port "+PORT,e);
+ LOGGER.log(Level.WARNING, "Failed to listen to UDP port "+PORT,e);
} catch (IOException e) {
LOGGER.log(Level.WARNING, "UDP handling problem",e);
}
@@ -106,4 +108,17 @@ public class UDPBroadcastThread extends Thread {
public static final int PORT = Integer.getInteger("hudson.udp",33848);
private static final Logger LOGGER = Logger.getLogger(UDPBroadcastThread.class.getName());
+
+ /**
+ * Multicast socket address.
+ */
+ public static InetAddress MULTICAST;
+
+ static {
+ try {
+ MULTICAST = InetAddress.getByAddress(new byte[]{(byte)239, (byte)77, (byte)124, (byte)213});
+ } catch (UnknownHostException e) {
+ throw new Error(e);
+ }
+ }
}
diff --git a/test/src/test/java/hudson/UDPBroadcastThreadTest.java b/test/src/test/java/hudson/UDPBroadcastThreadTest.java
index a35672e7b4..239fd2d3a5 100644
--- a/test/src/test/java/hudson/UDPBroadcastThreadTest.java
+++ b/test/src/test/java/hudson/UDPBroadcastThreadTest.java
@@ -2,26 +2,65 @@ package hudson;
import org.jvnet.hudson.test.HudsonTestCase;
import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParserFactory;
+import javax.xml.parsers.ParserConfigurationException;
import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.io.StringReader;
+import java.io.IOException;
/**
* @author Kohsuke Kawaguchi
*/
public class UDPBroadcastThreadTest extends HudsonTestCase {
- public void test1() throws Exception {
+ /**
+ * Old unicast based clients should still be able to receive some reply,
+ * as we haven't changed the port.
+ */
+ public void testLegacy() throws Exception {
DatagramSocket s = new DatagramSocket();
+ sendQueryTo(s, InetAddress.getLocalHost());
+ s.setSoTimeout(5000); // to prevent test hang
+ receiveAndVerify(s);
+ }
+
+ /**
+ * Multicast based clients should be able to receive multiple replies.
+ */
+ public void testMulticast() throws Exception {
+ UDPBroadcastThread second = new UDPBroadcastThread(hudson);
+ second.start();
+ second.ready.block();
+
+ try {
+ DatagramSocket s = new DatagramSocket();
+ sendQueryTo(s, UDPBroadcastThread.MULTICAST);
+ s.setSoTimeout(5000); // to prevent test hang
+
+ // we should at least get two replies since we run two broadcasts
+ receiveAndVerify(s);
+ receiveAndVerify(s);
+ } finally {
+ second.interrupt();
+ }
+ }
+
+ private void sendQueryTo(DatagramSocket s, InetAddress dest) throws IOException {
DatagramPacket p = new DatagramPacket(new byte[1024],1024);
- p.setAddress(InetAddress.getLocalHost());
+ p.setAddress(dest);
p.setPort(UDPBroadcastThread.PORT);
s.send(p);
- s.setSoTimeout(5000); // to prevent test hang
+ }
+ /**
+ * Reads a reply from the socket and makes sure its shape is in order.
+ */
+ private void receiveAndVerify(DatagramSocket s) throws IOException, SAXException, ParserConfigurationException {
+ DatagramPacket p = new DatagramPacket(new byte[1024],1024);
s.receive(p);
String xml = new String(p.getData(), 0, p.getLength(), "UTF-8");
System.out.println(xml);