/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package net.jini.discovery; import com.sun.jini.config.Config; import com.sun.jini.discovery.Discovery; import com.sun.jini.discovery.DiscoveryConstraints; import com.sun.jini.discovery.DiscoveryProtocolException; import com.sun.jini.discovery.EncodeIterator; import com.sun.jini.discovery.MulticastAnnouncement; import com.sun.jini.discovery.MulticastRequest; import com.sun.jini.discovery.UnicastResponse; import com.sun.jini.discovery.internal.MultiIPDiscovery; import com.sun.jini.logging.Levels; import com.sun.jini.logging.LogUtil; import com.sun.jini.thread.TaskManager; import com.sun.jini.thread.WakeupManager; import com.sun.jini.thread.WakeupManager.Ticket; import java.io.IOException; import java.io.InterruptedIOException; import java.net.DatagramPacket; import java.net.MulticastSocket; import java.net.InetAddress; import java.net.NetworkInterface; import java.net.ServerSocket; import java.net.Socket; import java.net.SocketException; import java.net.SocketTimeoutException; import java.net.UnknownHostException; import java.nio.BufferUnderflowException; import java.nio.ByteBuffer; import java.rmi.RemoteException; import java.security.AccessController; import java.security.PrivilegedAction; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; import java.util.logging.LogRecord; import net.jini.config.Configuration; import net.jini.config.ConfigurationException; import net.jini.config.EmptyConfiguration; import net.jini.config.NoSuchEntryException; import net.jini.constraint.BasicMethodConstraints; import net.jini.core.constraint.InvocationConstraints; import net.jini.core.constraint.MethodConstraints; import net.jini.core.discovery.LookupLocator; import net.jini.core.lookup.ServiceID; import net.jini.core.lookup.ServiceRegistrar; import net.jini.io.UnsupportedConstraintException; import net.jini.security.BasicProxyPreparer; import net.jini.security.ProxyPreparer; import net.jini.security.Security; import net.jini.security.SecurityContext; import org.apache.river.config.LocalHostLookup; /** * This class is a helper utility class that encapsulates the functionality * required of an entity that wishes to employ multicast discovery to * find lookup services located within the entity's "multicast radius" * (roughly, the number of hops beyond which neither the multicast requests * from the entity, nor the multicast announcements from the lookup service, * will propagate). This class helps make the process of acquiring references * to lookup services - based on no information other than lookup service * group membership - much simpler for both services and clients. * * @com.sun.jini.impl * * The following implementation-specific items are discussed below: * * * *

* Configuring LookupDiscovery *

* * * This implementation of LookupDiscovery supports the * following configuration entries; where each configuration entry name * is associated with the component name * net.jini.discovery.LookupDiscovery. Note that the * configuration entries specified here are specific to this implementation * of LookupDiscovery. Unless otherwise stated, each entry * is retrieved from the configuration only once per instance of this * utility, where each such retrieval is performed in the constructor. * * * * *
• * * discoveryConstraints * *
  * Type: {@link net.jini.core.constraint.MethodConstraints} * *
  * Default: null * *
  * Description: * Constraints to apply to the multicast request, multicast * announcement and unicast discovery protocols. Multicast * request constraints are derived by calling * {@link MethodConstraints#getConstraints getConstraints} on the * obtained MethodConstraints instance with a * Method object for the * {@link com.sun.jini.discovery.DiscoveryConstraints#multicastRequest * multicastRequest} method; multicast announcement and unicast * discovery constraints are similarly obtained by passing * Method objects for the * {@link com.sun.jini.discovery.DiscoveryConstraints#multicastAnnouncement * multicastAnnouncement} and * {@link com.sun.jini.discovery.DiscoveryConstraints#unicastDiscovery * unicastDiscovery} methods, respectively. A null * value is interpreted as mapping all methods to empty * constraints. *

* This class supports the use of the following constraint types * to control discovery behavior: *

    *
  • {@link com.sun.jini.discovery.DiscoveryProtocolVersion}: * this constraint can be used to control which version(s) * of the multicast request, multicast announcement and * unicast discovery protocols are used. *
  • {@link com.sun.jini.discovery.MulticastMaxPacketSize}: * this constraint can be used to control the maximum size * of multicast request packets to send; it can also be * used to specify the size of the buffer used to receive * incoming multicast announcement packets. *
  • {@link com.sun.jini.discovery.MulticastTimeToLive}: this * constraint can be used to control the time to live (TTL) * value set on outgoing multicast request packets. *
  • {@link com.sun.jini.discovery.UnicastSocketTimeout}: * this constraint can be used to control the read timeout * set on sockets over which unicast discovery is * performed. *
  • {@link net.jini.core.constraint.ConnectionRelativeTime}: * this constraint can be used to control the relative * connection timeout set on sockets over which unicast * discovery is performed. *
  • {@link net.jini.core.constraint.ConnectionAbsoluteTime}: * this constraint can be used to control the absolute * connection timeout set on sockets over which unicast * discovery is performed. *
* Constraints other than those listed above are passed on to the * underlying implementations of versions 1 and 2 of the discovery * protocols. *
* * * * *
• * * finalMulticastRequestInterval * *
  * Type: long * *
  * Default: 2*60*1000 (2 minutes) * *
  * Description: * With respect to when this utility is started, as well * as when the set of groups to discover is changed, this * entry represents the number of milliseconds to wait * after sending the n-th multicast request where n is * equal to the value of the * multicastRequestMax entry of this component. *
* * * *
• * * initialMulticastRequestDelayRange * *
  * Type: long * *
  * Default: 0 milliseconds * *
  * Description: * With respect to when this utility is started, this entry controls * how long to wait before sending out the first multicast request. * If the value is positive, the first request will be delayed by a random * value between 0 and * initialMulticastRequestDelayRange * milliseconds. Subsequent request intervals are controlled by the * * multicastRequestInterval entry. Note that this entry * only has effect when this utility is initialized. The first multicast * request is not delayed if the groups to discover are subsequently * changed. *
* * * *
• * * multicastAnnouncementInterval * *
  * Type: long * *
  * Default: 2*60*1000 (2 minutes) * *
  * Description: * A lookup service will send out multicast packets * announcing its existence every N milliseconds; for some * value of N. The value of this entry controls how often * this utility examines the multicast announcements from * previously discovered lookup services for liveness. *
* * * * *
• * * multicastInterfaceRetryInterval * *
  * Type: int * *
  * Default: 5*60*1000 (5 minutes) * *
  * Description: * With respect to any network interface this utility is configured * to use to send and receive multicast packets (see entry * * multicastInterfaces), if failure is encountered * upon the initial attempt to set the interface or join the * desired multicast group, this utility will retry the failed * interface every * multicastInterfaceRetryInterval milliseconds * until success is encountered. *
* * * * *
• * * multicastInterfaces * *
  * Type: {@link java.net.NetworkInterface NetworkInterface[]} * *
  * Default: new * {@link java.net.NetworkInterface NetworkInterface[]} *   {all currently supported interfaces} * *
  * Description: * Each network interface that is represented by an element * in the array corresponding to this configuration item * will be used to send and receive multicast packets when * this utility is participating in the multicast discovery * process. When not set, this utility will use all of the * network interfaces in the system. When this entry is set * to a zero length array, multicast discovery is effectively * disabled. And when set to null, * the interface to which the operating system defaults will be * used. *
* * * * *
• * * multicastRequestHost * *
  * Type: String * *
  * Default: * {@link java.net.InetAddress}.getLocalHost().getHostAddress() * *
  * Description: * This entry specifies the host name to include in multicast * requests if participating in version 2 of the * multicast request protocol. The name cannot be null. *
* * * * *
• * * multicastRequestInterval * *
  * Type: long * *
  * Default: 5000 * *
  * Description: * With respect to when this utility is started, as well as * when the set of groups to discover is changed, this entry * represents the number of milliseconds to wait after * sending the n-th multicast request, and before sending * the (n+1)-st request, where n is less than the value of the * multicastRequestMax * entry of this component. *
* * * * *
• * * multicastRequestMax * *
  * Type: int * *
  * Default: 7 * *
  * Description: * The maximum number multicast requests to send when this * utility is started for the first time, and whenever the * groups to discover is changed. *
* * * * *
• * * registrarPreparer * *
  * Type: {@link net.jini.security.ProxyPreparer} * *
  * Default: new {@link net.jini.security.BasicProxyPreparer}() * * *
  * Description: * Preparer for the proxies to the lookup services that are * discovered and used by this utility. *

* This preparer should perform all operations required to use a * newly received proxy to a lookup service, which may including * verifying trust in the proxy, granting permissions, and setting * constraints. *

* The following methods of the * {@link net.jini.core.lookup.ServiceRegistrar ServiceRegistrar} * returned by this preparer are invoked by this implementation of * LookupDiscovery: *

    *
  • {@link net.jini.core.lookup.ServiceRegistrar#getServiceID * getServiceID} *
  • {@link net.jini.core.lookup.ServiceRegistrar#getGroups * getGroups} *
  • {@link net.jini.core.lookup.ServiceRegistrar#getLocator * getLocator} *
*
* * * * *
• * * taskManager * *
  * Type: {@link com.sun.jini.thread.TaskManager} * *
  * Default: new * {@link com.sun.jini.thread.TaskManager#TaskManager() * TaskManager}(15, (15*1000), 1.0f) * *
  * Description: * The object that pools and manages the various threads * executed by this utility. The default manager creates a * maximum of 15 threads, waits 15 seconds before removing * idle threads, and uses a load factor of 1.0 when * determining whether to create a new thread. This object * should not be shared with other components in the * application that employs this utility. *
* * * *
• * * unicastDelayRange * *
  * Type: long * *
  * Default: 0 milliseconds * *
  * Description: * Controls how long this utility will wait before sending out * unicast discovery requests. If the value is positive, any * unicast discovery request that it initiates will be delayed by a * random value between 0 and * unicastDelayRange milliseconds. A typical use of this * entry would be to achieve a more uniform distribution of unicast * discovery requests to a lookup service, when a large number of * LookupDiscovery instances simultaneously receive multicast * announcements from the lookup service. *
* * * *
• * * wakeupManager * *
  * Type: {@link com.sun.jini.thread.WakeupManager} * *
  * Default: new * {@link com.sun.jini.thread.WakeupManager#WakeupManager( * com.sun.jini.thread.WakeupManager.ThreadDesc) * WakeupManager}(new * {@link com.sun.jini.thread.WakeupManager.ThreadDesc}(null,true)) * *
  * Description: * Object used to schedule unicast discovery requests that are * delayed using the * unicastDelayRange * configuration entry of this utility. This entry is processed only * if unicastDelayRange has a positive value. *
* *

* Logging *

* * * This implementation of LookupDiscovery uses the {@link Logger} * named net.jini.discovery.LookupDiscovery to log information * at the following logging levels:

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* net.jini.discovery.LookupDiscovery *
Level Description
{@link java.util.logging.Level#SEVERE SEVERE} * when this utility is configured to use either the default network * interface assigned by the system, or a specific list of network * interfaces, if one of those interfaces is bad or not configured for * multicast, or if a runtime exception occurs while either sending * multicast requests, or while configuring one of the interfaces to * receive multicast announcements, that fact will be logged at this * level *
{@link java.util.logging.Level#INFO INFO} * when any exception other than an InterruptedIOException, * InterruptedException or * UnsupportedConstraintException occurs in a thread or task * while attempting to marshal an outgoing multicast request *
{@link java.util.logging.Level#INFO INFO} * when any exception other than an InterruptedIOException or * SocketTimeoutException occurs in a non-interrupted thread * while attempting to receive an incoming multicast packet *
{@link java.util.logging.Level#INFO INFO} * when any exception other than an InterruptedIOException * occurs while attempting unicast discovery *
{@link java.util.logging.Level#INFO INFO} * when this utility is configured to use either the default network * interface assigned by the system, or a specific list of network * interfaces, with respect to any such interface, if failure is * encountered upon the initial attempt to set the interface or join * the desired multicast group, the interface will be periodically * retried, and successful recovery will be logged at this level *
{@link java.util.logging.Level#INFO INFO}when any exception occurs while attempting to prepare a proxy
{@link java.util.logging.Level#CONFIG CONFIG} * when the multicastInterfaces entry is configured to * be null, multicast packets will be sent and received * through the default network interface assigned by the system, and * that fact will be logged at this level *
{@link java.util.logging.Level#CONFIG CONFIG} * when the multicastInterfaces entry is configured to * be a zero length array, multicast discovery will be disabled, and * and that fact will be logged at this level *
{@link java.util.logging.Level#CONFIG CONFIG} * when the multicastInterfaces entry contains a specific * list of network interfaces, multicast packets will be sent and * received through only the network interfaces contained in that list, * and those interfaces will be logged at this level *
{@link java.util.logging.Level#CONFIG CONFIG} * when the multicastInterfaces entry is excluded from * the configuration, multicast packets will be sent and received * through all interfaces in the system, and those interfaces will * be logged at this level *
{@link com.sun.jini.logging.Levels#FAILED FAILED} * when an UnknownHostException occurs while determining * the multicastRequestHost, but the caller does not have * permissions to retrieve the local host name. The original * UnknownHostException with the host name information * is logged *
{@link com.sun.jini.logging.Levels#HANDLED HANDLED} * when this utility is configured to use all network interfaces enabled * in the system, if one of those interfaces is bad or not configured for * multicast, or if a runtime exception occurs while either sending * multicast requests, or while configuring one of the interfaces to * receive multicast announcements, that fact will be logged at this * level *
{@link com.sun.jini.logging.Levels#HANDLED HANDLED} * when any exception occurs while attempting to unmarshal an incoming * multicast announcement *
{@link com.sun.jini.logging.Levels#HANDLED HANDLED} * when an UnsupportedConstraintException occurs while * marshalling an outgoing multicast request, indicating that the provider * that threw the exception will not be used for encoding that request *
{@link com.sun.jini.logging.Levels#HANDLED HANDLED} * when an IOException occurs upon attempting to close the * socket after the thread that listens for multicast responses is asked * to terminate *
{@link com.sun.jini.logging.Levels#HANDLED HANDLED} * when an exception is handled during unicast discovery *
{@link java.util.logging.Level#FINE FINE} * when this utility is configured to use all network interfaces enabled * in the system, with respect to any such interface, if failure is * encountered upon the initial attempt to set the interface or join * the desired multicast group, the interface will be periodically * retried, and successful recovery will be logged at this level *
{@link java.util.logging.Level#FINEST FINEST}whenever any thread or task is started
{@link java.util.logging.Level#FINEST FINEST} * whenever any thread (except the Notifier thread) or task * completes successfully *
{@link java.util.logging.Level#FINEST FINEST}whenever a discovered, discarded, or changed event is sent
{@link java.util.logging.Level#FINEST FINEST}whenever a proxy is prepared
*

* * * * @see net.jini.core.lookup.ServiceRegistrar * @see DiscoveryChangeListener * @see DiscoveryManagement * @see DiscoveryGroupManagement * @see DiscoveryListener * @see DiscoveryEvent * @see DiscoveryPermission */ public class LookupDiscovery implements DiscoveryManagement, DiscoveryGroupManagement { /* Name of this component; used in config entry retrieval and the logger.*/ private static final String COMPONENT_NAME = "net.jini.discovery.LookupDiscovery"; /* Logger used by this utility. */ private static final Logger logger = Logger.getLogger(COMPONENT_NAME); /** Convenience constant used to request that attempts be made to * discover all lookup services that are within range, and which * belong to any group. Must define this constant here as well as in * DiscoveryGroupManagement for compatibility with * earlier releases. */ public static final String[] ALL_GROUPS = DiscoveryGroupManagement.ALL_GROUPS; /** Convenience constant used to request that discovery by group * membership be halted (or not started, if the group discovery * mechanism is simply being instantiated). Must define this constant * here as well as in DiscoveryGroupManagement for * compatibility with earlier releases. */ public static final String[] NO_GROUPS = DiscoveryGroupManagement.NO_GROUPS; /** Maximum number of concurrent tasks that can be run in any task * manager created by this class. */ private static final int MAX_N_TASKS = 15; /** Default maximum size of multicast packets to send and receive. */ private static final int DEFAULT_MAX_PACKET_SIZE = 512; /** Default time to live value to use for sending multicast packets. */ private static final int DEFAULT_MULTICAST_TTL = 15; /** Default timeout to set on sockets used for unicast discovery. */ private static final int DEFAULT_SOCKET_TIMEOUT = 1*60*1000; /** Flag indicating whether or not this class is still functional. */ private boolean terminated = false; /** Set of listeners to be sent discovered/discarded/changed events. */ private ArrayList listeners = new ArrayList(1); /** The groups to discover. Empty set -- NO_GROUPS, null -- ALL_GROUPS */ private Set groups = null; /** Map from ServiceID to UnicastResponse. */ private Map registrars = new HashMap(11); /** * Set that takes one of the following: *

* Each element of this set represents a potential (or pending) discovered, * discarded, or changed event. Instances of UnicastDiscoveryTask retrieve * the next available element from this set and, based on the object type * of the element, determines the processing to perform and what event * type to send to the registered listeners. */ private Set pendingDiscoveries = new HashSet(11); /** Thread that handles pending notifications. */ private Notifier notifierThread; /** Notifications to be sent to listeners. */ private LinkedList pendingNotifies = new LinkedList(); /** Task manager for running UnicastDiscoveryTasks and * DecodeAnnouncementTasks. */ private TaskManager taskManager; /* WakeupManager to delay tasks. */ private WakeupManager discoveryWakeupMgr = null; private boolean isDefaultWakeupMgr = false; /* Outstanding tickets - Access synchronized on pendingDiscoveries */ private List tickets; /** Thread that handles incoming multicast announcements. */ private AnnouncementListener announceeThread; /** Collection that contains instances of the Requestor Thread class, * each of which participate in multicast discovery by periodically * sending out multicast discovery requests for a finite period of time. */ private Collection requestors = new LinkedList(); /** Thread that manages incoming multicast responses. Runs only when * there are Requestor threads running. */ private ResponseListener respondeeThread = null; /** Security context that contains the access control context to restore * for callbacks, etc. */ private final SecurityContext securityContext = Security.getContext(); /** Map from ServiceID to multicast announcement time stamps; used by the * process that monitors multicast announcements from already-discovered * lookup services, and determines when those announcements have stopped. */ private HashMap regInfo = new HashMap(11); /** Thread that monitors multicast announcements from already-discovered * lookup services and, upon determining that those announcements have * stopped, queues a reachability test with the UnicastDiscoveryTask * which will ultimately result in the lookup service being discarded * if the reachability test indicates that the lookup service is * actually down. */ private AnnouncementTimerThread announcementTimerThread; /* Preparer for the proxies to the lookup services that are discovered * and used by this utility. */ private ProxyPreparer registrarPreparer; /* Utility for participating in version 2 of discovery protocols. */ private Discovery protocol2 = Discovery.getProtocol2(null); /* Maximum number multicast requests to send when this utility is started * for the first time, and whenever the groups to discover are changed. */ private int multicastRequestMax = 7; /* With respect to when this utility is started, as well as when the set * of groups to discover is changed, the value of this field represents * the number of milliseconds to wait after sending the n-th multicast * request, and before sending the (n+1)-st request, where n is less than * the value of . */ private long multicastRequestInterval = 5000L; /* With respect to when this utility is started, as well as when the set * of groups to discover is changed, the value of this field represents * the number of milliseconds to wait after sending the n-th multicast * request, where n is equal to the value of * . */ private long finalMulticastRequestInterval = 2*60*1000L; /* Name of requesting host to include in multicast request if * participating in version 2 of multicast request protocol. */ private String multicastRequestHost; /* Constraints specified for outgoing multicast requests. */ private DiscoveryConstraints multicastRequestConstraints; /* The network interfaces (NICs) through which multicast packets will * be sent. */ private NetworkInterface[] nics; /* NICs that initially failed are retried after this number of millisecs.*/ private int nicRetryInterval = 5*60*1000; /* Controls how often (in milliseconds) this utility examines the * multicast announcements from previously discovered lookup services * for "liveness". */ private long multicastAnnouncementInterval = 2*60*1000L; /* * Controls how long to wait before responding to multicast * announcements */ private long unicastDelayRange = 0; /* Controls how long to wait before sending out multicast requests */ private long initialMulticastRequestDelayRange = 0; /* * Flag which indicates that initial multicast request thread has been * started. */ private boolean initialRequestorStarted = false; /* Constraints specified for incoming multicast announcements. */ private DiscoveryConstraints multicastAnnouncementConstraints; /* Unprocessed constraints specified for unicast discovery. */ private InvocationConstraints rawUnicastDiscoveryConstraints; /** Constants used to tell the notifierThread the type of event to send */ private static final int DISCOVERED = 0; private static final int DISCARDED = 1; private static final int CHANGED = 2; /** Constants used to indicate the set of network interfaces being used */ private static final int NICS_USE_ALL = 0;//use all NICs in the system private static final int NICS_USE_SYS = 1;//use NIC assigned by the system private static final int NICS_USE_LIST = 2;//use list of NICs from config private static final int NICS_USE_NONE = 3;//multicast disabled /** Flag that indicates how the set of network interfaces was configured */ private int nicsToUse = NICS_USE_ALL; /** Data structure containing task data processed by the Notifier Thread */ private static class NotifyTask { /** The set of listeners to notify */ public final ArrayList listeners; /** Map of discovered registrars-to-groups in which each is a member */ public final Map groupsMap; /** The type of event to send: DISCOVERED, DISCARDED, CHANGED */ public final int eventType; public NotifyTask(ArrayList listeners, Map groupsMap, int eventType) { this.listeners = listeners; this.groupsMap = groupsMap; this.eventType = eventType; } }//end class NotifyTask /** Thread that retrieves data structures of type NotifyTask from a * queue and, based on the contents of the data structure, sends the * appropriate event (discovered/discarded/changed) to each registered * listener. *

* Only 1 instance of this thread is run. */ private class Notifier extends Thread { /** Create a daemon thread */ public Notifier() { super("event listener notification"); setDaemon(true); }//end constructor public void run() { logger.finest("LookupDiscovery - Notifier thread started"); while (true) { final NotifyTask task; synchronized (pendingNotifies) { if (pendingNotifies.isEmpty()) { notifierThread = null; return; }//endif task = (NotifyTask)pendingNotifies.removeFirst(); }//end sync /* The call to notify() on the registered listeners is * performed inside a doPrivileged block that restores the * access control context that was in place when this utility * was created. * * This is done because the notify() method called below * executes in the client. But the listener object that * defines that notify() method may have been obtained by * the client from some (possibly untrusted) 3rd party. With * respect to 3rd party code executing in the client, it is * not desirable to allow such code to execute with more * priviledges than the client that created this utility. * Therefore, before executing notify() on any of the * registered listeners, the client's Subject should be * restored, and the listner code should be restricted to * doing nothing more than the client itself is allowed to do. */ AccessController.doPrivileged (securityContext.wrap(new PrivilegedAction() { public Object run() { boolean firstListener = true; for (Iterator iter = task.listeners.iterator(); iter.hasNext(); ) { DiscoveryListener l = (DiscoveryListener)iter.next(); /* Always send discovered and discarded events */ if( (task.eventType == CHANGED) && !(l instanceof DiscoveryChangeListener) ) { continue; }//endif DiscoveryEvent e = new DiscoveryEvent ( LookupDiscovery.this, deepCopy((HashMap)task.groupsMap) ); /* Log the event info about the lookup(s) */ if( firstListener && (logger.isLoggable(Level.FINEST)) ) { String eType = new String[]{"discovered", "discarded", "changed"}[task.eventType]; ServiceRegistrar[] regs = e.getRegistrars(); logger.finest(eType+" event -- "+regs.length +" lookup(s)"); Map groupsMap = e.getGroups(); for(int i=0;i * If the announcements are from a lookup service that has not already * been discovered, and if it is determined that the lookup service * belongs to at least one group of interest, a "pendingDiscovery" is * queued for the UnicastDiscoveryTask to process asynchronously, * completing the discovery process by performing unicast discovery. *

* If the announcements are from a lookup service that has already * been discovered, the lookup service's member groups - as indicated * in the announcements - are analyzed for changes that may result * in either the lookup service being discarded, or in a changed event * being sent. *

* Only 1 instance of this thread is run. */ private class AnnouncementListener extends Thread { /** Multicast socket for receiving packets */ private MulticastSocket sock; /* Set of interfaces whose elements also belong to the nics[] array, * which encountered failure when setting the interface or joining * the desired multicast group, and which will be retried periodically. */ private ArrayList retryNics = null; /** Create a daemon thread */ public AnnouncementListener() throws IOException { super("multicast discovery announcement listener"); setDaemon(true); sock = new MulticastSocket(Constants.discoveryPort); switch(nicsToUse) { case NICS_USE_ALL: /* Using all interfaces. Skip (but report) any interfaces * that are "bad" or not configured for multicast. */ for(int i=0;iinterrupted flag. */ public boolean isInterrupted() { return interrupted; }//end isInterrupted /** Convenience method that retries any previously failed interfaces.*/ private void retryBadNics() { if(retryNics == null) return;//no failed NICs to retry if( !retryNics.isEmpty() ) { String recoveredStr = "network interface has recovered " +"from previous failure: {0}"; ArrayList tmpList = (ArrayList)retryNics.clone(); retryNics.clear(); for(int i=0; i sys default interface try { sock.joinGroup(Constants.getAnnouncementAddress()); retryNics = null; logger.log(Level.INFO, "system default network " +"interface has recovered from " +"previous failure"); } catch(IOException e1) { } }//endif(!retryNics.isEmpty()) }//end retryBadNics public void run() { logger.finest("LookupDiscovery - AnnouncementListener thread " +"started"); byte[] buf = new byte[ multicastAnnouncementConstraints.getMulticastMaxPacketSize( DEFAULT_MAX_PACKET_SIZE)]; DatagramPacket pkt = new DatagramPacket(buf, buf.length); long endTime = System.currentTimeMillis() + nicRetryInterval; while (!isInterrupted()) { try { int delta_t = 0; if(retryNics != null) {//bad NICs, retry when time's up delta_t = (int)(endTime - System.currentTimeMillis()); if( delta_t <= 0) { retryBadNics(); if(retryNics != null) {//still bad, reset timer delta_t = nicRetryInterval; endTime = System.currentTimeMillis() + delta_t; } else {//all NICs recovered, turn off timer delta_t = 0; }//endif }//endif }//endif sock.setSoTimeout(delta_t); pkt.setLength(buf.length); try { sock.receive(pkt); } catch (NullPointerException e) { break; // workaround for bug 4190513 } restoreContextAddTask(new DecodeAnnouncementTask(pkt)); buf = new byte[buf.length]; pkt = new DatagramPacket(buf, buf.length); } catch (SocketTimeoutException e) {//continue/retry bad NICs } catch (InterruptedIOException e) { break; } catch (Exception e) {//ignore if( isInterrupted() ) break; logger.log(Level.INFO, "exception while listening for multicast " +"announcements", e); } }//end loop(!interrupted) sock.close(); logger.finest("LookupDiscovery - AnnouncementListener thread " +"completed"); }//end run }//end class AnnouncementListener /** Thread that listens for multicast responses to the multicast requests * sent out by the Requestor Thread class. Upon receiving a multicast * response, the socket that accepted the connection request associated * with the the multicast response is added to the set of * pendingDiscoveries so that it (the socket) will be used by the * UnicastDiscoveryTask to complete the discovery process asynchronously. *

* Only 1 instance of this thread is run. */ private class ResponseListener extends Thread { /** Server socket for accepting connections */ public ServerSocket serv; /** Create a daemon thread */ public ResponseListener() throws IOException { super("multicast discovery response listener"); setDaemon(true); serv = new ServerSocket(0); }//end constructor /** True if thread has been interrupted */ private volatile boolean interrupted = false; /* This is a workaround for Thread.interrupt not working on * ServerSocket.accept on all platforms. ServerSocket.close * can't be used as a workaround, because it also doesn't work * on all platforms. */ public void interrupt() { interrupted = true; try { (new Socket(LocalHostLookup.getLocalHost(), getPort())).close(); } catch (IOException e) { /* ignore */ } }//end interrupt /** Accessor method that returns the interrupted flag. */ public boolean isInterrupted() { return interrupted; }//end isInterrupt public void run() { logger.finest("LookupDiscovery - ResponseListener thread started"); while (!isInterrupted()) { try { Socket sock = serv.accept(); if (isInterrupted()) { try { sock.close(); } catch (IOException e) { } break; }//end if synchronized (pendingDiscoveries) { pendingDiscoveries.add(sock); restoreContextAddTask(new UnicastDiscoveryTask(sock)); }//end sync } catch (InterruptedIOException e) { break; } catch (Exception e) {//ignore logger.log(Level.INFO, "exception while listening for multicast " +"response", e); } }//end loop(!isInterrupted) try { serv.close(); } catch (IOException e) {//ignore logger.log(Levels.HANDLED, "IOException while attempting a socket close", e); } logger.finest("LookupDiscovery - ResponseListener thread " +"completed"); }//end run /** Return the local port of the socket */ public int getPort() { return serv.getLocalPort(); }//end getPort }//end class ResponseListener /** Thread that periodically sends out multicast requests for a limited * period of time, and then exits. *

* An instance of this thread is run at startup, and each time the * set of groups to discover is changed. */ private class Requestor extends Thread { /** Multicast socket for sending packets */ private MulticastSocket sock; /** Unicast response port */ private int responsePort; /** Groups to request */ private String[] groups; private boolean delayFlag; /** Create a daemon thread */ public Requestor(String[] groups, int port, boolean delayFlag) throws IOException { super("multicast discovery request"); setDaemon(true); sock = new MulticastSocket(Constants.discoveryPort); sock.setTimeToLive( multicastRequestConstraints.getMulticastTimeToLive( DEFAULT_MULTICAST_TTL)); responsePort = port; this.groups = groups == null ? new String[0] : groups; this.delayFlag = delayFlag; }//end constructor /** This method sends out N (for small N) multicast requests. Until * the last request is sent out, this method sleeps for 5 seconds * after each request is sent. After the last request is sent, * this method sleeps for 2 minutes to allow the ResponseListener * time to receive and process any multicast responses sent in * reply to the multicast requests. Before sending a request, a * new multicast request is constructed so that updates * can be made to the set of service IDs of the lookup services * discovered due to previous requests. *

* After all requests have been sent, and the ResponseListener * has been given the appropriate time to receive and process * any multicast responses, if there are no more active instances * of this thread, this method terminates (interrupts) the * ResponseListener. Note that although it is more desirable to * have the ResponseListener set a timeout on the server socket * (using setSoTimeout) and then simply exit after a period of * time in which both the ResponseListener has been idle, and * there have been no active Requestor threads, using setSoTimeout * in this way can cause random hangs on the Solaris(TM) operating * system. */ public void run() { logger.finest("LookupDiscovery - Requestor thread started"); int count; // bug 4084783/4187594 try { if (delayFlag && (initialMulticastRequestDelayRange > 0) && (multicastRequestMax >= 0)) { Thread.sleep((long) (Math.random() * initialMulticastRequestDelayRange)); } for (count = multicastRequestMax; --count >= 0 && !isInterrupted(); ) { DatagramPacket[] reqs = encodeMulticastRequest (new MulticastRequest(multicastRequestHost, responsePort, groups, getServiceIDs())); sendPacketByNIC(sock, reqs); Thread.sleep(count > 0 ? multicastRequestInterval:finalMulticastRequestInterval); }//end loop } catch (InterruptedException e) {//terminate gracefully } catch (InterruptedIOException e) {//terminate gracefully } catch (Exception e) { logger.log(Level.INFO,"exception while marshalling outgoing " +"multicast request", e); } finally { synchronized (requestors) { requestors.remove(Thread.currentThread()); if (respondeeThread != null && requestors.isEmpty()) { respondeeThread.interrupt(); respondeeThread = null; } }//end sync sock.close(); logger.finest("LookupDiscovery - Requestor thread completed"); }//end try/catch/finally }//end run }//end class Requestor /** * This thread monitors the multicast announcements sent from the * lookup service(s) that have already been discovered by this class, * looking for indications that those announcements have terminated. * * The data structure used to map the discovered lookup services to * the time of arrival of the most recent multicast announcement from * each such lookup service is examined at regular intervals; dependent * on the system property net.jini.discovery.announce. * * If the difference between the current time and the last time of * arrival for any announcement exceeds a predetermined threshold, the * corresponding lookup is polled for its current set of member groups. * If that lookup service is unreachable, or if it is reachable but its * member groups have been replaced, the lookup service is discarded. */ private class AnnouncementTimerThread extends Thread { /* Number of interval to exceed for declaring announcements stopped */ private static final long N_INTERVALS = 3; /** Create a daemon thread */ public AnnouncementTimerThread() { super("multicast announcement timer"); setDaemon(true); } public synchronized void run() { long timeThreshold = N_INTERVALS*multicastAnnouncementInterval; try { while(!isInterrupted()) { wait(multicastAnnouncementInterval); long curTime = System.currentTimeMillis(); synchronized (registrars) { /* can't modify regInfo while iterating over it, * so clone it */ HashMap regInfoClone = (HashMap)(regInfo.clone()); Set eSet = regInfoClone.entrySet(); for(Iterator itr = eSet.iterator(); itr.hasNext(); ) { Map.Entry pair = (Map.Entry)itr.next(); ServiceID srvcID = (ServiceID)pair.getKey(); long tStamp = ((AnnouncementInfo)pair.getValue()).tStamp; long deltaT = curTime - tStamp; if(deltaT > timeThreshold) { /* announcements stopped, queue reachability * test and potential discarded event */ UnicastResponse resp = (UnicastResponse)registrars.get(srvcID); Object req = new CheckReachabilityMarker(resp); synchronized (pendingDiscoveries) { if(pendingDiscoveries.add(req)) { restoreContextAddTask( new UnicastDiscoveryTask(req)); }//endif }//end sync }//end if }//end loop (itr) }//end sync }//end loop (!isInterrupted) } catch (InterruptedException e) { } }//end run }//end class AnnouncementTimerThread /** * Marker object placed in pendingDiscoveries set to indicate to * UnicastDiscoveryTask that the groups of the lookup service which sent * the contained announcement need to be verified. */ private static class CheckGroupsMarker { /** Announcement sent by lookup service to check groups of */ final MulticastAnnouncement announcement; CheckGroupsMarker(MulticastAnnouncement announcement) { this.announcement = announcement; } public int hashCode() { return announcement.getServiceID().hashCode(); } public boolean equals(Object obj) { return obj instanceof CheckGroupsMarker && announcement.getServiceID().equals( ((CheckGroupsMarker) obj).announcement.getServiceID()); } } /** * Marker object placed in pendingDiscoveries set to indicate to * UnicastDiscoveryTask that reachability of the lookup service which sent * the contained unicast response needs to be verified. */ private static class CheckReachabilityMarker { /** Response sent by lookup service to check reachability of */ final UnicastResponse response; CheckReachabilityMarker(UnicastResponse response) { this.response = response; } public int hashCode() { return response.getRegistrar().hashCode(); } public boolean equals(Object obj) { return obj instanceof CheckReachabilityMarker && response.getRegistrar().equals( ((CheckReachabilityMarker) obj).response.getRegistrar()); } } /** * Task which decodes received multicast announcement packets. This is * separated into a task to allow the AnnouncementListener thread to * quickly loop and receive new announcement packets; the act of decoding * packets may involve relatively slow cryptographic operations such as * signature verification, and would impede the packet receiving loop if it * were performed inline. */ private class DecodeAnnouncementTask implements TaskManager.Task { private final DatagramPacket datagram; /** * Creates a task for decoding the given multicast announcement packet. */ public DecodeAnnouncementTask(DatagramPacket datagram) { this.datagram = datagram; } /** * Restore the privileged context and run */ public void run() { Security.doPrivileged(new PrivilegedAction() { public Object run() { doRun(); return null; }//end run });//end doPrivileged } /** * Decodes this task's multicast announcement packet. If the * constraints for decoding multicast announcements are satisfied and * the announcement merits further processing, an appropriate object is * added to the pendingDiscoveries set, and control is transferred to a * UnicastDiscoveryTask. */ private void doRun() { MulticastAnnouncement ann; try { ann = decodeMulticastAnnouncement(datagram); } catch (Exception e) { if (!(e instanceof InterruptedIOException)) { logger.log(Levels.HANDLED, "exception decoding multicast announcement", e); } return; } /* If the registrars map contains the service ID of the registrar * that sent the current announcement then that registrar has * already been discovered. * * Determine if the member groups of the already-discovered * registrar have been replaced by a set containing none of the * desired groups. If yes, then discard the registrar. * * If the registrar that sent the current announcement has not * already been discovered, then check to see if any of the * group(s) in which the registrar is a member are in the set of * desired groups to discover. If yes, then queue the registrar for * unicast discovery. */ Object pending = null; ServiceID srvcID = ann.getServiceID(); synchronized (registrars) { UnicastResponse resp = (UnicastResponse) registrars.get(srvcID); if (resp != null) { // already in discovered set, timestamp announcement AnnouncementInfo aInfo = (AnnouncementInfo) regInfo.get(srvcID); aInfo.tStamp = System.currentTimeMillis(); long currNum = ann.getSequenceNumber(); if ((newSeqNum(currNum, aInfo.seqNum)) && (!groupSetsEqual(resp.getGroups(), ann.getGroups()))) { /* Check if the groups have changed. In the case of * split announcement messages, eventually, group difference * will be seen for the given sequence number. This * check ignores other differences, such as port numbers, * but for the purposes of LookupDiscovery, this is not * important. */ pending = new CheckGroupsMarker(ann); } } else if (groupsOverlap(ann.getGroups())) { // newly discovered pending = new LookupLocator(ann.getHost(), ann.getPort()); } } if (pending != null) { try { checkAnnouncementConstraints(ann); } catch (Exception e) { if (!(e instanceof InterruptedIOException)) { logger.log(Levels.HANDLED, "exception decoding multicast announcement", e); } return; } if (pending instanceof CheckGroupsMarker) { synchronized(registrars) { // Since this is a valid announcement, update the // sequence number. AnnouncementInfo aInfo = (AnnouncementInfo) regInfo.get(srvcID); aInfo.seqNum = ann.getSequenceNumber(); } } boolean added; // enqueue and handle pending action, if not already enqueued synchronized (pendingDiscoveries) { added = pendingDiscoveries.add(pending); } if (added) { if (unicastDelayRange <= 0) { new UnicastDiscoveryTask(pending).run(); } else { final UnicastDiscoveryTask ud = new UnicastDiscoveryTask(pending, true); final Ticket t = restoreContextScheduleRunnable(ud); synchronized (ud) { ud.ticket = t; ud.delayRun = false; synchronized (pendingDiscoveries) { tickets.add(t); } ud.notifyAll(); } } } } } /** Returns true if currentNum is a new sequence number * that needs to be inspected. A -1 occurs if the announcement had no * sequence number (for e.g. DiscoveryV1) or the service had been * discovered through unicast discovery. REMIND: Ideally the * message should have a flag which indicates no sequence number instead * of overloading the -1 value */ private boolean newSeqNum(long currentNum, long oldNum) { if (oldNum == -1) { // No sequence number information, so we guess that this is // a new announcement of interest. return true; } else if (currentNum > oldNum) { return true; } else { return false; } } /** No ordering */ public boolean runAfter(List tasks, int size) { return false; } } /** Task which retrieves elements from the set of pendingDiscoveries and * performs the appropriate processing based on the object type of * the element. *

* Each element of the set of pendingDiscoveries is one of the following * object types: Socket, LookupLocator, CheckGroupsMarker, * or CheckReachabilityMarker. *

* When the element to process is a Socket, the element was a result * of a multicast request/response exchange (see the Requestor and * ResponseListener Thread classes). In this case, this task completes * the discovery of the associated lookup service by performing the * final stage of unicast discovery, ultimately resulting in a discovered * event being sent to all registered listeners. *

* When the element to process is a LookupLocator, the element was a * result of a multicast announcement received from a lookup service - * belonging to at least one group of interest - which has not already * been discovered. In this case, this task also completes the discovery * of the lookup service referenced in the announcement by performing the * final stage of unicast discovery, ultimately resulting in a discovered * event being sent to all registered listeners. *

* When the element to process is a CheckGroupsMarker, the * element was a result of a multicast announcement received from an * already-discovered lookup service whose member groups have changed * in some way. In this case, this task determines how those member * groups have changed and, based on how they have changed, whether * (or not) to send a discarded event or a changed event to the * appropriate registered listeners. *

* When the element to process is a CheckReachabilityMarker, the * element was a result of a determination that the multicast * announcements from an already-discovered lookup service have * stopped being received (see the AnnouncementTimerThread class). * In this case, this task determines if the affected lookup service * is still available ("reachable"). If this task cannot communicate * with the lookup service, a discarded event is queued to be sent * to all registered listeners. *

* Rather than performing unicast discovery synchronously, after multicast * discovery has occurred in either the AnnouncementListener thread * (the multicast announcement protocol) or the ResponseListener thread * (the multicast request protocol), the unicast discovery processing * that is required to complete the discovery process is queued for * asynchronous execution in this task. Unicast discovery is performed * asynchronously because unicast discovery can take quite a while to * fail if a lookup service "disappears" (because the network or the * lookup service itself has crashed) between the time a multicast * announcement or response indicates the existence of a lookup service * eligible for unicast discovery, and the time unicast discovery * actually starts. If unicast discovery is performed synchronously * in the threads that implement the multicast announcement and multicast * request protocols, other multicast announcements (as well as other * unicast discoveries) will be missed whenever a lookup service * disappears prior to the commencement of the unicast discovery stage. */ private class UnicastDiscoveryTask implements TaskManager.Task { private Object req; private Ticket ticket = null; private boolean delayRun = false; UnicastDiscoveryTask(Object req) { this(req, false); } UnicastDiscoveryTask(Object req, boolean delayRun) { this.req = req; this.delayRun = delayRun; } /** * Restore the privileged context and run */ public void run() { Security.doPrivileged(new PrivilegedAction() { public Object run() { doRun(); return null; }//end run });//end doPrivileged } private void doRun() { logger.finest("LookupDiscovery - UnicastDiscoveryTask started"); try { synchronized (this) { while (delayRun) { this.wait(); } synchronized (pendingDiscoveries) { // If this was run by a WakeupManager, remove its // ticket from the list of outstanding tickets. if (ticket != null) { tickets.remove(ticket); } } } Socket sock = null; MulticastAnnouncement announcement = null; UnicastResponse response = null; if (req instanceof Socket) { // Perform unicast discovery on the connected socket. DiscoveryConstraints unicastDiscoveryConstraints = DiscoveryConstraints.process( rawUnicastDiscoveryConstraints); sock = (Socket)req; UnicastResponse resp; try { prepareSocket(sock, unicastDiscoveryConstraints); resp = doUnicastDiscovery(sock, unicastDiscoveryConstraints); } finally { try { sock.close(); } catch (IOException e) { /* ignore */ } } maybeAddNewRegistrar(resp); } else if(req instanceof LookupLocator) { // Perform unicast discovery using the LookupLocator // host and port. LookupLocator loc = (LookupLocator)req; UnicastResponse resp = new MultiIPDiscovery() { protected UnicastResponse performDiscovery( Discovery disco, DiscoveryConstraints dc, Socket s) throws IOException, ClassNotFoundException { return doUnicastDiscovery(s, dc, disco); } protected void singleResponseException(Exception e, InetAddress addr, int port) { logger.log( Levels.HANDLED, "Exception occured during unicast discovery " + addr + ":" + port, e); } }.getResponse(loc.getHost(), loc.getPort(), rawUnicastDiscoveryConstraints); maybeAddNewRegistrar(resp); } else if(req instanceof CheckGroupsMarker) { // handle group changes announcement = ((CheckGroupsMarker)req).announcement; ServiceID srvcID = announcement.getServiceID(); UnicastResponse resp = null; synchronized (registrars) { resp = (UnicastResponse)registrars.get(srvcID); } if(resp != null) { maybeSendEvent(resp, announcement.getGroups()); }//endif } else if(req instanceof CheckReachabilityMarker) { // test reachability response = ((CheckReachabilityMarker)req).response; maybeSendEvent(response, null); }//endif } catch (InterruptedIOException e) { logger.log(Levels.HANDLED, "exception occurred during unicast discovery", e); } catch (Throwable e) { if (((req instanceof Socket) || (req instanceof LookupLocator)) && logger.isLoggable(Level.INFO)) { String logmsg = "exception occurred during unicast discovery to " + "{0}:{1,number,#} with constraints {2}"; String methodName = "run"; if (req instanceof Socket) { Socket sock = (Socket) req; LogUtil.logThrow(logger, Level.INFO, this.getClass(), methodName, logmsg, new Object[] { sock.getInetAddress().getHostName(), Integer.valueOf(sock.getPort()), rawUnicastDiscoveryConstraints }, e); } else { LookupLocator loc = (LookupLocator) req; LogUtil.logThrow(logger, Level.INFO, this.getClass(), methodName, logmsg, new Object[] { loc.getHost(), Integer.valueOf(loc.getPort()), rawUnicastDiscoveryConstraints }, e); } } else { logger.log(Level.INFO, "exception occurred during unicast discovery", e); } } finally { // Done with the request. Remove it regardless of // if we succeeded or failed. synchronized (pendingDiscoveries) { pendingDiscoveries.remove(req); } }//end try/catch logger.finest("LookupDiscovery - UnicastDiscoveryTask completed"); }//end run /** Returns true if current instance must be run after task(s) in * task manager queue. * @param tasks the tasks to consider. * @param size elements with index less than size are considered. */ public boolean runAfter(List tasks, int size) { return false; }//end runAfter }//end class UnicastDiscoveryTask /** * Construct a new lookup discovery object, set to discover the * given set of groups. The set is represented as an array of * strings. This array may be empty, which is taken as the empty * set, and discovery is not performed. The reference passed in * may be null, which is taken as no set, and in which case * discovery of all reachable lookup services is performed. * Otherwise, the array contains the names of groups to discover. * The caller must have DiscoveryPermission for each group (or * for all groups, if the array is null). * * @param groups the set of group names to discover (null for no * set, empty for no discovery) * * @throws java.lang.NullPointerException input array contains at least * one null element * * @throws java.io.IOException an exception occurred in starting discovery * * @see #NO_GROUPS * @see #ALL_GROUPS * @see #setGroups * @see DiscoveryPermission */ public LookupDiscovery(String[] groups) throws IOException { try { beginDiscovery(groups, EmptyConfiguration.INSTANCE); } catch(ConfigurationException e) { /* swallow this exception */ } }//end constructor /** * Constructs a new lookup discovery object, set to discover the * given set of groups, and having the given Configuration. *

* The set of groups to discover is represented as an array of * strings. This array may be empty, which is taken as the empty * set, and discovery is not performed. The reference passed in * may be null, which is taken as no set, and in which * case discovery of all reachable lookup services is performed. * Otherwise, the array contains the names of groups to discover. * The caller must have DiscoveryPermission for each * group (or for all groups, if the array is null). * * @param groups the set of group names to discover (null for no * set, empty for no discovery) * * @param config an instance of Configuration, used to * obtain the objects needed to configure the current * instance of this class * * @throws java.lang.NullPointerException input array contains at least * one null element or null is input * for the configuration * * @throws java.io.IOException an exception occurred in starting discovery * * @throws net.jini.config.ConfigurationException indicates an exception * occurred while retrieving an item from the given * Configuration * * @see #NO_GROUPS * @see #ALL_GROUPS * @see #setGroups * @see DiscoveryPermission * @see net.jini.config.Configuration * @see net.jini.config.ConfigurationException */ public LookupDiscovery(String[] groups, Configuration config) throws IOException, ConfigurationException { beginDiscovery(groups, config); }//end constructor /** * Register a listener as interested in receiving DiscoveryEvent * notifications. * * @param l the listener to register * * @throws java.lang.NullPointerException this exception occurs when * null is input to the listener parameter * l. * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see DiscoveryEvent * @see #removeDiscoveryListener */ public void addDiscoveryListener(DiscoveryListener l) { if(l == null) { throw new NullPointerException("can't add null listener"); } synchronized (registrars) { if (terminated) { throw new IllegalStateException("discovery terminated"); } if (listeners.indexOf(l) >= 0) return; //already have this listener listeners.add(l); if (registrars.isEmpty()) return;//nothing to send the new listener HashMap groupsMap = new HashMap(registrars.size()); Iterator iter = registrars.values().iterator(); while (iter.hasNext()) { UnicastResponse resp = (UnicastResponse)iter.next(); groupsMap.put(resp.getRegistrar(),resp.getGroups()); } ArrayList list = new ArrayList(1); list.add(l); addNotify(list, groupsMap, DISCOVERED); } }//end addDiscoveryListener /** * Indicate that a listener is no longer interested in receiving * DiscoveryEvent notifications. * * @param l the listener to unregister * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see #addDiscoveryListener */ public void removeDiscoveryListener(DiscoveryListener l) { synchronized (registrars) { if (terminated) { throw new IllegalStateException("discovery terminated"); } listeners.remove(l); } }//end removeDiscoveryListener /** * Returns an array of instances of ServiceRegistrar, each * corresponding to a proxy to one of the currently discovered lookup * services. For each invocation of this method, a new array is returned. * * @return array of instances of ServiceRegistrar, each * corresponding to a proxy to one of the currently discovered * lookup services * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see net.jini.core.lookup.ServiceRegistrar * @see net.jini.discovery.DiscoveryManagement#removeDiscoveryListener */ public ServiceRegistrar[] getRegistrars() { synchronized (registrars) { if (terminated) { throw new IllegalStateException("discovery terminated"); } if (registrars.isEmpty()) { return new ServiceRegistrar[0]; } Iterator iter = registrars.values().iterator(); ServiceRegistrar[] regs = new ServiceRegistrar[registrars.size()]; for (int i=0;iter.hasNext();i++) { regs[i] = ((UnicastResponse)iter.next()).getRegistrar(); } return regs; } }//end getRegistrars /** * Discard a registrar from the set of registrars already * discovered. This does not prevent that registrar from being * rediscovered; it is intended to be used to clear unreachable * entries from the set.

* * If the registrar has been discovered using this LookupDiscovery * object, each listener registered with this object will have its * discarded method called with the given registrar as parameter. * * @param reg the registrar to discard * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see DiscoveryListener#discarded */ public void discard(ServiceRegistrar reg) { synchronized (registrars) { if (terminated) { throw new IllegalStateException("discovery terminated"); } if(reg == null) return; sendDiscarded(reg,null); }//end sync }//end discard /** Terminate the discovery process. */ public void terminate() { synchronized (registrars) { if (terminated) return; terminated = true; } nukeThreads(); }//end terminate /** * Return the set of group names this LookupDiscovery instance is * trying to discover. If this method returns the empty array, * that value is guaranteed to be referentially equal to * LookupDiscovery.NO_GROUPS. * * @return the set of groups to be discovered (null for all, empty * for no discovery) * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see #NO_GROUPS * @see #ALL_GROUPS * @see #setGroups */ public String[] getGroups() { synchronized (registrars) { if (terminated) { throw new IllegalStateException("discovery terminated"); } if (groups == null) return ALL_GROUPS; if (groups.isEmpty()) return NO_GROUPS; return collectionToStrings(groups); } }//end getGroups /** * Add a set of groups to the set to be discovered. * The caller must have DiscoveryPermission for each group. * * @param newGroups the groups to add * * @throws java.io.IOException the multicast request protocol failed * to start * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @throws java.lang.UnsupportedOperationException there is no set of * groups to add to * * @see DiscoveryPermission */ public void addGroups(String[] newGroups) throws IOException { testArrayForNullElement(newGroups); checkGroups(newGroups); synchronized (registrars) { if (terminated) throw new IllegalStateException("discovery terminated"); if (groups == null) throw new UnsupportedOperationException( "can't add to \"any groups\""); Collection req = new ArrayList(newGroups.length); for (int i = 0; i < newGroups.length; i++) { if (groups.add(newGroups[i])) req.add(newGroups[i]); } if (!req.isEmpty()) requestGroups(req); } }//end addGroups /** * Change the set of groups to be discovered to correspond to the * given set. The set is represented as an array of strings. * This array may be empty, which is taken as the empty set, and * discovery is not performed. The reference passed in may be * null, which is taken as no set, and in which case discovery of * all reachable lookup services is performed. Otherwise, the * array contains the names of groups to discover. * The caller must have DiscoveryPermission for each group (or * for all groups, if the array is null). * * @param newGroups the new set of groups to discover (null for * all, empty array for no discovery) * * @throws java.io.IOException an exception occurred when starting * multicast discovery * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @see #LookupDiscovery * @see #ALL_GROUPS * @see #NO_GROUPS * @see DiscoveryPermission * @see #getGroups */ public void setGroups(String[] newGroups) throws IOException { testArrayForNullElement(newGroups); checkGroups(newGroups); boolean maybeDiscard = false; Set newGrps = null; if (newGroups != null) { newGrps = new HashSet(newGroups.length * 2); for (int i = 0; i < newGroups.length; i++) { newGrps.add(newGroups[i]); } } synchronized (registrars) { if (terminated) throw new IllegalStateException("discovery terminated"); if (newGroups == null) { if (groups != null) { groups = null; requestGroups(null); } return; } if (groups == null) { groups = new HashSet(11); maybeDiscard = true; } Set toAdd = new HashSet(newGrps); toAdd.removeAll(groups); // Figure out which groups to get rid of. We start off // with the full set for which we are already listening, // and eliminate any that are in both the new set and the // current set. Collection toRemove = new HashSet(groups); toRemove.removeAll(newGrps); // Add new groups before we remove any old groups, because // removeGroups will start a new round of multicast requests // if the set of groups becomes empty, and we don't want it // to do so without reason. groups.addAll(toAdd); if (!toRemove.isEmpty()) maybeDiscard |= removeGroupsInt(collectionToStrings(toRemove)); if (!toAdd.isEmpty()) requestGroups(toAdd); } if (maybeDiscard) maybeDiscardRegistrars(); }//end setGroups /** * Remove a set of groups from the set to be discovered. * * @param oldGroups groups to remove * * @throws java.lang.IllegalStateException this exception occurs when * this method is called after the terminate * method has been called. * * @throws java.lang.UnsupportedOperationException there is no set of * groups from which to remove */ public void removeGroups(String[] oldGroups) { testArrayForNullElement(oldGroups); boolean maybeDiscard; synchronized (registrars) { if (terminated) throw new IllegalStateException("discovery terminated"); if (groups == null) throw new UnsupportedOperationException( "can't remove from \"any groups\""); maybeDiscard = removeGroupsInt(oldGroups); } if (maybeDiscard) maybeDiscardRegistrars(); }//end removeGroups /** * Sends the given packet data on the given MulticastSocket * through each of the network interfaces corresponding to elements of * the array configured when this utility was constructed. * * @param mcSocket the MulticastSocket on which the data * will be sent * @param packet DatagramPacket array whose elements are * the data to send * * @throws java.io.InterruptedIOException */ private void sendPacketByNIC(MulticastSocket mcSocket, DatagramPacket[] packet) throws InterruptedIOException { switch(nicsToUse) { case NICS_USE_ALL: /* Using all interfaces. Skip (but report) any interfaces * that are "bad" or not configured for multicast. */ for(int i=0;iMulticastSocket * through the network interface that is currently set. * * @param mcSocket the MulticastSocket on which the data * will be sent * @param packet DatagramPacket array whose elements are * the data to send * * @throws java.io.IOException */ private static void sendPacket(MulticastSocket mcSocket, DatagramPacket[] packet) throws IOException { for(int i=0;iString array containing the group * names from the first set used in the comparison * @param groupSet1 String array containing the group * names from the second set used in the comparison * * @return true if the contents of each set is identical; * false otherwise */ private static boolean groupSetsEqual(String[] groupSet0, String[] groupSet1) { if(groupSet0.length != groupSet1.length) return false; /* is every element of one set contained in the other set? */ iLoop: for(int i=0;iServiceRegistrar corresponding to the given * UnicastResponse parameter, this method * determines whether or not the registrar's member groups have * changed in such a way that either a changed event or a discarded * event is warranted. *

* Note that even if the contents of the new set of groups initially * indicate that the corresponding registrar is a candidate for * a discarded or a changed event, further analysis must be performed. * This is because there is no guarantee that the new set of member * groups have not been "split" across the multicast announcements * sent by the lookup service; and so there is no guarantee that the * contents of the new group set actually reflect a change that warrants * an event. To guarantee that the new group set accurately reflects * the registrar's member groups, this method makes a remote call to * the registrar to retrieve its actual member groups. *

* There is one situation where it is not necessary to query the * registrar for its current member groups. That situation is * when the set of groups input to the newGroups parameter * is equivalent to NO_GROUPS. If that new group set is equivalent * to NO_GROUPS, it is guaranteed that the registrar's member groups * have not been split across the multicast announcements. * * @param response instance of UnicastResponse * corresponding to the registrar whose current and * previous member groups are to be compared * @param newGroups String array containing the new * member groups of the registrar corresponding to the * response parameter (just after a * possible change) */ private void maybeSendEvent(UnicastResponse response, String[] newGroups) { ServiceRegistrar reg = response.getRegistrar(); boolean getActual = true; if(newGroups == null) { // newGroups null means get actual groups now newGroups = getActualGroups(reg); if(newGroups == null) return; // if null, then it was discarded getActual = false; }//endif if(groupSetsEqual(response.getGroups(),newGroups)) return; String[] actualGroups = newGroups; if( getActual && (newGroups.length > 0) ) { actualGroups = getActualGroups(reg); if(actualGroups == null) return; // null ==> was already discarded }//endif synchronized (registrars) { // Other events may have occured to registrars while we were // making our remote call. UnicastResponse resp = (UnicastResponse) registrars.get(reg.getServiceID()); if (resp == null) { // The registrar was discarded in the meantime. Oh well. return; } notifyOnGroupChange(reg, resp.getGroups(), actualGroups); } }//end maybeSendEvent /** After a possible change in the member groups of the given * ServiceRegistrar parameter, this method compares * the registrar's original set of member groups to its new set * of member groups. *

* If the criteria shown below is satisfied, either a discarded event * or a changed event will be sent to any registered listeners. The * criteria is based on whether the old and new groups are equal, * and whether one or more elements of the new group set also belong * to the set of groups to discover (the new groups are "still of * interest"). The criteria is as follows: *

* if (old groups and new groups) *

*

* * @param reg instance of ServiceRegistrar * corresponding to the registrar whose current and * previous member groups are to be compared; and * whose corresponding service ID is used as the key * into the various data structures that contain * pertinent information about that registrar * @param oldGroups String array containing the member * groups of the reg parameter prior to * being changed * @param newGroups String array containing the current * member groups of the reg parameter * (just after a possible change) */ private void notifyOnGroupChange(ServiceRegistrar reg, String[] oldGroups, String[] newGroups) { boolean equal = groupSetsEqual(oldGroups,newGroups); boolean stillInterested = groupsOverlap(newGroups); if(!equal && stillInterested) { sendChanged(reg,newGroups); } else if(!stillInterested) { sendDiscarded(reg,newGroups); }//endif }//end notifyOnGroupChange /** Convenience method that sends a discarded event containing only * one registrar to all registered listeners. This method must be * called from within a block that is synchronized on the registrars * map. * * @param reg instance of ServiceRegistrar * corresponding to the registrar to include in the * event * @param curGroups String array containing the current * member groups of the registrar referenced by the * reg parameter */ private void sendDiscarded(ServiceRegistrar reg, String[] curGroups) { ServiceID srvcID = reg.getServiceID(); if(curGroups == null) { // discard request is from external source UnicastResponse resp = (UnicastResponse)registrars.get(srvcID); if(resp == null) return; curGroups = resp.getGroups(); }//endif if( registrars.remove(srvcID) != null ) { regInfo.remove(srvcID); if( !listeners.isEmpty() ) { addNotify((ArrayList)listeners.clone(), mapRegToGroups(reg,curGroups), DISCARDED); }//endif }//endif }//end sendDiscarded /** Convenience method that sends a changed event containing only * one registrar to all registered listeners that are interested in * such events. This method must be called from within a block that * is synchronized on the registrars map. * * @param reg instance of ServiceRegistrar * corresponding to the registrar to include in the * event * @param curGroups String array containing the current * member groups of the registrar referenced by the * reg parameter */ private void sendChanged(ServiceRegistrar reg, String[] curGroups) { /* replace old groups with new; prevents repeated changed events */ UnicastResponse resp = (UnicastResponse)registrars.get(reg.getServiceID()); registrars.put(reg.getServiceID(), new UnicastResponse(resp.getHost(), resp.getPort(), curGroups, resp.getRegistrar())); if( !listeners.isEmpty() ) { addNotify((ArrayList)listeners.clone(), mapRegToGroups(reg,curGroups), CHANGED); }//endif }//end sendChanged /** Creates and returns a deep copy of the input parameter. This method * assumes the input map is a HashMap of the registrar-to-groups mapping; * and returns a clone not only of the map, but of each key-value pair * contained in the mapping. * * @param groupsMap mapping from a set of registrars to the member groups * of each registrar * * @return clone of the input map, and of each key-value pair contained * in the input map */ private Map deepCopy(HashMap groupsMap) { /* clone the input HashMap */ HashMap newMap = (HashMap)(groupsMap.clone()); /* clone the values of each mapping in place */ Set eSet = newMap.entrySet(); for(Iterator itr = eSet.iterator(); itr.hasNext(); ) { Map.Entry pair = (Map.Entry)itr.next(); /* only need to clone the value of the order pair */ pair.setValue( ((String[])pair.getValue()).clone() ); } return newMap; }//end deepCopy /** This method retrieves from the given ServiceRegistrar, * the current groups in which that registrar is a member. If the * registrar is un-reachable, then this method will discard the * registrar. * * @param reg instance of ServiceRegistrar referencing the * registrar whose member groups are to be retrieved and returned * * @return String array containing the current member groups * of the registrar referenced by the reg parameter */ private String[] getActualGroups(final ServiceRegistrar reg) { /* The retrieval of the member groups of the given ServiceRegistrar * is performed inside a doPrivileged block that restores the access * control context that was in place when this utility was created. * * This is done because the call to getGroups() below is executed * on a proxy to the given ServiceRegistrar; which may be downloaded * code supplied by a 3rd party. With respect to downloaded, 3rd party * code, it is not desirable to allow such code to execute with more * priviledges than the client that created this utility. Therefore, * before executing getGroups() on the given proxy, the client's * Subject should be restored, and the proxy code should be * restricted to doing nothing more than the client itself is * allowed to do. */ try { return (String[])AccessController.doPrivileged ( securityContext.wrap(new PrivilegedExceptionAction() { public Object run() throws RemoteException { return reg.getGroups(); }//end run }),//end PrivilegedExceptionAction and wrap securityContext.getAccessControlContext());//end doPriv } catch(Throwable e) { /* A RemoteException, wrapped in a PriviligedActionException, * occurred. This means that the reg is unreachable; discard it. */ discard(reg); return null; }//end try }//end getActualGroups /** Convenience method that creates and returns a mapping of a single * ServiceRegistrar instance to a set of groups. * * @param reg instance of ServiceRegistrar * corresponding to the registrar to use as the key * to the mapping * @param curGroups String array containing the current * member groups of the registrar referenced by the * reg parameter; and which is used * as the value of the mapping * * @return Map instance containing a single mapping from * a given registrar to its current member groups */ private Map mapRegToGroups(ServiceRegistrar reg, String[] curGroups) { HashMap groupsMap = new HashMap(1); groupsMap.put(reg,curGroups); return groupsMap; }//end mapRegToGroups /** * This method is used by the public methods of this class that are * specified to throw a NullPointerException when the given * array of group names contains one or more null elements; * in which case, this method throws a NullPointerException * which should be allowed to propagate outward. * * @throws java.lang.NullPointerException this exception occurs when * one or more of the elements of the groupArray * parameter is null. */ private void testArrayForNullElement(String[] groupArray) { if(groupArray == null) return; for(int i=0;iConfiguration, initializes the current * instance of this utility, and initiates the discovery process for * the given set of groups. * * @param groups the set of group names to discover * * @param config an instance of Configuration, used to * obtain the objects needed to configure this utility * * @throws java.lang.NullPointerException input array contains at least * one null element or null is input * for the configuration * * @throws java.io.IOException an exception occurred when initiating * discovery processing * * @throws net.jini.config.ConfigurationException indicates an exception * occurred while retrieving an item from the given * Configuration */ private void beginDiscovery(String[] groups, Configuration config) throws IOException, ConfigurationException { testArrayForNullElement(groups); checkGroups(groups); if (groups != null) { this.groups = new HashSet(groups.length * 2); for (int i = 0; i < groups.length; i++) { this.groups.add(groups[i]); }//end loop }//endif init(config); if(nicsToUse == NICS_USE_NONE) return;//disable discovery try { Security.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws Exception { announceeThread = new AnnouncementListener(); announcementTimerThread = new AnnouncementTimerThread(); return null; }//end run });//end doPrivileged } catch (PrivilegedActionException e) { throw (IOException)e.getException(); } if (this.groups == null || !this.groups.isEmpty()) { requestGroups(this.groups); }//endif announceeThread.start(); announcementTimerThread.start(); }//end beginDiscovery /* Convenience method that encapsulates the retrieval of the configurable * items from the given Configuration object. */ private void init(Configuration config) throws IOException, ConfigurationException { if(config == null) throw new NullPointerException("config is null"); /* Lookup service proxy preparer */ registrarPreparer = (ProxyPreparer)config.getEntry (COMPONENT_NAME, "registrarPreparer", ProxyPreparer.class, new BasicProxyPreparer()); /* constraints */ MethodConstraints constraints = (MethodConstraints)config.getEntry (COMPONENT_NAME, "discoveryConstraints", MethodConstraints.class, null); if (constraints == null) { constraints = new BasicMethodConstraints(InvocationConstraints.EMPTY); } multicastRequestConstraints = DiscoveryConstraints.process( constraints.getConstraints( DiscoveryConstraints.multicastRequestMethod)); multicastAnnouncementConstraints = DiscoveryConstraints.process( constraints.getConstraints( DiscoveryConstraints.multicastAnnouncementMethod)); rawUnicastDiscoveryConstraints = constraints.getConstraints( DiscoveryConstraints.unicastDiscoveryMethod); /* Task manager */ try { taskManager = (TaskManager)config.getEntry(COMPONENT_NAME, "taskManager", TaskManager.class); } catch(NoSuchEntryException e) { /* use default */ taskManager = new TaskManager(MAX_N_TASKS,(15*1000),1.0f); } /* Multicast request-related configuration items */ multicastRequestMax = ( (Integer)config.getEntry (COMPONENT_NAME, "multicastRequestMax", int.class, Integer.valueOf(multicastRequestMax) ) ).intValue(); multicastRequestInterval = ( (Long)config.getEntry (COMPONENT_NAME, "multicastRequestInterval", long.class, Long.valueOf(multicastRequestInterval) ) ).longValue(); finalMulticastRequestInterval = ( (Long)config.getEntry (COMPONENT_NAME, "finalMulticastRequestInterval", long.class, Long.valueOf(finalMulticastRequestInterval) ) ).longValue(); try { multicastRequestHost = (String) Config.getNonNullEntry(config, COMPONENT_NAME, "multicastRequestHost", String.class); } catch (NoSuchEntryException nse) { multicastRequestHost = getLocalHost(); } /* Configuration items related to the network interface(s) */ try { nics = (NetworkInterface[])config.getEntry (COMPONENT_NAME, "multicastInterfaces", NetworkInterface[].class); if(nics == null) { nicsToUse = NICS_USE_SYS; logger.config("LookupDiscovery - using system default network " +"interface for multicast"); } else {//(nics != null) if( nics.length == 0 ) { nicsToUse = NICS_USE_NONE; logger.config("LookupDiscovery - MULTICAST DISABLED"); } else {//(nics.length > 0), use the given specific list nicsToUse = NICS_USE_LIST; if( logger.isLoggable(Level.CONFIG) ) { logger.log(Level.CONFIG, "LookupDiscovery - multicast network " +"interface(s): {0}", Arrays.asList(nics) ); }//endif }//endif }//endif } catch(NoSuchEntryException e) {// no config item, use default - all Enumeration en = NetworkInterface.getNetworkInterfaces(); List nicList = (en != null) ? Collections.list(en) : Collections.EMPTY_LIST; nics = (NetworkInterface[])(nicList.toArray (new NetworkInterface[nicList.size()]) ); nicsToUse = NICS_USE_ALL; if( logger.isLoggable(Level.CONFIG) ) { logger.log(Level.CONFIG,"LookupDiscovery - multicast network " +"interface(s): {0}", nicList); }//endif } nicRetryInterval = ( (Integer)config.getEntry (COMPONENT_NAME, "multicastInterfaceRetryInterval", int.class, Integer.valueOf(nicRetryInterval) ) ).intValue(); /* Multicast announcement-related configuration items */ multicastAnnouncementInterval = ( (Long)config.getEntry (COMPONENT_NAME, "multicastAnnouncementInterval", long.class, Long.valueOf(multicastAnnouncementInterval) ) ).longValue(); unicastDelayRange = Config.getLongEntry(config, COMPONENT_NAME, "unicastDelayRange", 0, 0, Long.MAX_VALUE); tickets = new ArrayList(); if (unicastDelayRange > 0) { /* Wakeup manager */ try { discoveryWakeupMgr = (WakeupManager)config.getEntry(COMPONENT_NAME, "wakeupManager", WakeupManager.class); } catch(NoSuchEntryException e) { /* use default */ discoveryWakeupMgr = new WakeupManager( new WakeupManager.ThreadDesc(null, true)); isDefaultWakeupMgr = true; } } initialMulticastRequestDelayRange = Config.getLongEntry(config, COMPONENT_NAME, "initialMulticastRequestDelayRange", 0, 0, Long.MAX_VALUE); }//end init /** * Decodes received multicast announcement packet. Constraint checking is * delayed. */ private MulticastAnnouncement decodeMulticastAnnouncement( final DatagramPacket pkt) throws IOException { // REMIND: cache recently received announcements to skip re-decoding? int pv; try { pv = ByteBuffer.wrap( pkt.getData(), pkt.getOffset(), pkt.getLength()).getInt(); } catch (BufferUnderflowException e) { throw new DiscoveryProtocolException(null, e); } multicastAnnouncementConstraints.checkProtocolVersion(pv); final Discovery disco = getDiscovery(pv); try { return (MulticastAnnouncement) AccessController.doPrivileged( securityContext.wrap(new PrivilegedExceptionAction() { public Object run() throws IOException { return disco.decodeMulticastAnnouncement( pkt, multicastAnnouncementConstraints. getUnfulfilledConstraints(), true); } }), securityContext.getAccessControlContext()); } catch (PrivilegedActionException e) { throw (IOException) e.getCause(); } } /* * Restore the original context while checking constraints. */ private void checkAnnouncementConstraints(final MulticastAnnouncement ann) throws IOException { try { AccessController.doPrivileged( securityContext.wrap(new PrivilegedExceptionAction() { public Object run() throws IOException { ann.checkConstraints(); return null; } }), securityContext.getAccessControlContext()); } catch (PrivilegedActionException e) { throw (IOException) e.getCause(); } } /** * Encodes outgoing multicast requests based on protocol in use, applying * configured security constraints (if any). */ private DatagramPacket[] encodeMulticastRequest(final MulticastRequest req) throws IOException { // REMIND: cache latest request to skip re-encoding final Discovery disco = getDiscovery( multicastRequestConstraints.chooseProtocolVersion()); final List packets = new ArrayList(); AccessController.doPrivileged( securityContext.wrap(new PrivilegedAction() { public Object run() { EncodeIterator ei = disco.encodeMulticastRequest( req, multicastRequestConstraints.getMulticastMaxPacketSize( DEFAULT_MAX_PACKET_SIZE), multicastRequestConstraints.getUnfulfilledConstraints() ); while (ei.hasNext()) { try { packets.addAll(Arrays.asList(ei.next())); } catch (Exception e) { logger.log( (e instanceof UnsupportedConstraintException) ? Levels.HANDLED : Level.INFO, "exception encoding multicast request", e); } } return null; } }), securityContext.getAccessControlContext()); if (packets.isEmpty()) { throw new DiscoveryProtocolException("no encoded requests"); } return (DatagramPacket[]) packets.toArray( new DatagramPacket[packets.size()]); } private void restoreContextAddTask(final TaskManager.Task t) { AccessController.doPrivileged( securityContext.wrap(new PrivilegedAction() { public Object run() { taskManager.add(t); return null; } }), securityContext.getAccessControlContext()); } private Ticket restoreContextScheduleRunnable(final UnicastDiscoveryTask t) { return (Ticket) AccessController.doPrivileged( securityContext.wrap(new PrivilegedAction() { public Object run() { return discoveryWakeupMgr.schedule( System.currentTimeMillis() + (long) (Math.random() * unicastDelayRange), new Runnable() { public void run() { taskManager.add(t); } } ); } }), securityContext.getAccessControlContext()); } /** * Performs unicast discovery over given socket based on protocol in use, * applying configured security constraints (if any). */ private UnicastResponse doUnicastDiscovery( final Socket socket, final DiscoveryConstraints unicastDiscoveryConstraints, final Discovery disco) throws IOException, ClassNotFoundException { try { return (UnicastResponse) AccessController.doPrivileged( securityContext.wrap(new PrivilegedExceptionAction() { public Object run() throws Exception { return disco.doUnicastDiscovery( socket, unicastDiscoveryConstraints. getUnfulfilledConstraints(), null, null, null); } }), securityContext.getAccessControlContext()); } catch (PrivilegedActionException e) { Throwable t = e.getCause(); if (t instanceof IOException) { throw (IOException) t; } else if (t instanceof ClassNotFoundException) { throw (ClassNotFoundException) t; } else { throw new AssertionError(t); } } } private UnicastResponse doUnicastDiscovery( final Socket socket, final DiscoveryConstraints unicastDiscoveryConstraints) throws IOException, ClassNotFoundException { Discovery disco = getDiscovery(unicastDiscoveryConstraints.chooseProtocolVersion()); return doUnicastDiscovery(socket, unicastDiscoveryConstraints, disco); } /** * Returns Discovery instance for the given version, or throws * DiscoveryProtocolException if the version is unsupported. */ private Discovery getDiscovery(int version) throws DiscoveryProtocolException { switch (version) { case Discovery.PROTOCOL_VERSION_1: return Discovery.getProtocol1(); case Discovery.PROTOCOL_VERSION_2: return protocol2; default: throw new DiscoveryProtocolException( "unsupported protocol version: " + version); } } /** * Holder class for the time and sequence number of the last * received announcement. The regInfo map contains instances of this * class as values. */ private static class AnnouncementInfo { private long tStamp; private long seqNum; private AnnouncementInfo(long tStamp, long seqNum) { this.tStamp = tStamp; this.seqNum = seqNum; } } }//end class LookupDiscovery