Examples of net.jini.core.event.EventRegistration

net.jini.core.event.EventRegistration
A utility class for use as a return value for event-interest registration methods. Objects of this class are meant to encapsulate the information needed by a client to identify a notification as a response to a registration request and to maintain that registration request. It is not mandatory for an event-interest registration method to use this class.
A registration of interest in some kind of event that occurs within the scope of a transaction is leased in the same way as other event interest registrations. However, the duration of the registration is the minimum of the length of the lease and the duration of the transaction. Simply put, when the transaction ends (either because of a commit or an abort) the interest registration also ends. This is true even if the lease for the event registration has not expired and no call has been made to cancel the lease. @author Sun Microsystems, Inc. @since 1.0

        evntLeaseDurMS = 5*QATestUtils.N_MS_PER_SEC;
        srvcItems = super.createServiceItems(TEST_SRVC_CLASSES);
  srvcRegs = super.registerAll();
  proxy = super.getProxy();
  emptyTmpl = new ServiceTemplate(null,null,null);
  EventRegistration evntReg
      = proxy.notify(emptyTmpl,
         ServiceRegistrar.TRANSITION_NOMATCH_MATCH |
         ServiceRegistrar.TRANSITION_MATCH_NOMATCH |
         ServiceRegistrar.TRANSITION_MATCH_MATCH,
         listener, null, evntLeaseDurMS);

