Updated multi-cast DNS logic, added TaskEngine to Wildfire.

git-svn-id: http://svn.igniterealtime.org/svn/repos/wildfire/trunk@6160 b35dd754-fafc-0310-a699-88a17e54d16e

src/java/org/jivesoftware/util/TaskEngine.java

+/**
+ * $Revision: 4005 $
+ * $Date: 2006-06-16 08:58:27 -0700 (Fri, 16 Jun 2006) $
+ *
+ * Copyright (C) 2006 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.util;
+
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.Date;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Performs tasks using worker threads. It also allows tasks to be scheduled to be
+ * run at future dates. This class mimics relevant methods in both
+ * {@link ExecutorService} and {@link Timer}. Any {@link TimerTask} that's
+ * scheduled to be run in the future will automatically be run using the thread
+ * executor's thread pool. This means that the standard restriction that TimerTasks
+ * should run quickly does not apply.
+ *
+ * @author Matt Tucker
+ */
+public class TaskEngine {
+
+    private static TaskEngine instance = new TaskEngine();
+
+    /**
+     * Returns a task engine instance (singleton).
+     *
+     * @return a task engine.
+     */
+    public static TaskEngine getInstance() {
+        return instance;
+    }
+
+    private Timer timer;
+    private ExecutorService executor;
+
+    /**
+     * Constructs a new task engine.
+     */
+    private TaskEngine() {
+        timer = new Timer("timer-enterprise", true);
+        executor = Executors.newCachedThreadPool(new ThreadFactory() {
+
+            final AtomicInteger threadNumber = new AtomicInteger(1);
+
+            public Thread newThread(Runnable runnable) {
+                // Use our own naming scheme for the threads.
+                Thread thread = new Thread(Thread.currentThread().getThreadGroup(), runnable,
+                                      "pool-enterprise" + threadNumber.getAndIncrement(), 0);
+                // Make workers daemon threads.
+                thread.setDaemon(true);
+                if (thread.getPriority() != Thread.NORM_PRIORITY) {
+                    thread.setPriority(Thread.NORM_PRIORITY);
+                }
+                return thread;
+            }
+        });
+    }
+
+    /**
+     * Submits a Runnable task for execution and returns a Future
+     * representing that task.
+     *
+     * @param task the task to submit.
+     * @return a Future representing pending completion of the task,
+     *      and whose <tt>get()</tt> method will return <tt>null</tt>
+     *      upon completion.
+     * @throws java.util.concurrent.RejectedExecutionException if task cannot be scheduled
+     *      for execution.
+     * @throws NullPointerException if task null.
+     */
+    public Future<?> submit(Runnable task) {
+        return executor.submit(task);
+    }
+
+    /**
+     * Schedules the specified task for execution after the specified delay.
+     *
+     * @param task  task to be scheduled.
+     * @param delay delay in milliseconds before task is to be executed.
+     * @throws IllegalArgumentException if <tt>delay</tt> is negative, or
+     *         <tt>delay + System.currentTimeMillis()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, or timer was cancelled.
+     */
+    public void schedule(TimerTask task, long delay) {
+        timer.schedule(new TimerTaskWrapper(task), delay);
+    }
+
+    /**
+     * Schedules the specified task for execution at the specified time.  If
+     * the time is in the past, the task is scheduled for immediate execution.
+     *
+     * @param task task to be scheduled.
+     * @param time time at which task is to be executed.
+     * @throws IllegalArgumentException if <tt>time.getTime()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, timer was cancelled, or timer thread terminated.
+     */
+    public void schedule(TimerTask task, Date time) {
+        timer.schedule(new TimerTaskWrapper(task), time);
+    }
+
+    /**
+     * Schedules the specified task for repeated <i>fixed-delay execution</i>,
+     * beginning after the specified delay.  Subsequent executions take place
+     * at approximately regular intervals separated by the specified period.
+     *
+     * <p>In fixed-delay execution, each execution is scheduled relative to
+     * the actual execution time of the previous execution.  If an execution
+     * is delayed for any reason (such as garbage collection or other
+     * background activity), subsequent executions will be delayed as well.
+     * In the long run, the frequency of execution will generally be slightly
+     * lower than the reciprocal of the specified period (assuming the system
+     * clock underlying <tt>Object.wait(long)</tt> is accurate).
+     *
+     * <p>Fixed-delay execution is appropriate for recurring activities
+     * that require "smoothness."  In other words, it is appropriate for
+     * activities where it is more important to keep the frequency accurate
+     * in the short run than in the long run.  This includes most animation
+     * tasks, such as blinking a cursor at regular intervals.  It also includes
+     * tasks wherein regular activity is performed in response to human
+     * input, such as automatically repeating a character as long as a key
+     * is held down.
+     *
+     * @param task   task to be scheduled.
+     * @param delay  delay in milliseconds before task is to be executed.
+     * @param period time in milliseconds between successive task executions.
+     * @throws IllegalArgumentException if <tt>delay</tt> is negative, or
+     *         <tt>delay + System.currentTimeMillis()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, timer was cancelled, or timer thread terminated.
+     */
+    public void schedule(TimerTask task, long delay, long period) {
+        timer.schedule(new TimerTaskWrapper(task), delay, period);
+    }
+
+    /**
+     * Schedules the specified task for repeated <i>fixed-delay execution</i>,
+     * beginning at the specified time. Subsequent executions take place at
+     * approximately regular intervals, separated by the specified period.
+     *
+     * <p>In fixed-delay execution, each execution is scheduled relative to
+     * the actual execution time of the previous execution.  If an execution
+     * is delayed for any reason (such as garbage collection or other
+     * background activity), subsequent executions will be delayed as well.
+     * In the long run, the frequency of execution will generally be slightly
+     * lower than the reciprocal of the specified period (assuming the system
+     * clock underlying <tt>Object.wait(long)</tt> is accurate).
+     *
+     * <p>Fixed-delay execution is appropriate for recurring activities
+     * that require "smoothness."  In other words, it is appropriate for
+     * activities where it is more important to keep the frequency accurate
+     * in the short run than in the long run.  This includes most animation
+     * tasks, such as blinking a cursor at regular intervals.  It also includes
+     * tasks wherein regular activity is performed in response to human
+     * input, such as automatically repeating a character as long as a key
+     * is held down.
+     *
+     * @param task   task to be scheduled.
+     * @param firstTime First time at which task is to be executed.
+     * @param period time in milliseconds between successive task executions.
+     * @throws IllegalArgumentException if <tt>time.getTime()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, timer was cancelled, or timer thread terminated.
+     */
+    public void schedule(TimerTask task, Date firstTime, long period) {
+        timer.schedule(new TimerTaskWrapper(task), firstTime, period);
+    }
+
+    /**
+     * Schedules the specified task for repeated <i>fixed-rate execution</i>,
+     * beginning after the specified delay.  Subsequent executions take place
+     * at approximately regular intervals, separated by the specified period.
+     *
+     * <p>In fixed-rate execution, each execution is scheduled relative to the
+     * scheduled execution time of the initial execution.  If an execution is
+     * delayed for any reason (such as garbage collection or other background
+     * activity), two or more executions will occur in rapid succession to
+     * "catch up."  In the long run, the frequency of execution will be
+     * exactly the reciprocal of the specified period (assuming the system
+     * clock underlying <tt>Object.wait(long)</tt> is accurate).
+     *
+     * <p>Fixed-rate execution is appropriate for recurring activities that
+     * are sensitive to <i>absolute</i> time, such as ringing a chime every
+     * hour on the hour, or running scheduled maintenance every day at a
+     * particular time.  It is also appropriate for recurring activities
+     * where the total time to perform a fixed number of executions is
+     * important, such as a countdown timer that ticks once every second for
+     * ten seconds.  Finally, fixed-rate execution is appropriate for
+     * scheduling multiple repeating timer tasks that must remain synchronized
+     * with respect to one another.
+     *
+     * @param task   task to be scheduled.
+     * @param delay  delay in milliseconds before task is to be executed.
+     * @param period time in milliseconds between successive task executions.
+     * @throws IllegalArgumentException if <tt>delay</tt> is negative, or
+     *         <tt>delay + System.currentTimeMillis()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, timer was cancelled, or timer thread terminated.
+     */
+    public void scheduleAtFixedRate(TimerTask task, long delay, long period) {
+        timer.scheduleAtFixedRate(new TimerTaskWrapper(task), delay, period);
+    }
+
+    /**
+     * Schedules the specified task for repeated <i>fixed-rate execution</i>,
+     * beginning at the specified time. Subsequent executions take place at
+     * approximately regular intervals, separated by the specified period.
+     *
+     * <p>In fixed-rate execution, each execution is scheduled relative to the
+     * scheduled execution time of the initial execution.  If an execution is
+     * delayed for any reason (such as garbage collection or other background
+     * activity), two or more executions will occur in rapid succession to
+     * "catch up."  In the long run, the frequency of execution will be
+     * exactly the reciprocal of the specified period (assuming the system
+     * clock underlying <tt>Object.wait(long)</tt> is accurate).
+     *
+     * <p>Fixed-rate execution is appropriate for recurring activities that
+     * are sensitive to <i>absolute</i> time, such as ringing a chime every
+     * hour on the hour, or running scheduled maintenance every day at a
+     * particular time.  It is also appropriate for recurring activities
+     * where the total time to perform a fixed number of executions is
+     * important, such as a countdown timer that ticks once every second for
+     * ten seconds.  Finally, fixed-rate execution is appropriate for
+     * scheduling multiple repeating timer tasks that must remain synchronized
+     * with respect to one another.
+     *
+     * @param task   task to be scheduled.
+     * @param firstTime First time at which task is to be executed.
+     * @param period time in milliseconds between successive task executions.
+     * @throws IllegalArgumentException if <tt>time.getTime()</tt> is negative.
+     * @throws IllegalStateException if task was already scheduled or
+     *         cancelled, timer was cancelled, or timer thread terminated.
+     */
+    public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period) {
+        timer.scheduleAtFixedRate(new TimerTaskWrapper(task), firstTime, period);
+    }
+
+    /**
+     * Shuts down the task engine service.
+     */
+    public void shutdown() {
+        executor.shutdownNow();
+        executor = null;
+
+        timer.cancel();
+        timer = null;
+    }
+
+    /**
+     * Wrapper class for a standard TimerTask. It simply executes the TimerTask
+     * using the executor's thread pool.
+     */
+    private class TimerTaskWrapper extends TimerTask {
+
+        private TimerTask task;
+
+        public TimerTaskWrapper(TimerTask task) {
+            this.task = task;
+        }
+
+        public void run() {
+            executor.submit(task);
+        }
+    }
+}
\ No newline at end of file

