Examples of net.jini.core.event.RemoteEvent

net.jini.core.event.RemoteEvent
The base class or superclass for remote events.
The abstract state contained in a RemoteEvent object includes a reference to the object in which the event occurred, a long which identifies the kind of event relative to the object in which the event occurred, a long which indicates the sequence number of this instance of the event kind, and a MarshalledObject that is to be handed back when the notification occurs. The combination of the event identifier and the object reference obtained from the RemoteEvent object should uniquely identify the event type.
The sequence number obtained from the RemoteEvent object is an increasing value that can act as a hint to the number of occurrences of this event relative to some earlier sequence number. Any object that generates a RemoteEvent is required to insure that for any two RemoteEvent objects with the same event identifier, the sequence number of those events differ if and only if the RemoteEvent objects are a response to different events. This guarantee is required to allow notification calls to be idempotent. A further guarantee is that if two RemoteEvents, x and y, come from the same source and have the same event identifier, then x occurred before y if and only if the sequence number of x is lower than the sequence number of y.
A stronger guarantee is possible for those generators of RemoteEvents that can support it. This guarantee states that not only do sequence numbers increase, but they are not skipped. In such a case, if RemoteEvent x and y have the same source and the same event identifier, and x has sequence number m and y has sequence number n, then if m < n there were exactly n-m-1 events of the same event type between the event that triggered x and the event that triggered y. Such sequence numbers are said to be "fully ordered".
An event registration that occurs within a transaction is considered to be scoped by that transaction. This means that any occurrence of the kind of event of interest that happens as part of the transaction will cause a notification to be sent to the recipients indicated by the registration that occurred in the transaction. Such events must have a separate event identifier to allow third-party store and forward entities to distinguish between an event that happens within a transaction and those that happen outside of the transaction. Notifications of these events will not be sent to entities that registered interest in this kind of event outside the scope of the transaction until and unless the transaction is committed.
Because of this, notifications sent from inside a transaction will have a different sequence number than the notifications of the same events would have outside of the transaction. Within a transaction, all RemoteEvent objects for a given kind of event are given a sequence number relative to the transaction. This is true even if the event that triggered the RemoteEvent object being sent occurs outside of the scope of the transaction (but is visible within the transaction). @author Sun Microsystems, Inc. @since 1.0

  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }


  RemoteEvent[] bogus = {
      new RemoteEvent(myGen, 9999, 9999, null),
      new RemoteEvent(myGen, 5678, 1234, null),
  };


  // Enable the first of our listener objects
  assertCount(bad, 0);
  logger.log(Level.INFO, "Enabling delivery to our REL" + bad);
  mr.enableDelivery(bad);


        // Wait for events to arrive and verify.
  // Note that the listener object throws a 
  // NoSuchObjectException and should only
  // receive the first event.  This should cause
  // the event mailbox to disableDelivery until
  // an another enableDelivery call occurs.
  logger.log(Level.INFO, "Wating for event delivery");
  badCount = 1;
        waitForEvents(bad, badCount, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(bad, badCount);
  logger.log(Level.INFO, "Verifying events ");
  assertEvent(bad, events[0]);
  if (bad.verifyEvents(events) ||
      bad.verifyEvents(bogus)    ) 
  {
      throw new TestException("Successfully verified bogus events");
  }


  // Send another event
  logger.log(Level.INFO, "Generating another event");
  RemoteEvent re = myGen.generateEvent(evtReg.getID(), 3);


  // Verify that the listener is not called.
  logger.log(Level.INFO, "Asserting that event count hasn't changed");
  assertCount(bad, badCount);

View Full Code Here

      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }
  myRelCount += NUM_EVENTS;


  RemoteEvent[] bogus = {
      new RemoteEvent(myGen, 9999, 9999, null),
      new RemoteEvent(myGen2, 1234, 1, null),
  };


  // Enable the first of our listener objects
  assertCount(myRel, 0);
  logger.log(Level.INFO, "Enabling delivery to our REL" + myRel);
  mr.enableDelivery(myRel);


      // Wait for events to arrive and verify
  logger.log(Level.INFO, "Wating for event delivery");
  waitForEvents(myRel, myRelCount, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel, myRelCount);
  assertEvents(myRel, events);
  if (myRel.verifyEvents(bogus)) {
      throw new TestException("Successfully verified bogus events");
  }


  // Re-submit listener again
  logger.log(Level.INFO, "Re-enabling delivery to our REL");
  mr.enableDelivery(myRel);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel, myRelCount);


      // Generate some more events
  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }
  myRelCount += NUM_EVENTS;
  waitForEvents(myRel, myRelCount, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel, myRelCount);
  assertEvents(myRel, events);
  // enable second listener object
  logger.log(Level.INFO, "Enabling delivery to our REL2" + myRel2);
  mr.enableDelivery(myRel2);
  assertCount(myRel2, myRelCount2);


  // Generate some more events 
  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }
  myRelCount2 += NUM_EVENTS;


      // Wait for events to arrive and verify
  logger.log(Level.INFO, "Wating for event delivery");
  waitForEvents(myRel2, myRelCount2, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel2, myRelCount2);
  assertEvents(myRel2, events);


  // Generate some more events from second generator
  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen2.generateEvent(evtReg2.getID(), 3);
  }
  myRelCount2 += NUM_EVENTS;
  // Wait for events to arrive and verify
  logger.log(Level.INFO, "Wating for event delivery");
  waitForEvents(myRel2, myRelCount2, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel2, myRelCount2);
  assertEvents(myRel2, events);
  // disable delivery
  mr.disableDelivery();
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);
  logger.log(Level.INFO, "Disabled delivery");


      // Generate some more events from each generator
  logger.log(Level.INFO, "Generating more events");
  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }


  RemoteEvent[] events2 = new RemoteEvent[NUM_EVENTS];
  for (i = 0; i < NUM_EVENTS; i++) {
      events2[i] = myGen2.generateEvent(evtReg2.getID(), 3);
  }


  logger.log(Level.INFO, "Verifying that event counts haven't changed");
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


  logger.log(Level.INFO, "enabling delivery to REL");
  mr.enableDelivery(myRel);
  myRelCount += NUM_EVENTS*2;


  // Wait for events to arrive and verify
  logger.log(Level.INFO, "Wating for event delivery");
  waitForEvents(myRel, myRelCount, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery");
  assertCount(myRel, myRelCount);
  assertEvents(myRel, events);
  assertEvents(myRel, events2);


  // Submit the null listener
  logger.log(Level.INFO, "Calling enableDelivery(null)");
  mr.enableDelivery(null);
  logger.log(Level.INFO, "Asserting that event counts haven't changed");
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


  // Generate another event 
  logger.log(Level.INFO, "Generating another event");
  RemoteEvent evt = myGen.generateEvent(evtReg.getID(), 3);


  logger.log(Level.INFO, "Asserting that event counts haven't changed");
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


  logger.log(Level.INFO, "Enabling REL2");
  myRelCount2 += 1;
  mr.enableDelivery(myRel2);
  logger.log(Level.INFO, "Wating for event delivery");
  waitForEvents(myRel2, myRelCount2, MAX_WAIT);
  logger.log(Level.INFO, "Asserting event counts ");
  assertCount(myRel2, myRelCount2);
  assertEvent(myRel2, evt);
  assertCount(myRel, myRelCount);


  logger.log(Level.INFO, "Disabling delivery");
  mr.disableDelivery();
  logger.log(Level.INFO, "Asserting event counts ");
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


      // Generate another event 
  logger.log(Level.INFO, "Generating another event");
  evt = myGen.generateEvent(evtReg.getID(), 3);


  logger.log(Level.INFO, "Disabling delivery again");
  mr.disableDelivery();
  logger.log(Level.INFO, "Asserting event counts ");
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


  // Generate another event 
  logger.log(Level.INFO, "Generating another event");
  RemoteEvent evt2 = myGen2.generateEvent(evtReg2.getID(), 3);
  assertCount(myRel, myRelCount);
  assertCount(myRel2, myRelCount2);


  logger.log(Level.INFO, "Enabling REL2 ");
  mr.enableDelivery(myRel2);

View Full Code Here

  for (i = 0; i < NUM_EVENTS; i++) {
      events[i] = myGen.generateEvent(evtReg.getID(), 3);
  }


  RemoteEvent[] bogus = {
      new RemoteEvent(myGen, 9999, 9999, null),
      new RemoteEvent(myGen, 5678, 1234, null),
  };


  // Enable the first of our listener objects
  assertCount(badListener, badCount);
  logger.log(Level.INFO, "Enabling delivery to our bad REL" + badListener);
  mr.enableDelivery(badListener);


        // Wait for events to arrive and verify.
  // Note that the listener object throws a 
  // RemoteException and can receive multiple
  // events (duplicate) events from redelivery
  // attempts.
  logger.log(Level.INFO, "Wating for event delivery");
  badCount = 1;
        waitForEvents(badListener, badCount, MAX_WAIT);
  logger.log(Level.INFO, "Verifying event delivery count of " 
      + badCount);
  assertCount(badListener, badCount);
  logger.log(Level.INFO, "Verifying events ");
  assertEvent(badListener, events[0]);
  if (badListener.verifyEvents(events) ||
      badListener.verifyEvents(bogus)    ) 
  {
      throw new TestException("Successfully verified bogus events");
  }


        // Delay to (hopefully) ensure that 
        // some retries are attempted. This test
        // is timing dependent since after MAX_RETRIES 
        // the mailbox will discard the
        // remote event and move onto the next one, if any. 
        // If this delay is long enough to exceed the
        // MAX_RETRIES then the count will get bumped and
        // the test will fail.
        long delay = 7000;
  logger.log(Level.INFO, "Sleeping for " + delay);
  try {
            Thread.sleep(delay);
  } catch (InterruptedException ie) {
      logger.log(Level.INFO, "Sleep interrupted");
  } 


        // Note that the count should still be 1 since
        // retries will try to deliver the same event.
        // Listener counts distinct events. See note above.
  logger.log(Level.INFO, "Verifying event delivery count of " 
      + badCount);
  assertCount(badListener, badCount);
  // No need to assertEvents since it be the same one
  // as before.


  // Enable good listener
  assertCount(goodListener, goodCount);
  logger.log(Level.INFO, "Enabling good listener");
  mr.enableDelivery(goodListener);


  goodCount = 5;
  logger.log(Level.INFO, "Wating for event delivery of " + goodCount);
        waitForEvents(goodListener, goodCount, MAX_WAIT);
  logger.log(Level.INFO, "Asserting event count");
  assertCount(goodListener, goodCount);
  logger.log(Level.INFO, "Verifying events");
  assertEvents(goodListener, events);


  logger.log(Level.INFO, "Generating another event");
  RemoteEvent re = myGen.generateEvent(evtReg.getID(), 3);
  goodCount++;
  logger.log(Level.INFO, "Wating for event delivery" + goodCount);
        waitForEvents(goodListener, goodCount, MAX_WAIT);
  logger.log(Level.INFO, "Asserting event count");
  assertCount(goodListener, goodCount);

View Full Code Here

      /* If we are here then we need to send an event (probably
       * someone could have sent our event between the time
       * we released the lock and now).
       */
      getListener(preparer).notify(
    new RemoteEvent(source, eventID, seqNum, handback));


      // success!, update lastSeqNumDelivered, but don't go backward
      synchronized (EventRegistrationWatcher.this) {
    if (seqNum > lastSeqNumDelivered)
        lastSeqNumDelivered = seqNum;

View Full Code Here

        // if the registration is invalid (i.e. expired or non-existent)
        ServiceRegistration reg = getServiceRegistration(uuid); 


//TODO - validate entries (i.e. non-null)
  Iterator iter = unknownEvents.iterator();
        RemoteEvent ev;
        while (iter.hasNext()) {
            ev = (RemoteEvent)iter.next();
            addUnknownEventDo(uuid, new EventID(ev));
        }

View Full Code Here

  try {
      EventLogIterator eli = reg.iterator();
            if (eli.hasNext()) {
                //TODO - configurable logic for determining initial batch size
                RemoteEventData[] evts = eli.readAhead(Integer.MAX_VALUE);
                RemoteEvent evt = null;
//TODO - try-catch around getRemoteEvent for CNFE? Send anyway?
                for (int i=0; i < evts.length; i++) {
                    evt = evts[i].getRemoteEvent();           
                    if (evt != null && 
                        !reg.getUnknownEvents().containsKey(new EventID(evt))) {

View Full Code Here

            
            do {
               if (eli.hasNext()) {
                    //TODO - configurable logic for determining initial batch size
                    RemoteEventData[] evts = eli.readAhead(Integer.MAX_VALUE);
                    RemoteEvent evt = null;
                    for (int i=0; i < evts.length; i++) {
                        try {
                            evt = evts[i].getRemoteEvent();           
                            if (evt != null && 
                                !reg.getUnknownEvents().containsKey(new EventID(evt))) {

View Full Code Here

      private RemoteEvent getNextEvent(ServiceRegistration reg) {
            if (operationsLogger.isLoggable(Level.FINER)) {
          operationsLogger.entering(notifyTaskSourceClass, 
              "getNextEvent", reg);
      }
          RemoteEvent evt = null;
      try {
              if (reg.iterator().hasNext()) {
        try {
            evt =  (RemoteEvent)reg.iterator().next();
        } catch (IOException ioe) {

View Full Code Here

          boolean succeeded = false;           // attempt this task again?      
          boolean deleteEvent = false;         // delete the retrieved event? 
          boolean doNotify = true;             // attempt notification?
          ServiceRegistration reg = null;      // 
          RemoteEventListener listener = null; // event delivery target
      RemoteEvent ev = null;               // event to deliver


          if (deliveryLogger.isLoggable(Level.FINEST)) {
                deliveryLogger.log(Level.FINEST,
        "Attempting event delivery for: {0} at {1}",
            new Object[] {
                regID,
                new java.util.Date(System.currentTimeMillis())
            });
      }
    
            // Put an upper time limit on how long to keep
            // this task on the active list.  This prevents
            // slow/bad event recipients from monopolizing
            // a thread in the thread pool. This will not 
            // prevent a "malicious" event recipient from 
            // hanging up this thread if it never returns
            // from the notify() call.
      long curTime = System.currentTimeMillis();
          if (curTime - startTime() > MAX_TIME) {
    succeeded = true;
    deleteEvent = false;
              doNotify = false;
              if (deliveryLogger.isLoggable(Level.FINEST)) {
                    deliveryLogger.log(Level.FINEST,
            "Cancelling delivery due to time limit expiration.");
    }
      } else {
                // Get required delivery information
                concurrentObj.readLock();
          try {
              try { 
                        // Note: the following method will throw a 
                        // ThrowThis exception if the registration 
                        // is invalid (i.e. expired or non-existent)
                        reg = getServiceRegistration(regID); 
            listener = reg.getEventTarget();
            ev = getNextEvent(reg);
    
                        // Check to see if either the listener or the event 
                        // is null. If so, skip the notify() call.
                        // If the event is not null, make an 
                        // additional check to see if the event is on the 
                        // unknown event list for this registration.
                        // If so, then skip the notify() call as well.
            if (listener == null) {
           succeeded = true;   // don't try again
                deleteEvent = false; // don't delete event
                doNotify = false;    // skip notify
          if (deliveryLogger.isLoggable(Level.FINEST)) {
                                deliveryLogger.log(Level.FINEST,
                        "Cancelling delivery because of disabled listener");
                }
             } else if (ev == null) {
                succeeded = true;    // don't try again
                // Note that if getNextEvent returned null
                // then there was a problem reading or extracting
                // the event. If so, the EventLog mechanism
                // wil have already advanced past the offending
                // event, so we don't have to remove it.
                deleteEvent = false; 
                doNotify = false;    // skip notify
                          if (deliveryLogger.isLoggable(Level.FINEST)) {
                                deliveryLogger.log(Level.FINEST,
                        "Cancelling delivery because of null event");
          }
      } else if (ev != null &&
                 reg.getUnknownEvents().containsKey(
                     new EventID(ev))) {
          // If this event type caused an 
          // UnknownEventException in the past, then
          // delete it since it likely do so again.
                succeeded = true;    // don't try again
                deleteEvent = true;  // delete event
                doNotify = false;    // skip notify
                          if (deliveryLogger.isLoggable(Level.FINEST)) {
                                deliveryLogger.log(Level.FINEST,
                        "Cancelling delivery because of unknown event");
          }
            }
        } catch (ThrowThis tt) { // reg was not valid ... skip it
                succeeded = true;        // don't try again
                deleteEvent = false;     // don't remove event
            doNotify = false;        // skip notify
                      if (deliveryLogger.isLoggable(Level.FINEST)) {
                            deliveryLogger.log(Level.FINEST,
                    "Cancelling delivery because of unknown registration");
      }
            }
          } finally {
                    concurrentObj.readUnlock();
          }
      } // end else
          
          // Important - don't hold any locks during a remote invocation
            if (doNotify) { 
          if (deliveryLogger.isLoggable(Level.FINEST)) {
                    deliveryLogger.log(Level.FINEST,
            "Delivering evt: {0}, ID {1}, Seq# {2}",
                new Object[] {ev, new Long(ev.getID()), 
                new Long(ev.getSequenceNumber())});
          }
    try {
        // Notify target listener and note a successful delivery
        listener.notify(ev);
        succeeded = true;

View Full Code Here


        // Get events and verify
  logger.log(Level.INFO, "Getting events.");
        RemoteEventIterator rei = mr.getRemoteEvents();
        ArrayList receivedEvents = new ArrayList();
        RemoteEvent rei_event;
        while ((rei_event = rei.next(MAX_WAIT)) != null) {
            receivedEvents.add(rei_event);
        }
  logger.log(Level.INFO, "Received events {0}", receivedEvents);
        
   logger.log(Level.INFO, "Verifying received events");
        assertEvents(generatedEvents, receivedEvents);


        if (receivedEvents.size() != expectedEventCount) {
            throw new TestException("Received " + receivedEvents.size()
                + " events, but expected " + expectedEventCount);
        }


  logger.log(Level.INFO, "Generating " + NUM_EVENTS 
            + " soon to be unknown events");
  for (i = 0; i < NUM_EVENTS; i++) {
      genEvents[i] = myGen.generateEvent(evtReg.getID(), 3);
  }
  logger.log(Level.INFO, "Sent soon to be unknown events {0}", 
            java.util.Arrays.asList(genEvents));        
        
        // Set myGen events as unknown events
   logger.log(Level.INFO, "Calling addUnknownEvents");
        mr.addUnknownEvents(java.util.Arrays.asList(genEvents));
        
        //Verify that events aren't delivered
        RemoteEvent re = null;
        if ((re = rei.next(MAX_WAIT)) != null) {
            throw new TestException("Unexpected event received " + re);
        }
    logger.log(Level.INFO, "Did not receive any unknown events");

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of net.jini.core.event.RemoteEvent

com.sun.jini.mercury.MailboxImpl

com.sun.jini.mercury.MailboxImpl$NotifyTask

com.sun.jini.mercury.PersistentEventLog

com.sun.jini.mercury.RemoteEventData

com.sun.jini.mercury.RemoteEventIteratorImpl

com.sun.jini.outrigger.EventRegistrationWatcher$BasicEventSender

com.sun.jini.test.impl.mercury.BadEventCodebaseTest

com.sun.jini.test.impl.mercury.ListenerRecoveryTest

com.sun.jini.test.impl.mercury.PullListenerRecoveryTest

com.sun.jini.test.impl.mercury.PullTimeoutTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.