View Full Code Here

        Transaction txn = createTransaction();


        // generate EventListeners
        SimpleEventListener tCatcher = null;
        SimpleEventListener nCatcher = null;
        EventRegistration tReg = null;
        EventRegistration nReg = null;


        try {
            tCatcher = new SimpleEventListener(getConfig().getConfiguration());
            nCatcher = new SimpleEventListener(getConfig().getConfiguration());
            tReg = space.notify(template, txn, tCatcher, Lease.FOREVER,

View Full Code Here

        final Transaction txn = createTransaction();
        final SimpleEventListener listener = new SimpleEventListener(getConfig().getConfiguration());


        // Force an event registration under transaction
        logger.log(Level.INFO, "Registering for notification");
        final EventRegistration reg = space.notify(notifyEntry, txn,
                listener, Lease.FOREVER, null);
        Lease lease = reg.getLease();
        lease = (Lease)
                getConfig().prepare("test.outriggerLeasePreparer", lease);
        addLease(lease, true);


        // Force a notifiedOp

View Full Code Here

  RemoteEventListener mbRel = getMailboxListener(mr);


  // Create an event generator and pass it the
  // mailbox's remote event listener.
  TestGenerator myGen = TestUtils.createGenerator(manager);
  EventRegistration evtReg = 
      myGen.register(EVENT_ID,  // Event ID to use
         null,    // handback
         mbRel,    // Notification target
         DURATION1);  // Lease duration
  Lease tgl = evtReg.getLease();
  checkLease(tgl, DURATION1); 


  // Create two listener objects
  TestListener bad = TestUtils.createNSOListener(manager);
  int badCount = 0;
  TestListener good = TestUtils.createListener(manager);
  int goodCount = 0;


  // Generate some events from first generator
  logger.log(Level.INFO, "Generating " + NUM_EVENTS + " events");
  RemoteEvent[] events = new RemoteEvent[NUM_EVENTS];
  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

  RemoteEventListener mbRel = getMailboxListener(mr);


  // Create an event generator and pass it the
  // mailbox's remote event listener.
  TestGenerator myGen = TestUtils.createGenerator(manager);
  EventRegistration evtReg = 
      myGen.register(EVENT_ID,       // Event ID to use
         null,      // handback
         mbRel,          // Notification target
         DURATION1);  // Lease duration
  Lease tgl = evtReg.getLease();
  checkLease(tgl, DURATION1); 


  // Create another event generator and pass it the
  // mailbox's remote event listener.
  TestGenerator myGen2 = TestUtils.createGenerator(manager);
  EventRegistration evtReg2 = 
      myGen2.register(EVENT_ID2,       // Event ID to use
          null,      // handback
          mbRel,          // Notification target
          DURATION1);  // Lease duration
  Lease tgl2 = evtReg2.getLease();
  checkLease(tgl2, DURATION1); 


  // Create two listener objects
  TestListener myRel = TestUtils.createListener(manager);
  TestListener myRel2 = TestUtils.createListener(manager);
  int myRelCount = 0, myRelCount2 = 0;


  // Generate some events from first generator
  RemoteEvent[] events = new RemoteEvent[NUM_EVENTS];
  for (i = 0; i < NUM_EVENTS; i++) {
      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

  RemoteEventListener mbRel = getMailboxListener(mr);


  // Create an event generator and pass it the
  // mailbox's remote event listener.
  TestGenerator myGen = TestUtils.createGenerator(manager);
  EventRegistration evtReg = 
      myGen.register(EVENT_ID,  // Event ID to use
         null,    // handback
         mbRel,    // Notification target
         DURATION1);  // Lease duration
  Lease tgl = evtReg.getLease();
  checkLease(tgl, DURATION1); 


  // Create two listener objects
  TestListener badListener = TestUtils.createREListener(manager);
  TestListener goodListener = TestUtils.createListener(manager);
  int badCount = 0;
  int goodCount = 0;


  // Generate some events 
  logger.log(Level.INFO, "Generating " + NUM_EVENTS + " events");
  RemoteEvent[] events = new RemoteEvent[NUM_EVENTS];
  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

  }


  protected void setupNotify() {
    if(registrar != null) {
      try {
  EventRegistration reg =
      registrar.notify(stmpl,
           ServiceRegistrar.TRANSITION_MATCH_NOMATCH |
           ServiceRegistrar.TRANSITION_NOMATCH_MATCH |
           ServiceRegistrar.TRANSITION_MATCH_MATCH,
           receiver.proxy,
           null,
           Lease.ANY);
  elease = (Lease) browser.leasePreparer.prepareProxy(reg.getLease());
  browser.leaseMgr.renewUntil(elease, Lease.ANY,
            new Browser.LeaseNotify());
  eventID = reg.getID();
  seqNo = reg.getSequenceNumber();
      } catch (Throwable t) {
  logger.log(Level.INFO, "event registration failed", t);
      }
    }
  }

View Full Code Here

  if (shouldRegister) {      
      logger.log(Level.INFO, "Registering for warning events");


      final MarshalledObject handback = 
    new MarshalledObject(new Long(348));
      EventRegistration reg = set.setExpirationWarningListener(
                listener, minWarning, handback);
            reg = prepareNormEventRegistration(reg);


      if (!set.equals(reg.getSource())) {
    throw new TestException(
                    "Source object in event registration is not set");
            }
      if (reg.getID() != LeaseRenewalSet.EXPIRATION_WARNING_EVENT_ID){
    throw new TestException(
                    "Event ID in registration is not correct");
            }
      if (!reg.getLease().equals(
                prepareNormLease(set.getRenewalSetLease())))
            {
    throw new TestException(
                    "Lease in registration is not correct");
            }

View Full Code Here

  // mailbox's remote event listener.
  TestGenerator myGen = TestUtils.createGenerator(manager);
  logger.log(Level.FINEST, 
      "Test generator class tree" 
      + getClassLoaderTree(myGen.getClass().getClassLoader()));
  EventRegistration evtReg = 
      myGen.register(EVENT_ID,  // Event ID to use
         null,    // handback
         mbRel,    // Notification target
         DURATION1);  // Lease duration
  Lease tgl = evtReg.getLease();
  checkLease(tgl, DURATION1); 


  // Create another event generator and pass it the
  // mailbox's remote event listener.
  TestGenerator myGen2 = TestUtils.createGenerator(manager);
  logger.log(Level.FINEST, 
      "Test generator class tree" 
      + getClassLoaderTree(myGen2.getClass().getClassLoader()));
  EventRegistration evtReg2 = 
      myGen2.register(EVENT_ID2,  // Event ID to use
         null,    // handback
         mbRel,    // Notification target
         DURATION1);  // Lease duration
  Lease tgl2 = evtReg2.getLease();
  checkLease(tgl2, DURATION1); 
        
        int expectedEventCount = 0;
  // Generate some events 
  logger.log(Level.INFO, "Generating " + NUM_EVENTS + " events");
  ArrayList generatedEvents = new ArrayList();
        RemoteEvent[] genEvents = new RemoteEvent[NUM_EVENTS];
  for (i = 0; i < NUM_EVENTS; i++) {
      generatedEvents.add(myGen.generateEvent(evtReg.getID(), 3));
  }
        expectedEventCount += NUM_EVENTS;
        
  // Generate some events 
  logger.log(Level.INFO, "Generating " + NUM_EVENTS + " events");
  for (i = 0; i < NUM_EVENTS; i++) {
      generatedEvents.add(myGen2.generateEvent(evtReg2.getID(), 3));
  }
  logger.log(Level.INFO, "Sent events {0}", generatedEvents);        
        expectedEventCount += NUM_EVENTS;


        // 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");


  // Generate some myGen2 events -- should be accepted
  logger.log(Level.INFO, "Generating " + NUM_EVENTS + " events");
  for (i = 0; i < NUM_EVENTS; i++) {
      generatedEvents.add(myGen2.generateEvent(evtReg2.getID(), 3));
  }
       expectedEventCount += NUM_EVENTS;
       
       logger.log(Level.INFO, "Sent events {0}", generatedEvents);

View Full Code Here

  addLease(prepareNormLease(set.getRenewalSetLease()), false);


  // Register for failure events
  final OurListener listener = new OurListener();
  final MarshalledObject handback = new MarshalledObject(new Long(347));
  EventRegistration reg = 
      set.setRenewalFailureListener(listener, handback);
  reg = prepareNormEventRegistration(reg);


  if (!set.equals(reg.getSource())) 
      throw new TestException( "Source object in event registration is not set");


  if (reg.getID() != LeaseRenewalSet.RENEWAL_FAILURE_EVENT_ID)
      throw new TestException( "Event ID in registration is not correct");


  if (!reg.getLease().equals(prepareNormLease(set.getRenewalSetLease())))
      throw new TestException( "Lease in registration is not correct");


  listener.setRegInfo(reg, handback);


  final Lease first = LocalLease.getLocalLease(0, 60000, 1, 1);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

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

com.sun.jini.example.browser.Browser

com.sun.jini.example.browser.ServiceEditor

com.sun.jini.fiddler.FiddlerImpl

com.sun.jini.norm.LeaseSet

com.sun.jini.norm.NormServerBaseImpl

com.sun.jini.outrigger.OutriggerServerImpl

com.sun.jini.reggie.RegistrarImpl

com.sun.jini.test.impl.mercury.InterOpTest

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

com.sun.jini.test.impl.mercury.PullInterOpTest

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.