Examples of net.jini.lease.LeaseRenewalSet

net.jini.lease.LeaseRenewalSet
A collection of leases being managed by a lease renewal service.
Clients of the renewal service organize the leases they wish to have renewed into lease renewal sets (or sets, for short). These sets are represented by objects implementing this interface. The LeaseRenewalService.createLeaseRenewalSet method is provided to create sets. Sets are populated by methods on the sets themselves. Two leases in the same set need not be granted by the same service or have the same expiration time; in addition, they can be added or removed from the set independently.
This interface is not a remote interface; each implementation of the renewal service exports proxy objects that implement the LeaseRenewalSet interface that use an implementation-specific protocol to communicate with the actual remote server. All of the proxy methods obey normal RMI remote interface semantics except where explicitly noted. Two proxy objects are equal if they are proxies for the same set created by the same renewal service. Every method invocation (on both a LeaseRenewalService and all the LeaseRenewalSet instances created by that server) is atomic with respect to other invocations.
A number of the methods in this class throw RemoteException, each of these may throw the java.rmi.NoSuchObjectException subclass. If a client receives a NoSuchObjectException when calling a method on a renewal set, the client can infer that the set has been destroyed; however, it should not infer that the renewal service has been destroyed.
The term client lease is used to refer to a lease that has been placed into a renewal set. Client leases are distinct from the leases that the renewal service grants on renewal sets it has created.
Each client lease has two expiration related times associated with it: the desired expiration time for the lease, and the actual expiration time granted when the lease was created or last renewed. The desired expiration represents when the client would like the lease to expire. The actual expiration represents when the lease is going to expire if it is not renewed. Both time values are absolute times, not relative time durations. When a client lease's desired expiration arrives, the lease will be removed from the set without further client intervention.
Each client lease also has two other associated attributes: a desired renewal duration and a remaining desired duration. The desired renewal duration is specified by the client (directly or indirectly) when the lease is added to the set. This duration must normally be a positive number, however, it may be Lease.ANY if the lease's desired expiration is Lease.FOREVER. The remaining desired duration is always the desired expiration less the current time.
Each time a client lease is renewed, the renewal service will ask for an extension equal to the lease's renewal duration if the renewal duration is:
- Lease.ANY, or
- less than the remaining desired duration,
otherwise, it will ask for an extension equal to the lease's remaining desired duration.
If a client lease's actual expiration is later than its desired expiration, the renewal service will not renew the lease; the lease will remain in the set until its desired expiration is reached, the set is destroyed, or it is removed by the client.
Each set is leased from the renewal service. If the lease on a set expires or is cancelled, the renewal service will destroy the set and take no further action with regard to the client leases in the set. Each lease renewal set has associated with it an expiration warning event that occurs at a client-specified time before the lease on the set expires. Clients can register for warning events using methods provided by the set. A registration for warning events does not have its own lease, but instead is covered by the same lease under which the set was granted.
The term definite exception is used to refer to an exception that could be thrown by an operation on a client lease (such as a remote method call) that would be indicative of a permanent failure of the client lease. For purposes of this document, all bad object exceptions, bad invocation exceptions, and LeaseExceptions are considered to be definite exceptions.
Each lease renewal set has associated with it a renewal failure event that will occur in either of two cases: if any client lease in the set reaches its actual expiration before its desired expiration is reached, or if the renewal service attempts to renew a client lease and gets a definite exception. Clients can register for failure events using methods provided by the set. A registration for failure event does not have its own lease, but instead is covered by the same lease under which the set was granted.
Once placed in a set, a client lease will stay there until one or more of the following occurs:
- The lease on the set itself expires or is cancelled, causing destruction of the set
- The client lease is removed by the client
- The client lease's actual or desired expiration is reached
- A renewal attempt on the client lease results in a definite exception
Each client lease in a set will be renewed as long as it is in the set. If a renewal call throws an indefinite exception, the renewal service should retry the lease renewal until the lease would otherwise be removed from the set. The renewal service will never cancel a client lease. The preferred method of cancelling a client lease is for the client to first remove the lease from the set and then call cancel on it. It is also permissible for the client to cancel the lease without first removing the lease from the set, although this is likely to result in additional network traffic.
Client leases get returned to clients in a number of ways (via remove and getLeases calls, as components of events, etc.). In general, they should have their serial format set to Lease.DURATION before being transferred to the client's virtual machine. In some exceptional circumstances, this may not be possible (for example, the client lease was recovered from persistent storage and could not be deserialized in the server's virtual machine). In these cases, it is acceptable to transfer the lease to the client using the Lease.ABSOLUTE serial format.
Whenever a client lease gets returned to a client, its actual expiration should reflect either:
- The result of the last successful renewal call that the renewal service made or
- The expiration time the lease originally had when it was added to the set, if the renewal service has not yet successfully renewed the lease
@author Sun Microsystems, Inc. @see LeaseRenewalService

  // Create 2 renewal sets for the supplied duration
  LeaseRenewalService lrs = getLRS();


  logger.log(Level.FINE, "Creating the lease renewal set #1 with " +
        "duration of " + renewSetDur + " milliseconds.");
  LeaseRenewalSet set01 = lrs.createLeaseRenewalSet(renewSetDur);
  set01 = prepareSet(set01);


  logger.log(Level.FINE, "Creating the lease renewal set #2 with " +
        "duration of " + renewSetDur + " milliseconds.");
  LeaseRenewalSet set02 = lrs.createLeaseRenewalSet(renewSetDur);
  set02 = prepareSet(set02);


  // register a failing listener for expiration warning events
  long minWarning = renewSetDur * 2 / 10;
  logger.log(Level.FINE, "Registering failing listener #1 with set #1" +
        " for\n" + "expiration warning events : " +
        "minWarning = " + minWarning);
  set01.setExpirationWarningListener(failingListener01, minWarning,
             null);


  // register a normal listener for expiration warning events
  logger.log(Level.FINE, "Registering normal listener #1 with set #2" +
        " for\n" + "expiration warning events : " +
        "minWarning = " + minWarning);
  set02.setExpirationWarningListener(normalListener01, minWarning,
             null);


  // register a failing listener for renewal failure events
  logger.log(Level.FINE, "Registering failing listener #2 with set #2" +
        " for renewal failure events");
  set02.setRenewalFailureListener(failingListener02, null);


  // register a normal listener for renewal failure events
  logger.log(Level.FINE, "Registering normal listener #2 with set #1" +
        " for renewal failure events");
  set01.setRenewalFailureListener(normalListener02, null);


  // create a 2 leases that will fail on renewal
  long renewGrant = renewSetDur * 5 / 10;
  logger.log(Level.FINE, "Creating failing lease #1 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease01 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  
  logger.log(Level.FINE, "Creating failing lease # 2 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease02 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  
  // add lease01 to set01 and lease02 to set02
  logger.log(Level.FINE, "Adding lease #1 to set #1");
  set01.renewFor(lease01, Long.MAX_VALUE);
  logger.log(Level.FINE, "Adding lease #2 to set #2");
  set02.renewFor(lease02, Long.MAX_VALUE);
  
  /* wait for the expiration warning events to arrive. 
     By the time they do, all RenewalFailureEvents should also 
     have arrived. */
  rstUtil.waitForRemoteEvents(normalListener01, 1, renewSetDur);
  rstUtil.waitForRemoteEvents(failingListener01, 1, renewSetDur);
  
  // Assert that we had one call each on the failing listeners
  RemoteEvent[] events01 = failingListener01.getEvents();
  RemoteEvent[] events02 = failingListener02.getEvents();


  if (events01.length != 1) {
      String message = "Failing Listener #1 received " + 
    events01.length + " events but is required to\n" +
    "receive exactly 1.";
      throw new TestException(message);
  }


  if (events02.length != 1) {
      String message = "Failing Listener #2 received " + 
    events02.length + " events but is required to\n" +
    "receive exactly 1.";
      throw new TestException(message);
  }


  // Assert that we had one call each on the normal listeners
  events01 = normalListener01.getEvents();
  events02 = normalListener02.getEvents();


  if (events01.length != 1) {
      String message = "Normal Listener #1 received " + 
    events01.length + " events but is required to\n" +
    "receive exactly 1.";
      throw new TestException(message);
  }


  if (events02.length != 1) {
      String message = "Normal Listener #2 received " + 
    events02.length + " events but is required to\n" +
    "receive exactly 1.";
      throw new TestException(message);
  }


  // Assert we can renew both set's leases without error
  renewSetDur = renewSetDur * 6 / 10; // use a shorter time


  try {
      logger.log(Level.FINE, "Renewing set #1's lease with duration " +
            "of " + renewSetDur + " milliseconds.");
      prepareLease(set01.getRenewalSetLease()).renew(renewSetDur);
  } catch (UnknownLeaseException ex) {
      String message = "Attempt to renew lease for renewal set\n" +
    "#1 has failed due to " + ex;
      throw new TestException(message, ex);
  }      


  try {
      logger.log(Level.FINE, "Renewing set #2's lease with duration " +
            "of " + renewSetDur + " milliseconds.");
      prepareLease(set02.getRenewalSetLease()).renew(renewSetDur);
  } catch (UnknownLeaseException ex) {
      String message = "Attempt to renew lease for renewal set\n" +
    "#2 has failed due to " + ex;
      throw new TestException(message, ex);
  }      


  /* Assert that calls to remove do not result in a 
     NoSuchObjectException. Given the renewal of the leases
     above this assertion is probably somewhat redundant. */


  try {
      Lease managedLease = set01.remove(lease01);
  } catch (NoSuchObjectException ex) {
      String message = "Attempt to call remove on set\n" +
    "#1 has failed due to a NoSuchObjectException";
      throw new TestException(message, ex);
  }      


  try {
      Lease managedLease = set02.remove(lease02);
  } catch (NoSuchObjectException ex) {
      String message = "Attempt to call remove on set\n" +
    "#2 has failed due to a NoSuchObjectException";
      throw new TestException(message, ex);
  }      


  // Restore both sets to original configurations
  renewGrant = renewSetDur * 3 / 10;
  logger.log(Level.FINE, "Creating failing lease #3 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease03 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  logger.log(Level.FINE, "Adding lease #3 to set #1");
  set01.renewFor(lease03, Long.MAX_VALUE);
  
  logger.log(Level.FINE, "Creating failing lease #4 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease04 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  logger.log(Level.FINE, "Adding lease #4 to set #2");
  set02.renewFor(lease04, Long.MAX_VALUE);
  
  /*
   * Wait until the expiration warning event rolls in.
   * By that time the renewal failure event should also have arrived.
   */

View Full Code Here

  logger.log(Level.FINE, "AddRemoveTest: In run() method.");


  // get a lease renewal set w/ duration for as long as we can
  logger.log(Level.FINE, "Creating the lease renewal set.");
  LeaseRenewalService lrs = getLRS();
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(Lease.FOREVER);
  set = prepareSet(set);
  
  // get a lease for 2 hours (that ought to suffice).
  logger.log(Level.FINE, "Creating the lease to be managed.");
  long duration = 120 * 60 * 1000;
  TestLease testLease = 
      leaseProvider.createNewLease(rstUtil.durToExp(duration));


  // start managing the lease for as long as we can
  logger.log(Level.FINE, "Adding managed lease to lease renewal set.");
  set.renewFor(testLease, Lease.FOREVER);
  
  // remove the lease and make certain it is the same one we added
  logger.log(Level.FINE, "Removing the managed lease from the set.");
  Lease managedLease = set.remove(testLease);
  if (managedLease.equals(testLease) == false) {
      String message = "Remove failed to return the lease whose\n";
      message += "removal was requested.";
      throw new TestException(message);
  }


  // assuming a successful remove it better be gone now ...
  logger.log(Level.FINE, "Checking that removal was successful.");
  Lease duplicateLease = set.remove(testLease);
  if (duplicateLease != null) {
      String message = "Removal of the same lease was\n";
      message += "successfully performed twice.";
      throw new TestException(message);
  }

View Full Code Here

  // grab the ever popular LRS
  LeaseRenewalService lrs = getLRS();


  // create a renewal set
  long renewSetDur = Lease.FOREVER;
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(renewSetDur);
  set = prepareSet(set);
  lrm.renewFor(prepareLease(set.getRenewalSetLease()), renewSetDur, null);
  logger.log(Level.FINE, "Created renewal set with lease duration of " +
        "Lease.FOREVER.");


  // create a test lease to be managed
  logger.log(Level.FINE, "Creating the lease to be managed.");
  logger.log(Level.FINE, "Duration == " + renewGrant);
  TestLease testLease = 
      leaseProvider.createNewLease(leaseOwner, 
           rstUtil.durToExp(renewGrant));
  testLease.setSerialFormat(Lease.ABSOLUTE);
  long originalExpTime = testLease.getExpiration();


  // start managing the lease 
  logger.log(Level.FINE, "Adding lease with membership of " +
        "Long.MAX_VALUE");
  set.renewFor(testLease, Long.MAX_VALUE);


  // sleep until the test lease expires
  long sleepTime = renewGrant * 2;
  logger.log(Level.FINE, "Sleeping for " + sleepTime + " milliseconds");
  Thread.sleep(sleepTime);


  // assert that the current expiration time is Long.MAX_VALUE
  Lease managedLease = set.remove(testLease);
  long currentExpTime = managedLease.getExpiration();
  if (currentExpTime != Long.MAX_VALUE) {
      String message = "The current expiration time of the lease" +
    " is " + currentExpTime + " but should be Long.MAX_VALUE" +
    " (" + Long.MAX_VALUE + ").";

View Full Code Here


  // create a renewal set
  logger.log(Level.FINE, "Creating renewal set with lease duration of " +
        "Lease.FOREVER.");
  long renewSetDur = Lease.FOREVER;
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(renewSetDur);
  set = prepareSet(set);
  lrm.renewFor(prepareLease(set.getRenewalSetLease()), renewSetDur, null);


  // create 3 test leases to be managed
  logger.log(Level.FINE, "Creating a normal lease #1 to be managed.");
  logger.log(Level.FINE, "Duration == Lease.FOREVER");
  TestLease testLease01 = 
      leaseProvider.createNewLease(leaseOwner, Lease.FOREVER);


  logger.log(Level.FINE, "Creating a normal lease #2 to be managed.");
  logger.log(Level.FINE, "Duration == Lease.FOREVER");
  TestLease testLease02 = 
      leaseProvider.createNewLease(leaseOwner, Lease.FOREVER);


  logger.log(Level.FINE, "Creating a normal lease #3 to be managed.");
  logger.log(Level.FINE, "Duration == Lease.FOREVER");
  TestLease testLease03 = 
      leaseProvider.createNewLease(leaseOwner, Lease.FOREVER);


  // start managing the normal leases forever
  logger.log(Level.FINE, "Adding normal lease #1 with membership of " +
        "Lease.FOREVER");
  set.renewFor(testLease01, Lease.FOREVER);


  logger.log(Level.FINE, "Adding normal lease #2 with membership of " +
        "Lease.FOREVER");
  set.renewFor(testLease02, Lease.FOREVER);


  logger.log(Level.FINE, "Adding normal lease #3 with membership of " +
        "Lease.FOREVER");
  set.renewFor(testLease03, Lease.FOREVER);


  // create 2 unreadable test leases to be managed
  logger.log(Level.FINE, "Creating an unreadable lease #1 to be" +
        " managed.");
  logger.log(Level.FINE, "Duration == Lease.FOREVER");
  TestLease specialLease01 = 
      unreadableLeaseProvider.createNewLease(leaseOwner, 
               Lease.FOREVER);


  logger.log(Level.FINE, "Creating an unreadable lease #2 to be" +
        " managed.");
  logger.log(Level.FINE, "Duration == Lease.FOREVER");
  TestLease specialLease02 = 
      unreadableLeaseProvider.createNewLease(leaseOwner, 
               Lease.FOREVER);
  // start managing the unreadable leases forever
  logger.log(Level.FINE, "Adding unreadable lease #1 with membership" +
        " of Lease.FOREVER");
  set.renewFor(specialLease01, Lease.FOREVER);


  logger.log(Level.FINE, "Adding unreadable lease #2 with membership" +
        " of Lease.FOREVER");
  set.renewFor(specialLease02, Lease.FOREVER);


  /* Assert that a LeaseUnmarshalException is thrown when getLeases()
     is called */
  try {
      UnreadableTestLease.setFailMode(true);
      Lease[] leaseArray = set.getLeases();
      UnreadableTestLease.setFailMode(false);


      /* here we have succeeded to getLeases so something went
         frightfully wrong */
      String message =

View Full Code Here

  logger.log(Level.FINE, "ExpireRemoveTest: In run() method.");


  // get a lease renewal set w/ duration for as long as we can
  logger.log(Level.FINE, "Creating the lease renewal set.");
  LeaseRenewalService lrs = getLRS();
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(Lease.FOREVER);
  set = prepareSet(set);
  
  // get a lease for 2 hours (that ought to suffice).
  logger.log(Level.FINE, "Creating the lease to be managed.");
  logger.log(Level.FINE, "Duration == " + renewGrant);
  TestLease testLease = 
      leaseProvider.createNewLease(owner, 
           rstUtil.durToExp(renewGrant));


  // start managing the lease for only half of its grant time
  logger.log(Level.FINE, "Adding managed lease to lease renewal set.");
  long membership = renewGrant / 2;
  logger.log(Level.FINE, "Membership duration == " + membership);
  set.renewFor(testLease, membership);
  
  // sleep for 3/4 of the renewGrant time
  long sleeptime = renewGrant * 3 / 4;
  logger.log(Level.FINE, "Waiting " + sleeptime + " milliseconds for " +
        "membership duration to expire.");
  Thread.sleep(sleeptime);


  // attempt to remove the lease. Removal should fail.
  logger.log(Level.FINE, "Removing the managed lease from the set.");
  Lease managedLease = set.remove(testLease);
  logger.log(Level.FINE, "Lease ==> " + managedLease);
  if (managedLease != null) {
      String message = "Lease was not removed after membership\n";
      message += "duration expired.";
      throw new TestException(message);

View Full Code Here


  // create a lease renewal set that hangs around a long time
  logger.log(Level.FINE, "Creating Set with lease duration of " +
        "Lease.FOREVER.");
  long renewSetDur = Lease.FOREVER;
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(renewSetDur);
  set = prepareSet(set);


  // register the listener to receive renewal failure events
  logger.log(Level.FINE, "Registering listener to receive " +
        "RenewalFailureEvents.");
  set.setRenewalFailureListener(normalListener, null);


  // create a lease that will fail during renewal attempts
  logger.log(Level.FINE, "Creating lease with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  
  // add the lease to the renewal set w/ membership of renewGrant
  logger.log(Level.FINE, "Adding lease to renewal set.");
  long membership = renewGrant;
  logger.log(Level.FINE, "membership = " + membership + " milliseconds.");
  set.renewFor(lease, membership);


  // wait for the failure to roll in ...
  rstUtil.waitForRemoteEvents(normalListener, 1, renewGrant * 2);


  // capture the event

View Full Code Here


  // get a lease renewal set w/ duration for as long as we can
  logger.log(Level.FINE, "Creating the lease renewal set with duration" +
        " of Lease.FOREVER");
  LeaseRenewalService lrs = getLRS();
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(Lease.FOREVER);
  set = prepareSet(set);
  lrm.renewFor(prepareLease(set.getRenewalSetLease()), Lease.FOREVER, null);


  // register a listener to receive renewal failure events
  logger.log(Level.FINE, "Registering listener to receive " +
        "RenewalFailureEvents.");
  EventRegistration reg = set.setRenewalFailureListener(rrl, null);
  reg = prepareRegistration(reg);


  // validate the registration (just for grins)
  if (rstUtil.isValidRenewFailEventReg(reg, set) == false) {
      String message = "Registration is invalid because:\n" +
    rstUtil.getFailureReason();
      throw new TestException(message);
  }


  // create the three leases to be managed
  logger.log(Level.FINE, "Creating lease #1 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease01 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  set.renewFor(lease01, Long.MAX_VALUE);


  logger.log(Level.FINE, "Creating lease #2 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease02 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  set.renewFor(lease02, Long.MAX_VALUE);


  logger.log(Level.FINE, "Creating lease #3 with duration of " +
        renewGrant + " milliseconds.");
  TestLease lease03 = 
      leaseProvider.createNewLease(failingOwner, 
           rstUtil.durToExp(renewGrant));
  set.renewFor(lease03, Long.MAX_VALUE);


  // sleep until the leases have expired.
  rstUtil.waitForRemoteEvents(rrl, 3, renewGrant * 2);


  // ensure that we have exactly 3 events

View Full Code Here


  // clear the listener so we can reuse it
  rrl.clear();


  // create a new set
  LeaseRenewalSet set  = lrs.createLeaseRenewalSet(Lease.FOREVER);
  set = prepareSet(set);
  lrm.renewFor(prepareLease(set.getRenewalSetLease()), Lease.FOREVER, null);
  logger.log(Level.FINE, "Created renewal set with lease" +
        "duration of Lease.FOREVER.");


  // register listener to receive events
  logger.log(Level.FINE, "Registering listener for renewal failure " +
        "events.");
  set.setRenewalFailureListener(rrl, null);
  
  /* create 10 test leases which will throw definite exceptions
     and add each to the renewal set. */
  for (int i = 0; i < NUMBER_OF_TEST_LEASES; ++i) {
      logger.log(Level.FINE, "Creating lease with duration of " +
            renewGrant + " milliseconds.");
      testLease[i] = 
    leaseProvider.createNewLease(owner, 
               rstUtil.durToExp(renewGrant));
      set.renewFor(testLease[i], Lease.FOREVER);
  }


  // wait until the test leases have expired
  rstUtil.waitForRemoteEvents(rrl, NUMBER_OF_TEST_LEASES,
            renewGrant * 2);

View Full Code Here

  LeaseRenewalService lrs = getLRS();


  // create a renewal set for the requested duration
  logger.log(Level.FINE, "Creating renewal set w/ duration = " +
        renewSetDur + " milliseconds.");
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(renewSetDur);
  set = prepareSet(set);


  // register listener #1 to receive events
  logger.log(Level.FINE, "Registering listener #1 for warning events.");
  logger.log(Level.FINE, "minWarning = " + minWarning + ".");
  set.setExpirationWarningListener(rrl01, minWarning, null);


  /* We want to wait for three renewals (or more)
     before switching listeners. Some implementations that refuse
     to give out leases for the request grant duration may send 
     more events in that time. This is okay, it does not effect 
     the validity of the test. */
  long timeOut = renewSetDur * 3;
  rstUtil.waitForRemoteEvents(rrl01, 3, timeOut);
  
  // start listening immediately with listener #2
  logger.log(Level.FINE, "Registering listener #2 for warning events.");
  logger.log(Level.FINE, "minWarning = " + minWarning + ".");
  set.setExpirationWarningListener(rrl02, minWarning, null);


  // now lets wait for 3 more events to arrive
  rstUtil.waitForRemoteEvents(rrl02, 3, timeOut);


  // report on how many events were received by each (3 = minimum)

View Full Code Here


  // create a renewal set
  logger.log(Level.FINE, "Creating renewal set with lease duration of " +
        "Lease.FOREVER.");
  long renewSetDur = Lease.FOREVER;
  LeaseRenewalSet set = lrs.createLeaseRenewalSet(renewSetDur);
  set = prepareSet(set);
  lrm.renewFor(prepareLease(set.getRenewalSetLease()), renewSetDur, null);


  // create a test lease to be managed and add to renewal set
  Lease testLease[] = new Lease[3];
  for (int i = 0; i < 3; ++i) {
      logger.log(Level.FINE, "Creating the lease to be managed.");
      logger.log(Level.FINE, "Duration == " + renewGrant);
      testLease[i] = leaseProvider.createNewLease
    (leaseOwner, rstUtil.durToExp(renewGrant));


      long membershipDur = renewGrant * (i+1);
      // start managing the lease 
      logger.log(Level.FINE, "Adding lease with membership of " +
            membershipDur + " milliseconds.");
      set.renewFor(testLease[i], membershipDur);
  }


  // take a snap shot of the leases (should have them all)
  Lease[] leaseArray01 = set.getLeases();


  // sleep until the membership expiration ends for lease #1
  rstUtil.sleepAndTell(renewGrant,
           "for membership duration on lease #1 " +
           "to expire.");


  // take another snap shot (all but #1 should be present)
  Lease[] leaseArray02 = set.getLeases();


  // sleep again so that that lease #2 membership expires
  rstUtil.sleepAndTell(renewGrant,
           "for membership duration on lease #2 " +
           "to expire.");


  // take another snap shot (only #3 should be left)
  Lease[] leaseArray03 = set.getLeases();


  // sleep again so that that lease #3 membership expires
  rstUtil.sleepAndTell(renewGrant,
           "for membership duration on lease #3 " +
           "to expire.");


  // take another snap shot (the array should be empty)
  Lease[] leaseArray04 = set.getLeases();


  // assert that array #1 has all three leases
  int numberOfLeases = leaseArray01.length;
  if (numberOfLeases != 3) {
      String message = "Lease array #1 should contain 3 leases" +

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of net.jini.lease.LeaseRenewalSet

com.sun.jini.norm.NormServerBaseImpl

com.sun.jini.test.impl.norm.AddRenewRemoveTest

com.sun.jini.test.impl.norm.BatchRenewTest

com.sun.jini.test.impl.norm.ExpiredLeaseTest

com.sun.jini.test.impl.norm.GetLeasesTest

com.sun.jini.test.impl.norm.LeaseExpirationTest

com.sun.jini.test.impl.norm.OneExpireOneNotTest

com.sun.jini.test.impl.norm.RemoveExactlyOneTest

com.sun.jini.test.impl.norm.RenewalFailureTest

com.sun.jini.test.impl.norm.RenewAtTest

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.