[jbosscache-commits] JBoss Cache SVN: r6616 - in core/trunk/src/main/java/org/jboss/cache: invocation and 1 other directory.
jbosscache-commits at lists.jboss.org
jbosscache-commits at lists.jboss.org
Tue Aug 26 02:56:10 EDT 2008
Author: manik.surtani at jboss.com
Date: 2008-08-26 02:56:09 -0400 (Tue, 26 Aug 2008)
New Revision: 6616
Removed:
core/trunk/src/main/java/org/jboss/cache/invocation/AbstractInvocationContext.java
Modified:
core/trunk/src/main/java/org/jboss/cache/InvocationContext.java
core/trunk/src/main/java/org/jboss/cache/invocation/LegacyInvocationContext.java
core/trunk/src/main/java/org/jboss/cache/invocation/MVCCInvocationContext.java
Log:
Made invocation context an abstract class instead of an interface
Modified: core/trunk/src/main/java/org/jboss/cache/InvocationContext.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/InvocationContext.java 2008-08-26 06:44:18 UTC (rev 6615)
+++ core/trunk/src/main/java/org/jboss/cache/InvocationContext.java 2008-08-26 06:56:09 UTC (rev 6616)
@@ -1,12 +1,19 @@
package org.jboss.cache;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.jboss.cache.annotations.Compat;
import org.jboss.cache.commands.VisitableCommand;
import org.jboss.cache.config.Option;
import org.jboss.cache.marshall.MethodCall;
import org.jboss.cache.transaction.GlobalTransaction;
import org.jboss.cache.transaction.TransactionContext;
+import org.jboss.cache.transaction.TransactionTable;
+import org.jboss.cache.util.Immutables;
import javax.transaction.Transaction;
+import java.util.Collections;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
@@ -14,23 +21,48 @@
* A context that holds information regarding the scope of a single invocation. May delegate some calls to a {@link org.jboss.cache.transaction.TransactionContext}
* if one is in scope.
* <p/>
- * Note that prior to 3.0.0, InvocationContext was a concrete class and not an interface.
+ * Note that prior to 3.0.0, InvocationContext was a concrete class and not an abstract one.
* <p/>
*
* @author Manik Surtani (<a href="mailto:manik at jboss.org">manik at jboss.org</a>)
* @see org.jboss.cache.transaction.TransactionContext
*/
@SuppressWarnings("deprecation")
-public interface InvocationContext
+ at Compat(notes = "This really ought to be an interface, just like TransactionContext, but since this is public API making this an interface will break binary compat with 2.x.")
+public abstract class InvocationContext
{
+ private static final Log log = LogFactory.getLog(InvocationContext.class);
+ private static final boolean trace = log.isTraceEnabled();
+
+ private Transaction transaction;
+ private GlobalTransaction globalTransaction;
+ protected TransactionContext transactionContext;
+ private Option optionOverrides;
+ // defaults to true.
+ private boolean originLocal = true;
+ private boolean localRollbackOnly;
+ @Deprecated
+ private MethodCall methodCall;
+ @Deprecated
+ private VisitableCommand command;
+
/**
+ * LinkedHashSet of locks acquired by the invocation. We use a LinkedHashSet because we need efficient Set semantics
+ * but also need guaranteed ordering for use by lock release code (see JBCCACHE-874).
+ * <p/>
+ * This needs to be unchecked since we support both MVCC (Fqns held here) or legacy Opt/Pess locking (NodeLocks held here).
+ * once we drop support for opt/pess locks we can genericise this to contain Fqns. - Manik Surtani, June 2008
+ */
+ protected LinkedHashSet invocationLocks;
+
+ /**
* Retrieves a node from the registry of looked up nodes in the current scope.
*
* @param fqn fqn to look up
* @return a node, or null if it cannot be found.
* @since 3.0.
*/
- NodeSPI lookUpNode(Fqn fqn);
+ public abstract NodeSPI lookUpNode(Fqn fqn);
/**
* Puts an entry in the registry of looked up nodes in the current scope.
@@ -39,14 +71,14 @@
* @param n node to add
* @since 3.0.
*/
- void putLookedUpNode(Fqn f, NodeSPI n);
+ public abstract void putLookedUpNode(Fqn f, NodeSPI n);
/**
* Clears the registry of looked up nodes.
*
* @since 3.0.
*/
- void clearLookedUpNodes();
+ public abstract void clearLookedUpNodes();
/**
* Retrieves a map of nodes looked up within the current invocation's scope.
@@ -54,34 +86,46 @@
* @return a map of looked up nodes.
* @since 3.0
*/
- Map<Fqn, NodeSPI> getLookedUpNodes();
+ public abstract Map<Fqn, NodeSPI> getLookedUpNodes();
/**
* Marks teh context as only rolling back.
*
* @param localRollbackOnly if true, the context is only rolling back.
*/
- void setLocalRollbackOnly(boolean localRollbackOnly);
+ public void setLocalRollbackOnly(boolean localRollbackOnly)
+ {
+ this.localRollbackOnly = localRollbackOnly;
+ }
/**
* Retrieves the transaction associated with this invocation
*
* @return The transaction associated with this invocation
*/
- Transaction getTransaction();
+ public Transaction getTransaction()
+ {
+ return transaction;
+ }
/**
* Sets a transaction object on the invocation context.
*
* @param transaction transaction to set
*/
- void setTransaction(Transaction transaction);
+ public void setTransaction(Transaction transaction)
+ {
+ this.transaction = transaction;
+ }
/**
* @return the transaction entry associated with the current transaction, or null if the current thread is not associated with a transaction.
* @since 2.2.0
*/
- TransactionContext getTransactionContext();
+ public TransactionContext getTransactionContext()
+ {
+ return transactionContext;
+ }
/**
* Sets the transaction context to be associated with the current thread.
@@ -89,47 +133,73 @@
* @param transactionContext transaction context to set
* @since 2.2.0
*/
- void setTransactionContext(TransactionContext transactionContext);
+ public void setTransactionContext(TransactionContext transactionContext)
+ {
+ this.transactionContext = transactionContext;
+ }
/**
* Retrieves the global transaction associated with this invocation
*
* @return the global transaction associated with this invocation
*/
- GlobalTransaction getGlobalTransaction();
+ public GlobalTransaction getGlobalTransaction()
+ {
+ return globalTransaction;
+ }
/**
* Sets the global transaction associated with this invocation
*
* @param globalTransaction global transaction to set
*/
- void setGlobalTransaction(GlobalTransaction globalTransaction);
+ public void setGlobalTransaction(GlobalTransaction globalTransaction)
+ {
+ this.globalTransaction = globalTransaction;
+ }
+
/**
* Retrieves the option overrides associated with this invocation
*
* @return the option overrides associated with this invocation
*/
- Option getOptionOverrides();
+ public Option getOptionOverrides()
+ {
+ if (optionOverrides == null)
+ {
+ optionOverrides = new Option();
+ }
+ return optionOverrides;
+ }
/**
* @return true of no options have been set on this context, false otherwise.
*/
- boolean isOptionsUninitialised();
+ public boolean isOptionsUninitialised()
+ {
+ return optionOverrides == null;
+ }
/**
* Sets the option overrides to be associated with this invocation
*
* @param optionOverrides options to set
*/
- void setOptionOverrides(Option optionOverrides);
+ public void setOptionOverrides(Option optionOverrides)
+ {
+ this.optionOverrides = optionOverrides;
+ }
/**
* Tests if this invocation originated locally or from a remote cache.
*
* @return true if the invocation originated locally.
*/
- boolean isOriginLocal();
+ public boolean isOriginLocal()
+ {
+ return originLocal;
+ }
/**
* Returns an immutable, defensive copy of the List of locks currently maintained for the current scope.
@@ -144,7 +214,12 @@
* @return locks held in current scope.
*/
@SuppressWarnings("unchecked")
- List getLocks();
+ public List getLocks()
+ {
+ // first check transactional scope
+ if (transactionContext != null) return transactionContext.getLocks();
+ return invocationLocks == null || invocationLocks.isEmpty() ? Collections.emptyList() : Immutables.immutableListConvert(invocationLocks);
+ }
/**
* Adds a List of locks to the currently maintained collection of locks acquired.
@@ -159,7 +234,20 @@
* @param locks locks to add
*/
@SuppressWarnings("unchecked")
- void addAllLocks(List locks);
+ public void addAllLocks(List locks)
+ {
+ // first check transactional scope
+ if (transactionContext != null)
+ {
+ transactionContext.addAllLocks(locks);
+ }
+ else
+ {
+ // no need to worry about concurrency here - a context is only valid for a single thread.
+ if (invocationLocks == null) invocationLocks = new LinkedHashSet(4);
+ invocationLocks.addAll(locks);
+ }
+ }
/**
* Adds a lock to the currently maintained collection of locks acquired.
@@ -174,7 +262,20 @@
* @param lock lock to add
*/
@SuppressWarnings("unchecked")
- void addLock(Object lock);
+ public void addLock(Object lock)
+ {
+ // first check transactional scope
+ if (transactionContext != null)
+ {
+ transactionContext.addLock(lock);
+ }
+ else
+ {
+ // no need to worry about concurrency here - a context is only valid for a single thread.
+ if (invocationLocks == null) invocationLocks = new LinkedHashSet(4);
+ invocationLocks.add(lock);
+ }
+ }
/**
* Removes a lock from the currently maintained collection of locks acquired.
@@ -189,7 +290,19 @@
* @param lock lock to remove
*/
@SuppressWarnings("unchecked")
- void removeLock(Object lock);
+ public void removeLock(Object lock)
+ {
+ // first check transactional scope
+ if (transactionContext != null)
+ {
+ transactionContext.removeLock(lock);
+ }
+ else
+ {
+ // no need to worry about concurrency here - a context is only valid for a single thread.
+ if (invocationLocks != null) invocationLocks.remove(lock);
+ }
+ }
/**
* Clears all locks from the currently maintained collection of locks acquired.
@@ -201,9 +314,20 @@
* as well as legacy Optimistic and Pessimistic Locking schemes (which use {@link org.jboss.cache.lock.NodeLock} as locks). Once support for
* legacy node locking schemes are dropped, this method will be more strongly typed to accept {@link Fqn}.
*/
- void clearLocks();
+ public void clearLocks()
+ {
+ // first check transactional scope
+ if (transactionContext != null)
+ {
+ transactionContext.clearLocks();
+ }
+ else
+ {
+ // no need to worry about concurrency here - a context is only valid for a single thread.
+ if (invocationLocks != null) invocationLocks.clear();
+ }
+ }
-
/**
* Note that if a transaction is in scope, implementations should test this lock from on {@link org.jboss.cache.transaction.TransactionContext}.
* Using this method should always ensure locks checked in the appropriate scope.
@@ -211,12 +335,26 @@
* @param lock lock to test
* @return true if the lock being tested is already held in the current scope, false otherwise.
*/
- boolean hasLock(Object lock);
+ public boolean hasLock(Object lock)
+ {
+ // first check transactional scope
+ if (transactionContext != null)
+ {
+ return transactionContext.hasLock(lock);
+ }
+ else
+ {
+ return invocationLocks != null && invocationLocks.contains(lock);
+ }
+ }
/**
* @return true if options exist to suppress locking - false otherwise. Note that this is only used by the {@link org.jboss.cache.interceptors.PessimisticLockInterceptor}.
*/
- boolean isLockingSuppressed();
+ public boolean isLockingSuppressed()
+ {
+ return getOptionOverrides() != null && getOptionOverrides().isSuppressLocking();
+ }
/**
* If set to true, the invocation is assumed to have originated locally. If set to false,
@@ -224,17 +362,32 @@
*
* @param originLocal flag to set
*/
- void setOriginLocal(boolean originLocal);
+ public void setOriginLocal(boolean originLocal)
+ {
+ this.originLocal = originLocal;
+ }
/**
* @return true if the current transaction is set to rollback only.
*/
- boolean isLocalRollbackOnly();
+ public boolean isLocalRollbackOnly()
+ {
+ return localRollbackOnly;
+ }
/**
* Resets the context, freeing up any references.
*/
- void reset();
+ public void reset()
+ {
+ transaction = null;
+ globalTransaction = null;
+ optionOverrides = null;
+ originLocal = true;
+ invocationLocks = null;
+ methodCall = null;
+ command = null;
+ }
/**
* This is a "copy-factory-method" that should be used whenever a clone of this class is needed. The resulting instance
@@ -245,22 +398,50 @@
* @return a new InvocationContext
*/
@SuppressWarnings("unchecked")
- InvocationContext copy();
+ public abstract InvocationContext copy();
/**
* Sets the state of the InvocationContext based on the template context passed in
*
* @param template template to copy from
*/
- void setState(InvocationContext template);
+ public void setState(InvocationContext template)
+ {
+ if (template == null)
+ {
+ throw new NullPointerException("Template InvocationContext passed in to InvocationContext.setState() passed in is null");
+ }
+ this.setGlobalTransaction(template.getGlobalTransaction());
+ this.setLocalRollbackOnly(template.isLocalRollbackOnly());
+ this.setOptionOverrides(template.getOptionOverrides());
+ this.setOriginLocal(template.isOriginLocal());
+ this.setTransaction(template.getTransaction());
+ }
+
/**
* @return the method call associated with this invocation
*/
@Deprecated
@SuppressWarnings("deprecation")
- MethodCall getMethodCall();
+ public MethodCall getMethodCall()
+ {
+ if (methodCall == null)
+ {
+ methodCall = createMethodCall();
+ }
+ return methodCall;
+ }
+ @SuppressWarnings("deprecation")
+ private MethodCall createMethodCall()
+ {
+ if (command == null) return null;
+ MethodCall call = new MethodCall();
+ call.setMethodId(command.getCommandId());
+ call.setArgs(command.getParameters());
+ return call;
+ }
/**
* Sets the method call associated with this invocation.
@@ -269,16 +450,28 @@
* @deprecated not used anymore. Interceptors will get a {@link org.jboss.cache.commands.ReplicableCommand} instance passed in along with an InvocationContext.
*/
@Deprecated
- void setMethodCall(MethodCall methodCall);
+ public void setMethodCall(MethodCall methodCall)
+ {
+ this.methodCall = methodCall;
+ }
/**
* If the lock acquisition timeout is overridden for current call using an option, then return that one.
* If not overridden, return default value.
*
- * @param defaultTimeout timeout to fall back to
+ * @param timeout timeout to fall back to
* @return timeout to use
*/
- long getLockAcquisitionTimeout(long defaultTimeout);
+ public long getLockAcquisitionTimeout(long timeout)
+ {
+ // TODO: this stuff really doesn't belong here. Put it somewhere else.
+ if (getOptionOverrides() != null
+ && getOptionOverrides().getLockAcquisitionTimeout() >= 0)
+ {
+ timeout = getOptionOverrides().getLockAcquisitionTimeout();
+ }
+ return timeout;
+ }
/**
* This is only used for backward compatibility with old interceptors implementation and should <b>NOT</b> be
@@ -289,7 +482,10 @@
*/
@Deprecated
@SuppressWarnings("deprecation")
- void setCommand(VisitableCommand cacheCommand);
+ public void setCommand(VisitableCommand cacheCommand)
+ {
+ this.command = cacheCommand;
+ }
/**
* @return command that is in scope
@@ -297,18 +493,97 @@
*/
@Deprecated
@SuppressWarnings("deprecation")
- VisitableCommand getCommand();
+ public VisitableCommand getCommand()
+ {
+ return command;
+ }
/**
* @return true if there is current transaction associated with the invocation, and this transaction is in a valid state.
*/
- boolean isValidTransaction();
+ public boolean isValidTransaction()
+ {
+ // ought to move to the transaction context
+ return transaction != null && TransactionTable.isValid(transaction);
+ }
/**
* Throws the given throwable provided no options suppress or prevent this from happening.
*
- * @param throwable throwable to throw
+ * @param e throwable to throw
* @throws Throwable if allowed to throw one.
*/
- void throwIfNeeded(Throwable throwable) throws Throwable;
+ public void throwIfNeeded(Throwable e) throws Throwable
+ {
+ // TODO: this stuff really doesn't belong here. Put it somewhere else.
+ Option optionOverride = getOptionOverrides();
+ boolean shouldRethtrow = optionOverride == null || !optionOverride.isFailSilently();
+ if (!shouldRethtrow)
+ {
+ if (trace)
+ log.trace("There was a problem handling this request, but failSilently was set, so suppressing exception", e);
+ return;
+ }
+ throw e;
+ }
+
+ @SuppressWarnings("unchecked")
+ protected void doCopy(InvocationContext copy)
+ {
+ copy.command = command;
+ copy.globalTransaction = globalTransaction;
+ copy.invocationLocks = invocationLocks == null ? null : new LinkedHashSet(invocationLocks);
+ copy.localRollbackOnly = localRollbackOnly;
+ copy.optionOverrides = optionOverrides == null ? null : optionOverrides.copy();
+ copy.originLocal = originLocal;
+ copy.transaction = transaction;
+ copy.transactionContext = transactionContext;
+ }
+
+ @Override
+ public String toString()
+ {
+ return "InvocationContext{" +
+ "transaction=" + transaction +
+ ", globalTransaction=" + globalTransaction +
+ ", transactionContext=" + transactionContext +
+ ", optionOverrides=" + optionOverrides +
+ ", originLocal=" + originLocal +
+ '}';
+ }
+
+ @Override
+ public boolean equals(Object o)
+ {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ final InvocationContext that = (InvocationContext) o;
+
+ if (localRollbackOnly != that.localRollbackOnly) return false;
+ if (originLocal != that.originLocal) return false;
+ if (globalTransaction != null ? !globalTransaction.equals(that.globalTransaction) : that.globalTransaction != null)
+ {
+ return false;
+ }
+ if (optionOverrides != null ? !optionOverrides.equals(that.optionOverrides) : that.optionOverrides != null)
+ {
+ return false;
+ }
+ if (transaction != null ? !transaction.equals(that.transaction) : that.transaction != null) return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ int result;
+ result = (transaction != null ? transaction.hashCode() : 0);
+ result = 29 * result + (globalTransaction != null ? globalTransaction.hashCode() : 0);
+ result = 29 * result + (optionOverrides != null ? optionOverrides.hashCode() : 0);
+ result = 29 * result + (originLocal ? 1 : 0);
+ result = 29 * result + (localRollbackOnly ? 1 : 0);
+ return result;
+ }
}
Deleted: core/trunk/src/main/java/org/jboss/cache/invocation/AbstractInvocationContext.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/invocation/AbstractInvocationContext.java 2008-08-26 06:44:18 UTC (rev 6615)
+++ core/trunk/src/main/java/org/jboss/cache/invocation/AbstractInvocationContext.java 2008-08-26 06:56:09 UTC (rev 6616)
@@ -1,370 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- *
- * Distributable under LGPL license.
- * See terms of license at gnu.org.
- */
-package org.jboss.cache.invocation;
-
-import java.util.Collections;
-import java.util.LinkedHashSet;
-import java.util.List;
-
-import javax.transaction.Transaction;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.jboss.cache.InvocationContext;
-import org.jboss.cache.commands.VisitableCommand;
-import org.jboss.cache.config.Option;
-import org.jboss.cache.marshall.MethodCall;
-import org.jboss.cache.transaction.GlobalTransaction;
-import org.jboss.cache.transaction.TransactionContext;
-import org.jboss.cache.transaction.TransactionTable;
-import org.jboss.cache.util.Immutables;
-
-/**
- * This context holds information specific to a method invocation. This is used for Optimistic and Pessimisic Node Locking Schemes.
- *
- * @author <a href="mailto:manik at jboss.org">Manik Surtani (manik at jboss.org)</a>
- */
- at SuppressWarnings("deprecation")
-public abstract class AbstractInvocationContext implements InvocationContext
-{
- private static final Log log = LogFactory.getLog(AbstractInvocationContext.class);
- private static final boolean trace = log.isTraceEnabled();
-
- private Transaction transaction;
- private GlobalTransaction globalTransaction;
- protected TransactionContext transactionContext;
- private Option optionOverrides;
- // defaults to true.
- private boolean originLocal = true;
- private boolean localRollbackOnly;
- @Deprecated
- private MethodCall methodCall;
- @Deprecated
- private VisitableCommand command;
-
- /**
- * LinkedHashSet of locks acquired by the invocation. We use a LinkedHashSet because we need efficient Set semantics
- * but also need guaranteed ordering for use by lock release code (see JBCCACHE-874).
- * <p/>
- * This needs to be unchecked since we support both MVCC (Fqns held here) or legacy Opt/Pess locking (NodeLocks held here).
- * once we drop support for opt/pess locks we can genericise this to contain Fqns. - Manik Surtani, June 2008
- */
- protected LinkedHashSet invocationLocks;
-
- public void setLocalRollbackOnly(boolean localRollbackOnly)
- {
- this.localRollbackOnly = localRollbackOnly;
- }
-
- public Transaction getTransaction()
- {
- return transaction;
- }
-
- public void setTransaction(Transaction transaction)
- {
- this.transaction = transaction;
- }
-
- public TransactionContext getTransactionContext()
- {
- return transactionContext;
- }
-
- public void setTransactionContext(TransactionContext transactionContext)
- {
- this.transactionContext = transactionContext;
- }
-
- public GlobalTransaction getGlobalTransaction()
- {
- return globalTransaction;
- }
-
- public void setGlobalTransaction(GlobalTransaction globalTransaction)
- {
- this.globalTransaction = globalTransaction;
- }
-
- public Option getOptionOverrides()
- {
- if (optionOverrides == null)
- {
- optionOverrides = new Option();
- }
- return optionOverrides;
- }
-
- public boolean isOptionsUninitialised()
- {
- return optionOverrides == null;
- }
-
- public void setOptionOverrides(Option optionOverrides)
- {
- this.optionOverrides = optionOverrides;
- }
-
- public boolean isOriginLocal()
- {
- return originLocal;
- }
-
- @SuppressWarnings("unchecked")
- public List getLocks()
- {
- // first check transactional scope
- if (transactionContext != null) return transactionContext.getLocks();
- return invocationLocks == null || invocationLocks.isEmpty() ? Collections.emptyList() : Immutables.immutableListConvert(invocationLocks);
- }
-
- @SuppressWarnings("unchecked")
- public void addAllLocks(List locks)
- {
- // first check transactional scope
- if (transactionContext != null)
- {
- transactionContext.addAllLocks(locks);
- }
- else
- {
- // no need to worry about concurrency here - a context is only valid for a single thread.
- if (invocationLocks == null) invocationLocks = new LinkedHashSet(4);
- invocationLocks.addAll(locks);
- }
- }
-
- @SuppressWarnings("unchecked")
- public void addLock(Object lock)
- {
- // first check transactional scope
- if (transactionContext != null)
- {
- transactionContext.addLock(lock);
- }
- else
- {
- // no need to worry about concurrency here - a context is only valid for a single thread.
- if (invocationLocks == null) invocationLocks = new LinkedHashSet(4);
- invocationLocks.add(lock);
- }
- }
-
- @SuppressWarnings("unchecked")
- public void removeLock(Object lock)
- {
- // first check transactional scope
- if (transactionContext != null)
- {
- transactionContext.removeLock(lock);
- }
- else
- {
- // no need to worry about concurrency here - a context is only valid for a single thread.
- if (invocationLocks != null) invocationLocks.remove(lock);
- }
- }
-
- public void clearLocks()
- {
- // first check transactional scope
- if (transactionContext != null)
- {
- transactionContext.clearLocks();
- }
- else
- {
- // no need to worry about concurrency here - a context is only valid for a single thread.
- if (invocationLocks != null) invocationLocks.clear();
- }
- }
-
- public boolean hasLock(Object lock)
- {
- // first check transactional scope
- if (transactionContext != null)
- {
- return transactionContext.hasLock(lock);
- }
- else
- {
- return invocationLocks != null && invocationLocks.contains(lock);
- }
- }
-
- public boolean isLockingSuppressed()
- {
- return getOptionOverrides() != null && getOptionOverrides().isSuppressLocking();
- }
-
- public void setOriginLocal(boolean originLocal)
- {
- this.originLocal = originLocal;
- }
-
- @Override
- public String toString()
- {
- return "InvocationContext{" +
- "transaction=" + transaction +
- ", globalTransaction=" + globalTransaction +
- ", transactionContext=" + transactionContext +
- ", optionOverrides=" + optionOverrides +
- ", originLocal=" + originLocal +
- '}';
- }
-
- public boolean isLocalRollbackOnly()
- {
- return localRollbackOnly;
- }
-
- public void reset()
- {
- transaction = null;
- globalTransaction = null;
- optionOverrides = null;
- originLocal = true;
- invocationLocks = null;
- methodCall = null;
- command = null;
- }
-
- @SuppressWarnings("unchecked")
- protected void doCopy(AbstractInvocationContext copy)
- {
- copy.command = command;
- copy.globalTransaction = globalTransaction;
- copy.invocationLocks = invocationLocks == null ? null : new LinkedHashSet(invocationLocks);
- copy.localRollbackOnly = localRollbackOnly;
- copy.optionOverrides = optionOverrides == null ? null : optionOverrides.copy();
- copy.originLocal = originLocal;
- copy.transaction = transaction;
- copy.transactionContext = transactionContext;
- }
-
- public void setState(InvocationContext template)
- {
- if (template == null)
- {
- throw new NullPointerException("Template InvocationContext passed in to InvocationContext.setState() passed in is null");
- }
-
- this.setGlobalTransaction(template.getGlobalTransaction());
- this.setLocalRollbackOnly(template.isLocalRollbackOnly());
- this.setOptionOverrides(template.getOptionOverrides());
- this.setOriginLocal(template.isOriginLocal());
- this.setTransaction(template.getTransaction());
- }
-
- @Override
- public boolean equals(Object o)
- {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
-
- final AbstractInvocationContext that = (AbstractInvocationContext) o;
-
- if (localRollbackOnly != that.localRollbackOnly) return false;
- if (originLocal != that.originLocal) return false;
- if (globalTransaction != null ? !globalTransaction.equals(that.globalTransaction) : that.globalTransaction != null)
- {
- return false;
- }
- if (optionOverrides != null ? !optionOverrides.equals(that.optionOverrides) : that.optionOverrides != null)
- {
- return false;
- }
- if (transaction != null ? !transaction.equals(that.transaction) : that.transaction != null) return false;
-
- return true;
- }
-
- @Override
- public int hashCode()
- {
- int result;
- result = (transaction != null ? transaction.hashCode() : 0);
- result = 29 * result + (globalTransaction != null ? globalTransaction.hashCode() : 0);
- result = 29 * result + (optionOverrides != null ? optionOverrides.hashCode() : 0);
- result = 29 * result + (originLocal ? 1 : 0);
- result = 29 * result + (localRollbackOnly ? 1 : 0);
- return result;
- }
-
- @Deprecated
- @SuppressWarnings("deprecation")
- public MethodCall getMethodCall()
- {
- if (methodCall == null)
- {
- methodCall = createMethodCall();
- }
- return methodCall;
- }
-
- @SuppressWarnings("deprecation")
- private MethodCall createMethodCall()
- {
- if (command == null) return null;
- MethodCall call = new MethodCall();
- call.setMethodId(command.getCommandId());
- call.setArgs(command.getParameters());
- return call;
- }
-
- @Deprecated
- public void setMethodCall(MethodCall methodCall)
- {
- this.methodCall = methodCall;
- }
-
- public long getLockAcquisitionTimeout(long timeout)
- {
- // TODO: this stuff really doesn't belong here. Put it somewhere else.
- if (getOptionOverrides() != null
- && getOptionOverrides().getLockAcquisitionTimeout() >= 0)
- {
- timeout = getOptionOverrides().getLockAcquisitionTimeout();
- }
- return timeout;
- }
-
- @Deprecated
- @SuppressWarnings("deprecation")
- public void setCommand(VisitableCommand cacheCommand)
- {
- this.command = cacheCommand;
- }
-
- @Deprecated
- @SuppressWarnings("deprecation")
- public VisitableCommand getCommand()
- {
- return command;
- }
-
- public boolean isValidTransaction()
- {
- // ought to move to the transaction context
- return transaction != null && TransactionTable.isValid(transaction);
- }
-
- public void throwIfNeeded(Throwable e) throws Throwable
- {
- // TODO: this stuff really doesn't belong here. Put it somewhere else.
- Option optionOverride = getOptionOverrides();
- boolean shouldRethtrow = optionOverride == null || !optionOverride.isFailSilently();
- if (!shouldRethtrow)
- {
- if (trace)
- log.trace("There was a problem handling this request, but failSilently was set, so suppressing exception", e);
- return;
- }
- throw e;
- }
-}
Modified: core/trunk/src/main/java/org/jboss/cache/invocation/LegacyInvocationContext.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/invocation/LegacyInvocationContext.java 2008-08-26 06:44:18 UTC (rev 6615)
+++ core/trunk/src/main/java/org/jboss/cache/invocation/LegacyInvocationContext.java 2008-08-26 06:56:09 UTC (rev 6616)
@@ -15,7 +15,7 @@
* @deprecated will be removed along with optimistic and pessimistic locking.
*/
@Deprecated
-public class LegacyInvocationContext extends AbstractInvocationContext
+public class LegacyInvocationContext extends InvocationContext
{
DataContainer container;
Modified: core/trunk/src/main/java/org/jboss/cache/invocation/MVCCInvocationContext.java
===================================================================
--- core/trunk/src/main/java/org/jboss/cache/invocation/MVCCInvocationContext.java 2008-08-26 06:44:18 UTC (rev 6615)
+++ core/trunk/src/main/java/org/jboss/cache/invocation/MVCCInvocationContext.java 2008-08-26 06:56:09 UTC (rev 6616)
@@ -16,7 +16,7 @@
* @author Manik Surtani (<a href="mailto:manik at jboss.org">manik at jboss.org</a>)
* @since 3.0
*/
-public class MVCCInvocationContext extends AbstractInvocationContext
+public class MVCCInvocationContext extends InvocationContext
{
private HashMap<Fqn, NodeSPI> lookedUpNodes = null;
private MVCCTransactionContext mvccTCtx;
More information about the jbosscache-commits
mailing list