Author: mircea.markus
Date: 2008-04-23 10:38:02 -0400 (Wed, 23 Apr 2008)
New Revision: 5650
Added:
core/trunk/src/main/java/org/jboss/cache/interceptors/base/PostProcessingChainedInterceptor.java
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java
core/trunk/src/main/java/org/jboss/cache/interceptors/PessimisticLockInterceptor.java
core/trunk/src/main/java/org/jboss/cache/interceptors/base/SkipCheckChainedInterceptor.java
Log:
JBCACHE-1222 - bug fixing - release locks in case of timeout exception
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java
===================================================================
---
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java 2008-04-23
13:48:45 UTC (rev 5649)
+++
core/trunk/src/main/java/org/jboss/cache/interceptors/CacheStoreInterceptor.java 2008-04-23
14:38:02 UTC (rev 5650)
@@ -205,7 +205,7 @@
* access an element just removed, causing the CacheLoader to *load* the element
before *removing* it.
*/
@Override
- public Object executeRemoveFqnCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
+ public Object executeRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
{
if (!inTransaction())
{
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/PessimisticLockInterceptor.java
===================================================================
---
core/trunk/src/main/java/org/jboss/cache/interceptors/PessimisticLockInterceptor.java 2008-04-23
13:48:45 UTC (rev 5649)
+++
core/trunk/src/main/java/org/jboss/cache/interceptors/PessimisticLockInterceptor.java 2008-04-23
14:38:02 UTC (rev 5650)
@@ -15,7 +15,7 @@
import org.jboss.cache.commands.tx.RollbackCommand;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.factories.annotations.Inject;
-import org.jboss.cache.interceptors.base.ChainedInterceptor;
+import org.jboss.cache.interceptors.base.PostProcessingChainedInterceptor;
import org.jboss.cache.invocation.CacheData;
import org.jboss.cache.lock.IsolationLevel;
import org.jboss.cache.lock.LockManager;
@@ -44,7 +44,7 @@
* @author Bela Ban
* @version $Id$
*/
-public class PessimisticLockInterceptor extends ChainedInterceptor
+public class PessimisticLockInterceptor extends PostProcessingChainedInterceptor
{
private TransactionTable txTable;
private CacheData cacheData;
@@ -63,13 +63,13 @@
}
@Override
- public Object handlePutDataMapCommand(InvocationContext ctx, PutDataMapCommand
command) throws Throwable
+ public Object executePutDataMapCommand(InvocationContext ctx, PutDataMapCommand
command) throws Throwable
{
return handlePutCommand(ctx, command, false);
}
@Override
- public Object handlePutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand
command) throws Throwable
+ public Object executePutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand
command) throws Throwable
{
return handlePutCommand(ctx, command, command.isPutForExternalRead());
}
@@ -97,13 +97,11 @@
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(),
NodeLock.LockType.WRITE, true,
zeroAcquisitionTimeout, false, true, null, false);
}
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handlePrepareCommand(InvocationContext ctx, PrepareCommand command)
throws Throwable
+ public Object executePrepareCommand(InvocationContext ctx, PrepareCommand command)
throws Throwable
{
// 2-phase commit prepares are no-ops here.
if (!command.isOnePhaseCommit()) return invokeNextInterceptor(ctx, command);
@@ -116,7 +114,7 @@
}
@Override
- public Object handleCommitCommand(InvocationContext ctx, CommitCommand command) throws
Throwable
+ public Object executeCommitCommand(InvocationContext ctx, CommitCommand command)
throws Throwable
{
commit(command.getGlobalTransaction());
if (trace) log.trace("bypassed locking as method commit() doesn't require
locking");
@@ -126,7 +124,7 @@
}
@Override
- public Object handleRollbackCommand(InvocationContext ctx, RollbackCommand command)
throws Throwable
+ public Object executeRollbackCommand(InvocationContext ctx, RollbackCommand command)
throws Throwable
{
TransactionEntry entry = txTable.get(command.getGlobalTransaction());
if (trace)
@@ -156,7 +154,7 @@
}
@Override
- public Object handleMoveCommand(InvocationContext ctx, MoveCommand command) throws
Throwable
+ public Object executeMoveCommand(InvocationContext ctx, MoveCommand command) throws
Throwable
{
if (ctx.isLockingSuppressed()) return invokeNextInterceptor(ctx, command);
long timeout = ctx.getContextLockAcquisitionTimeout(lockAcquisitionTimeout);
@@ -185,12 +183,11 @@
{
n.getLock().releaseAll(Thread.currentThread());
}
- ctx.clearInvocationLocksAcquired();
return retValue;
}
@Override
- public Object handleRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
+ public Object executeRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
{
if (ctx.isLockingSuppressed()) return invokeNextInterceptor(ctx, command);
// need to make a note of ALL nodes created here!!
@@ -234,74 +231,64 @@
n.getLock().releaseAll(Thread.currentThread());
}
}
- ctx.clearInvocationLocksAcquired();
// if this is a delete op and we had to create the node, return a FALSE as nothing
*really* was deleted!
return created ? false : retVal;
}
@Override
- public Object handleRemoveKeyCommand(InvocationContext ctx, RemoveKeyCommand command)
throws Throwable
+ public Object executeRemoveKeyCommand(InvocationContext ctx, RemoveKeyCommand command)
throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.WRITE,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleRemoveDataCommand(InvocationContext ctx, RemoveDataCommand
command) throws Throwable
+ public Object executeRemoveDataCommand(InvocationContext ctx, RemoveDataCommand
command) throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.WRITE,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleEvictFqnCommand(InvocationContext ctx, EvictNodeCommand command)
throws Throwable
+ public Object executeEvictFqnCommand(InvocationContext ctx, EvictNodeCommand command)
throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.WRITE,
false, true, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleGetKeyValueCommand(InvocationContext ctx, GetKeyValueCommand
command) throws Throwable
+ public Object executeGetKeyValueCommand(InvocationContext ctx, GetKeyValueCommand
command) throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.READ,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleGetNodeCommand(InvocationContext ctx, GetNodeCommand command)
throws Throwable
+ public Object executeGetNodeCommand(InvocationContext ctx, GetNodeCommand command)
throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.READ,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleGetKeysCommand(InvocationContext ctx, GetKeysCommand command)
throws Throwable
+ public Object executeGetKeysCommand(InvocationContext ctx, GetKeysCommand command)
throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.READ,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
@Override
- public Object handleGetChildrenNamesCommand(InvocationContext ctx,
GetChildrenNamesCommand command) throws Throwable
+ public Object executeGetChildrenNamesCommand(InvocationContext ctx,
GetChildrenNamesCommand command) throws Throwable
{
lockManager.acquireLocksWithTimeout(ctx, command.getFqn(), NodeLock.LockType.READ,
false, false, false, false, null, false);
- Object retVal = invokeNextInterceptor(ctx, command);
- ctx.clearInvocationLocksAcquired();
- return retVal;
+ return invokeNextInterceptor(ctx, command);
}
+ public void doAfterCall(InvocationContext ctx)
+ {
+ ctx.clearInvocationLocksAcquired();
+ }
+
/**
* Remove all locks held by <tt>tx</tt>, remove the transaction from the
transaction table
*/
Added:
core/trunk/src/main/java/org/jboss/cache/interceptors/base/PostProcessingChainedInterceptor.java
===================================================================
---
core/trunk/src/main/java/org/jboss/cache/interceptors/base/PostProcessingChainedInterceptor.java
(rev 0)
+++
core/trunk/src/main/java/org/jboss/cache/interceptors/base/PostProcessingChainedInterceptor.java 2008-04-23
14:38:02 UTC (rev 5650)
@@ -0,0 +1,462 @@
+package org.jboss.cache.interceptors.base;
+
+import org.jboss.cache.InvocationContext;
+import org.jboss.cache.commands.cachedata.*;
+import org.jboss.cache.commands.remote.*;
+import org.jboss.cache.commands.tx.PrepareCommand;
+import org.jboss.cache.commands.tx.RollbackCommand;
+import org.jboss.cache.commands.tx.CommitCommand;
+import org.jboss.cache.commands.tx.OptimisticPrepareCommand;
+import org.jboss.cache.commands.channel.BlockChannelCommand;
+import org.jboss.cache.commands.channel.UnblockChannelCommand;
+import org.jboss.cache.commands.CacheCommand;
+
+/**
+ * This interceptor will call {@link #doAfterCall(org.jboss.cache.InvocationContext)}
after invoking each handler method.
+ * e.g. it is usefull if same resource needs to be released after all invocations.
+ *
+ * @author Mircea.Markus(a)jboss.com
+ * @since 2.2
+ */
+public abstract class PostProcessingChainedInterceptor extends ChainedInterceptor
+{
+ @Override
+ public final Object handlePutDataMapCommand(InvocationContext ctx, PutDataMapCommand
command) throws Throwable
+ {
+ try
+ {
+ return executePutDataMapCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executePutDataMapCommand(InvocationContext ctx, PutDataMapCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handlePutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand
command) throws Throwable
+ {
+ try
+ {
+ return executePutKeyValueCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executePutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeRemoveNodeCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleRemoveDataCommand(InvocationContext ctx, RemoveDataCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeRemoveDataCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeRemoveDataCommand(InvocationContext ctx, RemoveDataCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleEvictFqnCommand(InvocationContext ctx, EvictNodeCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeEvictFqnCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeEvictFqnCommand(InvocationContext ctx, EvictNodeCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleInvalidateCommand(InvocationContext ctx, InvalidateCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeInvalidateCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeInvalidateCommand(InvocationContext ctx, InvalidateCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleRemoveKeyCommand(InvocationContext ctx, RemoveKeyCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeRemoveKeyCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeRemoveKeyCommand(InvocationContext ctx, RemoveKeyCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGetDataMapCommand(InvocationContext ctx, GetDataMapCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeGetDataMapCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGetDataMapCommand(InvocationContext ctx, GetDataMapCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleExistsNodeCommand(InvocationContext ctx,
RemoteExistsNodeCommand command) throws Throwable
+ {
+ try
+ {
+ return executeExistsNodeCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeExistsNodeCommand(InvocationContext ctx, RemoteExistsNodeCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGetKeyValueCommand(InvocationContext ctx, GetKeyValueCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeGetKeyValueCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGetKeyValueCommand(InvocationContext ctx, GetKeyValueCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGetNodeCommand(InvocationContext ctx, GetNodeCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeGetNodeCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGetNodeCommand(InvocationContext ctx, GetNodeCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGetKeysCommand(InvocationContext ctx, GetKeysCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeGetKeysCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGetKeysCommand(InvocationContext ctx, GetKeysCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGetChildrenNamesCommand(InvocationContext ctx,
GetChildrenNamesCommand command) throws Throwable
+ {
+ try
+ {
+ return executeGetChildrenNamesCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGetChildrenNamesCommand(InvocationContext ctx,
GetChildrenNamesCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleMoveCommand(InvocationContext ctx, MoveCommand command)
throws Throwable
+ {
+ try
+ {
+ return executeMoveCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeMoveCommand(InvocationContext ctx, MoveCommand command) throws
Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleGravitateDataCommand(InvocationContext ctx,
GravitateDataCommand command) throws Throwable
+ {
+ try
+ {
+ return executeGravitateDataCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeGravitateDataCommand(InvocationContext ctx, GravitateDataCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handlePrepareCommand(InvocationContext ctx, PrepareCommand
command) throws Throwable
+ {
+ try
+ {
+ return executePrepareCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executePrepareCommand(InvocationContext ctx, PrepareCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleRollbackCommand(InvocationContext ctx, RollbackCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeRollbackCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeRollbackCommand(InvocationContext ctx, RollbackCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleCommitCommand(InvocationContext ctx, CommitCommand command)
throws Throwable
+ {
+ try
+ {
+ return executeCommitCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeCommitCommand(InvocationContext ctx, CommitCommand command)
throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleOptimisticPrepareCommand(InvocationContext ctx,
OptimisticPrepareCommand command) throws Throwable
+ {
+ try
+ {
+ return executeOptimisticPrepareCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeOptimisticPrepareCommand(InvocationContext ctx,
OptimisticPrepareCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleReplicateCommand(InvocationContext ctx, ReplicateCommand
command) throws Throwable
+ {
+ try
+ {
+ return executeReplicateCommands(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeReplicateCommands(InvocationContext ctx, ReplicateCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleAnnounceBuddyPoolName(InvocationContext ctx,
AnnounceBuddyPoolNameCommand command) throws Throwable
+ {
+ try
+ {
+ return executeAnnounceBuddyPoolName(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeAnnounceBuddyPoolName(InvocationContext ctx,
AnnounceBuddyPoolNameCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleRemoveFromBuddyGroupCommand(InvocationContext ctx,
RemoveFromBuddyGroupCommand command) throws Throwable
+ {
+ try
+ {
+ return executeRemoveFromBuddyGroupCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeRemoveFromBuddyGroupCommand(InvocationContext ctx,
RemoveFromBuddyGroupCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleAssignToBuddyGroupCommand(InvocationContext ctx,
AssignToBuddyGroupCommand command) throws Throwable
+ {
+ try
+ {
+ return executeAssignToBuddyGroupCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeAssignToBuddyGroupCommand(InvocationContext ctx,
AssignToBuddyGroupCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleDataGravitationCleanupCommand(InvocationContext ctx,
DataGravitationCleanupCommand command) throws Throwable
+ {
+ try
+ {
+ return executeDataGravitationCleanupCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeDataGravitationCleanupCommand(InvocationContext ctx,
DataGravitationCleanupCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleClusteredGetCommand(InvocationContext ctx,
ClusteredGetCommand command) throws Throwable
+ {
+ try
+ {
+ return executeClusteredGetCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeClusteredGetCommand(InvocationContext ctx, ClusteredGetCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleBlockChannelCommand(InvocationContext ctx,
BlockChannelCommand command) throws Throwable
+ {
+ try
+ {
+ return executeBlockChannelCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeBlockChannelCommand(InvocationContext ctx, BlockChannelCommand
command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public final Object handleUnblockChannelCommand(InvocationContext ctx,
UnblockChannelCommand command) throws Throwable
+ {
+ try
+ {
+ return executeUnblockChannelCommand(ctx, command);
+ } finally
+ {
+ doAfterCall(ctx);
+ }
+ }
+
+ public Object executeUnblockChannelCommand(InvocationContext ctx,
UnblockChannelCommand command) throws Throwable
+ {
+ return executeAll(ctx, command);
+ }
+
+ public Object executeAll(InvocationContext ctx, CacheCommand command) throws
Throwable
+ {
+ return invokeNextInterceptor(ctx, command);
+ }
+
+ public abstract void doAfterCall(InvocationContext ctx);
+}
Modified:
core/trunk/src/main/java/org/jboss/cache/interceptors/base/SkipCheckChainedInterceptor.java
===================================================================
---
core/trunk/src/main/java/org/jboss/cache/interceptors/base/SkipCheckChainedInterceptor.java 2008-04-23
13:48:45 UTC (rev 5649)
+++
core/trunk/src/main/java/org/jboss/cache/interceptors/base/SkipCheckChainedInterceptor.java 2008-04-23
14:38:02 UTC (rev 5650)
@@ -55,10 +55,10 @@
{
return invokeNextInterceptor(ctx, command);
}
- return executeRemoveFqnCommand(ctx, command);
+ return executeRemoveNodeCommand(ctx, command);
}
- public Object executeRemoveFqnCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
+ public Object executeRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand
command) throws Throwable
{
return executeAll(ctx, command);
}