| /* LeaseRenewingTask.java -- The task to renew the lease. |
| Copyright (C) 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package gnu.java.rmi.dgc; |
| |
| import gnu.java.rmi.server.UnicastRef; |
| |
| import java.lang.ref.WeakReference; |
| import java.rmi.dgc.Lease; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.Timer; |
| import java.util.TimerTask; |
| import java.util.WeakHashMap; |
| |
| /** |
| * The task to renew the lease to some object reference. The UnicastRef |
| * being renewed is stored as a weak reference. So the presence of the |
| * sheduled task does not prevent it from being garbage collected. If the |
| * reference has not been garbage collected, the task is resheduled after |
| * the lease is renewed. |
| * |
| * @author Audrius Meskauskas (Audriusa@Bioinformatics.org) |
| */ |
| public class LeaseRenewingTask |
| { |
| /** |
| * The sheduled timer task to call the renew() method. |
| */ |
| class LeaseTimerTask extends TimerTask |
| { |
| public void run() |
| { |
| renew(); |
| } |
| } |
| |
| /** |
| * The default requested lease duration time (one minute by default). |
| */ |
| public static long REQUEST_LEASE_DURATION = 60000; |
| |
| /** |
| * The reference to the UnicastRef that must renew its lease until not |
| * garbage collected. The different members of this list may point to the |
| * different instances of the UnicastRef's, but these references are |
| * pointing to the same remote object (they .equals() returns |
| * true when comparing with each other). Using LinkedList to make |
| * frequent deletions from the middle easy. |
| */ |
| LinkedList ref = new LinkedList(); |
| |
| /** |
| * The granted (or supposed) lease. |
| */ |
| Lease lease = new Lease(null, REQUEST_LEASE_DURATION); |
| |
| /** |
| * The timer, shared by all lease renewing tasks. The same instance is also |
| * used for the reference protector discarding in DGCImpl. |
| */ |
| static Timer timer = new Timer(true); |
| |
| /** |
| * Maps the UnicastRef to its renewing task. |
| */ |
| static WeakHashMap existingTasks = new WeakHashMap(); |
| |
| /** |
| * Creates the lease renewing task that renews the lease of the given |
| * UnicastRef until it is not collected. This constructor requests the lease |
| * value from the server and schedules the lease renewal action. |
| * |
| * @param renewIt the reference that must be renewed. |
| */ |
| public LeaseRenewingTask(UnicastRef renewIt) |
| { |
| lease = notifyDGC(renewIt); |
| if (lease != null) |
| { |
| schedule(lease); |
| ref.add(new WeakReference(renewIt)); |
| } |
| } |
| |
| /** |
| * Schedule periodic leases for the given UnicastRef reference. |
| * |
| * @param renewIt the reference, for that the leases must be scheduled. |
| */ |
| public static void scheduleLeases(UnicastRef renewIt) |
| { |
| // No need to schedule leases for null. |
| if (renewIt == null) |
| return; |
| try { |
| synchronized (existingTasks) |
| { |
| // Check maybe the task for refreshing this remote object already |
| // exists. |
| LeaseRenewingTask task = (LeaseRenewingTask) existingTasks.get(renewIt); |
| |
| if (task != null) |
| { |
| // Extend the reference list only. The scheduling must be |
| // alredy done with the previous lease. |
| synchronized (task.ref) |
| { |
| task.ref.add(new WeakReference(renewIt)); |
| } |
| } |
| else |
| existingTasks.put(renewIt, new LeaseRenewingTask(renewIt)); |
| } |
| } |
| catch (Exception ex) |
| { |
| InternalError ierr = new InternalError("Lease for "+renewIt); |
| ierr.initCause(ex); |
| throw ierr; |
| } |
| } |
| |
| /** |
| * Shedule the renewing call, taking into consideration that the following |
| * lease was granted. |
| * |
| * @param lease the lease that was granted. |
| */ |
| public void schedule(Lease lease) |
| { |
| long value = lease.getValue(); |
| |
| // Shedule a 10 % earlier because some time is needed for the message |
| // to reach the server. |
| long reduced = (value * 90)/100; |
| if (reduced == 0) |
| reduced = value; |
| |
| timer.schedule(new LeaseTimerTask(), reduced); |
| } |
| |
| /** |
| * Renew the lease. |
| */ |
| public void renew() |
| { |
| Object renewIt = null; |
| // Iterate throw the list of associated references. If all are |
| // discarded, there is no need to renew. |
| synchronized (ref) |
| { |
| Iterator iter = ref.iterator(); |
| WeakReference w; |
| while (iter.hasNext() && renewIt == null) |
| { |
| w = (WeakReference) iter.next(); |
| renewIt = w.get(); |
| if (renewIt == null) |
| // Discard the weak reference if its target has been garbage |
| // collected. |
| iter.remove(); |
| } |
| } |
| |
| if (renewIt!=null) |
| { |
| Lease lease = notifyDGC( (UnicastRef) renewIt); |
| |
| // Schedule the next renewing session. |
| if (lease!=null) |
| schedule(lease); |
| } |
| { |
| // All references collected - discard this entry. |
| } |
| } |
| |
| /** |
| * Notify DGC that we still hold this reference. |
| * |
| * @param renewIt the reference we still have (must not be null). |
| */ |
| public Lease notifyDGC(UnicastRef renewIt) |
| { |
| try |
| { |
| return renewIt.notifyDGC(lease); |
| } |
| catch (Exception e) |
| { |
| // Failed to notify. |
| // TODO Take some relevant action in the case if we failed |
| // to notify the remote object owner. |
| return null; |
| } |
| } |
| |
| } |