コード例 #1
0
  /** INTERNAL: Send out an announcement that we are here. */
  public void announceSession() {
    rcm.logDebug("sending_announcement", (Object[]) null);

    ServiceAnnouncement outMsg = new ServiceAnnouncement(rcm.getServiceId());
    byte[] outBytes = outMsg.toBytes();

    try {
      // Create a packet to send and send it out to everyone listening
      DatagramPacket sendPacket =
          new DatagramPacket(
              outBytes,
              outBytes.length,
              InetAddress.getByName(multicastGroupAddress),
              multicastPort);
      getCommunicationSocket().send(sendPacket);

      Object[] args = null;
      rcm.logInfo("announcement_sent", args);

    } catch (Exception ex) {
      // We got an exception. Map it to an RCM exception and call the handler
      DiscoveryException discoveryEx = DiscoveryException.errorSendingAnnouncement(ex);
      rcm.handleException(discoveryEx);
    }
  }
コード例 #2
0
  /** ADVANCED: Announce the local service and join the cluster */
  public void startDiscovery() {
    if (rcm.isCommandProcessorASession()) {
      rcm.getCommandProcessor().processCommand(new ProfileDiscoveryStartedCommand());
    }

    // Only start if we are currently stopped
    if (this.isDiscoveryStopped()) {
      this.rcm.getServerPlatform().launchContainerRunnable(this);
    }
  }
コード例 #3
0
 /** INTERNAL: Create the multicast socket and join the multicast group. */
 public void createCommunicationSocket() {
   Object[] args = {multicastGroupAddress, "" + multicastPort};
   rcm.logDebug("initializing_discovery_resources", args);
   if (communicationSocket == null) {
     try {
       communicationSocket = new MulticastSocket(multicastPort);
       communicationSocket.setTimeToLive(getPacketTimeToLive());
       communicationSocket.joinGroup(InetAddress.getByName(multicastGroupAddress));
     } catch (IOException ex) {
       // Either we couldn't create the socket or we couldn't join the group
       DiscoveryException discoveryEx = DiscoveryException.errorJoiningMulticastGroup(ex);
       rcm.handleException(discoveryEx);
     }
   }
 }
コード例 #4
0
 /**
  * ADVANCED: Stop accepting announcements from other services becoming available. Note that this
  * does not remove the local service from the cluster.
  */
 public void stopDiscovery() {
   if (rcm.isCommandProcessorASession()) {
     this.rcm.getCommandProcessor().processCommand(new ProfileDiscoveryStoppedCommand());
   }
   stopListening();
   try {
     // Put in a sleep to give the listener thread a chance to stop
     Thread.sleep(500);
   } catch (InterruptedException exception) {
   }
   communicationSocket = null;
 }
コード例 #5
0
  /**
   * INTERNAL: This is the main execution method of discovery. It will create a socket to listen on,
   * create a local connection for this service and announce that we are open for business.
   */
  public void run() {
    // Initialize the communication socket
    createCommunicationSocket();

    // Create the local connection from which we will receive commands
    rcm.getTransportManager().createLocalConnection();

    // Announce to all other discovery managers that this service is up. The
    // delay allows time for posting of connections to the name service
    try {
      Thread.sleep(announcementDelay);
    } catch (InterruptedException exception) {
    }
    announceSession();

    // Listen for other sessions that are joining
    startListening();
  }
コード例 #6
0
  /**
   * INTERNAL: This method puts us into the listening mode loop. This thread blocks, waiting on
   * announcements that we receive from other discovery managers.
   */
  public void startListening() {
    byte[] recvBuf = new byte[128];

    // Only stop when we get the directive to stop
    stopListening = false;
    rcm.logInfo("discovery_manager_active", (Object[]) null);
    while (!stopListening) {
      DatagramPacket recvPacket = new DatagramPacket(recvBuf, recvBuf.length);
      ServiceAnnouncement inMsg;

      // Block waiting for a message
      try {
        getCommunicationSocket().receive(recvPacket);
      } catch (IOException exception) {
        if (stopListening) {
          // We caused the exception by closing the socket
          rcm.logInfo("discovery_manager_stopped", (Object[]) null);
          return;
        } else {
          // Exception was caused by something else (e.g. network error, etc.)
          rcm.handleException(DiscoveryException.errorReceivingAnnouncement(exception));
        }
      }

      // We received a message, unmarshall it into an announcement
      try {
        inMsg = new ServiceAnnouncement(recvPacket.getData());
      } catch (Exception ex) {
        // Log a warning that we couldn't process the announcement
        Object[] args = {ex};
        rcm.logWarning("received_corrupt_announcement", args);
        continue;
      }

      // If the msg is not from ourselves, and is announcing a service on
      // the same channel as we are on then we should do something about it
      if (!rcm.getServiceId().getId().equals(inMsg.getServiceId().getId())
          && (rcm.getServiceId()
              .getChannel()
              .equalsIgnoreCase(inMsg.getServiceId().getChannel()))) {
        receivedAnnouncement(inMsg.getServiceId());
      }
    }
  }
コード例 #7
0
 /** INTERNAL: Process the announcement that indicates that a new service is online */
 public void receivedAnnouncement(ServiceId serviceId) {
   Object[] args = {serviceId};
   rcm.logInfo("announcement_received", args);
   // Notify the RCM that a new service has been detected
   rcm.newServiceDiscovered(serviceId);
 }