inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-08-07 17:49:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added callback-based JobLockService refreshLock

Browse Source 
- JobLockService.refreshLock(..., JobLockRefreshCallback)
 - Added to support ALF-4898: Deployment: Reduce lock TTL


git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@22812 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Derek Hulley
2010-10-01 14:50:43 +00:00
parent d82de33326
commit 71f1312474
3 changed files with 667 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
source/java/org/alfresco/repo/lock/JobLockService.java
View File

@@ -44,8 +44,9 @@ public interface JobLockService
/**
* Take a transactionally-managed lock. This method can be called repeatedly to both
* initially acquire the lock as well as to maintain the lock. This method should
* either be called again before the lock expires or the transaction should end before
* the lock expires.
* be called repeatedly during the transaction to ensure that the lock remains refreshed.
* <b>DO NOT</b> use a long-lived lock to avoid calling this method at intervals; long-lived
* locks get left behind during server crashes, amongst other things.
* <p>
* The following rules apply to taking and releasing locks:<br>
* - Expired locks can be taken by any process<br>
@@ -58,20 +59,42 @@ public interface JobLockService
* release the owned locks will invalidate the transaction and cause rollback.
*
* @param lockQName the name of the lock to acquire
* @param timeToLive the time (in milliseconds) for the lock to remain valid
* @param timeToLive the time (in milliseconds) for the lock to remain valid.
* This value <b>must not</b> be larger than either the anticipated
* operation time or a server startup time. Typically, it should be
* a few seconds.
* @throws LockAcquisitionException if the lock could not be acquired
* @throws IllegalStateException if a transaction is not active
*/
void getTransactionalLock(QName lockQName, long timeToLive);
/**
* {@inheritDoc JobLockService#getTransactionalLock(QName, long)}
* Take a transactionally-managed lock. This method can be called repeatedly to both
* initially acquire the lock as well as to maintain the lock. This method should
* be called repeatedly during the transaction to ensure that the lock remains refreshed.
* <b>DO NOT</b> use a long-lived lock to avoid calling this method at intervals; long-lived
* locks get left behind during server crashes, amongst other things.
* <p>
* The following rules apply to taking and releasing locks:<br>
* - Expired locks can be taken by any process<br>
* - Lock expiration does not prevent a lock from being refreshed or released<br>
* - Only locks that were manipulated using another token will cause failure
* <p>
* The locks are automatically released when the transaction is terminated.
* <p>
* Any failure to acquire the lock (after retries), refresh the lock or subsequently
* release the owned locks will invalidate the transaction and cause rollback.
* <p>
* If the lock cannot be immediately acquired, the process will wait and retry. Note
* that second and subsequent attempts to get the lock during a transaction cannot
* make use of retrying; the lock is actually being refreshed and will therefore never
* become valid if it doesn't refresh directly.
*
* @param lockQName the name of the lock to acquire
* @param timeToLive the time (in milliseconds) for the lock to remain valid.
* This value <b>must not</b> be larger than either the anticipated
* operation time or a server startup time. Typically, it should be
* a few seconds.
* @param retryWait the time (in milliseconds) to wait before trying again
* @param retryCount the maximum number of times to attempt the lock acquisition
* @throws LockAcquisitionException if the lock could not be acquired
@@ -87,22 +110,34 @@ public interface JobLockService
* available by expiry. No deadlock management is provided, either.
*
* @param lockQName the name of the lock to acquire
* @param timeToLive the time (in milliseconds) for the lock to remain valid
* @param timeToLive the time (in milliseconds) for the lock to remain valid.
* This value <b>must not</b> be larger than either the anticipated
* operation time or a server startup time. Typically, it should be
* a few seconds.
* @return Returns the newly-created lock token
* @throws LockAcquisitionException if the lock could not be acquired
*/
String getLock(QName lockQName, long timeToLive);
/**
* {@inheritDoc JobLockService#getLock(QName, long)}
* Take a manually-managed lock. The lock current thread or transaction will not be tagged -
* the returned lock token must be used for further management of the lock.
* <p>
* No lock management is provided: the lock must be released manually or will only become
* available by expiry. No deadlock management is provided, either.
* <p>
* If the lock cannot be immediately acquired, the process will wait and retry.
*
* @param lockQName the name of the lock to acquire
* @param timeToLive the time (in milliseconds) for the lock to remain valid.
* This value <b>must not</b> be larger than either the anticipated
* operation time or a server startup time. Typically, it should be
* a few seconds.
* @param retryWait the time (in milliseconds) to wait before trying again
* @param retryCount the maximum number of times to attempt the lock acquisition
* @throws LockAcquisitionException if the lock could not be acquired
*/
String getLock(QName lockQName, long timeToLive, long retryWait, int retryCount);
String getLock(QName lockQName, long timeToLive, long retryWait, int retryCount);
/**
* Refresh the lock using a valid lock token.
@@ -114,6 +149,25 @@ public interface JobLockService
*/
void refreshLock(String lockToken, QName lockQName, long timeToLive);
/**
* Provide a callback to refresh a lock using a valid lock token, pushing responsibility
* for regular lock refreshing onto the service implementation code. This method should only
* be called <u>once for a given lock token</u> to prevent unnecessary refreshing.
* <p/>
* Since the lock is not actually refreshed by this method, there will be no LockAcquisitionException.
* <p/>
* The TTL (time to live) will be divided by two and the result used to trigger a timer thread
* to initiate the callback.
*
* @param lockToken the lock token returned when the lock was acquired
* @param lockQName the name of the previously-acquired lock
* @param timeToLive the time (in milliseconds) for the lock to remain valid
* @param callback the object that will be called at intervals of timeToLive/2 (about)
*
* @since 3.4.0a
*/
void refreshLock(String lockToken, QName lockQName, long timeToLive, JobLockRefreshCallback callback);
/**
* Release the lock using a valid lock token.
*
@@ -121,4 +175,64 @@ public interface JobLockService
* @param lockQName the name of the previously-acquired lock
*/
void releaseLock(String lockToken, QName lockQName);
/**
* Interface for implementations that need a timed callback in order to refresh the lock.
* <p/>
* This callback is designed for processes that need to lock and wait for external processes
* to complete; keeping a local thread to refresh the lock is possible but it is more
* efficient for the thread pool and timer mechanisms to be shared.
* <p/>
* The callback implementations <b>must</b> be thread-safe and <b>should be</b> independent
* of other callbacks i.e. the simplest and safest is to use an anonymous inner class for
* the implementation.
* <p/>
* <b>IMPORTANT:</b> Do not block the calls to this interface - other callbacks might be held
* up producing inconsistent behaviour. Failure to observe this will lead
* to warnings and lock termination i.e. the service implementation will
* force early termination of the lock and will discard the callback.
*
* @author Derek Hulley
* @since 3.4.0b
*/
public interface JobLockRefreshCallback
{
/**
* Timed callback from the service to determine if the lock is still required.
* <p/>
* <b>IMPORTANT:</b> Do not block calls to this method for any reason and do perform any
* non-trivial determination of state i.e. have the answer to this
* method immediately available at all times. Failure to observe this
* will lead to warnings and lock termination.
* <p/>
* The original lock token <b>is not</b> provided in the callback; this is to prevent
* implementations from attempting to link the lock token back to the specific callback
* instances.
*
* @return Return <tt>true</tt> if the task associated with the callback
* is still active i.e. it still needs the lock associated with the
* callback or <tt>false</tt> if the lock is no longer required.
*
* @since 3.4.0b
*/
boolean isActive();
/**
* Callback received when the lock refresh has failed. Implementations should immediately and
* gracefully terminate their associated processes as the associated lock is no longer valid,
* which is a direct indication that a competing process has taken and is using the required
* lock or that the process has already completed and released the lock.
* <p/>
* As a convenenience, this method is called when a VM shutdown is detected as well; the
* associated lock is not refreshed and this method is called to instruct the locking process
* to terminate.
* <p/>
* This method is also called if the initiating process is self-terminated i.e. if the originating
* process releases the lock itself. This method is not called if the process is not
* {@link #isActive() active}.
*
* @since 3.4.0b
*/
void lockReleased();
}
}