src/java/org/jivesoftware/util/Version.java

 /**
- * $RCSfile$
  * $Revision$
  * $Date$
  *
- * Copyright (C) 2004 Jive Software. All rights reserved.
+ * Copyright (C) 2004-2006 Jive Software. All rights reserved.
  *
  * This software is published under the terms of the GNU Public License (GPL),
  * a copy of which is included in this distribution.
  */
+
 package org.jivesoftware.util;
 
 /**

src/java/org/jivesoftware/wildfire/XMPPServer.java

@@ -862,6 +862,9 @@ public class XMPPServer {
         for (XMPPServerListener listener : listeners) {
             listener.serverStopping();
         }
+        // Shutdown the task engine.
+        TaskEngine.getInstance().shutdown();
+
         // If we don't have modules then the server has already been shutdown
         if (modules.isEmpty()) {
             return;

src/java/org/jivesoftware/wildfire/net/MulticastDNSService.java

@@ -16,29 +16,64 @@ import org.jivesoftware.wildfire.XMPPServer;
 import org.jivesoftware.wildfire.XMPPServerInfo;
 import org.jivesoftware.wildfire.ServerPort;
 import org.jivesoftware.util.Log;
-import org.jivesoftware.admin.AdminConsole;
+import org.jivesoftware.util.PropertyEventDispatcher;
+import org.jivesoftware.util.PropertyEventListener;
+import org.jivesoftware.util.TaskEngine;
 
 import javax.jmdns.JmDNS;
 import javax.jmdns.ServiceInfo;
 import java.io.IOException;
 import java.util.Iterator;
+import java.util.Map;
+import java.util.TimerTask;
 
 /**
- * Publishes Wildfire as a service using the Multicast DNS (marketed by Apple
+ * Publishes Wildfire information as a service using the Multicast DNS (marketed by Apple
  * as Rendezvous) protocol. This lets other nodes on the local network to discover
  * the name and port of Wildfire.<p>
  *
- * The multicast DNS entry is published with a type of "_xmpp-client._tcp.local.".
+ * The multicast DNS entries published:<ul>
+ *  <li>Client connections: type of "_xmpp-client._tcp.local.".
+ *  <li>Component connections: type of "_xmpp-component._tcp.local.".
+ * </ul>
  *
  * @author Matt Tucker
  */
 public class MulticastDNSService extends BasicModule {
 
     private JmDNS jmdns;
-    private ServiceInfo serviceInfo;
 
     public MulticastDNSService() {
         super("Multicast DNS Service");
+
+        PropertyEventDispatcher.addListener(new PropertyEventListener() {
+
+            public void propertySet(String property, Map params) {
+                // Restart the service if component settings changes.
+                if (property.equals("xmpp.component.socket.active") ||
+                        property.equals(" xmpp.component.socket.port"))
+                {
+                    stop();
+                    start();
+                }
+            }
+
+            public void propertyDeleted(String property, Map params) {
+                // Restart the service if component settings changes.
+                if (property.equals("xmpp.component.socket.active") ||
+                        property.equals(" xmpp.component.socket.port"))
+                {
+                    stop();
+                    start();
+                }
+            }
+
+            public void xmlPropertySet(String property, Map params) {
+            }
+
+            public void xmlPropertyDeleted(String property, Map params) {
+            }
+        });
     }
 
     public void initialize(XMPPServer server) {
@@ -46,36 +81,45 @@ public class MulticastDNSService extends BasicModule {
     }
 
     public void start() throws IllegalStateException {
-        if (jmdns != null) {
-            Runnable startService = new Runnable() {
-                public void run() {
-                    XMPPServerInfo info = XMPPServer.getInstance().getServerInfo();
-                    Iterator ports = info.getServerPorts();
-                    int portNum = -1;
-                    while (ports.hasNext()) {
-                        ServerPort port = (ServerPort)ports.next();
-                        if (port.isClientPort() && !port.isSecure()) {
-                            portNum = port.getPort();
-                        }
+        TimerTask startService = new TimerTask() {
+            public void run() {
+                XMPPServerInfo info = XMPPServer.getInstance().getServerInfo();
+                Iterator ports = info.getServerPorts();
+                int clientPortNum = -1;
+                int componentPortNum = -1;
+                while (ports.hasNext()) {
+                    ServerPort port = (ServerPort)ports.next();
+                    if (port.isClientPort()) {
+                        clientPortNum = port.getPort();
+                    }
+                    else if (port.isComponentPort()) {
+                        componentPortNum = port.getPort();
+                    }
+                }
+                try {
+                    if (jmdns == null) {
+                        jmdns = new JmDNS();
                     }
-                    try {
-                        if (jmdns == null) {
-                            jmdns = new JmDNS();
-                        }
-                        if (portNum != -1) {
-                            String serverName = AdminConsole.getAppName();
-                            serviceInfo = new ServiceInfo("_xmpp-client._tcp.local.",
-                                    serverName, portNum, 0, 0, "XMPP Server");
-                            jmdns.registerService(serviceInfo);
-                        }
+                    String serverName = XMPPServer.getInstance().getServerInfo().getName();
+
+                    if (clientPortNum != -1) {
+                        ServiceInfo clientService = new ServiceInfo("_xmpp-client._tcp.local.",
+                                serverName + "._xmpp-client._tcp.local.", clientPortNum, "XMPP Server");
+                        jmdns.registerService(clientService);
                     }
-                     catch (IOException ioe) {
-                        Log.error(ioe);
+                    if (componentPortNum != -1) {
+                        ServiceInfo componentService = new ServiceInfo("_xmpp-component._tcp.local.",
+                                serverName +  "._xmpp-component._tcp.local.", componentPortNum, "XMPP Component Server");
+                        jmdns.registerService(componentService);
                     }
                 }
-            };
-            new Thread(startService).start();
-        }
+                 catch (IOException ioe) {
+                    Log.error(ioe);
+                }
+            }
+        };
+        // Schedule the task to run in 5 seconds, to give Wildire time to start the ports. 
+        TaskEngine.getInstance().schedule(startService, 5000);
     }
 
 
@@ -84,7 +128,9 @@ public class MulticastDNSService extends BasicModule {
             try {
                 jmdns.close();
             }
-            catch (Exception e) { }
+            catch (Exception e) {
+                // Ignore.
+            }
         }
     }