9:43 a.m.
Author: manik.surtani(a)jboss.com
Date: 2008-05-27 10:43:21 -0400 (Tue, 27 May 2008)
New Revision: 5889
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticInterceptor.java
core/trunk/src/main/java/org/jboss/cache/lock/LockManager.java
core/trunk/src/main/java/org/jboss/cache/lock/NodeBasedLockManager.java
Log:
Fixed broken behaviour
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticInterceptor.java
===================================================================
---
core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticInterceptor.java 2008-05-27
13:28:31 UTC (rev 5888)
+++
core/trunk/src/main/java/org/jboss/cache/interceptors/OptimisticInterceptor.java 2008-05-27
14:43:21 UTC (rev 5889)
@@ -111,14 +111,14 @@
@SuppressWarnings("unchecked")
protected WorkspaceNode lockAndCreateWorkspaceNode(NodeFactory nodeFactory, NodeSPI
node, TransactionWorkspace workspace, GlobalTransaction gtx, long timeout)
{
- boolean locked = lockManager.lock(node.getFqn(), READ, gtx, timeout);
+ boolean locked = lockManager.lock(node, READ, gtx, timeout);
if (!locked)
throw new TimeoutException("Unable to lock node " + node.getFqn() +
" after timeout " + timeout + " for copying into workspace");
WorkspaceNode wn = nodeFactory.createWorkspaceNode(node, workspace);
- lockManager.unlock(node.getFqn(), gtx);
+ lockManager.unlock(node, gtx);
return wn;
}
Modified: core/trunk/src/main/java/org/jboss/cache/lock/LockManager.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/lock/LockManager.java 2008-05-27 13:28:31 UTC
(rev 5888)
+++ core/trunk/src/main/java/org/jboss/cache/lock/LockManager.java 2008-05-27 14:43:21 UTC
(rev 5889)
@@ -47,6 +47,17 @@
boolean lock(Fqn fqn, LockType lockType, Object owner, long timeout);
/**
+ * As {@link #lock(org.jboss.cache.Fqn, LockType, Object, long)} except that a NodeSPI
is passed in instead of an Fqn.
+ *
+ * @param node node to lock
+ * @param lockType type of lock to acquire
+ * @param owner owner to acquire the lock for
+ * @param timeout maximum length of time to wait for (in millis)
+ * @return true if the lock was acquired, false otherwise.
+ */
+ boolean lock(NodeSPI node, LockType lockType, Object owner, long timeout);
+
+ /**
* Acquires a lock of type lockType, on a specific Node in the cache, denoted by fqn.
This
* method will try for a period of time and give up if it is unable to acquire the
required lock. The period of time
* is specified in {@link org.jboss.cache.config.Option#getLockAcquisitionTimeout()}
and, if this is unset, the default timeout
@@ -88,18 +99,18 @@
/**
* Releases the lock passed in, held by the specified owner
*
- * @param lock NodeLock to unlock
+ * @param fqn Fqn of the node to unlock
* @param owner lock owner
*/
- void unlock(NodeLock lock, Object owner);
+ void unlock(Fqn fqn, Object owner);
/**
* Releases the lock passed in, held by the specified owner
*
- * @param fqn Fqn of the node to unlock
+ * @param node Node to unlock
* @param owner lock owner
*/
- void unlock(Fqn fqn, Object owner);
+ void unlock(NodeSPI node, Object owner);
/**
* Releases locks present in an invocation context and transaction entry, if one is
available.
Modified: core/trunk/src/main/java/org/jboss/cache/lock/NodeBasedLockManager.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/lock/NodeBasedLockManager.java 2008-05-27
13:28:31 UTC (rev 5888)
+++ core/trunk/src/main/java/org/jboss/cache/lock/NodeBasedLockManager.java 2008-05-27
14:43:21 UTC (rev 5889)
@@ -60,6 +60,7 @@
private NodeLock acquireLock(NodeSPI node, LockType lockType, Object owner, long
timeout)
{
+ if (node == null) return null;
NodeLock lock = node.getLock();
boolean acquired = false;
try
@@ -92,6 +93,12 @@
return acquireLock(fqn, lockType, owner, timeout) != null;
}
+ public boolean lock(NodeSPI node, LockType lockType, Object owner, long timeout)
+ {
+ return acquireLock(node, lockType, owner, timeout) != null;
+ }
+
+
public boolean lockAndRecord(Fqn fqn, LockType lockType, InvocationContext ctx)
{
return lockAndRecord(dataContainer.peek(fqn), lockType, ctx);
@@ -121,11 +128,12 @@
public void unlock(InvocationContext ctx)
{
List<NodeLock> locks = ctx.getTransactionEntry() != null ?
ctx.getTransactionEntry().getLocks() : ctx.getInvocationLocksAcquired();
+ if (locks == null || locks.isEmpty()) return;
Object owner = getLockOwner(ctx);
// Copying out to an array is faster than creating an ArrayList and iterating,
// since list creation will just copy out to an array internally
- IdentityLock[] lockArray = locks.toArray(new IdentityLock[locks.size()]);
+ NodeLock[] lockArray = locks.toArray(new NodeLock[locks.size()]);
for (int i = lockArray.length - 1; i >= 0; i--)
{
if (trace)
@@ -135,7 +143,7 @@
locks.clear();
}
- public void unlock(NodeLock lock, Object owner)
+ private void unlock(NodeLock lock, Object owner)
{
if (trace) log.trace("releasing lock for " + lock.getFqn() + "
(" + lock + "), owner " + owner);
lock.release(owner);
@@ -146,6 +154,11 @@
unlock(dataContainer.peek(fqn).getLock(), owner);
}
+ public void unlock(NodeSPI node, Object owner)
+ {
+ unlock(node.getLock(), owner);
+ }
+
public boolean lockAll(NodeSPI node, LockType lockType, Object owner)
{
return lockAll(node, lockType, owner, lockAcquisitionTimeout, false);
@@ -168,6 +181,7 @@
*/
private List<NodeLock> lockAllNodes(NodeSPI node, LockType lockType, Object
owner, long timeout, boolean excludeInternalFqns)
{
+ if (node == null) return null;
List<NodeLock> locks = null;
try
{